Classes, interfaces

Classes

public abstract class TheClass extends TheSuperClass implements Interface1, Interface2 { ... }

1. Modifiers (abstract, public, final) - mais pas private ou protected
2. Le mot-clé class
3. Le nom de la classe
4. Eventuellement extends le nom de la classe parent
5. Eventuellement implements suivi du nom de(s) interface(s) implémentée(s)
6. Le corps de la classe, encadré par { ... }

public class Circle {

    public static final double PI= 3.14159;

    public static double radiansToDegrees(double radians) { return radians * 180 / PI; }
    
    private double r;

    public Circle() { this(1.0); } // L'overloading (polymorphisme ad'hoc) est aussi possible pour les constructeurs
    
    public Circle(double r) { this.r = r; }
    
    public double getRadius() { return r; }
    
    public void setRadius(double r) {
        if (r < 0.0){
            throw new IllegalArgumentException("radius may not be negative.");
        }
        this.r = r;
    }
    
    public double area() { return PI * r * r; }
    
    public double circumference() { return 2 * PI * r; }
    
}

Visibilité des classes

• public : classe accessible partout
• Non spécifié (package) : la classe ne sera accessible qu'aux classes du même package.
• private et protected : ne sont pas des mots-clés permettant d'exprimer la visibilité d'une classe.
  Mais on peut écrire ce genre de code :

  public class Main1{
      private class MyClass1{ ... }
      protected class MyClass2{ ... }
  }
  

  (code dans Main1.java)
  Ici on spécifie la visibilité d'un membre de la classe Main1 (qui se trouve être une classe, voir Nested types).

Membres d'une classe

Visibilité des membres

Variables de classe ou d'instance

class Exemples{
    public static final int DAYS_PER_WEEK = 7;
    
    protected String[] daynames = new String[DAYS_PER_WEEK];

    private String name;
    
    int x = 1;
    
    public int a = 17, b = 37, c = 53;
    
    private static int nbInstances = 0;
}

Valeurs par défaut

class TestDefaultValues1{
    static int a;
    public static void main(String[] args){
        System.out.println("a = " + a);
    }
}

java TestDefaultValues1

a = 0

class TestDefaultValues2{
    public static void main(String[] args){
        int b;
        System.out.println("b = " + b);
    }
}

Manipuler des variables de classe (static)

A l'extérieur de la classe

import package1.Circle;
...
double piSur2 = Circle.PI / 2.0;
...

import static package1.Circle.*;
...
double piSur2 = PI / 2.0;
...

A l'intérieur de la classe

Manipuler des variables d'instance

A l'extérieur de la classe

public class Circle {
    ...
    public Circle() { this(1.0); }
    public Circle(double r) { this.r = r; }
    ...
}

Circle c1 = new Circle(3.5);
Circle c2 = new Circle();

Circle c = new Circle(3.5);
double radius = c.r;
double surface = c.area();

A l'intérieur de la classe (this)

    public double area() { return PI * this.r * this.r; }
    // identique à :
    public double area() { return PI * r * r; }

public class Circle {
    public Circle(double r) { this.r = r; }
    public void setRadius(double r) { this.r = r; }
}

Modifier final

Autres modifiers

Constructeurs

Circle c = new Circle(0.25);

public Circle(double r) { this.r = r; }
public Circle() { this(1.0); }

Initialisations

Dans un contexte d'instance

public class ClasseAvecTableau {

    public int len = 10;
    
    public int[] table = new int[len];
    
    public ClasseAvecTableau() {
        for(int i = 0; i < len; i++){
            table[i] = i;
        }
    }
}

    public int len;
    
    public int[] table;
    
    public ClasseAvecTableau() {
        len = 10;               // ou this.len = 10;
        table = new int[len];   // ou this.table = new int[this.len]
        for(int i = 0; i < len; i++){
            table[i] = i;
        }
    }

public class MyClass{

    // variables
    private static final int NUMPTS = 100;
    private int[] data = new int[NUMPTS];
    
    // initialisation
    {
        for(int i = 0; i < NUMPTS; i++){
            data[i] = i;
        }
    }
    
    // méthodes
    public MyClass(){ ... }
    
}

Dans un contexte static

public class Circle2 {
    
    private static final int NUM = 500;
    
    private static double sines[] = new double[NUM];
    
    private static double cosines[] = new double[NUM];
    
    static {
        double delta_x = (Circle.PI/2)/(NUM-1);
        double x = 0.0;
        for(int i = 0; i < NUM; i++, x += delta_x) {
            sines[i] = Math.sin(x);
            cosines[i] = Math.cos(x);
        }
    }
    
