Java – Object-oriented programming – polymorphic

For Java, the implementation mechanism of polymorphic follow one principle: when the superclass object reference variable reference subclass object, is the type of the reference object rather than a reference variable type whose members decided the call method, but this is the method called must be defined in the parent class, which is covered by a subclass.

upcasting

An upcast occurs when an object referenced by a subclass is converted to a superclass type. In layman’s terms, a subclass object is converted into a superclass object. Here the superclass object can be an interface.

public class Animal {
public void eat(){
System.out.println("animal eatting...");
}
}

public class Cat extends Animal{

    public void eat(){

        System.out.println("Cats eat fish.");
    }
}
public class Dog extends Animal{

public void eat(){
System.out.println("Dogs eat bones.");
}

public void run(){
System.out.println("I can run."); } } public class Main { public static void main(String[] args) { animal = new Dog(); // Animal.eat (); }}Copy the code

Output: Dogs eat bonesCopy the code

Animal Animal = new Dog(); Convert Dog, a subclass object, to Animal. In this case the animal reference calls a subclass method.

Problems needing attention in the process of transformation

• Methods defined separately by subclasses are lost when you transition up. For example, if an animal reference points to an instance of Dog, the run method cannot be accessed.animal.run()Complains.
• Subclass references cannot point to superclass objects.Dog d = (Dog)new Animal()That’s not going to work.

The benefits of upward transition

• Reduce repetitive code and simplify code.
• Improve system scalability.

Downward transition (with pits)

The opposite of upward transformation is downward transformation. A downward transformation is to turn a parent object into a subclass object. Attention, please! There are pits.)

A = new cat (); Cat c = ((Cat) a); c.eat(); // I eat fish d = ((Dog) a); d.eat(); / / error: Java. Lang. ClassCastException: com.chengfan.animal.Cat cannot be cast to com.chengfan.animal.Dog Animal a1 = new Animal(); Cat c1 = ((Cat) a1); c1.eat(); / / error: Java. Lang. ClassCastException: com. Chengfan. Animal. The animal always be cast to com. Chengfan. Animal. The CatCopy the code

Why doesn’t the first code report an error? Because A itself is a Cat object, so of course it can be converted to Cat, and because it’s Cat, it can’t be converted to Dog.

While A1 is an Anmail object, it cannot downcast any subclass of Wie. Like finding a fossil and knowing it’s an animal, but you can’t just say it’s a cat or it’s a dog.

Notes for downward transition

• A downward transition requires that the superclass object refers to a subclass object (that is, it must be upward before it can be downward)

• A downward transition can only turn into this class of objects (cats cannot turn into dogs).

The instanceof keyword: Instanceof is a binary Java and PHP operator (operator) in the same class as ==, >, and <. Because it is composed of letters, it is also a Reserved Java keyword. It determines whether the object on its left is an instance of the class on its right and returns Boolean data. Can be used to determine whether an instance of an inherited subclass is an implementation of the parent class.

Instanceof usually precedes type conversions to avoid exceptions!

Public void eat(Animal a){/* * Subclass refers to an instance (object) of the parent class, which must be used to cast * the instance can call subclass-specific methods * Must meet the transformation condition to convert (), Subclasses cannot cast each other arbitrarily, but a subclass reference to a parent instance can cast the * instanceof operator: returntrue/false, * /if(a instanceof Dog){ Dog d = (Dog)a; d.eat(); d.run(); // Dogs have a way of running}if(a instanceof Cat){  
        Cat c = (Cat)a;
        c.eat();
        System.out.println("I wish I could run, but I can't."); } a.at (); } eat(new Cat()); eat(new Cat()); eat(new Dog());Copy the code

Hua Mulan joined the army in her father’s place

Hua Mulan joins the army for her father, Hua Arc. So at this time Hua Mulan is a subclass, hua Arc is the parent class. The flower arc has its own member attributes age, name, gender. Mulan also has these attributes, but they are obviously completely different. Flower arc has her own non-static method of ‘riding a horse to kill an enemy’, and Mulan also inherited the same method of ‘riding a horse to kill an enemy’ from her father. Hua Arc also has a static method of ‘self-introduction’, everyone can ask hua Arc what his name is. Mulan also has a unique non-static member method of her own: “Paint”. But now Hua Mulan joins the army in her father’s place, disguising herself as a man. This time is equivalent to the parent class reference the name (arc) point to a subclass object (hua mu LAN this person), then access on the rest of the class (and others) subclass objects (hua mu LAN this person) member attributes (name, age, gender, actually saw the hua mulan her father’s name (arc), age (60), gender (male). When accessing the non-static member method of a subclass object (Mulan the person), you see Mulan herself riding a horse to fight a war using her 18 martial arts. When visiting Hua Mulan’s static method (self-introduction), Hua Mulan herself introduces herself to others using her father’s name information. And at this time Mulan cannot use her own unique method of membership ‘paint’.

—– the upward transformation in polymorphism so finally a will be successful ten thousand bones withered, the battle started to win, Hua Mulan bid farewell to the war life. One day, met his beloved man, at this time the power of love will parent class object reference (flower arc this name) forced conversion to subclass object original reference (Hua Mulan this name), so Hua Mulan again become her own, at this time she is completely her own. Name is Hua Mulan, age is 28, gender is female, fighting is still as fierce female man, self-introduction is dignified to tell others my name is Hua Mulan. OMG!!! Finally, it was time to use its own unique member method of ‘painting’. Since then, Hua Mulan has completely returned to the hua Mulan she was before she joined the army for her father. And with their beloved man happy life. —– downward transition in polymorphism

Remember, the upward transformation downward transformation must be under the premise of polymorphism, otherwise forced to change the daughter into a father, or father into a woman, will become Oriental invincible, the system will report an error at this time illegal type conversion. Hahahaha. In addition, the development generally uses the polymorphic declaration formal parameters, and creates the anonymous object of the subclass as the actual parameters. The above.

Polymorphic member access features

• Member variables compile to the left (parent), run to the left (parent)
• Member methods compile to the left (parent class) and run to the right (subclass). Dynamic binding
• Static methods compile to the left (superclass) and run to the left (superclass).

Static is class-specific, not overridden, so access is still left, only non-static member methods, compile to the left, run to the right

Classic Case Analysis

public class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    } 

}

public class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A"); } } public class C extends B{ } public class D extends B{ } public class Test { public static void main(String[] args) {  A a1 = new A(); A a2 = new B(); B b = new B(); C c = new C(); D d = new D(); System.out.println("1--" + a1.show(b));
        System.out.println("2 --" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8 --" + b.show(c));
        System.out.println("9--"+ b.show(d)); }}Copy the code

1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and DCopy the code

When a parent object references a variable that references a subclass object, the type of the referenced object determines whose member method is called, and the type of the referenced variable determines which method can be called. If the method is not overridden in a subclass, it is looked for in the parent class.Copy the code

class X {
    public void show(Y y){
        System.out.println("x and y");
    }

    public void show(){
        System.out.println("only x");
    }
}

class Y extends X {
    public void show(Y y){
        System.out.println("y and y"); } public void show(int i){ } } class main{ public static void main(String[] args) { X x = new Y(); x.show(new Y()); x.show(); }} // result //y and y //only xCopy the code

Show (O), super.show(O), this.show((super)O), super.show((super)O).Copy the code