Java面向对象03——三大特性之继承
  RtL5yBUUyius 2024年04月27日 54 0

一、继承(extends)

1.1、继承是什么

继承就是 Java 允许我们用 extends 关键字,让一个类与另一个类建立起一种父子关系;

被继承的类称为父类(基类、超类),继承父类的类都称为子类(派生类) ,当子类继承父类后,就可以直接使用父类公共的属性和方法了

当子类继承父类后,就可以直接使用父类公共的属性和方法了

2.2、继承的用处

来看看下面两个类

图片01

  • 可以看到,一个是学生类,一个是老师类;他们之间都有着相同的特征:成员变量、方法
  • 这样的话,重复代码又多了,是一种很不好的现象

我们使用继承,来优化代码

图片02

这样减少代码冗余,提高了代码的复用性,增强类的功能扩展性。

2.3、继承的语法

​ 修饰符 class 子类名 extends 父类名


//父类:定义了一个公用方法ports
public class People {
    public void ports(){
        System.out.println("父类方法被调用!");
    }
}
//子类:使用extends继承了来自父类的people类
public class Student extends People{
 
}
public class ExtendsTest01 {
    public static void main(String[] args) {
        //创建student子类对象
        Student s = new Student(); 
        //由于student类继承了people类,所以子类可以调用父类的公用方法
        s.ports();              
    }

2.4、继承的设计规范

子类们相同特征:共性属性,共性方法;都放在父类中定义

子类独有的属性,方法;应该定义在子类自己里面。

// 人类:父类
// 包含了子类相同的属性和行为
public class People {
//    1.定义需求中子类们相同的属性
    private String name;
    private int age;
//    2.提供属性对应的getter,setter方法,暴露其取值和赋值
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    } 
    public void setAge(int age) {
        this.age = age;
    }
//    3.定义子类们相同的行为方法:查看课表
    public void queryCourse(){
        System.out.println(name+"查看了课表");
    }
}
//学生类:子类继承People02父类得到属性和行为
public class Student extends People{
//    1.定义学生子类自己独有的属性
    private String className;
 
//    2.提供属性的getter和setter方法,暴露其取值和赋值
    public String getClassName() {
        return className;
    } 
    public void setClassName(String className) {
        this.className = className;
    }
//    3.定义子类自己独有的行为方法:填写听课反馈
    public void writeInfo(){
        System.out.println(className+"的"+getName()+"对老师给出极高的评价!");
    }
}
//教师类:子类 继承父类得到属性和行为
public class Teacher extends People{
//    1.定义子类自己的独有属性
    private String departmentName;
 
//    2.提供属性对应的getter,setter方法,暴露其取值和赋值
    public String getDepartmentName() {
        return departmentName;
    }
 
    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }
//    3.定义子类自己独有的行为方法:发布问题
    public void problem(){
        System.out.println(departmentName+"的"+getName()+"老师问:这节课教的怎么样?");
    }
}
//继承测试类
public class ExtendsTest {
    public static void main(String[] args) {
//        1.创建学生对象
        Student02 s = new Student02();
//        1.1调用父类行为方法写入学生信息
        s.setName("海绵宝宝");
        s.setAge(36);
//        1.2调用学生类自己的方法写入所在班级
        s.setClassName("19级比奇堡驾校一班");
//        1.3调用父类的行为方法:查看课表
        s.queryCourse();
        System.out.println("---------------");
 
//        2.创建教师对象
        Teacher02 t = new Teacher02();
//        2.1调用父类行为写入教师信息
        t.setName("泡芙");
        t.setAge(55);
//        2.2调用教师类自己的方法写入部门名称
        t.setDepartmentName("比奇堡驾校金牌教练组");
//        2.3调用父类的行为方法:查看课表
        t.queryCourse();
        System.out.println("---------------");
 
//        3.调用教师子类自己独有的方法:problem 发布问题
        t.problem();
//        4.调用学生子类自己独有的方法:writeInfo 填写反馈
        s.writeInfo();
    }
}

控制台输出结果:

图片03

2.5、继承的特点

子类可以继承父类的属性和行为,但是子类不能继承父类的构造器;

java 是单继承模式:一个类 只能继承一个直接父类;

  • 比如你,只能有一个亲爸,不可能隔壁的老王叔、老杨叔 … 都是你的亲爸吧? 那从伦理角度看,肯定是不支持
  • 从 Java 的角度的角度看,多继承会造成代码二义性,因此不支持

Java 不支持多继承,但是支持多层继承;

  • 就是你 不可以继承多个爸爸;但是你可以继承你爸的,你爸可以继承你爷爷的,多层继承;
  • 子类A 继承父类B;父类B 可以继承父类 C