    public static void main(String[] args){
        System.out.println("NUM = " + NUM);
        System.out.println("delta_x = " + delta_x); // Ne passe pas à la compilation
    }
}

• Comme dans les méthodes statiques, this ne peut pas être utilisé dans les static initializers.
• Une classe peut avoir plusieurs initialisateurs statiques, qui seront ajoutés par javac à la méthode d'initialisation statique.
• Les variables locales aux initialisateurs statiques ne sont pas accessibles au reste de la classe.

  javac Circle2.java
  

  Circle2.java:20: error: cannot find symbol
          System.out.println("delta_x = " + delta_x);
                                            ^
    symbol:   variable delta_x
    location: class Circle2
  1 error
  

Sous-classes et héritage

/**
    Un Circle est caractérisé par son rayon
    Un PlaneCircle est en plus caractérisé par les coordonnées de son centre dans un plan
**/
public class PlaneCircle extends Circle {
    
    private final double cx, cy;    // coordonnées du centre
    
    public PlaneCircle(double r, double x, double y) {
        super(r);
        this.cx = x;
        this.cy = y;
    }
    
    public double getCentreX() { return cx; }
    
    public double getCentreY() { return cy; }
    
    public boolean isInside(double x, double y) {
        double dx = x - cx, dy = y - cy;
        double distance = Math.sqrt(dx*dx + dy*dy); // théorème de Pythagore
        return (distance < getRadius());      // this.getRadius() nécessaire car Circle.r est private
    }
}

• Utilisation de extends
• Tous les membres non privés de la classe mère sont accessibles dans la classe fille.
• Syntaxe super() pour appeler le constructeur de la classe mère.

Narrowing and widening conversions (rappel)

PlaneCircle pc = new PlaneCircle(1.0, 0.0, 0.0);
Circle c = pc;

PlaneCircle pc2 = (PlaneCircle) c;

public class TestTypecast{

    public static void main(String[] args){
        PlaneCircle pc1 = new PlaneCircle(1.0, 0.0, 0.0);
        Circle c1 = pc1; // widening conversion
        PlaneCircle pc1bis = (PlaneCircle) c1; // narrowing conversion OK
        System.out.println("pc1bis : " + pc1bis);
        
        Circle c2 = new Circle();
        PlaneCircle pc2 = (PlaneCircle) c2; // narrowing conversion erreur exécution
        System.out.println("pc2 : " + pc2);
    }
    
}

javac TestTypecast.java
java TestTypecast 

pc1bis : PlaneCircle@42f30e0a
Exception in thread "main" java.lang.ClassCastException: Circle cannot be cast to PlaneCircle
	at TestTypecast.main(TestTypecast.java:13)

Classe déclarée final

Constructeurs

• Ne peut s'utiliser que dans le constructeur de la sous-classe.
• Doit être la première instruction du constructeur

PlaneCircle pc1 = new PlaneCircle(1.0, 0.0, 0.0);

1. Le constructeur de PlaneCircle est appelé.
2. Ce constructeur appelle explicitement super(), et appelle donc le constrcteur de Circle.
3. Le constructeur de Circle appelle implicitement le constructeur de Object.
   On atteint le sommet de la hiérarchie, les constructeurs vont pouvoir s'exécuter.
4. Le constructeur de Object est exécuté.
5. Le constructeur de Circle est exécuté.
6. Le constructeur de PlaneCircle est exécuté.

class MyClass {
    public MyClass() {
        super();
    }
}

Constructeurs privés

• Interdire le sous-classage : si la superclasse n'a pas de constructeur visible (par ex constructeur déclaré private), l'appel implicite de super() génère une erreur à la compilation.
• Certaines classes sont uniquement static et n'ont pas vocation à être instanciées (comme java.lang.Math ou java.lang.System).
  Par exemple voir dans le source de openJDK :

  public final class Math {
      /**
       * Don't let anyone instantiate this class.
       */
      private Math() {}
      // ...
  }
  

Overloading, overriding, hiding

Overloading

Overriding

protected Object clone() throws CloneNotSupportedException

class MyClass[
    @Override public MyClass clone(){ /* ... */ }
}

public class TestOverriding{
    
    public static void main(String[] args){
        Animal[] animaux = {
            new Chien(),
            new Chat()
        };
        for(Animal a : animaux){
            System.out.println(a.grogner());
        }
    }
}

