Compreensão pessoal e resumo do polimorfismo Java

Visão geral do polimorfismo

1. O polimorfismo é a terceira característica da orientação a objetos após o encapsulamento e a herança.
2. Para o significado prático e compreensão pessoal do polimorfismo:

• Polimorfismo: a mesma referência chama o mesmo método, mas faz coisas diferentes.
• Coisas reais muitas vezes refletem muitas formas, como alunos, alunos pertencem à categoria de pessoas e um colega de classe específico, Zhang San, pertence tanto à categoria de alunos quanto de pessoas, ou seja, existem várias formas. Essa é a coisa real Polimórfico.
• Como uma linguagem orientada a objetos, Java também pode descrever várias formas de uma coisa. Se a classe Aluno herda a classe Pessoas, o objeto de um Aluno é tanto Aluno quanto Pessoas.

3. O polimorfismo é refletido na variável de referência da classe pai pode apontar para o objeto da classe filho.
   Nota: Ao usar a variável de referência de classe pai polimórfica para chamar o método, o método reescrito da subclasse será chamado.

4. Definição e formato de uso do polimorfismo

     定义格式：父类类型 变量名=new 子类类型();
   

5. compreensão:

           多态是同一个行为具有多个不同表现形式或形态的能力。   
           多态就是同一个接口，使用不同的实例而执行不同操作。
   

6. Algumas vantagens do polimorfismo:
Interface, polimorfismo é que a superclasse fornece uma interface comum para a subclasse por meio de assinaturas de método, e a subclasse a completa ou substitui para alcançar;
substituibilidade, polimorfismo pode substituir o código existente;
escalabilidade, polimorfismo pode adicionar novas subclasses sem afetar a operação e operação do polimorfismo, herança e outras características das classes existentes;
flexibilidade, polimorfismo é muito flexível;
quinto, simplicidade, também simplifica o processo de escrever e modificar códigos de software de aplicação. .

Características de membros polimórficos

class People{
    
    
	private int num=6;
	int vis=666;
	public void eat() {
    
    
		System.out.println("米饭");
	}
	public void getNum() {
    
    
		System.out.println(num);
	}
}
class Student extends People{
    
    
	private int num=10;
	int vis=66;
	public void eat() {
    
    
		System.out.println("炸鸡");
	}
	public void study() {
    
    
		System.out.println("good good study");
	}
	public void getNum() {
    
    
		System.out.println(num);
	}	
}

public static void main(String[] args) {
    
    
		People p=new Student();
		System.out.println(p.vis);//
		p.eat();
		p.getNum();


//输出
//666
//炸鸡
//10

1. Variáveis ​​de membro polimórficas:
   apenas o valor da variável da classe pai pode ser obtido
2. Método de membro polimórfico:
   chame o método sobrescrito pela subclasse, mas deve ser um método na classe pai

Transformação para cima

Use o formato: nome da variável de tipo pai = novo tipo de subtipo ();
Cenário aplicável: quando não há necessidade de enfrentar o tipo de subtipo, a operação correspondente pode ser concluída melhorando a extensibilidade ou usando a função da classe pai.
** Compreensão: ** Use o método na classe pai, mas chame o método substituído pela subclasse

Abatido

Use o formato: nome da variável de tipo de subclasse = (tipo de subclasse) variável do tipo pai;
** Cenário aplicável: quando você deseja usar a função única da subclasse. **
** Compreensão: ** Use subcategorias para resolver problemas

Exibição de amostra de código

package ParentAndBase;

class People{
    
    
	private int num=6;
	public void eat() {
    
    
		System.out.println("米饭");
	}
	public void getNum() {
    
    
		System.out.println(num);
	}
}
class Student extends People{
    
    
	private int num=10;
	public void eat() {
    
    
		System.out.println("炸鸡");
	}
	public void study() {
    
    
		System.out.println("good good study");
	}
	public void getNum() {
    
    
		System.out.println(num);
	}	
}
class Teacher extends People{
    
    
	public void eat() {
    
    
		System.out.println("拉面");
	}
	public void study() {
    
    
		System.out.println("day day up");
	}
}
public class Demo {
    
    

	public static void main(String[] args) {
    
    
		People p=new Student();//向上转型
		p.eat();
		p.getNum();
		Student stu=(Student)p;//向下转型
		stu.study();
		stu.eat();

		People pp=new Teacher();
		pp.eat();
	}

}

Resumindo:

Java实现多态有三个必要条件：继承、重写、向上转型。

     继承：在多态中必须存在有继承关系的子类和父类。

     重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

     向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

     只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

  对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。