面向对象编程-继承

发布日期: 2022-08-17

文章字数: 1.8k

面向对象编程-继承

为什么要继承

我们编写了两个类，一个Pupil类(小学生)，一个是Graduate(大学毕业生).问题:两个类的属性和方法有很多是相同的，怎么办?

==>继承(代码复用性~)

//大学生->模拟大学生考试的简单情况
public class Graduate {
    public String name;
    public int age;
    private double score;//成绩

    public void setScore(double score) {
        this.score = score;
    }
    public  void testing(){
        System.out.println("大学生" + name + "正在考大学数学..");
    }
    public void showInfo() {
        System.out.println("学生名"+name+"  年龄"+age+"  成绩"+score);

    }
}

//小学生-》模拟小学生考试的一个情况
public class Pupil {
    public String name;
    public int age;
    private double score;//成绩

    public void setScore(double score) {
        this.score = score;
    }

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

    public void showInfo() {
        System.out.println("小学生名"+name+"  年龄"+age+"  成绩"+score);

    }
}

继承基本介绍和示意图

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

继承的基本语法

class 子类 extends 父类{
}

子类就会自动拥有父类定义的属性和方法
父类又叫超类，基类
子类又叫派生类

快速入门案例

import com.hspedu.extend_.Graduate;
import com.hspedu.extend_.Pupil;

public class Extends01 {
	public static void main(String[] args) {
		com.hspedu.extend_.Pupil pupil = new Pupil();
		pupil.name = "银角大王~";
		pupil.age = 11;
		pupil.testing();
		pupil.setScore(50);
		pupil.showInfo();
        
		System.out.println("=======");
		com.hspedu.extend_.Graduate graduate = new Graduate();
		graduate.name = "金角大王~";
        graduate.age = 23;
		graduate.testing();
		graduate.setScore(80);
		graduate.showInfo();
    }
}

//父类,是 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);
	}
}

//让 Pupil 继承 Student 类
public class Pupil extends Student {
	public void testing() {
		System.out.println("小学生 " + name + " 正在考小学数学..");
	}
}

public class Graduate extends Student {
	public void testing() {//和 Pupil 不一样
		System.out.println("大学生 " + name + " 正在考大学数学..");
    }
}

继承给编程带来的便利

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

继承的深入讨论/细节问题

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

public class ExtendDetail {
    public static void main(String[] args) {
//        System.out.println("====第一个对象====");
//        Sub sub = new Sub();//创建了子类对象
//        System.out.println("====第二个对象====");
//        Sub sub2 = new Sub("jack");
        System.out.println("====第三个对象====");
        Sub sub3 = new Sub("king",10);//先找子类的构造器


        //   sub.sayOk();
    //子类必须调用父类的构造器，完成父类的初始化
    }

}

public class TopBase  {//父类是Object
    public TopBase() {
        System.out.println("构造器TopBase被调用...");
    }
}

public class Base extends TopBase {//父类
    //四个属性
    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){

        System.out.println("父类Base(String name,int age)被调用");
    }
    public Base(String name){

        System.out.println("父类Base(String name)被调用");
    }

    //在父类提供一个public的方法

    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");
    }
    //call 调用
    public void callTest400(){
        test400();

    }
}

//可以输入ctrl+h可以看到类的继承关系
public class Sub extends Base {//子类

    public Sub() {//无参构造器
        //默认调用父类的无参构造器
         super("smith", 10);
        System.out.println("子类Sub()无参构造器被调用");
    }
    public Sub(String name,int age){
        //1.调用父类的无参构造器，如下 或者 什么都不写，默认调用super();
       // super();//父类的无参构造器
        //2.如果要调用父类的Base(String name)
        //super("frx");
        //3.调用父类的两个参数的构造器Base(String name,int age)
        super("king",20);
        //细节： super在使用时，必须放在构造器第一行
        //细节：super()和this()都只能放在构造器的第一行，
        // 因此这两个不能共存在一个构造器
        //this() 不能再使用了
        System.out.println("子类的Sub(String name,int age)被调用");
    }
    public Sub(String name){
        super("Tom",30);
        System.out.println("子类的Sub(String name)被调用");
    }
    public void  sayOk(){
        //非私有的属性和方法，可以在子类中访问
        //我们发现 除了父类的private不能访问，其他都能访问
        System.out.println(n1+" "+n2+" "+n3);
        test100();
        test200();
        test300();
        System.out.println("n4="+getN4());
        callTest400();//做中转
    }
}

继承的本质分析（重要）

我们看一个案例来分析当子类继承父类，创建子类对象时，内存中到底发生了什么?

/*
继承的本质
 */
public class ExtendTheory {
    public static void main(String[] args) {
      Son son=new Son();//内存的布局
        //（1）首先看子类是否有该属性
        //（2）如果子类有这个属性，并且可以访问，则返回信息
        //（3）如果子类没有这个属性，就看父类有没有这个属性（如果父类有，并且可以访问，就返回信息）
        //（4）如果父类没有这个属性，就按照（3）的规则，继续找上级父类，直到Object
        System.out.println(son.name);//返回的是大头儿子
        System.out.println(son.getAge());//返回的是39
        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="大头儿子";
}
//先加载类，Object->Grandpa->Father->Son
//在堆里面分配空间，先爷类分配空间