polimorfizm Java

Polimorfizm jest zdolność do samo zachowanie w wielu różnych formach lub morfologii.

Polimorfizm jest przedmiotem wielu form wyrazu.

W rzeczywistości, takie jak nacisnąć klawisz F1, aby to działanie:

• Jeśli prąd w interfejsie podnoszona lampa błyskowa jest jako dokumentacja 3 pomoc;
• Jeśli obecny jest w wysuwania Pomoc Słowo Słowo;
• W wyskakującym Windows jest Pomoc i obsługa techniczna systemu Windows.

To samo zdarzenie na różnych obiektach dadzą różne wyniki.

Trzy warunki niezbędne dla istnienia polimorfizmu:

• dziedziczyć
• przepisać
• Dominująca odniesienia do obiektu podklasy

Na przykład:

Parent p = new Child();

Przy użyciu metody polimorficzne wywołuje sposób należy najpierw sprawdzić, czy nie jest metodą z grupy macierzystej, a jeśli nie, to kompilator błędów, jeśli nie jest znowu wywołuje taki sam sposób podklasy.

Korzyści wielu stanach: Można by program dobre rozszerzenie, i może obsługiwać wszystkie wspólne obiektów tej klasy.

Poniższa prezentacja jest multi-state szczegółów przykład, patrz Nota:

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

Powyższy program, wyjście jest:

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

metody wirtualne

Będziemy wprowadzać w Javie, przy projektowaniu działań klasa jest nadpisywana metoda jak wpływa polimorfizm.

Omówiliśmy już metody obejścia, która jest podklasą mogą zastąpić klasę nadrzędną.

Kiedy obiekt podklasa wywołuje metodę zastąpiona, należy wywołać metodę podklasy, a nie klasę dominującą metody nadpisane.

Aby wywołać metodę klasy nadrzędnej jest przesłonięta, należy użyć słowa kluczowego 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;
   }
}

Zakładając następujące klasy dziedziczy klasę Pracownik:

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

Teraz czytamy następujący kod próbuje podać jego dane wyjściowe:

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

Powyższe przykłady zebrane wyniki przedstawiają się następująco:

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

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

Przykłady analityczne

• Instance, wystąpienia dwóch obiektów Pensja: Zastosowanie Wynagrodzenie odniesienie do s, a drugi za pomocą odnośników pracownicze e.

• Dzwoniąc s.mailCheck (), kompilator znaleźć MAILCHECK w czasie kompilacji () w klasie wynagrodzenia, proces implementacji JVM nazywa klasa Wynagrodzenie MAILCHECK ().

• Dzwoniąc s.mailCheck (), Java Virtual Machine (JVM), aby wywołać metodę klasy Zarobki MAILCHECK ().

• Ponieważ e jest odniesienie urzędnik, więc metoda rozmówcy e MAILCHECK (), gdy kompilator pójdzie klasy Employee wygląda metodę MAILCHECK ().

• W czasie kompilacji, kompilator używa metody klasy Employee MAILCHECK (), aby zweryfikować oświadczenie, ale w czasie wykonywania, Java Virtual Machine (JVM) jest wywoływana metoda klasy Wynagrodzenie MAILCHECK ().

Przez powyższego procesu nazywa wirtualnym wywołania metod, które nazywa się metoda wirtualna.

Wszystkie metody Java mogą zachowywać się w ten sposób, więc można zastąpić metodę zwaną w czasie wykonywania, niezależnie od kodu źródłowego przy kompilacji zmienną referencyjną, jaki typ danych.