Java-Polymorphismus

Polymorphismus ist die Fähigkeit, die gleiche Verhalten einer Anzahl unterschiedlicher Formen oder Morphologie haben.

Polymorphismus ist Gegenstand vieler Ausdrucksformen.

In der Realität, wie wir sie drücken Sie die F1-Taste zu dieser Aktion:

• Wenn der Strom in der Flash-Pop-up-Schnittstelle ist als 3-Hilfe;
• Wenn der Strom in der Eject-Word-Word-Hilfe;
• In dem Popup-Windows ist Windows-Hilfe und Support.

Das gleiche Ereignis auf verschiedene Objekte zu unterschiedlichen Ergebnissen führen.

Drei notwendigen Bedingungen für die Existenz von Polymorphismen:

• ererben
• umschreiben
• Eltern Verweis auf eine Unterklasse-Objekt

Zum Beispiel:

Parent p = new Child();

Bei der Verwendung von polymorphen Methode, um die Art und Weise nennt, zuerst prüfen, ob die Methode der Elternklasse ist, und wenn nicht, wird der Compiler-Fehler, wenn es wieder die gleiche Methode Unterklasse.

Multi-State-Vorteile: Sie können das Programm eine gute Erweiterung zu machen, und kann alle gängigen Objekte der Klasse behandeln.

Die folgende Darstellung ist eine Multi-State-Instanz Details siehe Anmerkung:

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("看家");  
    }  
}  

Das obige Programm, das Ausgabe ist:

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

virtuelle Methoden

Wir werden in Java, einführen, wenn Action-Klasse Gestaltung außer Kraft gesetzt ist Methode, wie es wirkt sich Polymorphismus.

Wir haben bereits die Überschreibung Verfahren diskutiert, die eine Unterklasse ist die übergeordnete Klasse außer Kraft setzen kann.

Wenn eine Unterklasse-Objekt die überschriebene Methode aufruft, rufen Sie die Unterklasse Methode, anstatt die übergeordnete Klasse überschriebenen Methoden.

Um die übergeordnete Klasse-Methode aufrufen, außer Kraft gesetzt ist, müssen Sie das Stichwort Super verwenden.

/* 文件名 : 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;
   }
}

Unter der Annahme der folgenden Klasse erbt Employee-Klasse:

/* 文件名 : 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;
   }
}

Nun lesen wir die folgenden Code versucht, seinen Ausgang zu geben:

/* 文件名 : 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();
    }
}

Die obigen Beispiele kompilierten Ergebnisse sind wie folgt:

Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck -- 
Salary 类的 mailCheck 方法 
邮寄支票给：员工 A ，工资为：3600.0

使用 Employee 的引用调用 mailCheck--
Salary 类的 mailCheck 方法 
邮寄支票给：员工 B ，工资为：2400.0

Beispiele Analytische

• Instanz, instanziiert zwei Objekte Gehalt: Gehalt einen Verweis auf s, und die andere e mit Mitarbeiterreferenzen.

• Wenn s.mailCheck () aufgerufen wird, der Compiler Mailcheck bei der Kompilierung () in der Gehaltsklasse gefunden, der Umsetzungsprozess JVM ruft die Gehaltsklasse Mailcheck ().

• Beim Aufruf s.mailCheck (), Java Virtual Machine (JVM) zu Gehaltsklassen Mailcheck () -Methode aufrufen.

• Da e Mitarbeiterreferenz, so des Anrufers e Mailcheck () -Methode, wenn der Compiler Klasse Employee gehen sieht Mailcheck () -Methode.

• Beim Kompilieren verwendet der Compiler die Klasse Employee Mailcheck () Methode, um die Aussage zu überprüfen, aber während der Laufzeit, Java Virtual Machine (JVM) ist Gehaltsklasse Mailcheck () -Methode aufgerufen.

Während des gesamten obigen Prozesses ist es eine virtuelle Methodenaufrufe genannt, die eine virtuelle Methode aufgerufen wird.

Alle Java-Methoden können auf diese Art und Weise verhalten, daher kann die Methode zur Laufzeit, unabhängig von der Quellcode genannt außer Kraft setzen, wenn eine Referenzvariable, welche Art von Daten zu kompilieren.