面向对象编程（oop）三大特征之二：继承

最新推荐文章于 2024-07-18 16:29:57 发布

YOLO_Di

最新推荐文章于 2024-07-18 16:29:57 发布

阅读量1.5k

点赞数 48

文章标签： java 前端开发语言

本文链接：https://blog.csdn.net/well_KD/article/details/135683491

版权

1.继承概念

1.1为什么需要继承

这是一个代码复用性的问题。比如我们编写两个类，一个是pupil小学生类，一个是graduate大学生类。这两个类在名字、年龄、考试等属性和方法上都是相同的。考虑到代码冗余，我们把这些相同的属性和方法提取到一个父类中，而后让pupil类和graduate类继承父类即可。

1.2继承基本介绍和示意图

继承可以解决代码复用，让我们的编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。如下为继承的示意图：

1.3继承的基本语法

class 子类 extends 父类{

}

2.入门案例

案例要求：

1.编写父类student，定义姓名、年龄、分数等属性

2.在父类中编写showinfo方法，打印输出学生信息；对分数进行私有化，使用set方法为学生分数赋值

3.编写pupil类继承student类，在pupil类中编写特有方法，打印输出学生考试状态

4.编写test类，写入main方法，创建一个学生对象并对属性赋值。

2.1 student类

//父类，是pupil和Graduate的父类
public class Student {
    //定义学生属性
    public String name;
    public int age;
    private double score;
    
    // 为学生分数赋值
    public void setScore(double score) {
        this.score = score;
    }
   
    //编写方法输出学生信息
    public void showInfo(){
        System.out.println("学生名:" + name + " 年龄:" + age + " 成绩:" + score);
    }
}

2.2 pupil类

public class pupil extends Student{

    public void testing() {
        System.out.println("小学生"+name+" 正在考试中");
    }
}

2.3 test类

public class Test {
    public static void main(String[] args) {
        //创建一个学生对象
        pupil xm = new pupil();
        //为各属性赋值
        xm.name = "xm";
        xm.age = 12;
        xm.setScore(80);
        //调用特有方法test
        xm.testing();
        //调用父类方法showinfo
        xm.showInfo();
    }
}

3.继承的好处及使用细节

3.1 继承的好处

代码的复用性提高了
代码的扩展性和维护性提高了

3.2 继承的使用细节

子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不可以，需要通过父类提供公共的方法去访问
子类必须调用父类的构造器，完成父类的初始化
当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中使用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则编译无法通过
如果希望指定去调用父类的某个构造器，则显示的调用一下：super(参数列表)
super在使用时，必须放在构造器第一行（super只能在构造器中使用）
super()和this()都只能放在构造器的第一行，因此这两个方法不能共存在一个构造器
java所有类都是Object类的子类！
父类构造器的调用不限于直接父类，将一直往上追溯到Object类
子类最多只能继承一个父类（指直接继承），即java中是单继承机制
不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

4.细节案例

案例要求：

1.编写父类Base，使用四个权限修饰符定义四个属性，提供方法输出四个属性的值

2.在父类中编写有参和无参构造器，让子类调用，明晰调用细节

3.编写子类sub，提供有参和无参构造器调用父类的构造

4.在子类中编写Sayok方法，调用父类的方法

5.编写ExtendsDetail类，创建3个对象，理解父类中构造器的调用过程

4.1 Base类

public class Base {
    //4个属性
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;

    //无参构造器
    public Base() {
        System.out.println("父类 Base()构造器被调用....");
    }

    public Base(String name, int age) {//有参构造器
        //默认super()
        System.out.println("父类 Base(String name, int age)构造器被调用....");
    }

    public Base(String name) {//有参构造器
        System.out.println("父类 Base(String name)构造器被调用....");
    }

    //父类提供一个public的方法,返回了n4
    public int getN4() {
        return n4;
    }

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

    protected void test200() {
        System.out.println("test200");
    }

    void test300() {
        System.out.println("test300");
    }

    private void test400() {
        System.out.println("test400");
    }

    //提供一个公共的方法让子类去调用test400
    public void callTest400() {
        test400();
    }
}

4.2 sub类

public class Sub extends Base {

    public Sub(String name, int age) {
        super("king", 20);
        //细节： super 在使用时，必须放在构造器第一行
        //细节: super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
        //this() 不能再使用了
        System.out.println("子类 Sub(String name, int age)构造器被调用....");
    }

    public Sub() {//无参构造器
        //super(); //默认调用父类的无参构造器
        super("smith", 10);
        System.out.println("子类 Sub()构造器被调用....");
    }

    //当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器
    public Sub(String name) {
        super("tom", 30);
        //do nothing...
        System.out.println("子类 Sub(String name)构造器被调用....");
    }

