Java SE 继承

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
• extends 扩展 子类是父类的扩展
• Java中类只有单继承，没有多继承
• 继承是类和类之间的一种关系
• object类
• super类
• 方法重写

object类

父类Person

package oop01.demo02;

public class Person {

    //在java中，所有的类，都默认直接或者间接继承Object
    //ctrl+H





    //public
    //protected
    //default
    //private
    public void say(){
        System.out.println("资本主义必将灭亡");


    }

    private int bloodMoney = 10_0000_0000;

    public int getBloodMoney() {
        return bloodMoney;
    }

    public void setBloodMoney(int bloodMoney) {
        this.bloodMoney = bloodMoney;
    }

}

两个子类 proletariat（无产阶级）和bourgeoisie（资产阶级）

package oop01.demo02;

public class proletariat extends Person {

}

package oop01.demo02;

public class bourgeoisie extends Person{
}

main方法

package oop01.demo02;

public class Application {
    public static void main(String[] args) {
        proletariat proletariat = new proletariat();
        proletariat.say();

        bourgeoisie bourgeoisie = new bourgeoisie();
        bourgeoisie.setBloodMoney(10_0000_0000);
        System.out.println(bourgeoisie.getBloodMoney());

    }

}

结果：

资本主义必将灭亡
1000000000

Process finished with exit code 0

ctrl+H

在java中，所有的类，都默认直接或者间接继承Object

super类

父类

package oop01.demo02;

public class Person {

    //无参构造器


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

    protected String name = "人民";


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

}

子类

package oop01.demo02;

public class proletariat extends Person {


    //public proletariat() {
        //隐藏代码；调用了父类的无参构造
        //super();// 调用父类的构造器
        //System.out.println("proletariat无参执行了");
    //}

    private String name = "无产阶级";

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

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


    public void  test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

}

测试类

package oop01.demo02;

public class Application {
    public static void main(String[] args) {
        proletariat proletariat = new proletariat();
        proletariat.test("gm");
        proletariat.test1();


    }

}

结果：

gm
无产阶级
人民
pro
pro
people

Process finished with exit code 0

重点

父类

package oop01.demo02;

public class Person {

    //无参构造器


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

    protected String name = "人民";


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

}

子类

package oop01.demo02;

public class proletariat extends Person {


    public proletariat() {
        //隐藏代码；调用了父类的无参构造
        super();// 调用父类的构造器
        System.out.println("proletariat无参执行了");
    }

    private String name = "无产阶级";

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

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


    public void  test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

}

测试类

package oop01.demo02;

public class Application {
    public static void main(String[] args) {
        proletariat proletariat = new proletariat();
        //proletariat.test("gm");
        //proletariat.test1();


    }

}

结果：

Person无参执行了
proletariat无参执行了

Process finished with exit code 0

隐藏代码；调用了父类的无参构造
super();// 调用父类的构造器

super注意点：

• super调用父类的构造方法，必须在构造方法的第一个（位置）
• super必须只能出现在子类的方法或者构造方法中
• super和this不能同时调用构造方法

和this的区别：

• 代表的对象不同：this本身调用者这个对象，super代表父亲对象的应用
• 前提：this没有继承也可以使用，只能在继承条件才可以使用
• 构造方法：this（）本类的构造，super（）父类的构造

方法重写

使用static静态方法时，方法的调用只和左边，定义的数据类型有关。

父类：

package oop01.demo02;

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

子类：

package oop01.demo02;

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

测试类：

package oop01.demo02;

public class Application {
    public static void main(String[] args) {
        //B.test();
        //A.test();

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


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

    }

}

结果：

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

Process finished with exit code 0

使用非静态方法：引入方法重写
父类：

package oop01.demo02;

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

子类：

package oop01.demo02;

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

fn+alt+delete override

测试类：

package oop01.demo02;

public class Application {
    public static void main(String[] args) {
        //B.test();
        //A.test();


        //静态方法和非静态方法区别很大

        //静态方法：//方法的调用只和左边，定义的数据类型有关
        //非静态：重写 public
        A a = new A();
        a .test();


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

    }

结果：

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

Process finished with exit code 0

重写：需要有继承关系，子类重写父类的方法

• 方法名必须相同
• 参数列表必须相同
• 修饰符：范围可以扩大 public>Protected>Default>private
• 抛出的异常：范围 可以被缩小，但不能扩大 ClassNotFoundException–>Exception(大)

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

为什么需要重写：

• 父类的功能，子类不一定需要，或者不一定满足。

fn+alt+delete ：override;