Java object-oriented polymorphism

Simple understanding of polymorphism:

The student class inherits the Person class, then the object of the student class is both a student and a person class

Polymorphism has two forms of presentation:

1. Polymorphism of methods:

(1) Method Overloading: The same method can implement different functions depending on the type or number of parameters passed in

(2) Overriding of methods: The same method may have different functions depending on the implementation subclass Implementation

2. Object polymorphism:

Conversion processing between parent class and subclass instances

(1) Object upward Transformation: parent class parent class instance = new subclass instance (); automatically complete the conversion

(2) Object downward transformation: subclass subclass instance = new (subclass) parent class instance (); mandatory Complete the conversion

Related video tutorial sharing:java free video tutorial

The final manifestation of polymorphism:

1. Parent class reference variables can point to subclass objects

2. The premise of polymorphism is that there must be a child-parent class relationship or a class implementation interface relationship, otherwise polymorphism cannot be achieved

3. When using polymorphism When the stateful parent class reference variable calls a method, the rewritten method of the subclass will be called

Polymorphic member variables:

1. When compiling, Reference: There is no such variable in the parent class. If there is, the compilation will be successful. If not, the compilation will fail.

2. When running, the variable value in the parent class will be run.

Member variable compilation The operation depends on the polymorphic member methods of the parent class

:

1. When compiling, refer to whether there is such a method in the parent class. If so, the compilation will be successful. If not, the compilation fails

2. When running. What is run is the overridden method of the subclass

When compiling member methods, look at the parent class, and when running, look at the subclass

Understanding of the two transformation methods of objects:

1. Object upward transformation:

After upward transformation, the subclass object can only call methods owned by the parent class, and cannot call methods owned by the subclass alone. This is achieved through upward transformation. The use of polymorphism

2. Object downward transformation:

If the object wants to use the unique method of the subclass but not the parent class after the upward transformation, Downcasting of objects needs to be used

Code demonstration:

public   class Person {
	public  void Eat(){
		//在person类中定义一个吃的抽象方法
	}
}

public class Student extends Person{
	public  void Eat(){
		System.out.println("学生吃学校食堂");//重写父类中的抽象方法
	}
	public void Learning()
	{
		System.out.println("学生在学习");//定义一个student类特有的方法
	}
}
public class Test {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Person p=new Student();//通过向上转型定义一个p对象
		p.Eat();//这是子父类共有的方法
		p.Learning();
	}
}

In this code we call a subclass-specific method through upward casting, but the following prompt will appear:

The Learning method is not defined in the parent class. But we must call the unique method of the subclass. At this time, we need to implement downward transformation.

The supplementary code is as follows:

Student stu=(Student)p;//将p对象向下转型实现方法调用
		stu.Learning();

If you want to learn more related tutorials, please visit: javaQuickstart

The above is the detailed content of Java object-oriented polymorphism. For more information, please follow other related articles on the PHP Chinese website!