Classe abstraite en Java

Question

Qu'est-ce qu'une "classe abstraite" en Java ?

Answer 1

Une classe abstraite ne peut pas être directement instanciée, mais doit être dérivée pour être utilisable. Une classe MUST être abstrait s'il contient des méthodes abstraites : soit directement

abstract class Foo {
    abstract void someMethod();
}

ou indirectement

interface IFoo {
    void someMethod();
}

abstract class Foo2 implements IFoo {
}

Cependant, une classe peut être abstraite sans contenir de méthodes abstraites. C'est une façon d'empêcher l'instantanéité directe, par exemple.

abstract class Foo3 {
}

class Bar extends Foo3 {

}

Foo3 myVar = new Foo3(); // illegal! class is abstract
Foo3 myVar = new Bar(); // allowed!

Ce dernier style de classes abstraites peut être utilisé pour créer des classes de type "interface". Contrairement aux interfaces, une classe abstraite est autorisée à contenir des méthodes non abstraites et des variables d'instance. Vous pouvez l'utiliser pour fournir une fonctionnalité de base aux classes d'extension.

Un autre modèle fréquent consiste à implémenter la fonctionnalité principale dans la classe abstraite et à définir une partie de l'algorithme dans une méthode abstraite qui sera implémentée par une classe d'extension. Exemple stupide :

abstract class Processor {
    protected abstract int[] filterInput(int[] unfiltered);

    public int process(int[] values) {
        int[] filtered = filterInput(values);
        // do something with filtered input
    }
}

class EvenValues extends Processor {
    protected int[] filterInput(int[] unfiltered) {
        // remove odd numbers
    }
}

class OddValues extends Processor {
    protected int[] filterInput(int[] unfiltered) {
        // remove even numbers
    }
}

Answer 2

Classe qui peut avoir des méthodes concrètes et non concrètes, c'est-à-dire avec et sans corps.

1. Les méthodes sans implémentation doivent contenir le mot clé "abstract".
2. Une classe abstraite ne peut pas être instanciée.

Answer 3

Une classe abstraite est une classe qui est déclarée abstraite - elle peut inclure ou non des méthodes abstraites. Les classes abstraites ne peuvent pas être instanciées, mais elles peuvent être sous-classées.

En d'autres termes, une classe qui est déclarée avec le mot clé abstract, est connue comme classe abstraite en java. Elle peut avoir des méthodes abstraites (méthode sans corps) et non-abstraites (méthode avec corps).

Note importante : - Les classes abstraites ne peuvent pas être utilisées pour instancier des objets, elles peuvent être utilisées pour créer des références d'objets, car l'approche de Java en matière de polymorphisme à l'exécution est mise en œuvre par l'utilisation de références de superclasses. Ainsi, il doit être possible de créer une référence à une classe abstraite afin qu'elle puisse être utilisée pour pointer vers un objet de sous-classe. Vous verrez cette fonctionnalité dans l'exemple ci-dessous

abstract class Bike{  
  abstract void run();  
}  

class Honda4 extends Bike{  
    void run(){
        System.out.println("running safely..");
    }  

    public static void main(String args[]){  
       Bike obj = new Honda4();  
       obj.run();  
    }  
}

Answer 4

Une classe abstraite est une classe qui n'est pas entièrement implémentée mais qui fournit une sorte de plan pour les sous-classes. Elle peut être partiellement implémentée dans la mesure où elle contient des méthodes concrètes entièrement définies, mais elle peut également contenir des méthodes abstraites. Ce sont des méthodes avec une signature mais sans corps de méthode. Toute sous-classe doit définir un corps pour chaque méthode abstraite, sinon elle doit également être déclarée abstraite. Comme les classes abstraites ne peuvent pas être instanciées, elles doivent être étendues par au moins une sous-classe pour pouvoir être utilisées. Considérez la classe abstraite comme la classe générique, et les sous-classes sont là pour compléter les informations manquantes.

Answer 5

Il ne fait rien, il fournit simplement un modèle commun qui sera partagé par ses sous-classes.