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、继承中变量访问的特点

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

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加一个构造方法，给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 中的关键字
• 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
• 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点文章来源地址https://www.toymoban.com/news/detail-859730.html

• this是当前对象的引用，当前对象即调用实例方法的对象，super 相当于是子类对象中从父类继承下来部分成员的引用
• 在非静态成员方法中，this 用来访问本类的方法和属性，super 用来访问父类继承下来的方法和属性
• 在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造方法中出现
• 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有

到了这里，关于Java面向对象03——三大特性之继承的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！