Polymorphisme Java
Le polymorphisme est la capacité d'un même comportement à avoir plusieurs manifestations ou formes différentes.
Le polymorphisme est l'incarnation de multiples expressions d'objets.
Trois conditions nécessaires à l'existence du polymorphisme :En réalité, par exemple, lorsqu'on appuie sur la touche F1 :
Le même événement produira des résultats différents lorsqu'il se produira sur différents objets.
Si le document d'aide d'AS 3 apparaît actuellement dans l'interface Flash <; 🎜 >
- Si l'aide de Word apparaît actuellement sous Word ;
- Si elle apparaît sous Windows, l'aide et le support Windows apparaissent.
- Héritage
- Réécriture
- La référence de la classe parent pointe vers l'objet de la sous-classe
Parent p = new Child();Lors de l'appel polymorphe d'une méthode, vérifiez d'abord si la classe parent existe est-ce cette méthode, sinon, une erreur de compilation se produit ; s'il y en a, alors appelez la méthode du même nom dans la sous-classe. Avantages du polymorphisme : Il permet au programme d'être bien étendu et peut gérer des objets de toutes les classes de manière universelle. Ce qui suit est une démonstration d'une instance polymorphe. Veuillez consulter les commentaires pour plus de détails :
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 catchMouse
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}Exécutez le programme ci-dessus et le résultat de sortie est : 吃鱼 抓老鼠 吃骨头 看家 吃鱼 抓老鼠
. Méthode virtuelleNous présenterons comment le comportement des méthodes remplacées affecte le polymorphisme lors de la conception de classes en Java. Nous avons discuté du remplacement de méthode, c'est-à-dire que les sous-classes peuvent remplacer les méthodes des classes parentes. Lorsqu'un objet de sous-classe appelle une méthode remplacée, la méthode de la sous-classe est appelée, et non la méthode remplacée dans la classe parent. Pour appeler une méthode surchargée dans la classe parent, vous devez utiliser le mot-clé super.
/* 文件名 : Employee.java */
public class Employee {
private String name;
private String address;
private int number;
public Employee(String name, String address, int number) {
System.out.println("Employee 构造函数");
this.name = name;
this.address = address;
this.number = number;
}
public void mailCheck() {
System.out.println("邮寄支票给： " + this.name
+ " " + this.address);
}
public String toString() {
return name + " " + address + " " + number;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
public void setAddress(String newAddress) {
address = newAddress;
}
public int getNumber() {
return number;
}
}Supposons que la classe suivante hérite de la classe Employee : /* 文件名 : Salary.java */
/* 文件名 : Salary.java */
public class Salary extends Employee
{
private double salary; // 全年工资
public Salary(String name, String address, int number, double salary) {
super(name, address, number);
setSalary(salary);
}
public void mailCheck() {
System.out.println("Salary 类的 mailCheck 方法 ");
System.out.println("邮寄支票给：" + getName()
+ " ，工资为：" + salary);
}
public double getSalary() {
return salary;
}
public void setSalary(double newSalary) {
if(newSalary >= 0.0) {
salary = newSalary;
}
}
public double computePay() {
System.out.println("计算工资，付给：" + getName());
return salary/52;
}
}Maintenant, nous lisons attentivement le code suivant et essayons de donner son résultat : /* 文件名 : VirtualDemo.java */
public class VirtualDemo {
public static void main(String [] args) {
Salary s = new Salary("员工 A", "北京", 3, 3600.00);
Employee e = new Salary("员工 B", "上海", 2, 2400.00);
System.out.println("使用 Salary 的引用调用 mailCheck -- ");
s.mailCheck();
System.out.println("\n使用 Employee 的引用调用 mailCheck--");
e.mailCheck();
}
}L'exemple de compilation ci-dessus et résultats d'exécution Comme suit : Employee 构造函数 Employee 构造函数 使用 Salary 的引用调用 mailCheck -- Salary 类的 mailCheck 方法 邮寄支票给：员工 A ，工资为：3600.0 使用 Employee 的引用调用 mailCheck-- Salary 类的 mailCheck 方法 邮寄支票给：员工 B ，工资为：2400.0Exemple d'analyse
- Dans l'exemple, deux objets Salary sont instanciés : l'un utilise Salary pour référencer s et l'autre utilise Employee pour référencer e.
- Lorsque s.mailCheck() est appelé, le compilateur constate que mailCheck() se trouve dans la classe Salary lors de la compilation, et le processus d'exécution JVM appelle mailCheck() de la classe Salary.
- Lors de l'appel de s.mailCheck(), la machine virtuelle Java (JVM) appelle la méthode mailCheck() de la classe Salary.
- Étant donné que e est une référence à Employee, lors de l'appel de la méthode mailCheck() de e, le compilateur ira à la classe Employee pour trouver la méthode mailCheck().
- Au moment de la compilation, le compilateur utilise la méthode mailCheck() dans la classe Employee pour vérifier l'instruction, Mais lors de son exécution, la machine virtuelle Java (JVM) appelle la méthode mailCheck() dans la classe Salary.
