面向对象之继承

1. 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

2. extends的意思是"拓展"。 子类是父类的拓展

3. Java中类只有单继承，没有多继承！一个儿子只可以有一个爸爸 一个爸爸可以有多个儿子

4. 继承是类和类之间的一种关系.除此之外，类和类之间的关系还有依赖、组合、聚合等。

5. 继承关系的俩个类，一个为子类(派生类)，一个为父类(基类).子类继承父类，使用关键字extends来表示.

6. 子类和父类之间，从意义上讲应该具有"is a"的关系

1. object类

//Application

import com.oop.Demo05.Student;

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

//父类
//Java中，所有的类，都默认直接或者间接继承Object类
// Person 人 ：父类
public class Person {
    //public 公共的
    //protected 受保护的
    //private 私有的
    //default 默认的

    public int money = 10_0000_0000;

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

//子类
//学生 is 人 ：派生类 子类
// 子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person {

    //Ctrl+h

}


//子类
//Teacher is 人 ：派生类、子类
public class Teacher extends Person {
}

2.super类

属性 

//Application
public class Application {
    public static void main(String[] args) {


        Student student = new Student();

        student.test("张大神");

    }

    }
//子类
private String name = "zhangyujie";
public void test(String name){
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(super.name);
        }

//父类
 protected String name = "张宇杰";

运行结果：
张大神
zhangyujie
张宇杰

方法 

//Application
public class Application {
    public static void main(String[] args) {


        Student student = new Student()；
        student.test1();


//父类
    public void print(){
        System.out.println("Person");
    }


//子类
    public void print() {
        System.out.println("Student");
    }

    public void test1() {
        print();//Student
        this.print();//Student
        super.print();//Person
    }

运行结果：
Student
Student
Person

构造器

//Application
public class Application {
    public static void main(String[] args) {


        Student student = new Student();


//父类
public Person() {
        System.out.println("父类无参构造执行了");
    }




// 子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person {
    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();//调用父类构造器，必须要写在子类构造器的第一行
        System.out.println("子类无参构造执行了！");
    }


//先执行父类构造器 再执行子类构造器

运行结果：
父类无参构造执行了
子类无参构造执行了！

super注意点：
    1.super调用父类的构造方法,必须在构造方法的第一个
    2.super 必须只能出现在子类的方法或者构造方法中！
    3. super 和this 不能同时调用构造方法！

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

重写

//Application
import com.oop.Demo05.A;
import com.oop.Demo05.B;

public class Application {

    //静态的方法和非静态的方法区别很大！
    //静态的方法 ：//方法的调用只和左边、定义的数据类型有关
    //非静态：重写


    public static void main(String[] args) {

        //方法的调用只和左边、定义的数据类型有关
        A a = new A();
        a.test();//A

        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();//B

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

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


//子类 A
//继承
public class A extends B{
    //Override 重写
    @Override //注解： 有功能的注释！
    public void test() {
        System.out.println("张宇杰");
    }
}

重写:需要有继承关系的，子类重写父类的方法！
    1.方法名必须相同
    2.参数列表必须相同，否则就变成重载了 重载时当前方法
    3.修饰符： 范围可以扩大 不可以缩小： public>Protected>Default>private
    4.抛出的异常：范围.可以被缩小，但不能扩大; ClassNoFoundException --> Exception(大) 范围缩小可以 变大不行

重写，子类的方法和父类必须要一致，方法名一样 方法体不同

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