    public void sayOk() {
        //非私有的属性和方法可以在子类直接访问
        //但是私有的属性和方法不能在子类直接访问
        System.out.println(n1 + " " + n2 + " " + n3);
        test100();
        test200();
        test300();
        //test400();
        //通过父类提供过的公共方法去访问
        System.out.println(getN4());
        callTest400(); //方法可以这么调用，call就是调用过的意思
    }
}

4.3 ExtendsDetail

public class ExtendsDetail {
    public static void main(String[] args) {
        System.out.println("===第1个对象====");
        Sub sub = new Sub();//创建了子类对象sub
        System.out.println("===第2个对象====");
        Sub sub2 = new Sub("jack");//创建了子类对象sub2
        System.out.println("===第3对象====");
        Sub sub3 = new Sub("king", 10);//创建了子类对象sub2
        sub.sayOk();
    }
}

5. 继承的本质

5.1 继承的内存布局

先来看一段代码，然后通过jvm的内存图来理解继承的本质。（为了方便，三个类写在了一起）

public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son(); 
    }
}
 class GrandPa {
    String name = "大头爷爷";
    String hobby = "旅游";
}

 class Father extends GrandPa{
    String name = "大头爸爸";
     int age = 39;
}

 class Son extends Father{
    String name = "大头儿子";
}

当子类对象创建完成后，会在内存中建立查找的关系。

当new一个son的对象时，正常来讲，会在内存中先加载son的信息，但是son继承了父类Father，Father又继承了GrandPa，GrandPa的父类是Object，所以最先在内存中加载的是Object类，而后是GrandPa类信息，继而Father，最后是Son类。如图方法区中右侧四个蓝色类信息，黑色箭头为联系关系。

因为Son有两个父类，所以在堆中会最先加载最上层的父类也就是GrangPa类的属性，如图堆中的黑色和蓝色箭头。而后是Father的属性，如图红色箭头。最后是Son类的属性如图最后一条黑箭头.其分别指向常量池中各自的地址。

各类信息分配好之后，堆中的0X11地址就会分配给主方法中的son属性，如图中main栈中的黑色箭头。

之后就按照语句的执行顺序正常执行就可以了。

但所有的属性当中有三个name，如果我们执行System.out.println(son.name);时，要按照什么样的规则输出呢？

这时注意，要按照查找关系来返回信息

(1) 首先看子类是否有该属性

(2) 如果子类有这个属性，并且可以访问，就返回这个信息

(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有这个属性，并且可以访问，就返回这个信息)

(4) 如果父类没有这个属性，就按照(3)的规则，继续找上级父类，直到Object...

其他的属性也是按照此规则来进行查找

5.2 继承代码练习

再来写一个案例，巩固一下继承的知识就结束本次内容啦。来吧！

案例需求：

编写Computer类，包含CPU、内存、硬盘等属性，getDetails方法用于返回Computer的详细信息
编写PC子类，继承Computer类，添加特有属性【品牌brand】
编写NotePad子类，继承Computer类，添加特有属性【color】
编写Test类，在main方法中创建PC和NotePad对象，分别给对象中特有的属性赋值，以及从Computer类继承的属性赋值，并使用方法并打印输出信息

为方便我就一起都写了。

public class ExtendsExercise {
    public static void main(String[] args) {
        PC pc = new PC("14900kf",512,"1TB","DELL");
        pc.info();
    }

}

class Computer{
   private String cpu;
   private int memory;
   private String disk;

    public Computer(String cpu, int memory, String disk) {
        this.cpu = cpu;
        this.memory = memory;
        this.disk = disk;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public int getMemory() {
        return memory;
    }

    public void setMemory(int memory) {
        this.memory = memory;
    }

    public String getDisk() {
        return disk;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    //getDetails方法用于返回Computer的详细信息
    public String getDetails(){
        return "cpu=" + cpu + " memory=" + memory + " disk=" + disk;
    }
}

class PC extends Computer{
    private String brand;
    //这里IDEA根据继承的规则，自动把构造器的调用写好
    //这里同时体现了，继承设计的基本思想，父类的构造器完成父类属性初始化
    public PC(String cpu, int memory, String disk, String brand) {
        super(cpu, memory, disk);
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public void info(){
        //这个写法有些繁琐，且父类中已经写了返回父类信息的方法，继承过后我们直接调用就行
        //System.out.println(getCpu()+getMemory()+getMemory()+getBrand());
        //把上面的输出注释掉，写一个简洁可复用的
        System.out.println(getDetails()+" brand=" + getBrand());
    }
}

以上就是本次全部内容。see ya！