灵雪的java12

day12

今天学习了多态

定义

​ 多态:是指同一行为,具有多个不同的表现形式。

​ 生活中,比如跑的动作,猫,狗,大象跑起来的动作都是不一样的,再比如飞的动作,昆虫、鸟类、人造飞机,飞起来的动作内容都是不一样的。可见,同一行为,通过不同的事物,可以表现出不同的形态。多态,描述的就是这样的一种状态。

 #### 		前提
  1. ​ 继承或者实现【二选其一】

  2. ​ 父类的引用指向子类的对象 【格式体现】

  3. ​ 方法的重写 【意义:不重写,是无意义的】

    多态的表现

    ​ 多态表现的格式:

    父类类型  变量名  = new 子类对象;
    变量名.方法名();
    

    备注:父类类型指的是子类对象继承的父类类型,或者实现的父接口类型

    public class  Fu {
        public void method() {
            System.out.println("这是父类的method方法");
        }    
    }
    // 1. 继承关系
    public class Zi extends Fu {
        // 2. 方法的重写
        @Override
        public void method(){
            System.out.println("这是子类的method方法被执行。。。");
        } 
    }
    // polymorphism  多态
    public class TestPolyDemo01 {
        public static void main(String[] args) {
            // 多态的格式
           /*
              父类类型  变量名  = new 子类对象;
              变量名.方法名();
            */ 
            // 3.父类的引用指向了子类的对象
            Fu fu = new Zi();
            fu.method();// 本质调用的是子类当中重写之后的method方法
        }
    }   
    

    如果在使用多态方式调用方法时,首先检查父类当中是否有该方法,如果没有,则编译报错,如果有,执行的是子类重写后的方法。

    多态的好处

    在实际开发中,父类类型作为方法的形式参数(不同于实际参数),传递子类对象(实参)给方法,进行方法的调用,更能体现出多态的扩展性和便利性。代码如下:

    // 定义抽象的父类
    public abstract class Animal{
        // 定义一个抽象的方法
        public abstract void eat();
        public void run(){
            System.out.println("用脚跑。。。");
        }
    }
    // 定义子类
    public class Cat extends Animal {
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    public class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("狗啃骨头");
        }
    }
    public class Bird extends Animal {
        @Override
        public void eat(){
            System.out.println("鸟吃虫");
        }
    }
    
    // 定义测试类
    public class TestDemo03 {
        
        public static void main(String[] args) {
            // 根据不同的对象,来表现不同的吃的内容
            Cat c = new Cat();
            showCatEat(c);// 猫吃鱼
            
            Dog dog = new Dog();
            showDogEat(dog);// 狗啃骨头
            
            Bird bird = new Bird();
            bird.eat();// 鸟吃虫子。。
            
            Cat c2 = new Cat();
            showAnimalEat(c2);
            
            // 
            Dog dog2 = new Dog();
            showAnimalEat(dog2);
            
        }
    	
       /* public static void showCatEat(Cat cat) {
            cat.eat();// 猫吃鱼
        }
        public static void showDogEat(Dog dog) {
            dog.eat();
        }
        public static void showBirdEat(Bird bird) {
            bird.eat();
        }*/
        
        /*
           以上三个方法可以用来多态进行优化,可以被showAnimalEat方法所替代
        */
        public static void showAnimalEat(Animal animal) {
            animal.eat();
            animal.run();
        }
        
    }
    
    

    说明:用于多态特性的支持,showAnimalEat方法当中的Animal类型,是Cat和Dog的父类类型,父类类型接收子类对象,当然可以把cat对象和dog对象传递给方法。

    当程序执行过程中。执行eat方法实际执行的是各自子类对象重写之后的eat方法

    不仅仅可以做到替代,在扩展性方面,无论之后出现多个子类,都不需要编写showXxxEat方法了,直接使用showAnimalEat()方法了。

    所以,多态的好处,体现在可以使程序编写更简单,并且具有良好的扩展性。

访问类中成员变量有两种方式:
		1. 直接通过对象名访问成员变量:看等号左边是谁,优先用谁,没有继续往上找

  			2. 间接通过成员方法访问成员变量:看该方法属于谁,优先用谁,没有则继续往上找。
// 定义一个父类
public class Fu {
    int num = 10;
    // 定义成员方法
    public void showNum() {
        System.out.println(num);
    }
}
// 定义子类
public class Zi extends Fu {
    int num = 20;  
    @Override
    public void showNum(){
        System.out.println(super.num);
    }
}
// 定义测试类
public class TestPolyFieldDemo01 {
    public static void main(String[] args) {
        // 多态的表示形式
        // 父类类型 变量名 = new 子类对象;
        // 变量名.成员变量名
        Fu fu = new Zi();
        System.out.println(fu.num);// 10  
        fu.showNum();// 20
        Zi zi = new Zi();
    }   
}

引用数据类型的转型

​ 多态的转型分为向上转型和向下转型两种:

###### 向上转型

​ 向上转型:多态本身就是子类类型向父类类型向上转型的过程,这个过程师默认的。

当一个父类引用指向了一个子类对象时,便是向上转型。

​ 使用格式:

父类类型  变量名 = new 子类类型();
比如: Animal animal = new Cat();
向下转型

​ 向下转型:父类类型向子类类型向下转换的过程,这个过程是强制的。

​ 一个已经向上转型的子类对象,将父类的引用转为子类应用,可以使用强制类型转换的格式,便是向下转型。

使用格式:

子类类型  变量名  = (子类类型) 父类变量名;
比如: Cat cat = (Cat) animal;
转型的异常

​ 在进行向下转换的过程中,一不小心就出现java.lang.ClassCastException类型转换异常。

为了避免这种类型转换异常的发生,Java提供了instanceof关键字,给引用变量做类型的校验。

格式如下:

变量名  instanceof  数据类型
如果变量属于该数据类型,则返回true
如果变量不属于该数据类型,则返回false

所以,我们在转换前,我们最好先进行引用变量的类型判断,代码如下:

public class Test {
    
    public static void main(String[] args) {
        // 向上转型
        Animal animal = new Cat();
        // 向下转型
        if (animal instanceof Cat) {
            // 表明你就是一只猫
            Cat cat = (Cat) animal;
            cat.eat();// 吃鱼
            cat.catchMouse();// 逮老鼠
        } else if (animal instanceof Dog) {
            // 表明你就是一只狗
            Dog dog = (Dog) animal;
            dog.lookDoor();
        }
    }
}
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页