[JAVA] Exemple d'utilisation d'une classe abstraite

introduction

Je connais la signification et la définition des classes abstraites, mais quand les utiliser et quelles bonnes choses y a-t-il? Comparons le programme implémenté avec la classe abstraite avec le programme implémenté sans elle pour confirmer la même exigence.

Programme JAVA

Supposons qu'il existe deux types d'imprimantes: jet d'encre et laser. Créez un programme qui en gère plusieurs et affiche une liste des informations sur l'imprimante gérée.

Programmes qui n'utilisent pas de classes abstraites

https://paiza.io/projects/Iwnh9NgDAaxPSZC36uZqsw

Structure de classe:

Il n'y a que des classes InkjetPrinter et LaserPrinter. Chacun a un nom de modèle (mModelName) et le nombre restant de feuilles (mPaper) en tant que variables membres. Il possède également une fonction getPrinterInfo () qui renvoie des informations sur l'imprimante.

La différence est que InkjetPrinter a la quantité d'encre restante (mRemainingInk) et LaserPrinter a la quantité restante de toner (mRemainingToner).

Programme utilisant une classe abstraite

https://paiza.io/projects/Xs-iNK2-SYDnlYIp1oWF3w

Structure de classe:

Nous avons créé une classe abstraite AbstractPrinter en généralisant les parties communes de la classe InkjetPrinter et de la classe LaserPrinter (nom de modèle de variable membre, quantité de papier restante et fonction qui renvoie les informations de l'imprimante). Les classes InkjetPrinter et LaserPrinter héritent de AbstractPrinter.

• Du point de vue de "l'abstraction", la classe InkjetPrinter et la classe LaserPrinter sont abstraites comme une imprimante qui a le nom du modèle et la quantité de papier restante et renvoie les informations de l'imprimante. *

Résultat d'exécution

Les deux produisent le même résultat.

Résultat de sortie

[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

Quelle est la différence

Je peux vous donner deux points.

Tout d'abord, la structure des classes. Une classe indépendante et une classe abstraite. Le concept de classes abstraites est expliqué en détail dans des livres et des sites qui expliquent l'orientation des objets, je vais donc l'omettre ici.

L'autre point est de savoir comment l'utiliser du côté de la gestion. Regardons cela de plus près.

Lorsque vous n'utilisez pas de classes abstraites

Principal lorsque vous n'utilisez pas de classes abstraites()

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

        //Enregistrez l'imprimante à jet d'encre à gérer.
        InkjetPrinter[] inkjets = {
            new InkjetPrinter("Epson P1", 10),
            new InkjetPrinter("Canon C1", 20),
        };
        
        //Enregistrez l'imprimante laser à gérer.
        LaserPrinter[] lasers = {
            new LaserPrinter("Xerox X1", 100),
            new LaserPrinter("Richo R1", 50),
            new LaserPrinter("Richo R2", 200),
        };
        
        //Répertoriez les imprimantes gérées.
        //Tout d'abord, l'imprimante à jet d'encre.
        for(int i = 0; i < inkjets.length; i++ ){
            System.out.println(inkjets[i].getPrinterInfo());
        }
        
        //Ensuite, une imprimante laser.
        for(int i = 0; i < lasers.length; i++ ){
            System.out.println(lasers[i].getPrinterInfo());
        }
    }

Il n'existe aucune relation entre la classe InkjetPrinter et la classe LaserPrinter, chacune étant un «type» indépendant.

** Les objets de la classe InkjetPrinter ne peuvent être stockés que dans des variables de type InkjetPrinter, et les objets de la classe LaserPrinter ne peuvent être stockés que dans des variables de type LaserPrinter. ** **

Par conséquent, une variable de type pour chaque type d'imprimante (dans ce cas, un tableau) est préparée, l'objet imprimante est stocké et la liste d'imprimantes est sortie en bouclant chacune d'elles.

Lors de l'utilisation d'une classe abstraite

Principal lors de l'utilisation de classes abstraites()

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

        //Enregistrez l'imprimante à gérer.
        AbstractPrinter[] 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),
        };
        
        //Répertoriez les imprimantes gérées.
        for(int i = 0; i < printers.length; i++ ){
            System.out.println(printers[i].getPrinterInfo());
        }
    }

