1. Interface

1.1 Aperçu des interfaces

Une interface est une collection de fonctions. Elle peut aussi être considérée comme un type de données, et elle est plus abstraite qu'une classe abstraite.Class 。

Une interface décrit uniquement les méthodes qu'elle doit avoir, sans implémentation concrète. L'implémentation concrète est réalisée par la classe d'implémentation de l'interface (équivalente à une sous-classe de l'interface). Cela sépare la définition de la fonctionnalité de son implémentation, ce qui optimise la conception du programme.

1.2 Format et utilisation des interfaces

1.2.1 Format d'une interface

Contrairement à la définition d'une classe,classla différence est que, lors de la définition d'une interface, il faut utiliser le mot-cléinterface.

Le fichier dans lequel l'interface est définie est toujours un fichier.java. Bien que la déclaration utilise le mot-cléinterface, après compilation, il produit toujours un fichier.classfichier. Cela nous permet de considérer une interface comme une classe spéciale qui ne contient que des déclarations de fonctionnalités.

Format de définition :
public interface 接口名 {
    抽象方法1;
    抽象方法2;
    抽象方法3;
}

1.2.2 Utilisation des interfaces

Toutes les méthodes d'une interface sont des méthodes abstraites. Utiliser directement `new` sur une interface pour appeler des méthodes n'a pas de sens, et Java ne l'autorise pas.

La relation entre une classe et une interface est une relation d'implémentation, c'est-à-dire qu'une classe implémente une interface. L'action d'implémentation est similaire à l'héritage, mais le mot-clé est différent ; l'implémentation utiliseimplements。

Après que d'autres classes (classes d'implémentation) implémentent une interface, cela équivaut à déclarer :"Je dois avoir la fonctionnalité de cette interface."La classe d'implémentation doit encore redéfinir les méthodes pour implémenter la fonctionnalité spécifique.

Format :

class 类 implements 接口 {
    重写接口中方法
}

Après qu'une classe implémente une interface, la classe hérite des méthodes abstraites de l'interface. À ce stade, la classe doit redéfinir ces méthodes abstraites pour compléter la logique concrète.

1.2.3 Code du cas 1

Exemple

/** L'héritage en Java est un héritage simple ; une sous-classe ne peut avoir qu'une seule classe parente (un fils ne peut avoir qu'un seul père biologique). * Java nous fournit un mécanisme pour gérer la limitation de l'héritage simple : les interfaces. * * Interface : Une interface est une classe encore plus abstraite qu'une classe abstraite. Toutes les méthodes d'une interface sont des méthodes abstraites. La relation entre une interface et une classe est une implémentation, en utilisant implements. * interface * * Format : * interface InterfaceName { * * } **/ public class InterfaceDemo { public static void main(String[] args) { BillGates gates = new BillGates(); gates.code(); } } class Boss { public void manage() { System.out.println("Gérer l'entreprise"); } } class Programmer { public void code() { System.out.println("Écrire du code"); } } //Bill Gates class BillGates extends Programmer { }

1.3 Caractéristiques des membres d'une interface

  • 1. Les variables peuvent être définies dans une interface, mais elles doivent être modifiées avec des modificateurs fixes : `public static final`. Par conséquent, les variables dans une interface sont aussi appelées constantes, et leurs valeurs ne peuvent pas être modifiées. Nous expliquerons le mot-clé `final` plus tard.

  • 2. Des méthodes peuvent être définies dans une interface, et les méthodes ont également des modificateurs fixes : `public abstract`.

  • 3. Une interface ne peut pas créer d'objets.

  • 4. Une sous-classe doit redéfinir toutes les méthodes abstraites de l'interface avant de pouvoir être instanciée. Sinon, la sous-classe est une classe abstraite.

1.3.1 Code d'exemple 2

Exemple

