Java面向对象（四）

多态

什么是多态

多态：理解为一个事物的多种形态

比如在现实生活中每个人都会扮演着不同的身份，比如张三可以是学生身份，可以是一个孩子身份，可以是教师身份，可以是父亲的身份。

Java中多态的体现

子类对象多态性：父类的引用指向子类的对象（或者子类的对象赋给父类引用）

举个例子：

public class Test {
    public static void main(String[] args) {
        //通过多态的形式，将父类引用指向子类的对象
        Person person=new Student();
    }
}

class Person{

}
class Student extends Person{

}

在多态场景下，调用方法时分为编译时和执行时两种。

　　①编译时，认为声明的对象是一个父类的对象（实际上生成的是子类对象），看父类中有什么属性成员和方法成员（即被重写的方法）。

　　②执行时，实际上执行的方法是子类重写父类的方法。

如果出现子类没有重写相对应的方法时，才会去执行父类的方法。

简称：编译看左边，运行看右边。

举个例子：

父类：

class Person {
    public void eat() {
        System.out.println("父亲吃饭");
    }
    public void show(){
        System.out.println("这是一个show方法");
    }
}

子类：

class Student extends Person {
    @Override
    public void eat() {
        System.out.println("儿子吃饭");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //通过多态的形式，将父类引用指向子类的对象
        Person person=new Student();
        //子类重写了eat方法
        person.eat();
        //子类没有重写eat方法
        person.show();
    }
}

效果展示：

 执行时会先执行子类重写父类的方法，如果没有重写方法，才调用父类的方法。

多态的缺点

①在使用多态时，子类的特有方法是会被屏蔽掉的，因为编译的时候父类并没有子类的方法所以是没办法调用的。

②创建子类对象的特有属性和特有方法也会加载到内存中，从而导致内存的浪费。

举个例子：

父类：

class Person {
    public void eat() {
        System.out.println("父亲吃饭");
    }
    public void show(){
        System.out.println("这是一个show方法");
    }
}

子类：

class Student extends Person {
    @Override
    public void eat() {
        System.out.println("儿子吃饭");
    }
    public void play(){
        System.out.println("儿子打游戏");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //通过多态的形式，将父类引用指向子类的对象
        Person person=new Student();
        //儿子中独特的play()方法
        //person.play() 由于父类并没有这个play()方法，所以编译时无法调用play()方法
    }
}

由于父类并没有这个方法，无法调用play()方法。

多态的优点

①提高代码的维护性，比如一个饲养员有一个饲养的方法，不可能每有一种动态就写一个饲养方法这样不合理，而多态的实现只需要写一个方法里面调用不同对象的方法，代码维护性提高。

②提高代码的扩展性，只需要改变每个对象的方法即可，不需要修改饲养员的饲养方法。

多态的前提

多态的两个前提条件是：

　　①存在继承关系：多态是基于继承关系建立的，即一个类可以派生出另一个类。在多态中，存在一个父类和多个子类，子类继承了父类的属性和方法。

　　②存在重写关系：多态要求子类能够重写父类的方法。子类在重写方法时可以根据自己的需求对方法进行不同的实现，从而实现实现多态的效果。

向上转型和向下转型

举个图例：

向上转型

多态就是向上转型：将子类的对象赋值给父类（程序是自动实现的，缺点是失去子类的特有的属性和方法）

语法：

父类   对象名  =  new   子类();

向下转型

把父类的对象转为子类的对象（需要强制转换）

语法：

子类类型  对象名  =  (子类类型)  父类引用

举个例子：

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal animal=new Cat();
        //向下转型，需要强制转换
        Cat cat = (Cat) animal;
        cat.eat();
    }
}

class Animal{

}
class Cat extends Animal {
    public void eat(){
        System.out.println("小猫吃鱼");
    }
}
class Dog extends Animal{
    public void  eat(){
        System.out.println("小狗吃骨头");
    }
}

效果展示：

代码上是没有任何问题的，但是当两者之间没有继承关系时是没办法强转的，否则会ClassCastException类型转换异常。

 

举个例子：

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal animal=new Cat();
        Animal animal1=new Dog();
        //向下转型，需要强制转换
        Dog dog=(Dog) animal;//发现现在编译是没出错哦
    }
}

class Animal{

}
class Cat extends Animal {
    public void eat(){
        System.out.println("小猫吃鱼");
    }
}
class Dog extends Animal{
    public void  eat(){
        System.out.println("小狗吃骨头");
    }
}

发现编译时并没有任何问题，但是效果展示：

就是因为上面代码中，animal是猫的对象它能变成小狗对象吗？很明显，小猫怎么可能变成小狗对吧。

所以运行时会出现类型转换异常。

instanceof关键字

正因为上面向下转型可能会出现异常，所以这里用到instanceof关键字来判断左边的对象是否为右边的类。

语法：

a instanceof A ：判断对象a是否为A类的实例
当对象a是类A的实例：返回true
当对象a不是类A的实例： 返回false

举个例子：

public class Test {
    public static void main(String[] args) {
        //向上转型
        Animal animal=new Cat();
        Animal animal1=new Dog();
        //向下转型，需要强制转换
        if(animal instanceof  Dog){
            Dog dog=(Dog) animal;//发现现在编译是没出错哦
        }else{
            System.out.println("animal不是Dog类的实例");
        }
    }
}

class Animal{

}
class Cat extends Animal {
    public void eat(){
        System.out.println("小猫吃鱼");
    }
}
class Dog extends Animal{
    public void  eat(){
        System.out.println("小狗吃骨头");
    }
}

效果展示：

判断出来animal并不是Dog类的实例所以不会执行

这句代码：Dog dog=(Dog) animal直接输出"animal不是Dog类的实例"