À partir de maintenant, je publierai ce que j'ai appris sur Qiita pour améliorer mes compétences. Cette fois, je parlerai du polymorphisme Java. Puisque Java et Qiita sont tous deux des débutants super qualifiés, il peut y avoir des erreurs. Ce serait utile si vous pouviez me le dire à ce moment-là.
Cet article utilise Java 11.0.6 installé sur Windows.
C'est une fonction qui facilite le développement en saisissant l'objet grossièrement. Par exemple, «roses», «tournesols» et «tulipes» sont ** en détail **, bien qu'ils soient cultivés différemment, ils ont tous le même point de floraison lorsque l'eau est donnée. Par conséquent, nous avons une ** façon approximative de penser ** ces trois types comme des «fleurs», et si nous savons que ce sont des «fleurs», nous les arroserons pour le moment. C'est du ** polymorphisme ** que cette façon de penser est également utilisée dans les programmes.
Il n'y a pas de manière spéciale de l'écrire, écrivez simplement le devoir.
Assignment.java
int num1 = 100;
int num2 = 200;
num1 = num2;
String str = "Polymorphisme";
Il s'agit de mettre des variables et des littéraux dans des variables.
Quand je l'écris, ça ressemble à ça.
Tataisei.java
Flower f2 = new Rose();
Il existe une classe appelée Rose dans le type de classe appelé Flower. En d'autres termes, il y a une instance Rose dans la boîte à fleurs. ** En détail, c'est ** Rose, mais ** En gros, ** Ne pensez pas à cela comme à une fleur.
Voici un exemple où le polymorphisme n'est pas utilisé correctement.
Tataisei.java
Flower f2 = new Doctor();
Rose f3 = new Flower();
Regardez d'abord la première ligne. Il est étrange que la boîte à fleurs contienne une instance Doctor. Le médecin n'est pas une fleur. Pour la deuxième ligne de code, le nom de la classe a été inversé. On dit que cette boîte contient Rose, et quand je regarde le contenu, on dirait qu'il y a une chose abstraite appelée Fleur.
L'astuce pour utiliser correctement le polymorphisme est de voir s'il a une relation «est-un». Voyons s'il dit "Le nom de classe de l'instance créée est un nom de classe de variable". Dans ce cas, "Rose est une fleur" est la relation correcte.
Le polymorphisme nous a permis d'avoir une idée approximative de l'instance. Si vous utilisez ceci, chacun des «rose», «tournesol» et «tulipe» sera instruit (méthode) à 8 heures du matin, si de l'eau est donnée, elle sera absorbée et les fleurs fleuriront. ), Mais si vous indiquez l'une des choses grossières appelées «fleurs», les instances qu'il contient joueront ** leurs rôles respectifs **.
D'un autre côté, si vous prenez cela comme une idée approximative, les problèmes suivants se poseront. Regardez les deux codes ci-dessous.
Flower.java
public abstract class Flower {
String name;
String color;
public void bloom() {
System.out.println("this.name + "Est" + this.color + "Fleuri en couleur");
}
}
Rose.java
public class Rose extends Flower {
int thron;
public void cutThorn() {
System.out.println(this.name + "Les épines" + this.thron + "Couper en morceaux");
}
La rose est fondamentalement la même que la classe Flower, mais elle a quelques épines. Par conséquent, en utilisant étend comme code, il hérite de Flower, et ses propres épines et méthodes caractéristiques sont écrites. En tant qu'image, le type de boîte est Flower et il semble que Rose y soit. Si vous instanciez Rose, bien sûr, vous devriez pouvoir utiliser la méthode cutThron (). Utilisons-le réellement.
Main.java
Rose r = new Rose();
Flower f = r;
f.bloom();
f.cutThron();
… En fait, avec ce code, tout va bien jusqu'à la 3ème ligne, mais une erreur de compilation se produit sur la 4ème ligne. Il est étrange que vous ayez créé une instance Rose. ..
La cause en est la première ligne utilisant le polymorphisme. Après tout, l'ordinateur sait seulement que ** une sorte de fleur se trouve dans une boîte appelée Fleur **. Si vous le mettez dans une boîte, vous ne pouvez pas voir le contenu.
En d'autres termes, puisque la classe Flower a à l'origine une méthode bloom ();, il peut être déterminé à partir de l'ordinateur que bloom () ne peut pas être utilisé pour le moment car il se trouve dans une boîte appelée ** Flower. Cependant, comme nous ne connaissons pas le contenu détaillé de la boîte (type de fleur), nous ne pouvons pas déterminer que l'instance contenue dans la boîte à fleurs est une instance Rose ** qui peut utiliser ** cutThron (). En conséquence, vous obtiendrez une erreur de compilation car vous ne pouvez pas faire quelque chose qui n'est pas certain.
À ce stade, je pense que le nombre de méthodes qui peuvent être utilisées pour le polymorphisme diminue, ce qui est peu pratique. Cependant, le polymorphisme présente des avantages qui vont au-delà de cet inconvénient. Dans cette section, nous décrirons les avantages. Le premier est ** le code est plus propre lorsqu'il est combiné avec un tableau **, et le second est ** chaque instance fait son travail avec une seule instruction **. Regardons un exemple concret. Dans le code ci-dessous, considérez que Rose, SunFlower et Tulip héritent de Flower, qui a une méthode bloom ().
Premièrement, si vous écrivez le code sans utiliser de polymorphisme, ce sera comme suit.
Main.java
public class Main {
poublic static void main(String[] args) {
Rose r = new Rose();
r.bloom();
SunFlower s = new SunFlower();
s.bloom();
Tulip t = new Tulip;
t.bloom();
Et ensuite, le code que j'ai écrit en utilisant le polymorphisme.
Main.java
public class Main {
public static void main(String[] args) {
Flower[] f = new Flower[3];
f[0] = new Rose();
f[1] = new SunFlower();
f[2] = new Tulip();
for (Flower fl : f) {
fl.bloom();
}
}
}
… Dans cet exemple, le nombre de lignes ne change pas beaucoup et je n'obtiens pas une impression nette, mais lol, si le nombre de types de fleurs augmente ou si le nombre de méthodes que je veux ajouter augmente à l'avenir, le nombre de lignes augmentera régulièrement avec l'ancienne méthode d'écriture. Je vais. De plus, avoir plusieurs variables peut être difficile à gérer. Ainsi, comme ce dernier, en regroupant des instances telles que Rose dans un tableau Flower et en les saisissant grossièrement comme une fleur, même si le nombre de types et de méthodes de fleurs augmente à l'avenir, il vous suffit d'ajouter des éléments, donc codez Vous pouvez écrire proprement.
Auparavant, le contenu de bloom () était le même pour toutes les instances. Cependant, en réalité, chaque fleur fleurit différemment. Par exemple, dans Rose, une tige se ramifie plusieurs fois et fleurit plusieurs fleurs, mais dans SunFlower, une seule fleur fleurit sur une tige. Dans cet esprit, disons que vous remplacez bloom () pour chaque instance. Normalement, vous devez écrire bloom () dans Main.java pour le nombre d'instances. Cependant, s'il est résumé dans Flower en raison du polymorphisme, nous n'avons besoin d'instruire bloom () qu'une fois **, et chaque instance exécutera sa propre bloom (). Cela peut être plus facile à comprendre si vous regardez le code. La commande à partir d'ici n'est bloom () qu'une seule fois, mais lorsque cela est exécuté, l'instance Rose ramifiera la tige et fleurira plusieurs fleurs, et l'instance Sun Flower fleurira une seule grande fleur sans ramifier la tige De plus, il a sa propre façon de fleurir.
Main.java
public class Main {
public static void main(String[] args) {
Flower[] f = new Flower[3];
f[0] = new Rose();
f[1] = new SunFlower();
f[2] = new Tulip();
for (Flower fl : f) {
f1.bloom();
}
}
}
En d'autres termes, même si nous considérons grossièrement la Rose et la Fleur du Soleil comme des Fleurs et donnons l'ordre de "fleurir!", La Rose et la Fleur du Soleil fleuriront dans leur propre manière unique de fleurir.
En un mot, le «polymorphisme» est une fonction merveilleuse qui permet aux humains du côté des commandants de s'amuser. Lol C'est une fonction difficile qui est difficile à entrer dans la tête juste en étudiant une fois, donc j'aimerais écrire le code plusieurs fois tout en étant conscient de "is-a" et du type de classe de la boîte. De plus, je veux m'habituer rapidement à Qiita. Merci d'avoir regardé jusqu'à présent.
Recommended Posts