15面向对象之多态

多态

1. 概念

多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

比如，你的女盆友让你买点水果回来，不管买回来的是苹果还是西瓜，只要是水果就行，这个就是生活中多态的体现

再比如，小猫、小狗、小猪我们可以把他们都归纳成小动物，每种小动物都需要吃东西,所以我们可以统一设置他们都必须吃，但是每种小动物的习性不一样，那这个就可以设置成小动物自己特有的功能,多态对象只能调用父类中定义子类中重写的功能,并不能调用子类的特有功能,这样就实现了代码的统一

class Animal{//1.定义父类Animal
	....eat(){syso("吃啥都行")}
}
class Cat extends Animal{//2.1定义子类Cat
	....eat(){syso("吃小鱼干")}
	....jump(){syso("小猫爱跳")}
}
class Dog extends Animal{//2.2定义子类Dog
	....eat(){syso("吃肉骨头")}
	....run(){syso("小狗爱跑")}
}
main(){
	//3.创建子类对象
	Cat c = new Cat();//小猫是小猫
	Dog d = new Dog();//小狗是小狗
	Pig p = new Pig();//小猪是小猪
	//4.创建多态对象(父类引用指向子类对象/编译看左边,运行看右边)
	Animal a1 = new Cat();//小猫是小动物
	Animal a2 = new Dog();//小狗是小动物
	a1.eat();//吃小鱼干
	a2.eat();//吃肉骨
	//a1.jump();//报错:多态对象把自己看做父类型,不能调用子类特有方法
	//a2.run();//报错:同上,如果想要调用子类特有功能,就创建子类对象

2 . 特点

1. 多态的前提1：是继承
2. 多态的前提2：要有方法的重写
3. 父类引用指向子类对象,如：Animal a = new Cat();
4. 多态中，编译看左边，运行看右边
   

3. 练习：多态入门案例

创建包: cn.tedu.oop
创建类: TestDemo.java

package cn.tedu.oop;
/**本类用于回顾多态*/
//1.多态的前提:继承+重写
//2.父类引用指向子类对象 编译看左边,运行看右边
/**如果想要调用子类特有调用的功能,创建子类对象即可
 * 如果想要父类定义规则,子类实现,统一调用标准,创建多态对象*/
public class ReviewDemo {
    public static void main(String[] args) {
        //6.创建纯纯的子类对象进行测试
        Animal a = new Animal();
        Cat c = new Cat();
        Dog d = new Dog();
        //a.eat();//小动物吃啥都行
        c.eat();//小猫爱吃小鱼干
        d.eat();//小狗爱吃肉骨头
        c.jump();//喜欢跳
        d.run();//喜欢跑
        //7.创建多态对象进行测试
        Animal a2 = new Cat();
        Animal a3 = new Dog();
        a2.eat();
        a3.eat();
//        a2.jump();
//        a3.run();
    }
}

//3.1创建父类
class Animal{
    //4.1创建父类的eat()
    public void eat(){
        System.out.println("小动物吃啥都行");
    }
}
//3.2创建子类
class Cat extends Animal{
    //4.2小猫类重写父类的eat()
    //@Override
    public void eat(){
        System.out.println("小猫爱吃小鱼干");
    }
    //5.1小猫类添加自己特有的功能jump()
    public void jump(){
        System.out.println("小猫喜欢跳");
    }
}
class Dog extends Animal{
    //4.3小狗类重写父类的eat()
    //@Override
    public void eat(){
        System.out.println("小狗爱吃肉骨头");
    }
    //5.2小狗类添加自己特有的功能run()
    public void run(){
        System.out.println("小狗喜欢跑");
    }
}

4. 多态的好处

1. 多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法
2. 提高了程序的可扩展性和可维护性

5. 多态的使用

前提:多态对象把自己看做是父类类型

1. 成员变量: 使用的是父类的
2. 成员方法: 由于存在重写现象,所以使用的是子类的
3. 静态成员: 随着类的加载而加载,谁调用就返回谁的

6. 练习：多态成员使用测试

创建包: cn.tedu.oop
创建类: TestDemo2.java

package cn.tedu.oopstatic;
/**本类用于多态中的元素测试*/
public class TestDemo2 {
	public static void main(String[] args) {
		//7.创建子类对象进行测试
		Dog2 d = new Dog2();
		System.out.println(d.sum);//20
		d.eat();//小狗要吃肉骨头
		d.play();//小狗爱打滚儿~~~
		
		//10.创建多态对象进行测试
		/**口诀1:父类引用指向子类对象*/
		/**口诀2:编译(保存)看左边,运行(测试)看右边*/
		Animal2 a = new Dog2();
		/**2.多态中,成员变量使用的都是父类的*/
		System.out.println(a.sum);//10
		/**3.多态中,成员方法使用的是父类的声明,子类的实现*/
		a.eat();
		/**4.多态中,如果父子类都有静态方法,使用的是父类的*/
		a.play();//玩啥都行
	}
}

//1.创建父类
class Animal2{
	//2.创建成员变量
	int sum = 10;
	//3.创建成员方法
	public void eat() {
		System.out.println("吃啥都行");
	}
	//8.父类中定义静态方法play()
	public static void play() {
		System.out.println("玩啥都行");
	}
}
/**1.多态的前提:继承+重写*/
//4.定义子类Dog2
class Dog2 extends Animal2{
	//5.定义子类的成员变量
	int sum = 20;
	//6.重写父类的eat()
	/**@Override 这个注解加在方法上,表示这是一个重写的方法*/
	@Override //注解--标签
	public void eat() {
		System.out.println("小狗要吃肉骨头");
	}
	
	//9.定义子类的静态方法play()
	//@Override --不是重写,不能加这个注解
	public static void play() {
		System.out.println("小狗爱打滚儿~~~");
	}
}
	/**注意!!!静态资源属于类,不存在重写现象,只是两个类中有同样声明的方法而已,不属于重写*/

7 拓展

7.1 设计汽车综合案例

创建包: cn.tedu.oopexec
创建类: DesignCar.java

package cn.tedu.design;
/*本类用于完成OOP汽车设计综合案例*/
public class DesignCar {
    //创建程序的入口函数
    public static void main(String[] args) {
        //8.创建一个纯纯的父类对象进行测试
        Car c = new Car();
        System.out.println(c.getColor());//null,需要使用get()/默认值
        c.start();//父类自己的功能
        c.stop();//父类自己的功能
        //c.fly();//父类不能使用子类的特有功能
        //9.创建一个纯纯的子类宝马类对象
        BMW b = new BMW();
        System.out.println(b.color);//五彩斑斓的黑,子类新定义的同名属性
        b.start();//没重写，使用的是父类的功能
        b.stop();//重写了，使用的是自己重写以后的功能
        //10.创建一个纯纯的子类保时捷类对象
        BSJ b2 = new BSJ();
        System.out.println(b2.getColor());//null
        System.out.println(b2.color);//黑不溜秋的白
        b2.start();//使用的是继承过来的父类中的功能
        b2.fly();//使用的是子类特有的功能
    }
}

//1.通过归纳总结，使用关键字class抽象封装形成一个"类"组件来描述一类事物
class Car{
    //2.属性--通过成员变量来描述
    //2.1 属性的封装--通过关键字private对属性进行封装
    private String brand;//品牌
    private String color;//颜色
    private double price;//价格
    private double size;//尺寸

    //3.行为--通过方法来描述
    public void start(){
        System.out.println("我的车车启动啦~");
    }
    public void stop(){
        System.out.println("哎呀妈，我的车车熄火了~");
    }

    //2.2 给被封装的属性提供公共的属性值设置和访问方式--GetXxx()、SetXxx()
    //快捷方式：右键->Generate->Getter and Setter->Shift全选->ok
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getSize() {
        return size;
    }

    public void setSize(double size) {
        this.size = size;
    }
}

//4.创建一个宝马类并且继承汽车类--通过关键字extends建立继承关系
class BMW extends Car{
    String color = "五彩斑斓的黑";
    //6.子类对父类方法不满意时可以重写父类中的方法
    //重写遵循两同两小一大原则，重写后，子类对象使用重写后的方法
    @Override
    public void stop(){
        System.out.println("宝马当然要帅气的停的稳当些啦~");
    }
}
//5.创建一个保时捷类并且继承汽车类--通过关键字extends建立继承关系
class BSJ extends Car{
    String color = "黑不溜秋的白";
    //7.新增子类特有功能--父类不可使用，只有子类对象可使用此功能
    public void fly(){
        System.out.println("启动加速度，我要起飞啦UP~UP~");
    }
}

7.2 静态变量和实例变量的区别

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

7.3 向上转型和向下转型

在JAVA中，继承是一个重要的特征，通过extends关键字，子类可以复用父类的功能，如果父类不能满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。
在应用中就存在着两种转型方式，分别是：向上转型和向下转型。
比如：父类Parent,子类Child
向上转型：父类的引用指向子类对象Parent p=new Child();
说明：向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类的方法就根据这个引用指向调用子类重写方法。
向下转型(较少)：子类的引用的指向子类对象，过程中必须要采取到强制转型。
Parent p = new Child();//向上转型，此时，p是Parent类型
Child c = (Child)p;//此时，把Parent类型的p转成小类型Child
//其实，相当于创建了一个子类对象一样，可以用父类的，也可以用自己的
说明：向下转型时，是为了方便使用子类的特殊方法，也就是说当子类方法做了功能拓展，就可以直接使用子类功能。