class Animal{
    public String grogner(){
        return "grogner() dans Animal";
    }
}
class Chat extends Animal {
    @Override
    public String grogner(){
        return "Miaou";
    }
}
class Chien extends Animal {
    @Override
    public String grogner(){
        return "Ouaf";
    }
}                                                                      

java TestOverriding 

Ouaf
Miaou

Method hiding

public class TestMethodHiding{
    
    public static void main(String[] args){
        System.out.println(Animal.grogner());
        System.out.println(Chat.grogner());
        System.out.println(Chien.grogner());
    }
}

class Animal{
    public static String grogner(){
        return "grogner() dans Animal";
    }
}
class Chat extends Animal {
    public static String grogner(){
        return "Miaou";
    }
}
class Chien extends Animal {
    public static String grogner(){
        return "Ouaf";
    }
}

java TestMethodHiding 

grogner() dans Animal
Miaou
Ouaf

Danger de confusion

public class TestMethodHiding2{
    
    public static void main(String[] args){
        Animal[] animaux = {
            new Chien(),
            new Chat()
        };
        for(Animal a : animaux){
            System.out.println(a.grogner());
        }
    }
}

class Animal{
    public static String grogner(){
        return "grogner() dans Animal";
    }
}
class Chat extends Animal {
    // @Override
    public static String grogner(){
        return "Miaou";
    }
}
class Chien extends Animal {
    // @Override
    public static String grogner(){
        return "Ouaf";
    }
}

TestMethodHiding2.java:21: error: static methods cannot be annotated with @Override
TestMethodHiding2.java:27: error: static methods cannot be annotated with @Override

java TestMethodHiding2 

grogner() dans Animal
grogner() dans Animal

Field hiding

public class TestFieldHiding{
    public static void main(String[] args){
        C c = new C();
        c.print();
    }
}

class A{
    public String x = "A";
}
class B extends A{
    public String x = "B";
}
class C extends B{
    public String x = "C";
    
    public void print(){
        System.out.println("x = \t\t" + x);
        System.out.println("this.x = \t" + this.x);
        System.out.println("super.x = \t" + super.x);
        System.out.println("((B)this).x = \t" + ((B)this).x);
        System.out.println("((A)this).x = \t" + ((A)this).x);
    }
}

java TestFieldHiding 

x = 		C
this.x = 	C
super.x = 	B
((B)this).x = 	B
((A)this).x = 	A

Utilisations de super

public class TestSuper {
    public static void main(String[] args) {
        var obj = new SousClasse();
        obj.instanceMethod();
    }
}


class SuperClasse {
    public void instanceMethod() {
        System.out.println("SuperClasse.instanceMethod()");
    }
}

class SousClasse extends SuperClasse {
    @Override
    public void instanceMethod(){
        System.out.println("SousClasse.instanceMethod()");
        super.instanceMethod();
    }
}

Abstract classes

abstract class Forme{
    public abstract double aire();
    public abstract double circonference();
}

class Carre extends Forme{
    public double aire(){ return 1.0; }
    public double circonference(){ return 1.0; }
}

class Triangle extends Forme{
    public double aire(){ return 1.0; }
    public double circonference(){ return 1.0; }
}

• Une classe qui a au moins une méthode déclarée abstract doit être déclarée abstract (sinon erreur de compilation).
• Une class abstraite ne peut être instanciée.
• Une sous-classe d'une classe abstraite qui implémente toutes les méthodes abstraites de sa super-classe peut être instanciée.
• Les méthodes static, private ou final ne peuvent être déclarées abstract puisqu'elles ne peuvent pas être overridées.
• Une classe peut être déclarée abstraite même si elle n'a aucune méthode abstraite ; elle ne peut pas être implémentée.

Interfaces

Définir un contrat

interface DéplacerVoiture{
    int tourner(Direction direction,
                double rayonDeCourbure,
                double vitesseInitiale,
                double vitesseFinale);
    
    int accélérer(...);
}

public Class Déplacer2CV implements DéplacerVoiture{
    public int tourner( ... ){ ... }
    public int accélérer( ... ){ ... }
}

public Class DéplacerMégane implements DéplacerVoiture{
    public int tourner( ... ){ ... }
    public int accélérer( ... ){ ... }
}

Définir une interface

interface Interface1 extends Interface2, Interface3{
    
    // déclaration de constante
    double constante1 = 2.718282;       // = public static final
 
    // déclaration de méthode
    void méthode1 (int i, double x);    // = public abstract
}

• Une interface peut être déclarée public ou de visibilité package (même règle de visibilité que pour les classes).
• Tous les membres d'une interface sont par défaut publics (déclarer un membre private ou protected déclenche une erreur de compilation).
  Par convention, le mot-clé public est en général omis dans la déclaration des membres.