Java 中所有的类都是 Object 类的子类。

  • java 中所有的类,要么是直接继承了 Object 类,要么默认继承了 Object 类,要么间接继承了 Object 类;

图片04

二、继承中成员访问的特点

2.1、继承中变量访问的特点

在子类方法中访问一个变量,采用的是就近原则。

  1. 子类局部范围找
  2. 子类成员范围找
  3. 父类成员范围找
  4. 如果都没有就报错(不考虑父亲的父亲…)
class Fu {
    int num = 10;
}
class Zi extends Fu{
    //int num = 20;
    public void show(){
        //num = 30;
        System.out.println(num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show(); // 输出10
    }
}

2.2、super

this & super 关键字:

  • this:代表本类对象的引用
  • super:代表父类存储空间的标识(可以理解为父类对象引用)

在子类方法中,如果想要明确访问父类中成员时,借助super关键字即可。

this 和 super 的使用分别

  • 成员变量:
    • this. 成员变量 - 访问本类成员变量
    • super. 成员变量 - 访问父类成员变量
  • 成员方法:
    • this. 成员方法 - 访问本类成员方法
    • super. 成员方法 - 访问父类成员方法
  • 构造方法:
    • this(…) - 访问本类构造方法
    • super(…) - 访问父类构造方法

2.3、继承中构造方法访问的特点

注意:子类中所有的构造方法默认都会访问父类中无参的构造方法。

子类会继承父类中的数据,可能还会使用父类的数据。所以,子类初始化之前,一定要先完成父类数据的初始化。

//父类,Animal类
class Animal {
	//构造函数
	public Animal() {
		System.out.println("Animal类的无参数构造函数执行");
	}
}
//子类,Cat类
class Cat extends Animal{
	//构造函数
	public Cat() {
        // super(); // 注意子类构造方法中默认会调用基类的无参构造方法:super(),
        // 用户没有写时,编译器会自动添加,而且super()必须是子类构造方法中第一条语句,
        // 并且只能出现一次
		System.out.println("Cat类的无参数构造函数执行");
	}
}
//执行代码
public static void main(String[] args) {
	Cat cat = new Cat(); 
}
//输出结果
Animal类的无参数构造函数执行
Cat类的无参数构造函数执行

在子类构造方法中,并没有写任何关于基类构造的代码,但是在构造子类对象时,先执行基类的构造方法,然后执行子类的构造方法,因为:**子类对象中成员是有两部分组成的,基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子,所以在构造子类对象时候 ,先要调用基类的构造方法,将从基类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整 **

问题:如果父类中没有无参构造方法,只有带参构造方法,该怎么办呢?

  1. 通过使用 super 关键字去显示的调用父类的带参构造方法
  2. 子类通过 this 去调用本类的其他构造方法,本类其他构造方法再通过 super 去手动调用父类的带参的构造方法

我们看下面这个例子:

public class MyTest {
	
	public static void main(String[] args) {
		Cat c1 = new Cat(3); 
		System.out.println("名字:" + c1.getName());
		System.out.println("年龄:" + c1.getAge());
	}
}

//父类,Animal类
class Animal {
	//私有属性:名字
	private String name;
	
	//setter and getter
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	
	//构造函数
	public Animal() {
		
	}
	public Animal(String name) {
		this.name = name;
	}
}

//子类,Cat类
class Cat extends Animal{
	//私有字段:年龄
	private int age;
	
	//setter and getter
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
	
	//构造函数
	public Cat() {
		
	}
	public Cat(int age) {
		this.age = age;
	}
}

输出结果

名字:null
年龄:3

因为c1对象没有给name赋值,所以是null

那么我们给Cat加一个构造方法,给nameage都赋值。如下:

public Cat(String name, int age) {
	this.name = name; //报错
	this.age = age
}

显然这样做是会报错的,因为name已经被父类封装成private的了,不能直接访问,可能有的人会这样做:

public Cat(String name, int age) {
	setName(name); // 因为父类的setName()方法是public的
	this.age = age;
}

显然这样做的确可以做到给父类的name赋值,但这样做是不建议的,我们在构造方法中通常只调用构造方法,不会去调用实例方法,况且当不止一个变量时,用set方法时,我们就要调用好多个实例方法去完成多个变量的赋值。这时候为什么不考虑使用super()方法呢?如下:

public Cat(String name, int age) {
   super(name);
   this.age = age;
}

注意: this(…)super(…) 必须放在构造方法的第一行有效语句,并且二者不能共存

2.4、继承中成员方法的特点

成员方法名字不同

public class Base {
	public void methodA(){
	System.out.println("Base中的methodA()");
	}
}
public class Derived extends Base{
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		methodB(); // 访问子类自己的methodB()
		methodA(); // 访问父类继承的methodA()
		// methodD(); // 编译失败,在整个继承体系中没有发现方法methodD()
	}
}

