Java Language Classes abstraites


Exemple

Une classe abstraite est une classe marquée avec le mot-clé abstract . Contrairement aux classes non abstraites, il peut contenir des méthodes abstraites sans implémentation. Il est cependant valable de créer une classe abstraite sans méthodes abstraites.

Une classe abstraite ne peut pas être instanciée. Il peut être sous-classé (étendu) tant que la sous-classe est soit abstraite, soit implémenter toutes les méthodes marquées comme abstraites par les super-classes.

Un exemple de classe abstraite:

public abstract class Component {
    private int x, y;
    
    public setPosition(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public abstract void render();
}

La classe doit être marquée abstraite lorsqu'elle a au moins une méthode abstraite. Une méthode abstraite est une méthode sans implémentation. D'autres méthodes peuvent être déclarées dans une classe abstraite ayant une implémentation afin de fournir un code commun à toutes les sous-classes.

Tenter d’instancier cette classe fournira une erreur de compilation:

//error: Component is abstract; cannot be instantiated   
Component myComponent = new Component();

Cependant, une classe qui étend Component et fournit une implémentation pour toutes ses méthodes abstraites et peut être instanciée.

public class Button extends Component {

    @Override
    public void render() {
        //render a button
    }
}

public class TextBox extends Component {

    @Override
    public void render() {
        //render a textbox
    }
}

Les instances d'héritage de classes peuvent également être converties en tant que classe parente (héritage normal) et elles fournissent un effet polymorphe lorsque la méthode abstraite est appelée.

Component myButton = new Button();
Component myTextBox = new TextBox();

myButton.render(); //renders a button
myTextBox.render(); //renders a text box

Classes abstraites vs interfaces

Les classes abstraites et les interfaces fournissent toutes deux un moyen de définir des signatures de méthode tout en exigeant que la classe d'extension / d'implémentation fournisse l'implémentation.

Il existe deux différences clés entre les classes abstraites et les interfaces:

  • Une classe ne peut étendre qu'une seule classe, mais peut implémenter de nombreuses interfaces.
  • Une classe abstraite peut contenir static champs d'instance (non static ), mais les interfaces ne peuvent contenir que static champs static .
Java SE 8

Les méthodes déclarées dans les interfaces ne pouvant contenir des implémentations, des classes abstraites ont été utilisées lorsqu'il était utile de fournir des méthodes supplémentaires que les implémentations appelaient les méthodes abstraites.

Java SE 8

Java 8 permet aux interfaces de contenir des méthodes par défaut , généralement implémentées à l'aide des autres méthodes de l'interface , ce qui rend les interfaces et les classes abstraites aussi puissantes à cet égard.

Sous-classes anonymes de classes abstraites

Comme commodité, Java permet l'instanciation d'instances anonymes de sous-classes de classes abstraites, qui fournissent des implémentations pour les méthodes abstraites lors de la création du nouvel objet. En utilisant l'exemple ci-dessus, cela pourrait ressembler à ceci:

Component myAnonymousComponent = new Component() {
    @Override
    public void render() {
        // render a quick 1-time use component
    }
}