polimorfismo Java

Il polimorfismo è la possibilità di avere lo stesso comportamento di un certo numero di forme o morfologia diverse.

Il polimorfismo è l'oggetto di molte forme di espressione.

In realtà, come abbiamo premere il tasto F1 per questa azione:

• Se la corrente nell'interfaccia pop-up Flash è AS 3 documentazione di aiuto;
• Se la corrente è in espulsione Guida di Word Word;
• In Windows pop-up è Guida e supporto tecnico di Windows.

Lo stesso evento su oggetti diversi produrrà risultati diversi.

Tre condizioni necessarie per l'esistenza di polimorfismo:

• ereditare
• riscrittura
• Parent riferimento a un oggetto sottoclasse

Ad esempio:

Parent p = new Child();

Quando si utilizza il metodo polimorfico chiama la strada, prima verificare se vi è il metodo della classe padre, e se non, l'errore del compilatore, se presente, di nuovo, chiama lo stesso metodo sottoclasse.

benefici multi-stato: È possibile effettuare il programma di una buona estensione, e in grado di gestire tutti gli oggetti comuni della classe.

La seguente presentazione è un multi-stato dettagli esempio, vedi 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("看家");  
    }  
}  

Il programma precedente, l'uscita è:

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

metodi virtuali

Introdurremo in Java, durante la progettazione di azione di classe è il metodo override di come essa influisce il polimorfismo.

Abbiamo già discusso il metodo di sostituzione, che è una sottoclasse può sostituire la classe genitore.

Quando un oggetto sottoclasse chiama il metodo override, chiamare il metodo sottoclasse, piuttosto che la classe genitore metodi sostituiti.

Per chiamare il metodo della classe genitore viene sovrascritto, è necessario utilizzare la parola chiave 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;
   }
}

Assumendo la seguente classe eredita 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;
   }
}

Ora leggiamo il seguente codice cerca di dare la sua uscita:

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

Gli esempi sopra risultati elaborati sono i seguenti:

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

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

Esempi di analisi

• Esempio, un'istanza di due oggetti Stipendio: Stipendio uso un riferimento a s, e l'altro utilizzando i riferimenti ai dipendenti e.

• Quando si chiama s.mailCheck (), il compilatore trovato MailCheck al momento della compilazione () nella classe di stipendio, il processo di implementazione JVM chiama la classe di stipendio MailCheck ().

• Quando si chiama s.mailCheck (), Java Virtual Machine (JVM) di chiamare il metodo classi di stipendio MailCheck ().

• Poiché la posta è di riferimento dei dipendenti, in modo che il chiamante e MailCheck () quando il compilatore andrà classe Employee sembra il metodo MailCheck ().

• Al momento della compilazione, il compilatore utilizza il metodo della classe Employee MailCheck () per verificare la dichiarazione, ma in fase di esecuzione, Java Virtual Machine (JVM) viene chiamato metodo Stipendio classe MailCheck ().

Durante tutto il processo di cui sopra si parla di chiamate di metodo virtuale, che si chiama un metodo virtuale.

Tutti i metodi Java possono comportarsi in questo modo, quindi, può eseguire l'override del metodo chiamato in fase di esecuzione, indipendentemente dal codice sorgente quando la compilazione di un variabile di riferimento che tipo di dati.