polimorfismo Java

O polimorfismo é a capacidade de ter o mesmo comportamento de um número de diferentes formas ou morfologia.

O polimorfismo é o objecto de muitas formas de expressão.

Na realidade, tal como nós pressione a tecla F1 para esta ação:

• Se a corrente na interface pop-up Flash é como documentação 3 ajuda;
• Se a corrente está na ejecção de Ajuda do Word Palavra;
• Nas janelas de pop-up é a Ajuda e Suporte do Windows.

O mesmo evento em objetos diferentes irá produzir resultados diferentes.

Três condições necessárias para a existência de polimorfismo:

• herdar
• reescrever
• referência pai para um objeto de subclasse

Por exemplo:

Parent p = new Child();

Quando se utiliza o método polimórfico chama o modo, em primeiro lugar verificar se há o método da classe principal, e se não, o erro do compilador, se houver, mais uma vez, chama o mesmo método da subclasse.

benefícios multi-estado: Você pode tornar o programa uma boa extensão, e pode lidar com todos os objetos comuns da classe.

A apresentação é um multi-estado de detalhes da instância, consulte a 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("看家");  
    }  
}  

O programa acima, a saída é:

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

métodos virtuais

Vamos introduzir em Java, na concepção de ação de classe é método substituído de como isso afeta o polimorfismo.

Nós já discutimos o método de substituição, que é uma subclasse pode substituir a classe pai.

Quando um objeto de subclasse chama o método substituído, chame o método da subclasse, ao invés da classe pai métodos substituídos.

Para chamar o método da classe pai for substituído, você deve usar a palavra-chave 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;
   }
}

Assumindo a seguinte classe herda da classe Funcionário:

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

Agora, lemos o seguinte código tenta dar sua saída:

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

Os exemplos acima são compilados os resultados como se segue:

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

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

Exemplos analíticos

• Exemplo, instanciar dois objetos Salário: uso Salário uma referência para s, e o outro usando referências a empregados e.

• Ao chamar s.mailCheck (), o compilador encontrou MailCheck em tempo de compilação () na classe de salário, o processo de implementação JVM chama a classe Salário MailCheck ().

• Ao chamar s.mailCheck (), Java Virtual Machine (JVM) para chamar o método aulas Salário MailCheck ().

• Porque e é referência do empregado, de modo e do chamador MailCheck () método quando o compilador irá classe Employee olha método MailCheck ().

• Em tempo de compilação, o compilador usa o método da classe Employee MailCheck () para verificar a declaração, mas em tempo de execução, Java Virtual Machine (JVM) é chamado método Salário classe MailCheck ().

Durante todo o processo acima é chamado de chamadas de método virtual, que é chamado um método virtual.

Todos os métodos Java pode se comportar desta maneira, portanto, pode substituir o método chamado em tempo de execução, independentemente do código-fonte ao compilar uma variável de referência que tipo de dados.