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(…)用户不写则没有
