8、继承 super关键字 重载和重写

1、继承

1.1、特点

1、通过extends关键字建立继承关系

2、Java只支持单继承(一个子类只能有一个父类)，继承可以传递（爷爷->爸爸->孙子）

3、子类特有的功能，父类不能使用

4、子类不可以使用父类的私有资源，原因是私有资源外部类不可见；但是一定注意：继承相当于子类把父类的资源复制了一份，也包含私有资源

5、子类必须是父类所下属的一种类型，依赖性非常强，耦合性也非常强

1.2、练习：继承入门案例

package cn.tedu.oppextends;
/*本类用于继承的入门案例*/

public class TestExtendsDemo {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Cat cat = new Cat();
        DingDang dingDang = new DingDang();
        /*2、子类继承父类以后，可以使用父类的功能
           继承可以传递，爷爷的功能传给爸爸，爸爸的功能传给儿子
           java只支持单继承，一个子类只能有一个父类，但一个父类可以有多个子类
        * */

        /*
            5、继承是一种is a的关系，小猫是小动物，DingDang是小猫
            要求子类必须是父类所下属的一种类型，依赖性非常强，耦合性也非常强
        * */
        animal.eat();
        cat.eat();
        dingDang.eat();
        dingDang.show();
        /*3、子类的特有功能，父类不能使用*/
    }
}


/*1、我们通过extends关键字让子类与父类建立继承关系  子类extends  父类*/
//1.创建一个爷爷类-动物类
class Animal {

    public void eat() {
        System.out.println("小动物吃啥都行~");
    }
}

//2.创建一个爸爸类-小猫类
class Cat extends Animal {
    int a = 10;
    //访问控制符，只能控制可见性，私有资源只能在本类中访问
    private int b = 100;

    public Cat(int a, int b) {
        System.out.println("");

    }

    public Cat() {
    }
}

//3.创建一个孙子类-DingDang
class DingDang extends Cat {
    public void show() {
        System.out.println(a);
        /*4、子类不可以使用父类的私有资源，原因是私有资源外部类不可见
          但是一定注意：继承相当于子类把父类的资源复制了一份，也包含私有资源
        * */
        //System.out.println(b);
        System.out.println("给你看看我的神奇口袋");
    }

}

2、super关键字

2.1、super的用法

在父类和子类成员变量重名时，需要调用父类的重名成员变量时使用

可以理解为Father super=new Father(); 通过super来调用父类的属性

package cn.tedu.oppextends;
/*本类用于测试继承的用法*/

public class TestExtends1 {
    public static void main(String[] args) {
        new Son().eat();
    }
}

class Father{
    int sum=10;
    int a=999;
}

class Son extends Father{
    int sum=100;
    public void eat(){
        int sum=1000;
        System.out.println(sum);
        System.out.println(this.sum);//this代表本类，指向成员变量

        /*super关键字代表父类   Father super=new Father();
        * 所以想指定同名的父类成员变量时，使用super来指定
        * */

        System.out.println(super.sum);
        System.out.println(a);//所以this和super在变量重名时使用，a没有重名直接调用
    }

}

3、重写(@Override)

两同两小一大，用@Override注解验证重写

package cn.tedu.oopextends;
/*本类中用于测试继承中方法的使用*/

public class TestExtends2 {
    public static void main(String[] args) {
        Son2 son2 = new Son2();
        son2.eat();
        son2.play();
        new Father2().eat();
        new Father2().play();
    }
}

/*  OCP原则：面向功能修改关闭，面向功能拓展开放
    比如重写，我们要在不修改父类方法的前提下，实现功能的更新
* */

/*子类可以重写父类的私有方法吗？  不可以，加@Override可以验证是否重写了方法*/

class Father2{
    public void eat(){
        System.out.println("爸爸爱吃肉~");
    }
    public void  play(){
        System.out.println("爱放风筝~");
    }

}


class Son2 extends Father2{
    /*1.方法的重写：子类对父类的方法不满意，可以重写*/
    @Override
    public void eat(){
        System.out.println("儿子爱吃蔬菜~");
    }

    /*2.子类可以拥有自己的特有功能--新功能*/
    public void work(){
        System.out.println("我们都是程序员");
    }

    /*3.方法重写的规则：两同两小一大原则
        两同：方法名&参数列表(方法签名)保持一致  play()
        两小：子类重写方法的返回值类型  <=  父类方法的返回值类型
              子类方法抛出的异常类型  <=   父类抛出的异常类型
        一大：子类重写方法的修饰符 >= 父类方法的修饰符  public
    **/

    @Override /*注解，小标签/标记，用于标记这个是一个重写的方法*/
    public void  play(){
        System.out.println("爱玩游戏~");
    }

}

4、继承中构造方法的调用

1、构造方法不能被继承;

2、子类构造方法第一行默认有super();

3、子类创建对象时要先调用父类的构造方法,有默认也可以自定义super(;😉;

4、构造方法不能被继承，因为构造方法名要和类名相同

package cn.tedu.oopextends;
/*本类用于测试继承中构造方法的使用  constructor*/

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public class TestCons {
    public static void main(String[] args) {
        Father father = new Father();
        Son son = new Son();
        Son son1 = new Son("大头儿子");
    }
}

class Father{

    public Father() {
        System.out.println("父类的无参构造");
    }

    public Father(int n) {
        System.out.println("父类的含参构造"+n);
    }

}



/*3.构造方法不能被继承，因为构造方法名要和类名相同*/
class Son extends Father{

    public Son() {
        /* 1.子类创建对象时会默认调用父类的构造方法
   子类构造方法中的第一行，默认存在super();->调用父类的无参构造*/

        /*2.子类创建对象时，要先调用父类的构造方法
            至于调用父类的哪种构造，并不关心，只要有父类构造调用就可以了
        * */
        super();
        System.out.println("子类的无参构造");
    }

    public Son(String s){
        super(3);
        System.out.println("子类的含参构造"+s);
    }


}

5、拓展

5.1、this和super的区别

1、this是调用本类，super是调用父类

2、this和super都是在变量重名时使用

3、调用super的前提是要有继承关系

4、子类继承父类时，子类的构造方法第一行默认有super();

5.2、重载Overload和重写Override的区别

重载：

1、重载是在一个类中存在多个方法名相同而参数列表不同的方法

2、好处：根据用户输入不同的参数调用不同的方法(方便消费者)，体现程序的灵活性

重写：

1、重写是在继承中子类修改父类原有的功能

2、意义：不修改源码的前提下，对功能的扩展和修改