Shulou(Shulou.com)06/02 Report--

This article mainly shows you "what problems you need to pay attention to when rewriting the java method", the content is simple and clear, and I hope it can help you solve your doubts. Let the editor lead you to study and learn the article "what problems you need to pay attention to when rewriting the java method".

In object-oriented programming, method rewriting (override) is a language feature, it is a concrete manifestation of polymorphism, it allows subclasses to redefine existing methods in the parent class, and the method name and parameter type and number in the subclass must be consistent with the parent class, which is method rewriting.

The simplest example of method rewriting is as follows, defining a parent class Father and a subclass Son, with a method method in the parent class and a method method overridden in the subclass, as shown in the following implementation code. The implementation code of the parent class Father is as follows:

/ * parent * / class Father {public void method (String name) {System.out.println ("Father:" + name);}}

Override the parent class method method in the subclass. The specific implementation code is as follows:

The printing behavior is redefined in the / * subclass * / class Son extends Father {@ Override public void method (String name) {/ / subclass, no longer Father:XXX, but Son:XXX System.out.println ("Son:" + name);}}

Call and execute the method method in the program. The specific implementation code is as follows:

Public class OverrideExample {public static void main (String [] args) {Father father = new Son (); father.method ("Java");}}

The execution result of the above program is shown in the following figure:

However, in the process of method rewriting, we also need to pay attention to the following problems.

Note 1: the subclass permission controller cannot be reduced.

The levels of permission control characters in Java are as follows:

Public > protected > none > private

If the method in the parent class defines a protected control character, the specific implementation code is as follows:

Class Father {protected void method (String name) {System.out.println ("Father:" + name);}}

At this point, if the subclass overrides the parent class method, the defined permission controller is less than protected, as shown in the following figure:

So the question is, can the access controllers in subclasses become larger? The answer is yes, as shown in the following figure:

Conclusion: when the subclass overrides the method of the parent class, the overridden method permission controller cannot be smaller, it can be equal to or greater than the permission controller of the parent class.

Note 2: the subclass return value type can only be smaller.

Before we talk about this note, let's take a look at the pre-knowledge. In the Java language, the Number class is the parent class of Long, and the inheritance relationship is shown in the following figure:

Next, we use the Number type in the parent class to represent the return type of the method:

Class Father {public Number method (int num1, int num2) {return num1 + num2;}}

Using the Long type of the Number type in the implementation of the subclass, you can normally override the methods of the parent class, as shown in the following figure:

Of course, it is also possible to be consistent with the return type of the parent class, as shown in the following figure:

However, if you try to enlarge the return type in the subclass, you will get an error, as shown in the following figure (Object is the parent of the Number type): picture

Note 3: the exception type thrown can only be reduced.

If the type of exception thrown in the subclass becomes larger, that is, the type of exception thrown in the subclass method is greater than that thrown by the parent method, the program will report an error, as shown in the following figure:

The correct solution at this point is to keep the types of exceptions thrown by the parent and subclasses the same, as shown in the following figure:

Note 4: the method name must be consistent

If the method name overridden by the subclass is not the same as the parent class, the program will also report an error, as shown in the following figure:

Note 5: the parameter type and number of methods must be the same.

The type and number of method parameters in the subclass should be the same as the parent method, otherwise an error will be reported, as shown in the following figure.

The parameter types of the method are inconsistent

The number of parameters of the method is inconsistent.

The above is all the contents of the article "what should be paid attention to when rewriting java methods". Thank you for your reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.