Java面向对象03——三大特性之继承
一、继承(extends)
1.1、继承是什么
继承就是 Java 允许我们用 extends 关键字,让一个类与另一个类建立起一种父子关系;
被继承的类称为父类(基类、超类),继承父类的类都称为子类(派生类) ,当子类继承父类后,就可以直接使用父类公共的属性和方法了
当子类继承父类后,就可以直接使用父类公共的属性和方法了
2.2、继承的用处
来看看下面两个类
- 可以看到,一个是学生类,一个是老师类;他们之间都有着相同的特征:成员变量、方法;
- 这样的话,重复代码又多了,是一种很不好的现象。
我们使用继承,来优化代码
这样减少代码冗余,提高了代码的复用性,增强类的功能扩展性。
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();
}
}
控制台输出结果:
2.5、继承的特点
子类可以继承父类的属性和行为,但是子类不能继承父类的构造器;
java 是单继承模式:一个类 只能继承一个直接父类;
- 比如你,只能有一个亲爸,不可能隔壁的老王叔、老杨叔 … 都是你的亲爸吧? 那从伦理角度看,肯定是不支持
- 从 Java 的角度的角度看,多继承会造成代码二义性,因此不支持
Java 不支持多继承,但是支持多层继承;
- 就是你 不可以继承多个爸爸;但是你可以继承你爸的,你爸可以继承你爷爷的,多层继承;
- 子类A 继承父类B;父类B 可以继承父类 C
Java 中所有的类都是 Object 类的子类。
- java 中所有的类,要么是直接继承了 Object 类,要么默认继承了 Object 类,要么间接继承了 Object 类;
二、继承中成员访问的特点
2.1、继承中变量访问的特点
在子类方法中访问一个变量,采用的是就近原则。
- 子类局部范围找
- 子类成员范围找
- 父类成员范围找
- 如果都没有就报错(不考虑父亲的父亲…)
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类的无参数构造函数执行
在子类构造方法中,并没有写任何关于基类构造的代码,但是在构造子类对象时,先执行基类的构造方法,然后执行子类的构造方法,因为:**子类对象中成员是有两部分组成的,基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子,所以在构造子类对象时候 ,先要调用基类的构造方法,将从基类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整 **
问题:如果父类中没有无参构造方法,只有带参构造方法,该怎么办呢?
- 通过使用
super
关键字去显示的调用父类的带参构造方法 - 子类通过
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
加一个构造方法,给name
和age
都赋值。如下:
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(…)用户不写则没有