• Une interface ne peut contenir que des méthodes abstract, static ou des default methods (depuis java8, voir plus loin).
  Le mot-clé abstract est aussi omis par convention.
  La définition d'une méthode abstraite se termine par un point-virgule (semicolon).
• On ne peut pas définir dans une interface des variables d'instance (car c'est un détail d'implémentation).
  Mais on peut définir des constantes.
  Comme tous les champs d'une interface sont nécessairement des constantes, les mots-clés public static final sont par convention omis.
• Une interface ne peut définir de constructeur (ce qui est normal puisqu'elle ne peut être instanciée).
• Une interface peut étendre plusieurs interfaces ; elle hérite de toutes les méthodes et constantes des super-interfaces.

Implémenter une interface

public Class1 extends class2 implements interface1, interface2{ ... }

interface Interface1{
    public void methode();
}
interface Interface2{
    public void methode();
}
class RepeteMethodes implements Interface1, Interface2{
    public void methode(){
        System.out.println("RepeteMethodes.methode()");
    }
}

Default methods

interface DoIt {
    // ...
   default void aNewMethod(int i){
    // ...  implémentation fournie
   }
}

• La possibilité de faire évoluer des interfaces sans casser le code existant (la compatibilité ascendante est un des points forts de java).
• Eviter de répéter du code, si l'implémentation est commune à plusieurs classes.

// Ne passe pas à la compilation
// error: default method toString in interface I overrides a member of java.lang.Object
interface I{
    @Override default public String toString(){ return "interface I"; }
}

Implémenter plusieurs interfaces avec les mêmes default methods

interface Interface1{
    default void method1(){
        System.out.println("Interface1.method1()");
    }
}
interface Interface2{
    default void method1(){
        System.out.println("Interface2.method1()");
    }
}

/* 
Ne passe pas à la compilation :
DefaultMethods.java:23: error: class C1 inherits unrelated defaults for method1() from types Interface1 and Interface2
*/
class C1 implements Interface1, Interface2{}

/* Compilation OK */
class C2 implements Interface1, Interface2{
    public void method1(){}
}

Etendre une interface avec des default methods

1. Ne pas mentionner la default method - dans ce cas, hérite de la default method.
2. Redéclarer la default method sans l'implémenter - dans ce cas, l'implémentation de la default method est "perdue".
3. Redéfinir la default method - dans ce cas, la nouvelle implémentation remplace la première.

interface Interface0{
    default void methode(){
        System.out.println("methode() dans Interface0");
    }
}

// cas 1
// OK ; C1 utilise l'implémentation de Interface0
interface Interface1 extends Interface0{ }
class C1 implements Interface1{}

// cas 2
interface Interface2 extends Interface0{
    void methode();
}
// erreur de compilation
// ExtendsDefault.java:19: error: C2 is not abstract and does not override abstract method methode() in Interface2
class C2 implements Interface2{}

// cas 3
// OK ; C3 utilise l'implémentation de Interface3
interface Interface3 extends Interface0{
     default void methode(){
        System.out.println("methode() dans Interface3");
    }
}
class C3 implements Interface3{}

Interface static methods

interface Interface1{
    static String doSomething(){ ... }
}

Méthodes privées dans les interfaces

Interfaces vides

// on a une liste, mais on ne sait pas quelle est sa classe concrète
List l = ...;
// on veut trier l
// on sait que la classe concrète de l contient une méthode sort()
// mais l'implémentation de sort() est beaucoup plus efficace pour des listes en random access
// donc avant de faire le sort(), on teste si on est dans un cas de random access
// si ce n'est pas le cas, on convertit l dans une implémentation en random access
if (l.size() > 2 && !(l instanceof RandomAccess)){
    l = new ArrayList(l);
}
l.sort();

Classe abstraite ou interface ?

• Une classe ne peut hériter que d'une seule classe.
• Une interface ne peut pas contenir de variable (que des constantes).
• Si on ajoute une méthode à une API publique, le problème est de ne pas casser la compatibilité du code existant. Dans les deux cas, l'ajout de nouvelles méthodes peut entrer en collision de nom avec des méthodes supplémentaires implémentées dans les classes concrètes.
• La "philosophie" des interfaces est de servir pour spécifier des APIs et de fournir une default method s'il n'y a qu'une implémentation possible, ou si la méthode est optionnelle, mais de laisser abstraites les méthodes qui doivent être implémentées par les classes concrètes.

Sealed classes et interfaces