It's good to experience polymorphism

Table of contents

Inheritance and Composition:

difference and connection

1. Security perspective (encapsulation)

2. Angle of flexibility (pull and move the whole body)

Polymorphism:

1. How to implement polymorphism

1. Complete upward transformation

Direct assignment:​​​​​​​

method parameter

method return value

2. Complete method rewriting:

3. Point to the subclass object through the parent class reference (overridden method)

dynamic binding

Parent class references point to subclass objects:

2. What is polymorphism:

3. The application of polymorphic thinking (drawing graphics)

Four. The benefits of polymorphism:

to add on:

1.To summarize the difference between rewriting and overloading:

2.Downward transformation

---

Preface
These contents are a review of the basic part of javase

---

Inheritance and Composition:


1. Relationally:
inheritance is a
combination has a
2. In terms of usage:
Both composition and inheritance can achieve code reuse. Whether to use inheritance or composition depends on the application scenario. The general suggestion is to use composition as much as possible.

>Similar to building a car, a car can be composed of wheels, lights... and write the code as follows

Combined code:

```java
//demo portfolio
class Tire{
    private int size;

    public void run(){
        System.out.println("tire turning");
    }

}
class Light{
    public void bright(){
        System.out.println("Light");
    }

}
public class Vehicle {
    private Tire tire;
    private Light light;
    public Vehicle(Tire tire,Light light){
        this.tire=tire;
        this.light=light;
    }
    public void operation(){
        tire.run();
        light.bright();
    }
    public static void main(String[] args) {
        Tire tire=new Tire();
        Light light=new Light();
        Vehicle vehicle=new Vehicle(tire,light);
        vehicle.operation();
    }

}


difference and connection


1. Security perspective (encapsulation)


The combination is assembled together. The internal implementation details are invisible and have better encapsulation (black box)
In an inheritance structure, the internal details of the parent class are visible to the child class. So we can usually say that code reuse through inheritance is a kind of white-box code reuse. (If the implementation of the base class changes, the implementation of the derived class will also change. This leads to unpredictable behavior of the subclass ;)

For example: the method of the class is used by other classes, in case other classes rewrite the method, this method will have an impact on the follow-up (all used)


2. Angle of flexibility (pull and move the whole body)


Inheritance, when writing code, it is necessary to specify which class to inherit, so the relationship is determined at compile time. (The implementation inherited from the base class cannot be changed dynamically at runtime, thus reducing the flexibility of the application.)
For example: callback (every time you inherit, call back the methods and properties in it)

Combination, interface-oriented programming can be used when writing code. Therefore, the composition relationship of classes is generally determined at runtime


Polymorphism

1. How to implement polymorphism


1. Complete upward transformation

Pay attention to three points

Direct assignment:

Directly assign subclass object to parent class

Animal animal=new Bird("Parrot",2);

animal.eat()

At this time, the parent class reference can only access its own methods. If you want to access the unique methods of the subclass, you need to downcast

method parameter

method return value

2. Complete method rewriting:

Pay attention to 6 points

 animal.eat();

 

The eat() of the subclass is called

The above process is actually a method rewriting


The conditions for method rewriting are met:
1. The method name is the same,
2. The parameter list is the same [number, type, order]
3. The return value is the same (or the return value of the subclass and the parent class form a parent-child relationship (covariant type))

This is the subclass

Here's the parent class:

public Animal eat() {
        System.out.println(name + "can cook");
        return new Animal("animal",18);
    }

Since the return value of the subclass and the parent class form a parent-child relationship, the running result is still the eat of the subclass

4. The static modification method cannot be overridden


5. The private modification method cannot be overridden (private can only be used in the current class)


6. The access modifier of the subclass needs to be greater than or equal to the access modifier of the parent class


Overriding the parent class method

3. Point to the subclass object through the parent class reference (overridden method)

dynamic binding

dynamic binding

Also called runtime binding, both subclasses and parent classes have this method

When compiling, it still calls the parent class itself, but at runtime, the program undergoes dynamic binding --- the subclass's own

This is what it looks like when compiled:

At runtime, the compiler quietly changes the address of the animal.eat method to 0x56

Parent class references point to subclass objects:

// Bird bird=new Bird("Parrot",2);
//        Animal animal=bird;

Animal animal=new Bird("Parrot",2);

animal.eat()

At this time, the parent class reference can only access its own methods. If you want to access the unique methods of the subclass, you need to downcast

2. What is polymorphism:

public static void function(Animal animal) {
    animal.eat();//The caller doesn't care who eats
}

public static void main(String[] args) {
    function(new Bird("Parrot",2));
    function(new Dog("dog",1));
}

The parent class reference refers to the subclass object. Through the parent class reference, the rewritten method is called. At this time, dynamic binding occurs. At this time, the parent class reference is only this one, but the object I reference is different. By calling the same method, we found that the form of expression at this time is different, and this phenomenon is called polymorphism

3. The application of polymorphic thinking (drawing graphics)

package polymorphism;
class Shape{
    public void draw(){
        System.out.println("draw graphics");
    }
}
class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("rectangle");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("round");
    }
}
class Triangle extends Shape{
    @Override
    public void draw() {
        System.out.println("△");
    }
}
public class Test2 {
    public static void drawMAP(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
       Rect rect=new Rect();
       Cycle cycle=new Cycle();
       Triangle triangle=new Triangle();
       drawMAP(rect);
       drawMAP(cycle);
       drawMAP(triangle);
    }
}

Suppose the graphics to be drawn now are in the shape array

    public static void main(String[] args) {
        Rect rect=new Rect();
        Cycle cycle=new Cycle();
        Triangle triangle=new Triangle();
        Shape[]shapes={rect,cycle,rect,cycle,rect,triangle};
        for (Shape shape:shapes) {
            //If the current shape reference object rewrites the draw method, it will be called, if not, it will call its own (already up-transformed and dynamically bound)
            shape.draw();
        }
    }

If not using polymorphism

Four. The benefits of polymorphism:

1. Reduce the cyclomatic complexity (reduce the number of conditional loop statements)

2. Strong expansion ability

to add on:

To summarize the difference between rewriting and overloading:

Method overloading is static binding. At compile time, the specific method is known according to the actual parameter type at compile time.

Method rewriting is dynamic binding. At runtime, determine which method to call,

 

Rewriting is to rewrite and build another bow and arrow. Overloading is to add functions on the original basis.

That is: method overloading is a polymorphic expression of a class, and method rewriting is a polymorphic expression of a subclass and a parent class

Downward transformation

unsafe:

Compile without error:

   //Indicates downcasting is not safe
    public static void main(String[] args) {
        Animal animal = new Dog("dog", 16);
        Bird bird = (Bird) animal;
        bird.fly();
    }


    public static void main1(String[] args) {
        Animal animal=new Bird("the bird",2);
        Bird bird=(Bird)animal;//Downward transformation, parent class type to subclass type
        bird.fly();
    }

When running, main displays: (a dog is not a bird)

main1 is fine because subclasses have this property (birds are animals)

Modify the code:

Introduce instance of

public static void main(String[] args) {
        Animal animal = new Dog("dog", 16);
        if (animal instanceof Bird) {
            //Not all animals are birds
            Bird bird = (Bird) animal;
            bird.fly();
        }
    }

Gouzi is not a bird. Obviously, there is no output and cannot be transformed downwards

Tags: Java JavaSE

Posted by dreamscape on Sat, 19 Nov 2022 11:22:21 +0530