Bonsoir,

j'ai un exercice à faire ou je dois créer un Point2D et un Segment2D

public class Point2D {
	private int x;
	private int y;
	
	public Point2D(int x, int y)
	{
		this.x = x;
		this.y = y;
	}

	public int distance(Point2D pt)
	{
		int rt = (this.x - pt.x) * (this.y - pt.y);
		return (int)(Math.sqrt(rt));
	}
	
	public static void main (String [] args){
		Point2D point = new Point2D(2,3);
		Point2D point2 = new Point2D(4,13);
		
		System.out.println(point.distance(point2));
	}
}

Et dans le Segment2D qui dérive de Point2D, où le segment est représenté par ses deux extrémités(héritage ET composition) et la je bloque je dois faire un constructeur avec quatre entiers en paramètres mais je sais pas comment le faire

public class Segment2D extends Point2D{

}

Si vous pouvez m'éclairer.

tu as essayé de faire:

public Segment2D(int x, int y ,int bla, int blabla)
{
   super(x, y);
}

Salut,

oui sauf que le problème j'ai pas de constructeur avec 4 paramètres dans mon Point, donc j'en ai aucune idée comment faire ça ..

une classe fille peut avoir un constructeur différent de la classe mère, sinon se serai hyper limité, il suffit juste d’appeler la fonction super()

Salut,

A mon avis ça n'a aucun sens que Segment2D hérite de Point2D, c'est comme si tu faisais Voiture extends Moteur...

Si c'est juste pour avoir des méthodes communes ( Calcul de distance, ... ) une interface serait bien mieux.

Un segment c'est rien de plus que 2 points (Point2D ici) donc au lieu d'avoir deux entiers comme dans Point2D (int x, int y) tu déclares deux Point2D et tu les instancies :

public final Point2D pt1;
public final Point2D pt2;

public Segment2D(int x1, int y1, int x2, int y2) {
   this.pt1 = new Point2D(x1, y1);
   this.pt2 = new Point2D(x2, y2);
}

J'ai mis en "public final" comme ça se sont des constantes et on y accède de l'extérieur sans s'encombrer d'accesseurs ( getPoint1, ...).

Je sais pas, y a écris noir sur blanc sur mon exo "Ecrire une classe Segment2D dérivant de la classe Point2D", est-ce que dans ce cas j'ai mal compris et dérivant ne veux pas dire hérite dans ce cas la

Lu'!

Ton exercice est mal foutu, change de cours ou de prof. Il n'y a aucune raison pour que Segment2D dérive de Point2D. Rappel : on a une possibilité (et bien une "possibilité" pas une nécessité) d'héritage entre deux éléments si l'élément dérivant EST-UN élément de base. Force est de constater qu'un segment n'est pas un point.

J'ai le même exercice à faire, et l'énoncé est tordu, mais bien la. Il faut que la classe Segment2D dérive de Point2D.

Je donne mon code, il compile et fonctionne (ceux qui le prendront sur moi seront sympas de le modifier un peu, pour pas que ca soit trop cramé, le copier/coller) :

public class Point2D{
    private int x, y;
    public Point2D(int xx, int yy){
        this.x = xx;
        this.y = yy;
    }
    public int x(){
        return( this.x );
    }
    public int y(){
        return( this.y );
    }
    public double distance(Point2D pt){
        return( Math.sqrt( ( this.x() - pt.x() ) * ( this.x() - pt.x() ) + ( this.y() - pt.y() ) * ( this.y() - pt.y() ) ) );
    }
}


public class Segment2D extends Point2D{
    private int x2 , y2;
    public Segment2D(int x , int y , int xx , int yy ){
        super(x , y );
        this.x2 = xx;
        this.y2 = yy;
    }
    public int x2(){
        return( this.x2 );
    }
    public int y2(){
        return( this.y2 );
    }
    public double lenght(){
        return(distance(new Point2D(this.x2 , this.y2 ) ) );
    }
    public static void main(String[] args){
        Point2D pt = new Point2D(0 ,  4 );
        System.out.println("doit etre 1.0 : " + pt.distance(new Point2D( 0 , 5 ) ) );
        Segment2D sg = new Segment2D(0 , 0 , 1 , 0 );
        System.out.println("doit etre 1.0 aussi : " + sg.lenght() );
        //ce code a été testé et fonctionne.
    }
}

 edit : les deux classes sont ici l'une a la suite de l'autre, mais il faut les compiler dans deux fichiers séparés (Point2D.java et Segment2D.java), sinon "javac" est pas content...

-
Edité par ellana29460 3 mars 2015 à 1:10:27

prog_casio35 a écrit:

J'ai le même exercice à faire, et l'énoncé est tordu, mais bien la. Il faut que la classe Segment2D dérive de Point2D.

Cela n'en reste pas moins une (grosse) erreur de conception. A ta place je réfléchirai bien au fait que la personne qui t'enseigne le Java te montre ici quelque chose qu'il ne faut absolument pas faire et que ce ne sera sûrement pas la seule bêtise qu'elle t'enseignera.