Day11Super和多态

Super和多态

第一节：方法的重写：

产生继承关系后，父类的方法无法满足子类需求时，子类可以定义和父类完全相同的方法，来满足自己的功能

称之为方法的覆盖(override)

方法覆盖的语法：

class Student{
	String name;
	String sex;
	public void study(){
		
	}
}
//产生继承关系后，xxx类继承过来一个方法study
class xxx extends Student{
	//父类的study方法无法满足需求，子类要进行重写
	public void study(){
		//逻辑代码
	}
}

方法重写的要求：
1.返回值类型、方法名称、参数列表要与父类完全相同
2.方法访问权限修饰符要么和父类相同，要么比父类更宽泛（private --> default -->protected --> public）

方法覆盖的执行流程：

当子类覆盖父类方法后，调用时优先执行子类覆盖后的方法

注意事项：

当子类继承父类的方法后，在子类当中隐式存在，当要进行编写相同方法的时候，一定要注意：如果参数列表不同，则实现的方法的重载。如果完全相同，则实现的是方法的重写。

面试题：

1.方法的重载和重写的区别

1.1.语法不同

1.2.场景不同

第二节：super关键字

场景：当子类和父类拥有重名的属性或方法时，子类想父类的属性或方法，加super.进行区分。

super里面存放的是父类引用的地址

class Student{
	String name = "学生";
	int age;
	public void study(){
		System.out.println("在自习室里学习");
	}
}
class xxx{
    String name = "谭某某";
    public void study(){
        super.study();//调用的是父类的study方法
        System.out.println(super.name+name);
    }					 //调用的是父类的name属性
}

super可以访问：

父类中的属性

父类中的方法

在使用super关键字的时候，一定要对其加 以区分：

1、this所代表的是当前对象。 当前对象的地址。

2、super代表的是父类对象 父类的地址。

super.可以在子类的方法中访问父类的属性和方法。
格式：  super.name;  super.age = 19;

super访问父类构造方法：

super访问父类的无参构造方法：

super（）；//调用父类的无参构造方法。必须放在构造方法的首行，如若不书写，则默认隐式存在首行。

super(实参);//调用父类的有参构造方法。必须在构造方法的首行，如若不书写，则默认隐式提供一个super();无参的

注意：

在同一个构造方法中，this()和super()不能同时存在。

继承后的对象创建过程：

第三节 多态

父类引用指向子类对象，从而产生多种形态:

父类引用     指向   子类对象
Animal animal = new Dog();

当父类引用指向子类对象后，仅可调用父类自身的属性和方法，不可调用子类独有的属性和方法。

当父类方法被子类方法覆盖后，父类引用调用的是子类覆盖后的方法。

3.1多态应用场景一：

把父类作为方法的形参，根据实际传入的实参，来决定实际子类对象。

 //1.多态的体现：  父类作为方法的形参，调用该方法时，参数可以传子类。从而实现多种形态。
    public void goHome(Vehicle vehicle){//方法的参数是交通工具父类，可以根据传入的工具，调用不同的行驶
        System.out.println("我要回家了！");
        vehicle.run();//乘坐交通工具回家~具体是什么交通工具，则看方法的形参实际类型是什么
    }
以上的代码根据调用时传入的子类实际对象，来决定调用的是哪个子类的覆盖后的eat方法

3.2 多态应用场景二：

把父类作为方法的返回值类型，使方法可以返回不同的子类对象

 //2.多态的体现：  父类作为方法的返回值类型，调用完该方法后，返回的是子类，不关心具体类型，统一父类类型。从而实现多态
    public Vehicle ByVehicle(int money){ // 2块骑自行车  5块 做公交   100  打小汽车
        Vehicle vehicle = null;
        if(money >=100){
           vehicle = new Car();//装箱。 子类到父类！  向上转型！
            vehicle.type="宝马";
            vehicle.price = 1300000;
            vehicle.speed = 100;
        }else if(money >=5){
            vehicle =  new Bus();//装箱。 子类到父类！
            vehicle.type="金龙";
            vehicle.price = 2300000;
            vehicle.speed = 80;
        }else if(money >=2){
            vehicle =  new Bicycle();//装箱。 子类到父类！
            vehicle.type="捷安特";
            vehicle.price = 1500;
            vehicle.speed = 600;
        }
        //80个选择
        return vehicle;//如果一个交通工具都无法满足，那只能不乘坐交通工具！
    }

第四节：向上转型 & 向下转型

向上转型：

父类引用保存子类对象，称为向上转型（多态的核心概念）

注意：当父类引用当中保存的是子类的对象，父类就仅可调用自身得方法以及子类重写后的。

父类 引用名 = new 子类();

向下转型

将父类引用中的实际对象，强制转换为实际对象的类型，使用子类独有属性和方法。
子类类型 引用名 = （子类类型）父类引用名;

instanceof

		//父类引用里  是不是   子类真实类型
        if(v instanceof Car){
            Car car = (Car) v;//前后类型如果不匹配，则会报ClassCastException 类型转换异常
            car.name = "740i";
        }else if(v instanceof  Bus){
            Bus bus = (Bus)v;
            bus.sitNums = 300;
        }else if(v instanceof  Bicycle){
            Bicycle bicycle = (Bicycle)v;
            bicycle.color = "骚红";
        }
使用instanceof 可以在向下转型时。由于前后类型不匹配无法转换报错，避免ClassCastException异常。

00;
}else if(v instanceof Bicycle){
Bicycle bicycle = (Bicycle)v;
bicycle.color = “骚红”;
}
使用instanceof 可以在向下转型时。由于前后类型不匹配无法转换报错，避免ClassCastException异常。