JavaSE-10 【面向对象OOP--多态】

JavaSE-10 【多态】

第一章 多态

1.1 多态的概述

• 1、多态是继封装、继承之后，面向对象编程的第三大特性
• 2、 现实中的事物通常会体现出多种形态 ，就是一个事物多种形态
• 3、 多态表现为父类引用变量可以指向子类对象 ，前提条件为必须存在继承关系并且要有方法的重写

1.2 多态的格式和使用

• 格式：
  • 父类类型 变量名称 = new 子类类名();
  • 接口名称 变量名称 = new 实现类名();

/**
 * 父类
 */
public class SuperClass {
    public void method1(){
        System.out.println("父类的成员方法");
    }
    public void method2(){
        System.out.println("父类特有，子类没有");
    }
}

/**
 * 子类
 */
public class SubClass extends SuperClass{
    @Override
    public void method1() {
        System.out.println("子类重写的父类的方法");
    }
}

/**
 * 多态：一种事物多种形态，即父类引用指向子类对象
 * 格式：
 *      父类名称 对象名 = new 子类名称();
 *      接口名称 变量名 = new 实现类名();
 */
public class TestPolymorphic {
    public static void main(String[] args) {
        //格式：父类类型 变量名称 = new 子类类名();
        //多态：父类引用指向子类对象
        SuperClass superClass = new SubClass();
        //调用方法
        superClass.method1();//编译是看左面，运行是看右面，右面没有，向上一级找到
        superClass.method2();//先找子类，子类没有，再找父类
    }
}

1.3 多态中成员变量的使用

• 多态访问成员变量：编译运行全部看等号左边
  • 1、直接通过对象名称访问成员变量
  • 2、通过成员方法获取变量

public class Father {
    int num = 200;

    public void getVariable(){
        System.out.println(num);
    }
}

public class Son extends Father{
    int num = 100;
}

/**
 * 多态访问成员变量：编译运行全部看等号左边
 *  1、直接通过对象名称访问成员变量
 *  2、通过成员方法获取变量
 */
public class TestVariable {
    public static void main(String[] args) {
        //多态写法
        Father father = new Son();
        //方式一：直接通过对象访问变量
        System.out.println(father.num);//200 访问的是父类的变量

        System.out.println("----------------------");
        //方式二：通过成员方法访问变量
        Father father1 = new Son();
        father.getVariable();//200 编译看左边，运行看右边，子类没有，再找父类
    }
}

1.4 多态中成员方法的使用

• 多态访问成员方法：编译时看左边，运行时看右边，子类没有，再向上找

public class Father {
    int num = 10;
    public void smoking(){
        System.out.println("父类特有的方法");
    }
    public void showNum(){
        System.out.println("父类的成员变量是："+num);
    }
}

public class Son extends Father{
    int num = 20;

    public void code(){
        System.out.println("儿子在写代码");
    }

    @Override
    public void showNum(){
        System.out.println("儿子的成员变量是："+num);
    }
}

/**
 *  多态访问成员方法：编译时看左边，运行时看右边，子类没有，再向上找
 */
public class TestMethod {
    public static void main(String[] args) {
        //多态：父类引用指向子类对象
        Father father = new Son();
        //调用成员方法
        father.smoking();//父子都有，找子类
        father.showNum();//子类没有。看父类，向上找
        //father.code();//错误写法，编译不通过，父类中没有此方法
    }
}

1.5 使用多态的优点

• 1、提高了代码的可维护性，提高了代码的扩展性
• 2、 可以当做形式参数，可以接受任意子类对象

第二章 对象类型转换

2.1 对象的向上转型

• 定义：创建一个子类对象，把它当做父类对象来使用
• 格式：父类名称 对象名称 = new 子类名称();
• 从小范围转换成更大范围，向上转型是安全的

2.2 对象的向下转型

• 定义：基于向上造型的前提下，将父类对象还原成本身的子类对象
• 格式：子类类型 对象名称 = (子类类型) 父类对象名称;
• 从大范围转换成小范围，向下造型不安全

//父类
public abstract class Animal {
    //定义抽象方法
    public abstract void eat();
}

//子类
public class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃老鼠");
    }

    //子类特有方法
    public void snoring(){
        System.out.println("猫睡觉打呼噜");
    }
}

/**
 * 对象的向上造型：父类引用指向子类对象
 *  格式：父类名称 对象名称 = new 子类名称();
 * 对象的向下造型：将父类对象还原成本身的子类对象，必须基于向上造型的基础上
 *  格式：子类类型 对象名称 = (子类类型) 父类对象名称;
 */
public class TestDemo {
    public static void main(String[] args) {
        //向上造型
        Animal animal = new Cat();
        //调用方法
        animal.eat();
        //调用子类特有方法
        //animal.snoring();//编译错误,向上转型无法调用子类特有的方法

        //向下造型
        Cat cat = (Cat) animal;
        //调用特有的方法
        cat.snoring();
    }
}

2.3 instanceof的用法

• 作用：判断父类引用指向的子类对象的类型
• 格式：对象名 instanceof 类型
• 注意：结果是一个boolean值，判断等号左边的对象是否可以作为后面对象类型的一个实例

public abstract class Animal {
    public abstract void eat();
}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫咪爱吃鱼");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("大黄狗吃骨头");
    }
}

/**
 * 判断父类引用指向的子类对象的类型
 * 格式：对象名 instanceof 类型
 * 注意：结果是一个boolean值，判断等号左边的对象是否可以作为等号右边对象类型的一个实例
 */
public class TestInstanceof {
    public static void main(String[] args) {
        //向上造型
        Animal animal = new Cat();
        animal.eat();

        System.out.println("-------------------");

        //向下造型，先判断
        if (animal instanceof Dog){//判断一下父类引用本类是否是Dog
            Dog dog = (Dog) animal;
            dog.eat();
        }
        else if (animal instanceof Cat){//判断一下父类引用本类是否是Cat
            Cat cat = (Cat) animal;
            cat.eat();
        }else {
            System.out.println("两者都不是");
        }
    }
} 

2.4 向下造型的异常

• 如果等号左边的对象不是等号右边的对象类型的一个实例，那么就会报类型转换异常
• java.lang.ClassCastException

/**
 * 向下造型异常
 */
public class TestEception {
    public static void main(String[] args) {
        //向上造型
        Animal animal = new Cat();
        animal.eat();

        //向下造型
        Dog dog = (Dog) animal;
        dog.eat();
    }
}