唠唠SE的面向对象-10——多态

2019独角兽企业重金招聘Python工程师标准>>>

10. 多态

我们先看一个例子：动物类实例化出人和猪

abstract class Animal {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

class Person extends Animal {
    
}

class Pig extends Animal {
    
}

public class Test1 {
    public static void main(String[] args) {
        Animal person = new Person();
        Animal pig = new Pig();
    }
}

难道人和猪都是一个祖师爷？？？？？？（黑人问号.jpg）

这就是所谓的多态。。。。。。

 

多态的原理：

1：当父类和子类具有相同的非静态成员变量，那么在多态下访问的是父类的成员变量

class Animal {
    public String name = "animal";
}

class Person extends Animal {
    public String name = "person";
}

public class Test1 {
    public static void main(String[] args) {
        Animal person = new Person();
        System.out.println(person.name); // animal
    }
}

2：当父类和子类具有相同的静态成员变量，那么在多态下访问的是父类的静态成员变量

        所以：父类和子类有相同的成员变量，多态下访问的是父类的成员变量。

class Animal {
    public static String name = "animal";
}

class Person extends Animal {
    public static String name = "person";
}

public class Test1 {
    public static void main(String[] args) {
        System.out.println(Animal.name); // animal
        System.out.println(Person.name); // person
        Animal person = new Person();
        System.out.println(person.name); // animal
    }
}

3：当父类和子类具有相同的非静态方法（就是子类重写父类方法），多态下访问的是子类的成员方法。

class Animal {
    public void say() {
        System.out.println("animal。。。");
    }
}

class Person extends Animal {
    public void say() {
        System.out.println("person。。。");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Animal person = new Person();
        person.say(); // person
    }
}

4：当父类和子类具有相同的静态方法（就是子类重写父类静态方法），多态下访问的是父类的静态方法。

class Animal {
    public static void say() {
        System.out.println("animal。。。");
    }
}

class Person extends Animal {
    public static void say() {
        System.out.println("person。。。");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Animal person = new Person();
        person.say(); // animal
    }
}

 

多态的特点：

1：编译时期，参考引用型变量所属的类是否有调用的方法，如果有，则编译通过，没有则编译失败

2：运行时期，参考对象所属类中是否有调用的方法。

3：总之，成员非静态方法在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点，无论编译和运行参考左边（引用型变量所属的类）。

在多态中，静态成员函数特点，无论编译和运行都参考左边

多态可以作为参数传入，可以作为返回值传出。（这部分在集合中体现的更为清晰，建议同集合部分一起食用，效果更佳￣へ￣）

 

 

 

多态可以实现隐式与显式的类型转换。向上转型为父类/接口，访问范围变小；向下转型为子类，访问范围变大，但需要强转。

Animal animal = new Person();
Person person = (Person) animal;

instanceof关键字：判断对象是否属于某个类

1：属于比较运算符：

2：instanceof关键字：该关键字用来判断一个对象是否是指定类的对象。

3：用法：对象 instanceof 类;

public class Test1 {
    public static void main(String[] args) {
        Animal animal = new Person();
        System.out.println(animal instanceof Person); // true
    }
}

该表达式是一个比较运算符，返回的结果是boolean类型 true|false

注意：使用instanceof关键字做判断时，两个类之间必须有关系，否则会在编译期报错。

 

class Person extends Animal {
    public static void say() {
        System.out.println("person。。。");
    }
}

class Pig {
    public static void say() {
        System.out.println("噜噜噜。。。");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person instanceof Pig); // 编译报错
    }
}

 

 

转载于:https://my.oschina.net/LinkedBear/blog/1615176