Java method coverage and variable coverage

First, let's take a look at the concise definition of overload and overwrite:

Method overload: If two methods have the same method name but different parameters, you can say that one method is the overload of the other method.

Method override: if a method is defined in a subclass, its name, return type, and parameter signature exactly match the name, return type, and parameter signature of a method in the parent class, you can say, the subclass method overwrites the parent class method.

We will focus on the coverage problem. The following code is used as an example:

 
 

  
  
Public class People {
  
  
Public String getName (){
  
  
Return "people ";
  
  
}
  
  
 
  
  
}
  
  
Public class Student extends People {
  
  

  
  
Public String getName (){
  
  
Return "student ";
  
  
}
  
  

  
  
}
  
  
Public static void main (String [] args ){
  
  
People p = new People ();
  
  
System. out. println (p. getName (); // The running result is "people ".
  
  

  
  
Student s = new Student ();
  
  
System. out. println (s. getName (); // The running result is student.
  
  

  
  
People pp = new Student ();
  
  
System. out. println (pp. getName (); // The running result is student.
  
  
 
  
  
}
 
 

The preceding result indicates that the getName method of the student class successfully overwrites the method of the parent class.

Let's take a look at the coverage of variables:

 
 

  
  
Public class People {
  
  
Protected String name = "people ";
  
  
 
  
  

  
  
}
  
  
Public class Student extends People {
  
  

  
  
Protected String name = "student ";
  
  

  
  
}
  
  
Public static void main (String [] args ){
  
  

  
  

  
  
People p = new People ();
  
  
System. out. println (p. name); // The running result is people.
  
  

  
  
Student s = new Student ();
  
  
System. out. println (s. name); // The running result is student.
  
  

  
  
People pp = new Student ();
  
  
System. out. println (pp. name); // The running result is "people ".
  
  
 
  
  
}
 
 

Through the running results, I found that the overwrite of variables is actually different from that of methods.

In my own words, the coverage of variables can only be considered half-hanging.

Otherwise, the upward conversion will not cause data loss.

 
 

  
  
People pp = new Student ();
  
  
System. out. println (pp. name); // The running result is "people ".
 
 

In my personal experience, it is easy for people to make mistakes by overwriting variables. It makes people feel that they have returned to the inheritance of C ++ [this does not mean the inheritance of C ++ with virtual]

Finally, let's take a look at the Code:

 
 

  
  
public class People {  
  
  
    protected String name="people";  
  
  
    public String getName() {  
  
  
        return name;  
  
  
    }  
  
  
}  
  
  
public class Student extends People {  
  
  
      
  
  
    protected String name="student";  
  
  
    public String getName() {  
  
  
        return name;  
  
  
    }  
  
  
}  
 
 

 
 

  
  
Main (String [] args ){
  
  

  
  
People p = new People ();
  
  
System. out. println (p. getName (); // The running result is "people ".
  
  

  
  
Student s = new Student ();
  
  
System. out. println (s. getName (); // The running result is student.
  
  

  
  
People pp = new Student ();
  
  
System. out. println (pp. getName (); // The running result is student.
  
  
 
  
  
}
 
 

Obviously, such coverage is more useful for us, because we can achieve the goal of abstracting a specific object into a general object, which is truly the same as polymorphism.

The above is my personal opinion. If you have any mistakes, please point them out for discussion.