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

This article mainly introduces "what is the difference between reloading and rewriting". In daily operation, I believe many people have doubts about the difference between reloading and rewriting. The editor consulted all kinds of materials and sorted out simple and easy-to-use methods of operation. I hope it will be helpful to answer the question of "what is the difference between reloading and rewriting"! Next, please follow the editor to study!

Single scheduling

Class Parent {void print (String a) {log.info ("Parent-String");} void print (Object a) {log.info ("Parent-Object");}} class Child extends Parent {void print (String a) {log.info ("Child-String");} void print (Object a) {log.info ("Child-Object");}}

What will be printed next?

String string = ""; Object stringstringObject = string; / / print what? Child child = new Child (); child.print (string); child.print (stringObject); Parent parent = new Child (); parent.print (string); parent.print (stringObject)

Answer:

Child.print (string); / print: "Child-String" child.print (stringObject); / print: "Child-Object" parent.print (string); / / print: "Child-String" parent.print (stringObject); / / print: "Child-Object"

Print (string) and parent.print (string) are textbook examples of Java object-oriented programming. The method being called depends on the actual instance type, not the declared instance type. For example, whether you define the variable as Child or Parent, because the actual instance type is Child, Child:: print will be called.

The second group is more complex because they are all identical strings. The only difference is that the string is declared as String and stringObject is declared as Object. When dealing with method parameters, what is important is the declared type of the parameter, not its actual type. Print (Object) is called even if the actual parameter type is String

Implicit rewriting

Class Parent {void print (Object a) {log.info ("Parent-Object");}} class Child extends Parent {void print (String a) {log.info ("Child-String");}}

Print what?

String string = ""; Parent parent = new Child (); parent.print (string)

Answer:

Parent.print (string); / / print: "Parent-Object"

The actual instance type is Child, the declared parameter type is String, and we do have a method defined for Child:: print (String). In fact, this is exactly what you chose when you called parent.print (string) in the previous example. However, this is not the method to be called here.

Before checking for subclass overrides, Java seems to first choose which method to call. In this case, the only way to match the declared instance type in Parent,Parent is Parent:: print (Object). Then, when Java checks for any potential overrides of Parent:: print (Object), it does not find any overrides, so this is how it is executed.

Explicit rewriting

Class Parent {void print (Object a) {log.info ("Parent-Object!");} void print (String a) {throw new RuntimeException ();}} class Child extends Parent {void print (String a) {log.info ("Child-String!");}}

Print what?

String string = ""; Parent parent = new Child (); parent.print (string)

Answer:

Parent.print (string); / / print: "Child-String!"

The only difference between this example and the previous example is that we have added a new Parent:: print (String) method. This method has never actually been executed-if it does, it throws an exception! However, its existence causes Java to perform a different approach.

When calculating Parent.print (String), the runtime now finds a matching Parent:: print (String) method and sees that this method is overridden by Child:: print (String).

Fuzzy parameter

Class Foo {void print (Cloneable a) {log.info ("I am cloneable!");} void print (Map a) {log.info ("I am Map!");}}

What is printed below?

HashMap cloneableMap = new HashMap (); Cloneable cloneable = cloneableMap; Map map = cloneableMap; / / What gets printed? Foo foo = new Foo (); foo.print (map); foo.print (cloneable); foo.print (cloneableMap)

Answer:

Foo.print (map); / / print: "I am Map!" Foo.print (cloneable); / / print: "I am cloneable!" Foo.print (cloneableMap); / / compilation failed

Similar to the single scheduling example, what matters here is the declared type of the parameter, not the actual type. In addition, if there are multiple methods that are equally valid for a given parameter, Java throws a compilation error and forces you to specify which method should be called.

Multiple inheritance-Interfac

Interface Father {default void print () {log.info ("I am Father!");}} interface Mother {default void print () {log.info ("I am Mother!");}} class Child implements Father, Mother {}

What is printed below?

New Child () .print ()

Similar to the previous example, this example also compiles and fails. Specifically, the class definition of Child itself will not compile because there are conflicting default methods in Father and Mother. You need to modify the behavior of the Child class to specify Child:: print.

Multiple inheritance-classes and interfaces

Class ParentClass {void print () {log.info ("I am a class!");}} interface ParentInterface {default void print () {log.info ("I am an interface!");}} class Child extends ParentClass implements ParentInterface {}

Print what?

New Child () .print ()

Answer:

New Child () .print (); / / print: "I am a class!"

If there is an inheritance conflict between the class and the interface, the class method takes precedence.

Transitive rewriting

Class Parent {void print () {foo ();} void foo () {log.info ("I am Parent!");}} class Child extends Parent {void foo () {log.info ("I am Child!");}}

Print what?

New Child () .print ()

Answer:

New Child () .print (); / / print: "I am Child!"

Overridden methods take effect even for passing calls, and people who read the Parent class might think that Parent:: print will always call Parent:: foo. But if the method is overridden, Parent:: print will call the rewritten version of foo ().

Private rewriting

Class Parent {void print () {foo ();} private void foo () {log.info ("I am Parent!");}} class Child extends Parent {void foo () {log.info ("I am Child!");}}

Print what?

New Child () .print ()

Answer:

New Child () .print (); / / print: "I am Parent!"

Except for one difference, this is exactly the same as the previous example. Now declare Parent.foo () as private. Therefore, when Parent.print () calls foo (), it doesn't matter whether there are other implementations of foo () in the subclass or the actual type of the instance that calls print ().

Static rewriting

Class Parent {static void print () {log.info ("I am Parent!");}} class Child extends Parent {static void print () {log.info ("I am Child!");}}

Print what?

Child child = new Child (); Parent parent = child; parent.print (); child.print ()

Answer:

Parent.print (); / / print: "I am Parent!" Child.print (); / / print: "I am Child!"

Java does not allow static methods to be overridden. If the same static methods are defined in both the parent and subclasses, the actual type of the instance does not matter at all. Only the declared type is used to determine which of the two methods is called.

This is another reason to mark all overridden methods with the @ override annotation. In the above example, when you add a comment to Child:: print, you get a compilation error that tells you that the method cannot be overridden because it is static.

Static link

Class Parent {void print () {staticMethod (); instanceMethod ();} static void staticMethod () {log.info ("Parent::staticMethod");} void instanceMethod () {log.info ("Parent::instanceMethod");}} class Child extends Parent {static void staticMethod () {log.info ("Child::staticMethod");} void instanceMethod () {log.info ("Child::instanceMethod");}}

Print what?

Child child = new Child (); child.print ()

Answer:

Parent::staticMethod Child::instanceMethod

This is a combination of some of the different concepts we discussed earlier. For example, the override takes effect even if the call is located in the parent method. However, for static methods, Parent:: staticMethod is called even if the declared type of the variable is Child, because there is an intermediate print () method.

At this point, the study of "what's the difference between overloading and rewriting" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

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.