2021-07-20

继承

在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。
注意：
1.父类的属性一般为私有：private，通过get、set方法设置封装
2.java中只有单继承，没有多继承，即一个父类可以有多个子类，而子类只能有一个父类
3.在java中，所有的类都默认直接或者间接继承object类
下面给出代码
主启动类：

package oop.demo06;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());
        Person person = new Person();

    }
}

父类：

package oop.demo06;

public class Person { //Preson ：父类\基类
    //父类的属性一般为私有：private，通过get、set方法设置封装
    //java中只有单继承，没有多继承，即一个父类可以有多个子类，而子类只能有一个父类
    //在java中，所有的类都默认直接或者间接继承object类
    //public
    //protected
    //default
    //private

    public void say(){
        System.out.println("说了一句话");
    }
    private int money=1_0000_0000;

    public int getMoney() {
        return money;
    }

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

子类：

package oop.demo06;
//子类继承了父类，就会拥有父类的全部方法！
//ctrl+H，用于观察继承情况的快捷键
public class Student extends Person{
}

ctrl+H快捷键用于查看继承树，即继承结构

Super关键字

super和this关键字类似，可以对比去学习
super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super 必须只能出现在子类的方法或者构造方法中!
3. super和 this 不能同时调用构造方法!
4. super关键字在子类中调用父类构造器时，一般可以省略不写的。

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

package oop.Super;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        //  student.test1("网络");   将此处两行代码注释是为了验证继承中
        //  student.test2();         调用父类和子类构造器的顺序。
    }
}

package oop.Super;

public class Person {
    protected String name="renxuliang";
    public void print(){
    System.out.println("Person");
}

    public Person() {
        System.out.println("Preson无参执行了");
    }
}

package oop.Super;

public class Student extends Person{
    private String name="wangluo";
    public void print(){
        System.out.println("Student");
    }
    public void test1(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
    public void test2(){
        print();
        this.print();
        super.print();
    }
//存在一行隐藏代码super();调用父类构造器，调用下面的子类构造器之前一定会先调用父类
//如果父类和子类的调用顺序调换，程序会报错，并且调用父类构造器必须要在子类构造器的第一行
    public Student() {
        System.out.println("Student无参执行了");
    }
}

方法的重写

重写：需要有继承关系，而且是子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同，否则就没办法和重载区分
3.修饰符：范围可以扩大但不能缩小：public>protected>default>private
4.抛出的异常：范围可以缩小但不能扩大：（暂时可以先不深入了解） ClassNotFoundException–>Exception（大）
重写：子类的方法必须和父类一致，方法体不同！

为什么需要重写：
1 父类的功能，子类不一定需要，或者不一定满足！
Alt+Insert：override
例：

package oop.Fangfachongxie;

public class Applocation {
    public static void main(String[] args) {
       //静态方法和非静态方法差别很大
        //静态方法：  //方法的调用只和左边定义的数据类型有关
        //非静态：重写
        A a = new A();
        a.test();
        //父类的引用指向子类
        B b=new A();//子类重写父类
        b.test();
    }
}

package oop.Fangfachongxie;

public class A extends B{
    @Override//重写：和静态方法无关，只和非静态方法有关系
             //方法重写的关键字是public
    public void test() {
        System.out.println("A=>test()");
    }
}

package oop.Fangfachongxie;
//重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B=>test()");
    }
}