1. Dans la déclaration de la classe, utilisez le mot-clé extends pour créer une sous-classe de la classe. Une classe déclare qu'elle utilise une ou plusieurs interfaces via le mot clé Implements.
Extends signifie hériter d'une certaine classe.Après l'héritage, vous pouvez utiliser les méthodes de la classe parent, ou vous pouvez remplacer les méthodes de la classe parent ;impléments signifie implémenter plusieurs interfaces. Les méthodes d'interface sont généralement vides et doivent être réécrites avant de pouvoir l'être. utilisé.
2. Extends hérite de la classe parent. Tant que la classe n'est pas déclarée comme finale ou que la classe est définie comme abstraite, JAVA ne prend pas en charge l'héritage multiple, mais elle peut être implémentée à l'aide d'interfaces. les implémentations doivent être utilisées. L'héritage ne peut hériter que d'une classe, mais les implémentations peuvent implémenter plusieurs interfaces, il suffit de les séparer par des virgules.
Copiez le code comme suit :
la classe A étend B implémente C,D,E
Après avoir longuement étudié, j'ai enfin compris la mise en œuvre aujourd'hui. C'est en fait très simple. Il suffit de regarder les exemples suivants~~.
Quelques notions d'interfaces
<!--[if !supportLineBreakNewLine]-->
Copiez le code comme suit :
coureur de face intérieure publique
{
identifiant entier = 1 ;
exécution nulle ();
}
interface Animal étend Runner
{
void respirer();
}
classe Outils à poisson Animal
{
exécution publique vide()
{
System.out.println("le poisson nage");
}
reniflard public()
{
System.out.println("le poisson bouillonne");
}
}
résumé LandAnimal implémente Animal
{
reniflard public ()
{
System.out.println("LandAnimal respire");
}
}
classe Étudiant étend Personne implémente Runner
{
...
exécution publique vide()
{
System.out.println("l'étudiant est en cours d'exécution");
}
...
}
dépliant d'interface
{
vider la mouche ();
}
la classe Bird implémente Runner, Flyer
{
exécution publique vide()
{
System.out.println("l'oiseau court");
}
public void fly()
{
System.out.println("l'oiseau vole");
}
}
classe TestFish
{
public static void main (String args[])
{
Poisson f = nouveau poisson ();
entier j = 0 ;
j = Runner.ID;
j = f.ID;
}
}
Notes sur l'implémentation de l'interface :
a. Implémenter une interface, c'est implémenter toutes les méthodes de l'interface (sauf les classes abstraites).
b. Les méthodes de l'interface sont abstraites.
c. Plusieurs classes non liées peuvent implémenter la même interface, et une classe peut implémenter plusieurs interfaces non liées.
=================================================== =========
La différence entre les extensions et les implémentations
extends consiste à hériter de la classe parent. Tant que la classe n'est pas déclarée comme finale ou que la classe est définie comme abstraite, JAVA ne prend pas en charge l'héritage multiple, mais elle peut être implémentée à l'aide d'interfaces. les implémentations doivent être utilisées. L'héritage ne peut hériter que d'une seule classe, mais les implémentations peuvent implémenter plusieurs interfaces, il suffit de les séparer par des virgules, par exemple.
la classe A étend B implémente C,D,E
Une classe déclare qu'elle utilise une ou plusieurs interfaces via le mot clé Implements. Dans la déclaration de classe, créez une sous-classe de la classe via le mot-clé extends.
Copiez le code comme suit :
le nom de la sous-classe de classe étend le nom de la classe parent implémente le nom de l'interface
{...
}
=================================================== =========
A a = new B(); Par conséquent, a est une instance de la classe A et ne peut accéder qu'aux méthodes de A. Alors, quelle est la différence entre A a = new A();?
=================================================== ========
la classe B étend A
Après l'héritage, certains membres ou méthodes introuvables dans la classe parent sont généralement définis.
A a = nouveau B();
C'est bon, téléchargez-le.
a est une instance d'un objet de classe parent et ne peut donc pas accéder aux nouveaux membres ou méthodes définis par la sous-classe.
=================================================== ========
Si défini comme ceci :
classe A{
int je;
vide f(){}
}
la classe B étend A{
int j;
void f(){}//Réécriture
vide g(){}
}
Alors:
Bb = nouveau B();
b est une instance d'un objet de sous-classe. Il peut non seulement accéder à ses propres propriétés et méthodes, mais également aux propriétés et méthodes de la classe parent. Des choses comme bi, bj, bf(), bg() sont toutes légales. À ce moment, bf() est f() dans B accessible
A a = nouveau B();
Bien que a utilise le constructeur de B, il devient une instance de l'objet de classe parent après la conversion ascendante et ne peut pas accéder aux propriétés et méthodes de la sous-classe. ai,af() sont légaux, mais aj,ag() sont illégaux. À l’heure actuelle, accéder à af() revient à accéder à f() en B
=================================================== ========
A a = new B(); Cette instruction comporte en fait trois processus :
(1) Un un ;
Déclarez a comme objet de classe parent, qui n'est qu'une référence et aucun espace n'est alloué.
(2) B temp = nouveau B ();
Une instance d'un objet de classe B est établie via le constructeur de classe B, c'est-à-dire initialisée
(3) a = (A)temp;
Convertissez l'objet de sous-classe temp en un objet de classe non parent et attribuez-le à a. Il s'agit d'un téléchargement (upcast), qui est sûr.
Après les trois processus ci-dessus, a est complètement devenu une instance de classe A.
Les sous-classes ont souvent plus de propriétés et de méthodes que les classes parentes. Le téléchargement les supprime uniquement, ce qui est sûr, tandis que le downcasting les augmente parfois, ce qui est généralement dangereux.
=================================================== =========
af() doit correspondre à la méthode f() de la classe B
Après avoir appelé le constructeur pour créer une instance, l'entrée de la méthode correspondante a été déterminée.
Depuis lors, bien que a ait été téléchargé en tant que classe A, la méthode remplacée f() est toujours la méthode f() de B. Autrement dit, chaque objet sait quelle méthode il doit appeler.
A a1 = nouveau B();
A a2 = nouveau C();
Bien que a1 et a2 soient tous deux des objets de classe A, leurs f() respectifs sont différents. C’est exactement l’incarnation du polymorphisme évoqué au premier étage.
Ces problèmes sont expliqués très clairement dans "Réflexions sur la programmation Java".
Implements implémente généralement l’interface. extends est une classe héritée. Les interfaces n'ont généralement que des déclarations de méthodes mais pas de définitions, il est donc logique que Java souligne spécifiquement l'implémentation des interfaces, car l'héritage signifie que la classe parent a implémenté des méthodes, tandis que les interfaces n'implémentent pas leurs propres méthodes, seulement des déclarations, c'est-à-dire Un en-tête de méthode n’a pas de corps de méthode. Par conséquent, vous pouvez comprendre qu’une interface est une sous-classe qui implémente ses déclarations de méthode plutôt que d’hériter de ses méthodes. Mais les méthodes de classe générales peuvent avoir des corps de méthode, il est donc plus raisonnable de les appeler héritage. L'importation d'un package peut utiliser toutes les classes implémentées qui n'y sont pas des interfaces. Ensuite, vous décidez si vous souhaitez ou non implémenter l'interface. Si vous souhaitez l'utiliser, vous ne pouvez pas appeler l'interface sans l'implémenter, car l'interface est une spécification, une collection de déclarations de méthode sans corps de méthode. Laissez-moi vous donner un exemple : une interface peut être comparée à un protocole. Par exemple, si je dis qu'un protocole « tue », alors vous pouvez utiliser une machette pour implémenter cette interface. Quant à la façon de tuer, la machette peut l'implémenter. Bien sûr, vous pouvez également utiliser grab pour implémenter l'interface de mise à mort, mais vous ne pouvez pas utiliser l'interface de mise à mort pour tuer des personnes, car l'interface de mise à mort n'est qu'une description de fonction et un protocole. La façon de le faire dépend de sa classe d'implémentation. . Donc, s'il y a une interface dans un package, vous n'êtes pas obligé de l'implémenter. Cela n'affecte pas votre utilisation des autres classes.
met en œuvre
Implements est un mot-clé utilisé par une classe pour implémenter une interface. Il est utilisé pour implémenter les méthodes abstraites définies dans l'interface. Par exemple : people est une interface, et elle a la méthode say. public interface people(){ public say();} Mais l'interface n'a pas de corps de méthode. Le corps de la méthode ne peut être implémenté que via une classe spécifique. Par exemple, la classe chinoise implémente l’interface people. public class Chinese implémente people{ public say() {System.out.println("Bonjour !");}}
En Java, implémente signifie que la sous-classe hérite de la classe parent. Par exemple, la classe A hérite de la classe B et est écrite comme la classe A implémente B{}.
Différence avec les extensions
extends, vous pouvez implémenter la classe parent ou appeler la classe parent pour initialiser this.parent(). Et cela écrasera les variables ou fonctions définies par la classe parent. L’avantage est que l’architecte peut définir l’interface et laisser l’ingénieur la mettre en œuvre. L'efficacité globale du développement du projet et les coûts de développement sont considérablement réduits.
implémente, implémente la classe parent et les sous-classes ne peuvent pas remplacer les méthodes ou les variables de la classe parent. Même si la sous-classe définit les mêmes variables ou fonctions que la classe parent, elles seront remplacées par la classe parent.
L'utilisation spécifique de ces deux implémentations dépend de la situation réelle du projet et doit être implémentée. Seule l'interface définie doit être implémentée spécifiquement, ou elle peut être modifiée pour avoir une bonne évolutivité.
<!--[endif]-->