所以说,成员方法没有同名时,在子类方法中或者通过子类对象访问方法时,则优先访问自己的,自己没有时再到父类中找,如果父类中也没有则报错。

成员方法名字相同

public class Base {
	public void methodA(){
		System.out.println("Base中的methodA()");
	}
	public void methodB(){
		System.out.println("Base中的methodB()");
	}
}
public class Derived extends Base{
	public void methodA(int a) {
		System.out.println("Derived中的method(int)方法");
	}
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		methodA(); // 没有传参,访问父类中的methodA()
		methodA(20); // 传递int参数,访问子类中的methodA(int)
		methodB(); // 直接访问,则永远访问到的都是子类中的methodB(),基类的无法访问到
	}
}
@Test
public void test() {
    Derived d = new Derived();
    d.methodC();
}

输出结果:

Base中的methodA()
Derived中的method(int)方法
Derived中的methodB()方法

说明:

  • 通过子类对象访问父类与子类中不同名方法时,优先在子类中找,找到则访问,否则在父类中找,找到则访问,否则编译报错。
  • 通过派生类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法适传递的参数选择合适的方法访问,如果没有则报错;

那么问题来了,如果子类中存在与父类中相同的成员时,那如何在子类中访问父类相同名称的成员呢?

使用 super 关键字

由于设计不好,或者因场景需要,子类和父类中可能会存在相同名称的成员,如果要在子类方法中访问父类同名成员时,该如何操作?直接访问是无法做到的,Java 提供了 super 关键字,该关键字主要作用:在子类方法中访问父类的成员。

public class Base {
	int a;
	int b;
	public void methodA(){
		System.out.println("Base中的methodA()");
	}
	public void methodB(){
		System.out.println("Base中的methodB()");
	}
}
public class Derived extends Base{
	int a; // 与父类中成员变量同名且类型相同
	char b; // 与父类中成员变量同名但类型不同
	// 与父类中methodA()构成重载
	public void methodA(int a) {
		System.out.println("Derived中的method()方法");
	}
	// 与基类中methodB()构成重写(即原型一致,重写后序详细介绍)
	public void methodB(){
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
		// 对于同名的成员变量,直接访问时,访问的都是子类的
		a = 100; // 等价于: this.a = 100;
		b = 101; // 等价于: this.b = 101;
		// 注意:this是当前对象的引用
		// 访问父类的成员变量时,需要借助super关键字
		// super是获取到子类对象中从基类继承下来的部分
		super.a = 200;
		super.b = 201;
		// 父类和子类中构成重载的方法,直接可以通过参数列表区分清访问父类还是子类方法
		methodA(); // 没有传参,访问父类中的methodA()
		methodA(20); // 传递int参数,访问子类中的methodA(int)
		// 如果在子类中要访问重写的基类方法,则需要借助super关键字
		methodB(); // 直接访问,则永远访问到的都是子类中的methodA(),基类的无法访问到
		super.methodB(); // 访问基类的methodB()
	}
}

2.5、super和this

super 和this 都可以在成员方法中用来访问:成员变量和调用其他的成员函数,都可以作为构造方法的第一条语句,那他们之间有什么区别呢?

相同点

  • 都是 Java 中的关键字
  • 只能在类的非静态方法中使用,用来访问非静态成员方法和字段
  • 在构造方法中调用时,必须是构造方法中的第一条语句,并且不能同时存在

不同点

  • this是当前对象的引用,当前对象即调用实例方法的对象,super 相当于是子类对象中从父类继承下来部分成员的引用
  • 在非静态成员方法中,this 用来访问本类的方法和属性,super 用来访问父类继承下来的方法和属性
  • 在构造方法中:this(…)用于调用本类构造方法,super(…)用于调用父类构造方法,两种调用不能同时在构造方法中出现
  • 构造方法中一定会存在super(…)的调用,用户没有写编译器也会增加,但是this(…)用户不写则没有
【版权声明】本文内容来自摩杜云社区用户原创、第三方投稿、转载,内容版权归原作者所有。本网站的目的在于传递更多信息,不拥有版权,亦不承担相应法律责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@moduyun.com

  1. 分享:
最后一次编辑于 2024年04月27日 0

暂无评论

推荐阅读
RtL5yBUUyius