polymorphisme Java
Le polymorphisme est la capacité d'avoir le même comportement d'un certain nombre de formes différentes ou de la morphologie.
Le polymorphisme est l'objet de nombreuses formes d'expression.
En réalité, comme nous appuyer sur la touche F1 pour cette action:
- Si le courant dans l'interface pop-up flash est aussi 3 documentation d'aide;
- Si le courant est dans l'éjection Mot Aide;
- Dans Windows de pop-up est Aide et support Windows.
Le même événement sur différents objets va produire des résultats différents.
Trois conditions nécessaires à l'existence du polymorphisme:
- hériter
- récrire
- référence Parent à un objet de sous-classe
Par exemple:
Parent p = new Child();
Lorsque vous utilisez la méthode polymorphique appelle la voie, d'abord vérifier s'il y a la méthode de la classe parent, et si non, l'erreur de compilation, s'il y a, à nouveau, appelle la même méthode sous-classe.
avantages multi-étatiques: Vous pouvez rendre le programme une bonne extension, et peut gérer tous les objets ordinaires de la classe.
La présentation qui suit est un multi-états détails de l'instance, voir la note:
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("看家");
}
}
Le programme ci-dessus, le résultat est:
吃鱼 抓老鼠 吃骨头 看家 吃鱼 抓老鼠
Les méthodes virtuelles
Nous introduisons en Java, lors de la conception class action est méthode redéfinie de la façon dont elle affecte le polymorphisme.
Nous avons déjà discuté de la méthode de remplacement, qui est une sous-classe peut remplacer la classe de parent.
Lorsqu'un objet de sous-classe appelle la méthode redéfinie, appelez la méthode de la sous-classe, plutôt que la classe parente méthodes redéfinies.
Pour appeler la méthode de la classe parent est annulée, 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;
}
}
En supposant que la classe suivante hérite la classe des employés:
/* 文件名 : 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 le code suivant tente de donner sa sortie:
/* 文件名 : 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();
}
}
Les exemples ci-dessus les résultats compilés sont les suivants:
Employee 构造函数 Employee 构造函数 使用 Salary 的引用调用 mailCheck -- Salary 类的 mailCheck 方法 邮寄支票给：员工 A ，工资为：3600.0 使用 Employee 的引用调用 mailCheck-- Salary 类的 mailCheck 方法 邮寄支票给：员工 B ，工资为：2400.0
Exemples d'analyse
Instance, instancier deux objets Salaire: utilisation Salaire une référence à s, et l'autre en utilisant des références des employés e.
Lorsque vous appelez s.mailCheck (), le compilateur a trouvé Mailcheck au moment de la compilation () dans la classe de salaire, le processus de mise en œuvre JVM appelle la classe salariale Mailcheck ().
Lorsque vous appelez s.mailCheck (), la machine virtuelle Java (JVM) pour appeler la méthode des classes de salaire Mailcheck ().
Parce que e est la référence des employés, de sorte que l'e de l'appelant Mailcheck () méthode lorsque le compilateur va classe Employee regarde méthode Mailcheck ().
Au moment de la compilation, du compilateur utilise la méthode classe Employee Mailcheck () pour vérifier la déclaration, mais au moment de l'exécution, la machine virtuelle Java (JVM) est appelée méthode de classe de salaire Mailcheck ().
Tout au long du processus ci-dessus, il est appelé un virtuels appels de méthode, qui est appelé une méthode virtuelle.
Toutes les méthodes Java peuvent se comporter de cette manière, par conséquent, peut remplacer la méthode appelée lors de l'exécution, quel que soit le code source lors de la compilation d'une variable de référence quel type de données.