Day27.继承 -Java面向对象OOP

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extends的意思是“扩展” 。 子类是父亲的扩展。
• JAVA中的类只有单继承，没有多继承！ 一个儿子只能有一个爸爸，一个爸爸可以有多个儿子
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系和两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
• 子类和父类之间的关系，从意义上讲应该具有“is a”的关系。

//在Java中，所有的类，都默认直接或者间接继承Object类
//Person 人  ： 基类，父类
public class Person /*extends Object 默认*/ {

    //public
    //private
    //default
    //protected
    private int money = 10_0000_0000;

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

    public int getMoney() {
        return money;
    }

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

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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

    //Ctrl + H 继承树表

}
1
2
3
4
5
6
7

//测试框
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//继承了Person类的say方法
        System.out.println(student.getMoney());

        Person person = new Person();

    }
}
1
2
3
4
5
6
7
8
9
10
11

• object类

  public class Person /*extends Object 默认*/
  1

• super - this

//学生 is 人 ： 派生类，子类
public class Student extends Person {

    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Stduent子类无参执行了");
    }

    private String name = "彦昌";

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

    public void test1(){
        print();//Student      当前Student子类的print方法
        this.print();//Student 当前Student子类的print方法
        super.print();//Person Person父类的print方法

    }

    public void test(String name){

        System.out.println(name);//yanchang 当前输入方法的实例参数
        System.out.println(this.name);//彦昌 当前子类的name
        System.out.println(super.name);//阿昌 Person父类的name
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

//Person 人  ： 基类，父类
public class Person  {

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

    protected String name = "阿昌";

    //私有的东西无法被继承！
    public void print(){
        System.out.println("Person");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

        Student student = new Student();
        student.test("yanchang");
        student.test1();
        //Person类无参执行了
        //Stduent子类无参执行了
    }
}
1
2
3
4
5
6
7
8
9
10

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

Vs this：
    代表的对象不同：
        this：   本身调用者这个对象
        super：  代表父类对象的应用
    前提
        this：   没有继承也可以使用
        super：  只能在继承条件下才可以使用
    构造方法
        this() :本类的构造
        super():父类的构造
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 方法重写：重点—>多态

//测试框
public class Application {

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

        A a = new A();
        a.test();// A

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

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//继承
public class A extends B {// 子类，A类继承B类

    //Override 重写
    @Override //注解:有功能的注释
    public void test() {
        System.out.println("A=>test()");
    }
}
1
2
3
4
5
6
7
8
9

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

    public  void test(){
        System.out.println("B=>test()");
    }
}
1
2
3
4
5
6
7

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

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

为什么需要重写：
    1.父类的功能，子类不一定需要，或者不一定满足
    Alt + Insert --->override;
*/
1
2
3
4
5
6
7
8
9
10
11
12