Composition

8. Réutilisation des classes - Composition

Réutilisation des classes - on utilise des classes construites et testées par quelqu'un d'autre sans modifier le code existant.
Deux approches pour réaliser la réutilisation - Composition et Heritage
Composition - on crée des objets des classes existantes à l'intérieur de la nouvelle classe. On peut aussi créer des nouvelles classes à l'intérieur de la classe.

8.1    Les objets membres

public class Point {
    private double x, y ;
    public Point(double x, double y){
        System.out.println("Constructing a point");
        this.x = x ;
        this.y = y ;
    }
    public String toString(){
        return "Point: (" + x + "," + y+")" ;
    }
    public void move(double dx, double dy){
        System.out.println("Moving the point");
        x+=dx;
        y+=dy;
    }
}
public class Test {
    public static void main(String[] arg){
        Point p1 =new Point(5.4,3.6);
        System.out.println(""+p1);
        p1.move(1.1, 2.3);
        System.out.println(""+p1);
    }
}

public class Circle {
    private Point c;        // center
    private double r;            // radius
    public Circle(double x, double y, double r){
        System.out.println("Constructing a circle");
        c = new Point(x,y);
        this.r =r;
    }
    public String toString(){
        return "Circle - center: "+c+" and radius:"+r;
    }
    public void move(double dx, double dy){
        System.out.print("moving the circle ");
        c.move(dx, dy);
    }
}

public class TestCrcl {
    public static void main(String arg[]){
        Circle cr = new Circle(9.3,8.2,17.1);
        System.out.println(""+cr);
        cr.move(3.1, 4.0);
        System.out.println(""+cr);
    }
}

8.2    Les classes internes

class External {                    // définition d’une classe usuelle (dite alors externe)
    .....                         // méthodes et données de la classe External
    class Internal {            // définition d’une classe interne à la classe External
        .....                     // méthodes et données de la classe Internal
    }
    .....                         // autres méthodes et données de la classe External
}

La définition de la classe Internal n’introduit pas de membre de type Internal dans External. On peut l'utiliser pour instancier un ou plusieurs objets de ce type:

class External {
    public void f() {                            // méthode de External
        Internal i = new Internal() ;         // création d’un objet de type Internal ; sa référence est
                                                // ici locale à la méthode f()
    }
    class Internal {
        .....
    }
    private Internal i1, i2 ;                 // les champs i1 et i2 de External sont des références
                                                // à des objets de type Internal
    .....                                         // autres méthodes et données de la classe External
}

Un objet d’une classe interne a toujours accès aux champs et méthodes (même privés) de l’objet externe lui ayant donné naissance (attention : ici, il s’agit bien d’un accès restreint à l’objet, et non à tous les objets de cette classe).
Un objet de classe externe a toujours accès aux champs et méthodes (même privés) d’un objet d’une classe interne auquel il a donné naissance. Une méthode statique n’est associée à aucun objet. Par conséquent, une méthode statique d’une classe externe ne peut créer aucun objet non statique d’une classe interne.
Une classe interne non statique ne peut pas contenir de membres statiques

Exemple:

public class Circle {
    public static class Point {   //inner class, can be made private or static
   // if static the standalone object can be created (outside any Circle)
        private double x, y ;
        public Point(double x, double y){
            System.out.println("Constructing a point");
            this.x = x ;
            this.y = y ;
        }
        public String toString(){
            return "Point: (" + x + "," + y+")" ;
        }
        public void move(double dx, double dy){
            System.out.println("Moving the point:"+dx+","+dy);
            x+=dx;
            y+=dy;
        }
    }
    private static Point c;        // center, if static - concentric circles
                                   // test it without 'static'
    private double r;            // radius
    public Circle(double x, double y, double r){
        System.out.println("Constructing a circle");
        c = new Point(x,y);
        this.r =r;
    }
    public String toString(){
        return "Circle - center: "+c+" and radius:"+r;
    }
    public void move(double dx, double dy){
        System.out.print("moving the circle - ");
        c.move(dx, dy);
    }
}

-------------------------------------------------------

public class TestCrcl {
    public static void main(String arg[]){
        Circle cr = new Circle(9.3,8.2,17.1);
        System.out.println("cr:"+ cr);
        Circle cr1=new Circle(1,2,3);   //if the member c is static - concentric circles
        System.out.println("cr:"+cr+"\n"+ "cr1:"+cr1);
        System.out.println();
        cr.move(3.1, 4.0);
        System.out.println("cr:"+cr+"\n"+"cr1:"+cr1);
        System.out.println();
        Circle.Point p=new Circle.Point(3, 5); //class Point must be static and accessible
        System.out.println(""+p);    //new point outside any circle
    }
}