java-继承和多态

（一）继承

 1.子类与父类的带参数的构造方法和不带参数的构造方法

 2.不是帮父类构造，而是给他初始化

（二）多态

        ⑴多态的概念

        ⑵多态的实现条件

                ①必须在继承体系下

                ②子类必须对父类中方法进行重写

                        Ⅰ重写

                        Ⅱ重写和重载的区别
                ③通过父类的引用调用重写的方法
                ④向上转型
                ⑤动态绑定：
        ⑶多态的优点
                ①可以少使用或者不使用大量的if-else语句（eg：画图形）
                ②可扩展能力强

（一）继承

 1.子类与父类的带参数的构造方法和不带参数的构造方法

 2.不是帮父类构造，而是给他初始化

/**
 * @Author: 黑木~
 * @DATE: 2022/11/11 15:58
 */
class Car{//如果不屏蔽这个<1>在我的这个Car类括号里就有两个构造方法--一个不带参数的构造方法<1>和带参数的构造方法<2>
    public int age;
    public String color;
    Car(){}//<1>  0.1假如我屏蔽了这个地方，那我得对象Car就只能调用我的带参数的构造方法，

    public Car(int age, String color) {//<2>
        this.age = age;
        this.color = color;
    }
}
class txt extends Car {
    //因为它自动和父类一样，子类也要有自己的构造方法，此时我就需要先帮父类构造再构造子类
    txt(int age,String color){
        super(age, color);
    }
    txt(){
        ;//如果屏蔽了<1>,报错--并提示（'com.baidu.demo2.Car' 中没有可用的默认构造函数）

    }
    /*txt(){  在子类自己写一个构造方法行不通
        super();
    }*/

}
public class TestDemo24 {
    public static void main(String[] args) {
        txt t= new txt(12,"red");//也就是说这里需要一个构造方法，编译器不自己提供了
        txt t1 = new txt();//此时调用的是不带参数的构造方法

        Car car = new Car(12,"red");
        car.color="red";
        car.age=22;
    }
    /*
    * 当我在子类和父类都没有写构造方法的时候，他们调用的是编译器自带的不带参数的构造方法
    * 如果要调用有参的构造方法那就自己写一个带参数的构造方法，此时编译器不再自己提供不带参数的构造方法
    * 那我的子类如果要调用无参的构造方法那就自己在父类写一个无参构造方法
    * 总之，不管子类还是父类一个方法都不写那就有自带的，一旦自己写了构造方法那编译器就不自带无参构造方法了
    * */
}

（二）多态

⑴多态的概念：同一个方法引用不同的对象就会有不同的形态（比如画图形）

☟先来个整体的多态思想

class Animalll{
    public String name;
    public void eat() {
        System.out.println("吃饭！");
    }
}
class Doggg extends Animalll {
    @Override
    public void eat() {
        System.out.println(name+"正在狗粮！");
    }
}
class Cattt extends Animalll {
    @Override
    public void eat() {
        System.out.println(name+"正在吃猫粮！");
    }
}
public class TestDemo1 {
    public static void function(Animalll animal) {
        animal.eat();
    }
    public static void main(String[] args) {
        Animalll animalll1 = new Doggg();
        animalll1.name="十四月";
        function(animalll1);
        Animalll animalll2 = new Cattt();
        animalll2.name = "猪猪";
        function(animalll2);
    }
}

 理解代码：

⑵多态的实现条件

①必须在继承体系下

   由上面的代码解释可以看到确实有继承；

这是第一个继承：

 这是第二个继承：

②子类必须对父类中方法进行重写

idear自己提示有两个重写：

Ⅰ重写：返回值和形参都不能改变。即外壳不变，核心重写！

这是父类的eat方法：

这是Doggg重写的eat方法：

这是Cattt重写的eat方法： 

从两个重写的eat方法可以看出 重写的方法只是核心不同，外壳一样；

Ⅱ重写和重载的区别

重写上面有，接下来就说重载：

 所以重写和重载的区别说人话就是：重写只是核心不同，重载是参数列表不同

 不说人话就是：

③通过父类的引用调用重写的方法

④向上转型

 ⑤动态绑定：

⑶多态的优点

①可以少使用或者不使用大量的if-else语句（eg：画图形）

 对上面代码的理解：

 

 

②可扩展能力强

class Shap{
    public void draw() {
        System.out.println("画图形！");
    }
}
class Rect extends Shap {

//Shap里面的画图形是不满足我的需求的

    @Override
    public void draw() {
        System.out.println("画矩形！");
    }
}
class Cycle extends Shap {
    @Override
    public void draw() {

//重写了父类的方法draw（）

        System.out.println("画圆 ！");
    }
}
/*class Flower extends Shap {
    @Override
    public void draw() {
        System.out.println("~❀~");
    }
}*/
public class TestDemo06 {
    public static void drawMap(Shap shape) {
        shape.draw();

//shape这个变量引用的对象不一样，画出的东西就不一样

    }
    public static void main(String[] args) {
        Rect rect = new Rect();
        drawMap(rect);
        Cycle  cycle= new Cycle();
        drawMap(cycle);

        
    }
}

 如果我想继续画花就比较方便：