[JAVA] Exemple d'utilisation de l'interface

introduction

Ceci est une version d'interface de Exemple d'utilisation d'une classe abstraite. Je connais la signification et la définition de l'interface, mais quand l'utiliser et quelles bonnes choses y a-t-il? Voici un exemple.

Conclusion soudaine. Ce sera fort contre le remodelage.

Identique à la classe abstraite / généralisation / héritage, il résiste à la modification. Voici un exemple d'une autre demande de modification pour le programme introduit dans Exemple d'utilisation de la classe abstraite.

Programme à modifier

Tout d'abord, passons en revue le programme introduit dans Exemple d'utilisation d'une classe abstraite.

Un programme qui gère les imprimantes, qui gère initialement les imprimantes à jet d'encre et les imprimantes laser et affiche une liste d'informations sur les imprimantes. Il y avait un besoin de remodelage pour ajouter une imprimante à impact de points comme imprimante gérable, donc j'ai créé un programme qui est fort contre le remodelage par abstraction (généralisation / héritage).

Structure de classe:

Il généralise les variables membres mModelName (nom du modèle) et mPaper (quantité de papier restante) et fait abstraction de la fonction getPrinterInfo () qui renvoie des informations sur l'imprimante.

Nouvelles exigences de rénovation

Cette fois, supposons qu'il existe une exigence supplémentaire "d'ajouter une imprimante 3D au type d'imprimante à gérer et d'afficher également les informations de l'imprimante".

Il n'y a rien que vous ne pouvez pas faire en héritant de AbstractPrinter comme lorsque vous avez ajouté une imprimante à impact par points, mais comme les imprimantes 3D n'impriment pas sur papier, mPaper (quantité de papier restante) n'est pas nécessaire. Les variables membres inutilisées ne doivent pas interférer avec la maintenance du programme.

Alors pourquoi ne pas créer une classe d'imprimantes 3D indépendante? Ensuite, il devient redondant comme un programme qui n'utilise pas la classe abstraite dans Exemple d'utilisation de la classe abstraite.

Alors que dois-je faire? Résolvons-le avec l'interface.

Essayez de modifier en utilisant l'interface

Commencez par créer l'interface.

//
//Interface d'imprimante
//
interface IPrinter{
    
    //Renvoie les informations de l'imprimante de la liste
    String getPrinterInfo();
}

Créez une classe d'imprimante 3D qui implémente l'interface d'imprimante IPrinter.

//
//Imprimante 3D
//
class ThreeDPrinter implements IPrinter{

    //Capacité du materiau
    private int mMaterial;
    
    //constructeur
    public ThreeDPrinter(int material){
        mMaterial = material;
    }
    
    //Méthode de renvoi des informations sur l'imprimante pour l'affichage de la liste
    public String getPrinterInfo(){
        
        return "[3D]Imprimante 3D en développement" + "Capacité imprimable:" + mMaterial + "litre";
    }
}

Implémentez également l'interface d'imprimante IPrinter dans la classe AbstractPrinter.

//
//Classe abstraite d'imprimante
//
abstract class AbstractPrinter implements IPrinter{
    //Abréviation
}

Modifiez le type de matrice qui stocke les imprimantes à gérer de AbstractPrinter à IPrinter.

    public static void main(String[] args) throws Exception {

        //Enregistrez l'imprimante à gérer.
        IPrinter[] printers = {
            new InkjetPrinter("Epson P1", 10),
            new InkjetPrinter("Canon C1", 20),
            new LaserPrinter("Xerox X1", 100),
            new LaserPrinter("Richo R1", 50),
            new LaserPrinter("Richo R2", 200),
            new DotimpactPrinter("NEC N1", 100),
            new DotimpactPrinter("Oki O1", 50),
            new ThreeDPrinter(5),
        };
        
        //Répertoriez les imprimantes gérées.
        for(int i = 0; i < printers.length; i++ ){
            String printerInfo = printers[i].getPrinterInfo();
            System.out.println(printerInfo);
        }
    }

seulement ça. Lançons-le.

Résultat d'exécution

[Jet d'encre]Epson P1 Nombre de feuilles imprimables: 10
[Jet d'encre]Numéro imprimable Canon C1: 20
[laser]Xerox X1 Nombre de feuilles imprimables: 100
[laser]Ricoh R1 Nombre de feuilles imprimables: 50
[laser]Richo R2 Nombre de feuilles imprimables: 200
[Impact de points]NEC N1 Nombre de feuilles imprimables: 100
[Impact de points]Oki O1 Nombre de feuilles imprimables: 50
[3D]Imprimante 3D en cours de développement Capacité imprimable: 5 litres

C'est fait! Comme pour Exemple d'utilisation d'une classe abstraite, le nombre de variables à gérer n'a pas augmenté et le processus d'affichage n'a pas été modifié. https://paiza.io/projects/wSSYJVnwbZfsI0vXHrsGjg

Structure de classe:

Résumé

L'interface est également un type. Il peut donc être utilisé comme type de variable. ** Une variable de type d'interface peut contenir des objets de la classe qui implémente cette interface. ** **

//Enregistrez l'imprimante à gérer.
IPrinter[] printers = {
    new InkjetPrinter("Epson P1", 10),
    //Abréviation
    new ThreeDPrinter(5),
};

La classe ThreeDPrinter et chaque classe dérivée de AbstractPrinter implémentent l'interface IPrinter, vous pouvez donc stocker cet objet dans une variable de type IPrinter. Et la variable de type IPrinter qui définit la fonction getPrinterInfo () peut être appelée car il est certain qu'elle implémente la fonction getPrinterInfo (), bien que je ne connaisse pas les détails des objets qu'elle contient. Je vais.

//Répertoriez les imprimantes gérées.
for(int i = 0; i < printers.length; i++ ){
    // printers[i]Je ne sais pas ce qu'il y a dedans
    // printers[i]Est un type IPrinter
    // getPrinterInfo()Est mis en œuvre pour que vous puissiez l'appeler.
    String printerInfo = printers[i].getPrinterInfo();
    System.out.println(printerInfo);
}