Java—面向对象(中)——继承

大大源码 • 2023年3月18日 pm8:16 • 未分类

继承基本介绍

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

继承给编程带来的便利

1.代码的复用性提高了

2.代码的扩展性和维护性提高了

一、继承的示意图

二、继承的基本语法

public 子类 extends 父类{

}

1.通过extends来声明继承父类，子类就会自动拥有父类定义的属性和方法

2.父类又叫基类，超类

3.子类又叫派生类

三、继承细节说明

1.子类继承了所有的属性和方法，非私有的属性和方法可以在子类中直接访问，但是私有的属性和方法不能在子类中直接访问，要通过父类提供公共的方法去访问

2.子类必须调用父类的构造器，完成对父类的初始化

3.子类如果想初始化对象，就得先让父类初始化对象；如果父类有无参构造器，子类不管调用无参还是有参构造器，都得先调用父类的无参构造器；如果父类没有提供无参构造器，而子类想初始化对象，就得在子类的构造器里写super(父类的有参构造器)

4.如果希望指定去调用父类的构造器，则需显示的调用一下：super(参数列表)

5.super在使用时，必须放在构造器的第一行（super只能在构造器里使用）

6.super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器里

7.java所有类都是Object类的子类，Object是所有类的基类

8.父类构造器的调用不限于直接父类！将一直往上追溯到Object类(顶级父类)

9.子类最多只能继承一个父类(指直接继承)，即java中是单继承机制

10.不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

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

        //sub.sayOK();
    }
}



public class Base extends TopBase{ //父类
    //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){
        System.out.println("父类Base(String name)构造器被调用....");
    }
    public Base(String name,int age){ //有参构造器
        //有一个默认的super()
        System.out.println("父类Base(String name,int age)构造器被调用....");
    }

    //父类提供一个public方法来间接访问n4,返回了n4
    public int getN4(){
        return n4;
    }

    //4个不同访问修饰符方法
    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被调用");
    }

    public void callTest400(){
        test400();
    }
}




public class Sub extends Base{  //子类
    
    public Sub() { //子类无参构造器
        //super(); //默认调用父类的无参构造器
        //super("smith",18);
        System.out.println("子类sub()构造器被调用....");
    }
    //当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果没有无参构造器需使用super
    public Sub(String name){
        //super("tom",30);
        System.out.println("子类Sub(String name)构造器被调用....");
    }
    public Sub(String name,int age){
        //1.调用父类的无参构造器，语句如下或者什么都不写，默认就是调用super()
        //super();
        //2.调用父类的Base(String name)构造器
        //super("hello");
        //3.调用父类Base(String name,int age)构造器
        super("hello",19);
        System.out.println("子类Sub(String name,int age)构造器被调用....");
    }


    public void sayOK(){ //子类方法
        //非私有的属性和方法可以在子类直接访问
        System.out.println(n1 + " " + n2 + " " + n3);
        test100();
        test200();
        test300();

        //私有属性可以通过父类提供公共的方法去访问
        System.out.println("n4=" + getN4());
        callTest400();
    }
}

四、继承的本质分析

子类创建的内存分布

案例

package com.learn.extend_.improve;

/*
    讲解继承的本质
 */
public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.name);//要按照查找关系来返回信息
        //规则
        //1.首先看子类是否有该属性
        //2.如果子类有该属性，并且可以访问，则返回信息
        //3.如果子类没有该属性，就看父类有没有该属性（如果父类有该属性并且可以访问，就返回信息..）
        //4.如果父类也没有该属性，就按照上一条规则继续找，直到Object...
        //System.out.println(son.age);//返回的是39
        System.out.println(son.getAge());
        System.out.println(son.hobby);
    }
}
class GrandPa { //爷类
    String name = "大头爷爷";
    String hobby = "旅游";
}

class Father extends GrandPa {//父类
    String name = "大头爸爸";
    private int age = 39;

    public int getAge() {
        return age;
    }
}

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

继承练习题

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

public class ExtendExercise03 {
    public static void main(String[] args) {
        PC pc = new PC("intel", 16, 512, "IBM");
        pc.printInfo();
        NotePad notePad = new NotePad("黑色");
        notePad.printInfo2();
    }
}


//编写 Computer 类，包含 CPU、内存、硬盘等属性，getDetails 方法用于返回 Computer 的详细信息
public class Computer   { //父类
    //属性
    private String cpu;
    private int memory;
    private int disk;

    //无参构造器
    public Computer() {
    }
    public Computer(String cpu, int memory, int disk) {
        this.cpu = cpu;
        this.memory = memory;
        this.disk = disk;
    }
    //返回Computer信息
    public String getDetails(){
        return "cpu=" + cpu + " memory=" + memory + " 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 int getDisk() {
        return disk;
    }
    public void setDisk(int disk) {
        this.disk = disk;
    }

}


//编写 PC 子类，继承 Computer 类，添加特有属性【品牌 brand】
public class PC extends Computer{ //子类

    private String brand;
    //这里IDEA根据继承的规则，自动把构造器的调用写好
    //这里也体现出：继承设计的基本思想，父类的构造器完成父类属性初始化
    //子类的构造器完成子类的属性初始化
    public PC(String cpu, int memory, int 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 printInfo(){
        System.out.println("===PC信息如下===");
        //调用父类的getDetail方法，得到相关属性信息
        System.out.println(getDetails() + " brand=" + brand);
    }
}


//编写 NotePad 子类，继承 Computer 类，添加特有属性【color】
public class NotePad extends Computer{ //子类

    private String color;

    public NotePad(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public void printInfo2(){
        System.out.println("color=" + color);
    }


}

原文链接：https://blog.csdn.net/weixin_61843013/article/details/122876865

THE END

统计学—–第四次作业—线性回归、χ2检验

< <上一篇

No operations defined in spec!

下一篇>>

大大搜源码

搜索内容