继承和方法重写

package com.oop.demo05;

/**
 * @ClassName: Person
 * @Author: 南冥有猫不须铭
 * @Date: 2021/4/2-17:29
 * @Description: 什么是继承
 */
//在Java中，所有的类，都默认直接或间接继承Object类
//Person 人 ：父类
public class Person /*extends Object*/ {    //继承Object可以省略，默认继承Object

    //public 公共的
    //protected 受保护的
    //default 默认的（可以不写）
    //private 私有的
    private int money = 10_0000_0000;

    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }


    public Person() {   //无参构造（器）函数
        System.out.println("Person无参执行了");
    }

    protected String name = "kuangshen";

    //私有的东西无法被继承！ private
    public void print(){
        System.out.println("Person");
    }
}

package com.oop.demo05;

/**
 * @ClassName: Student
 * @Author: 南冥有猫不须铭
 * @Date: 2021/4/2-17:35
 * @Description: 继承Person
 */

//学生   is  人 ：派生类、子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
    //Person person;    //组合：不是继承，去掉extends     继承（is a）    组合（has a）

    //Ctrl + H 打开继承树（列表）


    public Student() {  //无参构造（器）函数
        //隐藏代码：默认调用了父类的无参构造 （super()可以不写）

        super(); //调用父类的构造器，必须要在子类构造器的第一行（否则会报错）
        System.out.println("Student无参执行了");
    }

    public Student(String name) {
        this.name = name;
    }

    private String name = "qinjiang";

    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print(); //Student
        this.print(); //Student
        super.print(); //Person
    }

    public void test(String name){
        System.out.println(name);//输入的name 秦疆
        System.out.println(this.name);//当前类的name qinjiang
        System.out.println(super.name);//父类的name kuangshen
    }
}

package com.oop.demo05;

/**
 * @ClassName: Application
 * @Author: 南冥有猫不须铭
 * @Date: 2021/4/14-23:55
 * @Description: 测试 继承 和 super
 */
public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        student.say();
        //System.out.println(student.money); //public时
        System.out.println(student.getMoney());//private时

        //student.test("秦疆");
        //student.test1();

    }
}

package com.oop.demo05;

/**
 * @ClassName: A
 * @Author: 南冥有猫不须铭
 * @Date: 2021/4/16-2:13
 * @Description: 方法重写
 */
//继承
public class A extends B {

    /**
    public static void test(){
        System.out.println("A=>test()");
    }
     */

    //Override 重写
    @Override //注解：有功能的注释！
    public void test() {
        //super.test(); //默认调用父类test()，可省略
        System.out.println("A=>test()");
    }
}

package com.oop.demo05;

/**
 * @ClassName: B
 * @Author: 南冥有猫不须铭
 * @Date: 2021/4/16-2:13
 * @Description: 方法重写
 */

//重写都是方法的重写，与属性无关
public class B {

    public void test(){ //去掉static
        System.out.println("B=>test()");
    }
}

package com.oop.demo05;

/**
 * @ClassName: Application02
 * @Author: 南冥有猫不须铭
 * @Date: 2021/4/16-2:18
 * @Description: 测试  方法重写
 */
public class Application02 {

    //静态的方法和非静态的方法区别很大！
        //静态方法：方法的调用只和左边，定义的数据类型有关
        //非静态方法：重写  （只能用public修饰）
    public static void main(String[] args) {

        A a = new A();
        a.test();//A    A=>test() [静态] 、 A=>test() [非静态]

        //父类的引用指向了子类
        B b = new A();// 子类重写了父类的方法
        b.test();//B    B=>test() [静态] 、 A=>test() [非静态]
    }
}

super注意点：
    1. super调用父类的构造方法，必须在构造方法的第一个
    2. super必须只能出现在子类的方法或者构造方法中！
    3. super 和 this 不能同时调用构造方法！（二者都必须在第一行，会冲突）

VS this：
    代表的对象不同：
        this：本身调用者这个对象
        super：代表父类对象的引用
    前提不同：
        this：没有继承也可以使用
        super：只能在继承条件下才可以使用
    调用的构造方法不同：
        this()：调用本类的构造
        super()：调用父类的构造


重写：需要有继承关系，子类重写父类的方法！
    1. 方法名必须相同
    2. 参数列表必须相同（参数列表不同的是“重载”，而“重载”是类本身的，不需要继承关系）
    3. 修饰符：范围可以扩大但不能缩小：  public > protected > default > private
    4. 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大) （重写方法一定不能抛出新的检查异常或者比被重写方法声明更加宽泛的检查型异常）

重写，子类的方法和父类必须要一致；方法体不同（方法的内容不同）！

为什么要重写：
    1。 父类的功能，子类不一定需要，或者不一定满足！
    Alt + Insert（0:Ins):   Override;