What are the concepts of Java polymorphism?

1. The concept of polymorphism

Simply speaking, different objects complete the same behavior, but produce different states

A very simple example: a class in school Students take the same exam. After the exam, the test scores of different students are different. Some fail, some wander around the passing line, and some have high scores. So at what level are you~( ￣▽￣)~

To achieve polymorphism, conditions are required. The specific conditions are as follows:

1. It must be under the inheritance system, and upward transformation has occurred

2 .The subclass should override the method of the parent class

3. Call the rewritten method through the reference of the parent class

Some of the new concepts involved above will be introduced in detail below

2. Upward transformation

2.1 Concept

We modify the class written previously:

class Plant {
    String name;
    String source;
    String genu;
    public void func() {
        System.out.println("父类方法");
    }
}
class Tree extends Plant {
 
    public void trait() {
        System.out.println("子类方法");
    }
}

The so-called upward transformation is to create a subclass object and It is used as a parent class

The specific operation is as follows:

Plant tree=new Tree();

Because it is used as a parent class, tree cannot call the method of the subclass at this time

There is downward transformation in Java, but because downward transformation is unsafe, we will skip it

2.2 Common forms of upward transformation

In the above example, it is The first: direct assignment

In addition, there are two forms

as the parameters of the method

as the return value of the method

3. Rewriting

means that the subclass rewrites the method of the parent class. This method cannot be a constructor, nor can it be private or final And static modification, and what we rewrite is the content in the method. The method name, return value and parameters of the method cannot be modified.

We still modify the class:

class Plant {
    String name;
    String source;
    String genu;
    public void trait() {
        System.out.println("父类方法");
    }
}
class Tree extends Plant {
    @Override  //注解，此注解可以进行一些合法性校验
    public void trait() {
        System.out.println("子类方法");
    }
}

We transform upward Let’s take a look at the result of calling trait:

##The method of the subclass is called, and this is also the characteristic of overriding.

is actually compiled At that time, the method of the parent class is indeed called, but the overridden method determines which method to call during the execution phase (i.e. dynamic binding). This is also the essential difference between overwriting and overloading

3.1 Notes on rewriting

1. Static, final, private modified methods and constructor methods cannot be overridden

2. The access rights of subclass methods must be greater than or equal to the parent class

3. After JDK7, the return value type of the overridden method can be different, but it must have a parent-child relationship, which is a covariant type

4. Do not call the overridden method in the constructor

The last point is explained separately: Assume that the constructor of the parent class calls the overridden method, because the constructor of the subclass will first call the constructor of the parent class, so the object of the subclass is dynamic before it is fully constructed. The binding calls the rewritten method. In this case, the probability of program problems will be greatly increased.

After understanding upward transformation and rewriting, you basically know how to implement polymorphism in Java: in inheritance The system combines upward transformation and rewriting to achieve polymorphism

The above is the detailed content of What are the concepts of Java polymorphism?. For more information, please follow other related articles on the PHP Chinese website!