1. 什么是继承
1.1 继承的概念
Java中的类是对事物的抽象描述,但有时候一个类与其他类有许多的共性,比如猫和狗都是动物,那么猫和狗这两个类就难免会有许多相似之处:
class Dog{
public String name;
public int age;
public String color;
public void eat(){
}
public void sleep(){
}
}
class Cat{
public String name;
public int age;
public String color;
public void eat(){
}
public void sleep(){
}
}
可以看到,这两个类的成员变量和方法都可以有许多相似之处。
那么,是不是可以将这些共性的东西提取出来,形成一个动物类,让猫和狗之间使用呢?这就要说到Java中的继承了。所以,可以定义一个动物类,然后让猫类和狗类继承这些共性。
1.2 继承的语法
继承使用的是 extends 关键字:
class Animal{
String name;
int age;
public void eat(){
System.out.println(name + "eating");
}
public void sleep(){
System.out.println(name + "sleeping");
}
}
class Dog extends Animal{
//继承后,狗类就可以使用动物类的成员变量和方法
void bark(){
System.out.println(name + "barking");
}
}
public class TestExtend {
public static void main(String[] args) {
Dog dog = new Dog();
// name和age属性肯定是从父类Animal中继承下来的
System.out.println(dog.name);
System.out.println(dog.age);
// 方法也是从Animal中继承下来的
dog.eat();
dog.sleep();
dog.bark(); //子类自己的方法
}
}
我们称被继承的类为父类或基类,继承者称为子类。
子类可以在自己的类中添加特有的方法和变量,以区分共性和特性。
2. 父类与子类
2.1 子类访问父类成员变量
当子类中的成员变量与父类当中的成员变量不同时,子类可以直接访问父类的成员变量。
class Base {
int a;
int b;
}
class Derived extends Base{
int c;
public void method(){
a = 10; // 访问从父类中继承下来的a
b = 20; // 访问从父类中继承下来的b
c = 30; // 访问子类自己的c
}
}
因为子类继承了父类的成员变量,所以当变量名称不同时,可以区分出父类和子类的成员变量。
而当子类中的成员变量与父类中的成员变量名称相同时呢?
class Base {
int a;
int b;
}
class Derived extends Base{
int c;
int a; //子类中有同名变量
public void method(){
a = 10; // 访问的是谁的 a ?
b = 20; // 访问从父类中继承下来的b
c = 30; // 访问子类自己的c
}
}
这个情况下,会访问父类的变量 a 还是子类的呢?
答案是会访问子类的成员变量,因为遵循以下规律:
- 如果访问的成员变量子类中有,优先访问子类自己的;
- 如果访问的成员变量子类中没有,则访问从父类中继承下来的,如果父类也没有,则报错;
- 如果访问的成员变量子类和父类中都有且同名,则优先访问子类自己的。
2.2 子类访问父类成员方法
访问成员方法的情况与成员变量相同,如果成员方法名称不同,则访问父类继承的。
class Base {
public void methodA(){
System.out.println("Base中方法");
}
}
class Derived extends Base{
public void methodB(){
System.out.println("Derived中的方法");
}
public void methodC(){
methodB(); // 访问子类自己的methodB()
methodA(); // 访问父类继承的methodA()
}
}
那么当子类中的成员方法和父类中的相同时,怎么访问呢?
class Base {
public void methodA(){
System.out.println("Base中的A方法");
}
public void methodB(){
System.out.println("Base中的B方法");
}
}
class Derived extends Base{
public void methodA(int a) {
System.out.println("Derived中的int A方法");
}
public void methodB(){
System.out.println("Derived中的B方法");
}
public void methodC(){
methodA(); // 没有传参,访问父类中的methodA()
methodA(20); // 传递int参数,访问子类中的methodA(int)
methodB(); // 直接访问,则永远访问到的都是子类中的methodB(),基类的无法访问到
}
}
这里也会遵循以下规则:
- 通过子类对象访问父类与子类中不同名方法时,优先在子类中找,找到则访问,否则在父类中找,找到则访问,否则编译报错。
- 通过派生类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法适传递的参数选择合适的方法访问,如果没有则报错
那么就会引出一个问题,当子类中的成员名称和父类中的相同时,怎么访问父类的成员呢?
这就要引出 super 关键字了。
3. super关键字
3.1 super 的用法
有时候,会出现子类和父类存在相同名称的成员,那么这种情况下如何访问父类的成员呢,Java中的 super 关键字可以在子类中访问父类成员。
class Base {
int a;
int b;
public void methodA(){
System.out.println("Base中的A方法");
}
public void methodB(){
System.out.println("Base中的B方法");
}
}
class Derived extends Base{
int a; // 与父类中成员变量同名且类型相同
char b; // 与父类中成员变量同名但类型不同
// 与父类中methodA()构成重载
public void methodA(int a) {
System.out.println("Derived中的int A方法");
}
// 与基类中methodB()构成重写(即原型一致)
public void methodB(){
System.out.println("Derived中的B方法");
}
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关键字
super.methodB(); // 访问父类的methodB()
}
}
从上述代码中可以总结一下:
- 当成员变量同名时,在子类中,this. 访问子类自己的成员,super. 访问父类的;
- 当成员方法同名时(不是方法的重载),构成方法的重写(即返回值相同,参数相同,名称相同),这时,使用 super. 访问父类的成员方法;
需要注意的是:1. this访问的时候,不仅可以访问子类的,也可以访问父类的
2. 当使用this访问父类和子类同名的成员变量时,优先访问子类
3. super只能访问从父类继承过来的成员变量
3.2 子类的构造方法
构造方法前面也提到过,和成员方法的区别是,成员方法有 void ,而构造方法没有。
当父类中存在构造方法时,无论有无参数,子类在继承时,都要和父类一样存在构造方法且参数相同。而且,在执行子类中的构造方法时,会先执行父类的构造方法。
使用 IntelliJ IDEA 写代码时,可以鼠标右键--生成,一键生成构造方法,还是很方便的。
class Animals{
String name;
int age;
public Animals(String name) { //一个参数的构造方法
this.name = name;
}
public void eat(){ //子类重写父类的成员方法
System.out.println(name + "正在吃饭");
}
public void sleep(){
System.out.println(name + "正在睡觉");
}
}
//子类dog
class Dog extends Animals{
public Dog(String name) { //子类中可以创造匹配super的构造方法
super(name);
}
public void eat(){
System.out.println(name + "正在吃狗粮");
}
public void bark(){
System.out.println(name + "汪汪汪~~~");
}
}
需要注意的是:
- 若父类显式定义无参或者默认的构造方法,在子类构造方法第一行默认有隐含的super()调用,即调用基类构 造方法
- 如果父类构造方法是带有参数的,此时需要用户为子类显式定义构造方法,并在子类构造方法中选择合适的 父类构造方法调用,否则编译失败。
- 在子类构造方法中,super(...)调用父类构造时,必须是子类构造函数中第一条语句。
- super(...)只能在子类构造方法中出现一次,并且不能和 this 同时出现,因为都只能在第一行
3.3 super 与 this
super和this都可以在成员方法中用来访问:成员变量和调用其他的成员函数,都可以作为构造方法的第一条语句,那他们之间有什么区别呢?
相同点:
- 都是Java中的关键字
- 只能在类的非静态方法中使用,用来访问非静态成员方法和字段
- 在构造方法中调用时,必须是构造方法中的第一条语句,并且不能同时存在
不同点:
- this是当前对象的引用,当前对象即调用实例方法的对象,super相当于是子类对象中从父类继承下来部分成员的引用
- 在非静态成员方法中,this用来访问本类的方法和属性,super用来访问父类继承下来的方法和属性
- 在构造方法中,this(...) 用于调用本类构造方法,super(...) 用于调用父类构造方法,两种调用不能同时在构造方法中出现
- 构造方法中一定会存在 super(...) 的调用,用户没有写编译器也会增加,但是this(...)用户不写则没有
3.4 继承当中的初始化
上一章提到了使用代码块进行初始化,实例代码块 和 静态代码块 的执行顺序是:静态>实例。
而出现构造方法后,它们的执行顺序会有什么变化:
- 静态代码块先执行,并且只执行一次,在类加载阶段执行
- 当有对象创建时,才会执行实例代码块,实例代码块执行完成后,最后构造方法执行
所以,它们三个点执行顺序是:静态代码块(只执行一次) > 实例代码块 > 构造方法。
以上是在非继承情况下,那么在继承情况下,它们的顺序呢:
- 父类静态代码块优先于子类静态代码块执行,且是最早执行
- 父类实例代码块和父类构造方法紧接着执行
- 子类的实例代码块和子类构造方法紧接着再执行
- 第二次实例化子类对象时,所有静态代码块都不执行
结论是,在继承环境下,首先:父类 > 子类,其次:静态 > 实例 > 构造。
4. protected关键字
我们前面提到的几个限定词:public,private,default,protected,其中protected提到了可以在不同包的子类中访问,这里,提到了子类,那父类中不同访问权限的成员,在子类中的可见性又是什么样子的呢?
// extend01包中
class B {
private int a;
protected int b;
public int c;
int d;
}
// extend01包中
// 同一个包中的子类
class D extends B{
public void method(){
// super.a = 10;// 编译报错,父类private成员在相同包子类中不可见
super.b = 20; // 父类中protected成员在相同包子类中可以直接访问
super.c = 30; // 父类中public成员在相同包子类中可以直接访问
super.d = 40; // 父类中默认访问权限修饰的成员在相同包子类中可以直接访问
}
}
// extend02包中
// 不同包中的子类
class C extends B {
public void method(){
// super.a = 10; // 编译报错,父类中private成员在不同包子类中不可见
super.b = 20; // 父类中protected修饰的成员在不同包子类中可以直接访问
super.c = 30; // 父类中public修饰的成员在不同包子类中可以直接访问
//super.d = 40; // 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
}
}
上述代码解释了protected限定词在不同包的子类中可以访问的情况。
很明显,如果在不同包的非子类,即其他类中则不能访问。
5. 继承的多种方式
继承的方式有很多种,像刚才提到的狗继承动物类,是单继承。
还有多层继承 和 不同类继承同一类。
多层继承:C 继承 B,B 继承 A。因此 C 也间接继承了 A。
不同类继承同一类:C 和 B 同时继承了 A,但 C 和 B直接没有继承关系。
需要注意,Java中不支持一个类继承多个类,但这种思想可以通过后面会提到的接口来实现。
6. final 关键字
final 关键字也是用来修饰成员变量和成员方法的:
修饰变量的时候就会把变量变成常量,不能修改:
final int a = 10;
a = 20; //error
修饰方法的时候也是同理。表示该方法不能被重写。
另外,final 关键字还可以用来修饰类,被 final 修饰的类表示不能被继承。我们平时使用的 String 字符串类就是被 final 修饰的,所以不能被修改(可以使用 StringBuilder)。
7. 继承与组合
看到这里,大家可能会对继承有了比较深的了解,就像字面意思中的关系:狗是动物,猫是动物。继承者与被继承者之间是 is - a 的关系。
而还有一种思想是组合,就像是汽车与部件之间的关系:汽车有轮胎。 是一种 has - a 的关系。
下面举一个例子:
// 轮胎类
class Tire{
// ...
}
// 发动机类
class Engine{
// ...
}
// 车载系统类
class VehicleSystem{
// ...
}
class Car{
private Tire tire; // 可以复用轮胎中的属性和方法
private Engine engine; // 可以复用发动机中的属性和方法
private VehicleSystem vs; // 可以复用车载系统中的属性和方法
// ...
}
上述代码就是一个组合的过程,组合没有什么特别的语法结构,是一种思想。
当然,组合可以和继承串联起来,上述的汽车类,就可以具体化一个宝马汽车,创建一个宝马汽车,然后继承汽车类。
小结:
这一章主要讲了Java面向对象的关键部分:继承,后面还提到了组合的思想,都是日常中经常用到的。下面就是又一个关键部分:多态。