La classe InkjetPrinter et la classe LaserPrinter sont dérivées de la classe "AbstractPrinter" qui est une abstraction de "imprimante". La classe AbstractPrinter est une classe parente commune.

** Les variables peuvent stocker des objets de ce type et des objets dérivés de ce type. ** **

Par conséquent, la variable de type AbstractPrinter peut stocker l'objet de classe InkjetPrinter et l'objet de classe LaserPrinter, et les objets contenus dans cette variable peuvent être traités comme la classe AbstractPrinter.

En conséquence, les variables qui gèrent l'imprimante sont devenues une, et le traitement pour l'affichage est également devenu un.

Quelles bonnes choses y a-t-il

En introduisant la classe abstraite, les variables gérées et le traitement d'affichage sont devenus plus intelligents. Cela seul est bon, mais il y a de très bonnes choses telles que des améliorations qui vous rendent «résistant aux changements».

Disons que vous avez une exigence de modification pour ajouter une imprimante à impact de points à votre type d'imprimante.

Si vous n'utilisez pas de classes abstraites, la source est: C'est la ligne ajoutée par le processus qui a commenté "★ Ajouter ★".

Lorsque vous n'utilisez pas de classes abstraites

Structure de classe:

Principal lorsque vous n'utilisez pas de classes abstraites()

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

        //Enregistrez l'imprimante à jet d'encre à gérer.
        InkjetPrinter[] inkjets = {
            new InkjetPrinter("Epson P1", 10),
            new InkjetPrinter("Canon C1", 20),
        };
        
        //Enregistrez l'imprimante laser à gérer.
        LaserPrinter[] lasers = {
            new LaserPrinter("Xerox X1", 100),
            new LaserPrinter("Richo R1", 50),
            new LaserPrinter("Richo R2", 200),
        };
        
        //★ Ajout ★
        //Enregistrez l'imprimante à impact de points à gérer.
        DotimpactPrinter[] dotimpacts = {
            new DotimpactPrinter("NEC N1", 100),
            new DotimpactPrinter("Oki O1", 50),
        };

        //Répertoriez les imprimantes gérées.
        //Tout d'abord, l'imprimante à jet d'encre.
        for(int i = 0; i < inkjets.length; i++ ){
            System.out.println(inkjets[i].getPrinterInfo());
        }
        
        //Ensuite, une imprimante laser.
        for(int i = 0; i < lasers.length; i++ ){
            System.out.println(lasers[i].getPrinterInfo());
        }

        //★ Ajout ★
        //Vient ensuite l'imprimante à impact par points.
        for(int i = 0; i < dotimpacts.length; i++ ){
            System.out.println(dotimpacts[i].getPrinterInfo());
        }
    }

• Toutes les sources: https://paiza.io/projects/VL2hoWh-eWKiHF0lha_rXg *

Lors de l'utilisation d'une classe abstraite

Structure de classe:

Principal lors de l'utilisation de classes abstraites()

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

        //Enregistrez l'imprimante à gérer.
        AbstractPrinter[] 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), //★ Ajout ★
            new DotimpactPrinter("Oki O1", 50),  //★ Ajout ★
        };
        
        //Répertoriez les imprimantes gérées.
        for(int i = 0; i < printers.length; i++ ){
            System.out.println(printers[i].getPrinterInfo());
        }
    }

• Toutes les sources: https://paiza.io/projects/UHysfz9Nx6LPENUOuTnY6w *

Pour ceux qui n'utilisent pas de classes abstraites, nous avons ajouté des variables qui gèrent les imprimantes à impact de points et le traitement en boucle qui les affiche. Un traitement similaire a augmenté. C'est redondant.

D'autre part, ceux qui ont utilisé la classe abstraite n'ont ajouté que l'objet d'imprimante à impact point à la variable imprimantes qui gère l'imprimante, et il n'y a eu aucun changement dans le processus d'affichage. La quantité de modification du programme est faible.

Résumé

En fait, cet avantage n'est pas l'effet de la classe abstraite, mais l'avantage de la généralisation / héritage de la classe. Utiliser une classe abstraite signifie abstraction + généralisation / héritage, vous pouvez donc bénéficier de la généralisation / héritage.