继承

什么是继承

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

• extands的意思是“扩展”。子类是父类的扩展。

• JAVA中类只有单继承，没有多继承!

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

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

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

• object类

• super

• 方法重写

package com.oop.Demo05;

//在Java中，所有的类都直接或间接继承Object
//Person 人  父类
public class Person {
    //public  公共的
    //protected  受保护的
    //default   默认的
    //private   私有的
    private int money = 10000;
    public void say(){
        System.out.println("说了一句话");
    }

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

package com.oop.Demo05;

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

package com.oop.Demo05;


//老师 is 人  ：派生类，子类
public class Teacher extends Person {

}

package com.oop;

import com.oop.Demo05.Person;

public class Application {
    private static Person student;

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

    }

}

Super详解

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

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

package com.oop.Demo05;

import javax.swing.*;

//在Java中，所有的类都直接或间接继承Object
//Person 人  父类
public class Person {
    public Person() {
        System.out.println("Person无参执行了");
    }

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

package com.oop.Demo05;

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

    private String name = "lijy";
    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);//索隆女朋友
        System.out.println(this.name);//lijy
        System.out.println(super.name);//lzoro
    }
}

package com.oop;

import com.oop.Demo05.Student;
import com.oop.Demo05.Person;


public class Application {

    public static void main(String[] args){
        Student student = new Student();
//        student.test("索隆女朋友");
//        student.test1();

    }

}

方法重写

重写：需要有继承关系，子类重写父类的方法！
    1.方法名必须相同
    2.参数列表必须相同
    3.修饰符:范围可以扩大但不能缩小： public>Protected>Default>private
    4.抛出异常：范围，可以被缩小，但不能扩大： ClassNotFoundException(大)

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

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

package com.oop.Demo05;

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

package com.oop.Demo05;

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

package com.oop;

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();

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

    }

}

输出：

A>=test()
B>=test()

package com.oop.Demo05;

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

package com.oop.Demo05;

public class A extends B{

    //Override 重写
    @Override //注解：有功能的注释
    public void test() {
        System.out.println("A>=test()");
    }
}

package com.oop;

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

    }

}

输出：

A>=test()
A>=test()