Visitor Mode Discussion: dynamic binding and double dispatch of Java

Reproduced http://blog.csdn.net/zhengzhb/article/category/926691

Dynamic binding of Java

The so-called dynamic binding refers to determining the actual type of the referenced object during the execution period (rather than during the compilation period), and calling the corresponding method based on the actual type. The coverage in the Java inheritance system is dynamically bound. Take a look at the following code:

[Java]View plaincopy

1. Class father {
2. Public void method (){
3. System. Out. println ("this is Father's method ");
4. }
5. }
7. Class son1 extends father {
8. Public void method (){
9. System. Out. println ("this is son1's method ");
10. }
11. }
13. Class son2 extends father {
14. Public void method (){
15. System. Out. println ("this is son2's method ");
16. }
17. }
19. Public class test {
20. Public static void main (string [] ARGs ){
21. Father S1 = new son1 ();
22. S1.method ();
24. Father S2 = new son2 ();
25. S2.method ();
26. }
27. }

The running result is as follows:

This is son1's Method
This is son2's Method

The running result shows that although the referenced type is of the father type, the actual type (namely, son1 and son2) method is called during the running, which is dynamic binding. In Java, override in inheritance is dynamically bound. When we use the parent class to reference the instantiated subclass, the corresponding method will be called based on the actual referenced type.

 

Static binding of Java

Compared with dynamic binding, static binding determines which method to execute during the compilation period. In Java, the method overload (with the same method name and different parameters) is statically bound. During the overload, the method to be executed is determined during the compilation period. Take a look at the Code:

[Java]View plaincopy

1. Class father {}
2. Class son1 extends father {}
3. Class son2 extends father {}
5. Class execute {
6. Public void method (Father ){
7. System. Out. println ("this is Father's method ");
8. }
10. Public void method (son1 son ){
11. System. Out. println ("this is son1's method ");
12. }
14. Public void method (son2 son ){
15. System. Out. println ("this is son2's method ");
16. }
17. }
19. Public class test {
20. Public static void main (string [] ARGs ){
21. Father = new father ();
22. Father S1 = new son1 ();
23. Father S2 = new son2 ();
25. Execute EXE = new execute ();
26. EXE. Method (father );
27. EXE. Method (S1 );
28. EXE. Method (S2 );
29. }
30. }

The running result is as follows:

This is Father's Method
This is Father's Method
This is Father's Method

Here, the program has determined to use the method (Father) method during compilation, regardless of the actual type we pass in during runtime, it will always only execute the method (Father) method. That is to say, the Java overload is statically bound.

 

Instanceof operator and Transformation

Sometimes, we want the program to dynamically call the corresponding method based on the actual type of input parameters when using the overload, that is, we want the Java overload to be dynamic, not static. However, because the Java overload is not dynamic binding, we can only judge the type by the operator of the program. We generally use the instanceof operator to judge the type. We need to modify the method (Father) to determine the actual type during running in the method body. The modified method (Father) method is as follows:

[Java]View plaincopy

1. Public void method (Father ){
2. If (father instanceof son1 ){
3. Method (son1) Father );
4. } Else if (father instanceof son2 ){
5. Method (son2) Father );
6. } Else if (father instanceof father ){
7. System. Out. println ("this is Father's method ");
8. }
9. }

Please note that we must put the condition for determining whether the class is a parent class (that is, the condition for determining whether the class is a father class) At the end, otherwise it will be regarded as a father class, we cannot achieve our goal of dynamic judgment. After the code is modified, the program can dynamically call the corresponding method based on the actual type of the parameter. The running result is as follows:

This is Father's Method
This is son1's Method
This is son2's Method

However, this implementation method has an obvious disadvantage. It is pseudo-dynamic, and we still need to judge the type through the program. If father has 100 sub-classes, it is obviously inappropriate to do so. It must be implemented in other better ways. We can use the double dispatch method to implement dynamic binding.

Dynamic binding using double dispatch

First, what is double dispatch? Remember23 design modes (9): Visitor ModeFirst example?

The difference between Methods Method1 and method2 in Class A is that method2 is a double dispatch. Let's take a look at the features of Java double DISPATCH: first, there must be a primary class B. Class B provides a Showa (A) method. In the method, call the Method1 method of Class, then, the method2 method of Class A calls the Showa method of class B and passes it as a parameter to showa. This object is the core of Dual-allocation. Speaking of this, we already know what the dual-assignment is, but what effect does it have? The method can be dynamically bound. We can modify the above program. The Code is as follows:

[Java]View plaincopy

1. Class father {
2. Public void accept (execute exe ){
3. EXE. Method (this );
4. }
5. }
6. Class son1 extends father {
7. Public void accept (execute exe ){
8. EXE. Method (this );
9. }
10. }
11. Class son2 extends father {
12. Public void accept (execute exe ){
13. EXE. Method (this );
14. }
15. }
17. Class execute {
18. Public void method (Father ){
19. System. Out. println ("this is Father's method ");
20. }
22. Public void method (son1 son ){
23. System. Out. println ("this is son1's method ");
24. }
26. Public void method (son2 son ){
27. System. Out. println ("this is son2's method ");
28. }
29. }
31. Public class test {
32. Public static void main (string [] ARGs ){
33. Father = new father ();
34. Father S1 = new son1 ();
35. Father S2 = new son2 ();
37. Execute EXE = new execute ();
38. Father. Accept (exe );
39. S1.accept (exe );
40. S2.accept (exe );
41. }
42. }

We can see the modified location. Add a double dispatch method to father, son1, and son2 respectively. When calling, it was originally called the execute method. Now it is changed to calling the Father accept method. The running result is as follows:

This is Father's Method
This is son1's Method
This is son2's Method

The running result conforms to our expectation and implements dynamic binding. The essence of the dynamic binding of double dispatch is to add the inheritance system coverage before the delegation of the overload method. Because the coverage is dynamic, the overload is dynamic, the effect of using the instanceof operator is the same (the reason why the instanceof operator can realize dynamic binding of overload methods is also because the instanceof operator is dynamic ). However, compared to the dynamic binding using the instanceof operator, the scalability of the double dispatch method is much better.