/** Caractéristiques des membres d'une interface : * Ne peut avoir que des méthodes abstraites * Ne peut avoir que des constantes * Les méthodes sont modifiées avec public & abstract par défaut * Les méthodes ne peuvent être modifiées qu'avec public & abstract * Les variables membres sont modifiées avec public static final par défaut * * Suggestion : Il est recommandé d'ajouter manuellement les modificateurs par défaut. * * Remarque : * Une interface ne peut pas créer d'objets (ne peut pas être instanciée) * La relation entre une classe et une interface est une implémentation. Une classe qui implémente une interface doit implémenter toutes ses méthodes.*/ public class InterfaceDemo2 { public static void main(String[] args) { //Animal a = new Animal(); //Animal.num; } } interface Animal { public static final int num = 10; public abstract void eat(); } class Cat implements Animal { public void eat() { } }

1.4 Relation entre les interfaces et les classes

  • A : Entre les classes : relation d'héritage. Une classe ne peut hériter directement que d'une seule classe parente, mais prend en charge l'héritage à plusieurs niveaux.
  • B : Entre les classes et les interfaces : relation d'implémentation uniquement. Une classe peut implémenter plusieurs interfaces.
  • C : Entre les interfaces : relation d'héritage uniquement. Une interface peut hériter de plusieurs interfaces.

1.4.1 Exemple de code 3

Exemple

/** * Classe vs. Classe : relation d'héritage, héritage simple, héritage à plusieurs niveaux * Classe vs. Interface : relation d'implémentation, implémentation multiple * Interface vs. Interface : relation d'héritage, héritage multiple*/ public class InterfaceDemo3 { public static void main(String[] args) { } } interface InterA extends InterB { public abstract void method(); } interface InterB { public abstract void function(); } interface InterC extends InterA { } class Demo implements InterC { @Override public void method() { // TODO Auto-generated method stub } @Override public void function() { // TODO Auto-generated method stub } }

1.5 L'idée des interfaces

Précédemment, nous avons appris la représentation du code des interfaces. Maintenant, apprenons l'idée derrière les interfaces, puis expliquons avec des exemples de la vie quotidienne.

Par exemple: Nous savons tous qu'un ordinateur possède de nombreux ports, et que des périphériques correspondants peuvent y être branchés. Pourquoi ces appareils peuvent-ils être branchés ? La raison principale est que ces appareils respectaient les règles d'utilisation du port lors de leur fabrication ; sinon, ils ne pourraient pas être branchés au port, encore moins être utilisés. Il s'avère que l'existence de ces ports nous permet d'utiliser davantage d'appareils.

L'émergence des interfaces facilite l'utilisation et la maintenance ultérieures. D'un côté, on utilise l'interface (comme un ordinateur), et de l'autre, on implémente l'interface (les appareils branchés sur le port). Par exemple, un ordinateur portable utilise cette règle (interface), et les périphériques d'ordinateur implémentent cette règle (interface).

Les interfaces sont largement utilisées dans le framework des collections :

Collection 接口

    List 接口

       ArrayList 实现类

       LinkedList 实现类

    Set 接口

1.6 Avantages des interfaces

  • 1. La relation entre une classe et une interface est une implémentation, et il s'agit d'une implémentation multiple. Une classe peut implémenter plusieurs interfaces. La relation entre les classes est l'héritage. L'héritage en Java est un héritage simple ; une classe ne peut avoir qu'une seule classe parente. Cela lève la limitation de l'héritage.
  • 2. Fournir des règles au monde extérieur (interface USB).
  • 3. Réduire le couplage du programme (il permet le développement modulaire ; une fois les règles définies, chacun implémente son propre module, ce qui améliore l'efficacité du développement).

1.7 Différences entre les interfaces et les classes abstraites

1. Points communs :Toutes deux extraient continuellement des méthodes qui sont abstraites et sans implémentation concrète, et aucune des deux ne peut être instanciée (on ne peut pas créer d'objets).

2. Différences

1 : Relation avec les classes

(1) La relation entre une classe et une interface est une implémentation, et il s'agit d'une implémentation multiple ; une classe peut implémenter plusieurs interfaces. La relation entre une classe et une classe abstraite est l'héritage. L'héritage en Java est un héritage simple et un héritage à plusieurs niveaux ; une classe ne peut hériter que d'une seule classe parente, mais elle peut avoir une classe grand-parent.

(2) Différence 2 : Membres

a.成员变量
    抽象类可以有成员变量，也可以有常量
    接口只能有常量，默认修饰符public static final

b.成员方法
    抽象类可以有抽象方法，也可以有非抽象方法
    接口只能有抽象方法，默认修饰符 public abstract

c.构造方法
    抽象类有构造方法，为子类提供
    接口没有构造方法

1.8 Étude de cas : athlète

1.8.1 Code du cas 4

Exemple

/** Joueurs de basket-ball et entraîneurs Joueurs de tennis de table et entraîneurs Maintenant, les joueurs de basket-ball et les entraîneurs vont à l'étranger pour une visite et doivent apprendre l'anglais. Veuillez utiliser ce que vous avez appris pour analyser quelles sont les classes, quelles sont les classes abstraites et quelles sont les interfaces.*/ public class InterfaceTest { public static void main(String[] args) { //Créer un objet joueur de basket-ball BasketBallPlayer bbp = new BasketBallPlayer(); bbp.name = "Yao Ming"; bbp.age = 35; bbp.gender = "Male"; bbp.sleep(); bbp.study(); bbp.speak(); System.out.println("-------------"); //Créer un objet entraîneur de tennis de table PingpangCoach ppc = new PingpangCoach(); ppc.name = "Fatty Liu"; ppc.age = 40; ppc.gender = "Male"; ppc.sleep(); ppc.teach(); //ppc.speak(); } } class Person { String name;//Nom int age;//Âge String gender;//Genre //Constructeur sans argument public Person() {} //Constructeur paramétré public Person(String name,int age,String gender) { this.name = name; this.age = age; this.gender = gender; } //eat public void eat() { System.out.println("Manger"); } //sleep public void sleep() { System.out.println("Dormir"); } } //Apprendre à parler anglais interface SpeakEnglish { public abstract void speak(); } //Athlete abstract class Player extends Person { //Learn public abstract void study(); } //Coach abstract class Coach extends Person { //Teach public abstract void teach(); } //Joueur de basket-ball class BasketBallPlayer extends Player implements SpeakEnglish{ @Override public void study() { System.out.println("Apprendre à dunker"); } @Override public void speak() { System.out.println("Parler anglais"); } } //Joueur de tennis de table class PingpangPlayer extends Player { @Override public void study() { System.out.println("Apprendre à smasher"); } } //Entraîneur de basket-ball class BasketBallCoach extends Coach implements SpeakEnglish { @Override public void teach() { System.out.println("Enseigner le dunk"); } @Override public void speak() { System.out.println("Parler anglais"); } } //Entraîneur de tennis de table class PingpangCoach extends Coach { @Override public void teach() { System.out.println("Enseigner le smash"); } }

2. Polymorphisme

2.1 Aperçu du polymorphisme

Le polymorphisme est la troisième caractéristique majeure de la programmation orientée objet, après l'encapsulation et l'héritage.

Dans le monde réel, les choses présentent souvent plusieurs formes. Par exemple, un étudiant est un type de personne. Un étudiant spécifique, Zhang San, est à la fois un étudiant et une personne, présentant ainsi deux formes.

Java, en tant que langage orienté objet, peut également décrire plusieurs formes d'une même chose. Par exemple, si la classe Student hérite de la classe Person, alors un objet Student est à la fois un Student et un Person.

2.2 Définition et format d'utilisation du polymorphisme

Le format de définition du polymorphisme : en fait, il s'agit d'une variable de référence de la classe parente qui pointe vers un objet de la classe enfant.

父类类型  变量名 = new 子类类型();
变量名.方法名();

A : Format pour le polymorphisme avec des classes ordinaires

父类 变量名 = new 子类();

Comme :

class Fu {}
class Zi extends Fu {}
//类的多态使用
Fu f = new Zi();

B : Format pour le polymorphisme avec des classes abstraites

抽象类 变量名 = new 抽象类子类();

Comme :

abstract class Fu {
    public abstract void method();
}
class Zi extends Fu {
    public void method(){
        System.out.println(“重写父类抽象方法”);
    }
}
//类的多态使用
Fu fu= new Zi();

C : Format pour le polymorphisme avec des interfaces

接口 变量名 = new 接口实现类();

Comme :

interface Fu {
    public abstract void method();
}
class Zi implements Fu {
    public void method(){
        System.out.println(“重写接口抽象方法”);
    }
}
//接口的多态使用
Fu fu = new Zi();

2.2.1 Code du cas

Exemple

/** Prérequis pour le polymorphisme : * Relation d'héritage entre les classes enfant et parente * Redéfinition de méthode * La référence de la classe parente pointe vers un objet de la classe enfant * * Liaison dynamique : la méthode appelée pendant l'exécution est basée sur son type spécifique*/ public class PoymorphicDemo { public static void main(String[] args) { /*Cat c = new Cat(); c.eat();*/ //Référence de la classe parente Animal a //Pointe vers = //Subclass object new Cat() Animal a = new Cat(); a.eat(); } } class Animal { public void eat() { System.out.println("Eating"); } } class Cat extends Animal { public void eat() { System.out.println("Le chat mange du poisson"); } }

2.3 Caractéristiques des membres polymorphes

A : Variables membres polymorphes

Lorsqu'une variable membre portant le même nom apparaît à la fois dans la classe parente et dans la classe enfant, et que le polymorphisme appelle cette variable :

  • Au moment de la compilation : il vérifie si la classe à laquelle appartient la variable de référence contient la variable membre appelée. Si ce n'est pas le cas, la compilation échoue.
  • À l'exécution : il appelle également la variable membre de la classe à laquelle appartient la variable de référence.

Moyen mnémotechnique simple : la compilation et l'exécution font toutes deux référence au côté gauche du signe égal. La compilation et l'exécution regardent toutes les deux à gauche.

B : Méthodes membres polymorphes

  • Au moment de la compilation : on se réfère à la classe à laquelle appartient la variable de référence ; si la classe ne possède pas la méthode appelée, la compilation échoue.
  • À l'exécution : se référer à la classe à laquelle appartient l'objet pointé par la variable de référence, et exécuter la méthode membre de la classe à laquelle appartient l'objet.

En bref : la compilation regarde à gauche, l'exécution regarde à droite.

2.3.1 Cas de code six

Exemple

/** * Caractéristiques des membres polymorphes : * Variables membres la compilation regarde à gauche, l'exécution regarde à gauche * Méthodes membres la compilation regarde à gauche, l'exécution regarde à droite * Méthodes statiques la compilation regarde à gauche, l'exécution regarde aussi à gauche * * * Au moment de la compilation, tout regarde à gauche ; à l'exécution, les méthodes membres regardent à droite, tandis que les autres (variables membres et méthodes statiques) regardent toutes à gauche **/ public class PoymorphicDemo2 { public static void main(String[] args) { Dad d = new Kid(); //System.out.println(d.num); //d.method(); d.function();//Utiliser une variable pour appeler une méthode statique équivaut en fait à l'appeler avec le nom de la classe du type de la variable. } } class Dad { int num = 20; public void method() { System.out.println("Je suis la méthode de la classe parente"); } public static void function() { System.out.println("Je suis la méthode statique de la classe parente"); } } class Kid extends Dad { int num = 10; public void method() { System.out.println("Je suis la méthode de la classe enfant"); } public static void function() { System.out.println("Je suis la méthode statique de la classe enfant"); } }

2.4 Upcasting et Downcasting dans le polymorphisme

Le transtypage dans le polymorphisme est divisé en deux types : upcasting et downcasting :

A : Upcasting : lorsqu'un objet de sous-classe est affecté à une référence de classe parente, il s'agit d'un upcasting. Le polymorphisme lui-même est le processus d'upcasting.

Format d'utilisation :

父类类型  变量名 = new 子类类型();

Par exemple :

Person p = new Student();

B : Downcasting : un objet de sous-classe qui a déjà subi un upcasting peut utiliser le format de conversion de type forcée pour convertir une référence de classe parente en une référence de sous-classe. Ce processus est le downcasting. Si un objet de classe parente est créé directement, il ne peut pas subir de downcasting.

Format d'utilisation :

Subclass type variable name = (Subclass type) Parent class type variable;

Par exemple :

Student stu = (Student) p;  // 变量p 实际上指向 Student 对象

Exemple

/** * Upcasting et downcasting dans le polymorphisme : * * Conversion entre types de référence * Upcasting * De petit à grand (sous-type converti en type parent) * Downcasting * De grand à petit * Conversion des types de données de base * Conversion de type automatique * De petit à grand * byte short char --- int --- long --- float --- double * Conversion de type forcée * De grand à petit * * **/ public class PoymorphicDemo3 { public static void main(String[] args) { Animal2 a = new Dog();//Transtypage vers le haut //a.eat(); Dog d = (Dog)a;//Transtypage vers le bas d.swim(); } } class Animal2 { public void eat() { System.out.println("Eating"); } } class Dog extends Animal2 { public void eat() { System.out.println("Ronge des os"); } public void swim() { System.out.println("Nage du chien"); } }

2.5 Avantages et inconvénients du polymorphisme

Exemple

/** * Avantages et inconvénients du polymorphisme * Avantages : cela peut améliorer la maintenabilité (garantie par les prérequis du polymorphisme) et améliorer l'extensibilité du code Inconvénients : il ne peut pas accéder directement aux membres spécifiques de la sous-classe*/ public class PoymorphicDemo4 { public static void main(String[] args) { MiFactory factory = new MiFactory(); factory.createPhone(new MiNote()); fabrique.createPhone(new RedMi()); } } class MiFactory { /*public void createPhone(MiNote mi) { mi.call(); } public void createPhone(RedMi mi) { mi.call(); }*/ public void createPhone(Phone p) { p.call(); } } interface Phone { public void call(); } //Xiaomi Note class MiNote implements Phone{ public void call() { System.out.println("Xiaomi Note passe un appel"); } } //Redmi class RedMi implements Phone { public void call() { System.out.println("Redmi passe un appel"); } }

Adresse d'origine : https://www.cnblogs.com/yoke/p/7453864.html