文章目录
- 1. 为什么需要继承
- 2. 继承的概念
- 3. 继承的语法
- 4. 父类成员访问
- 4.1 子类中访问父类的成员变量
- 4.2 子类中访问父类的成员方法
- 5. super关键字
- 6. 子类的构造方法
- 7. super和this
- 8. 再谈初始化
- 9. protected 关键字
- 10. 继承方式
- 11. final 关键字
- 12. 继承与组合
1. 为什么需要继承
Dog类:
public class Dog {public String name;public int age;public String color;public void eat(){System.out.println(this.age + "正在吃饭......");}public void bark(){System.out.println(this.name + "正在汪汪叫.....");}public Dog(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}
}
Bird类:
public class Bird {public String name;public int age;public String color;public void eat(){System.out.println(this.name + "正在吃饭.....");}public void fly(){System.out.println(this.name + "正在飞.....");}public Bird(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}@Overridepublic String toString() {return "Bird{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}
}
可以看到这两个类有很多共同的属性,name、age、color、eat()。
这个时候就提出了继承的概念,专门用来进行共性抽取,实现代码的复用。
2. 继承的概念
上述图示中,Dog和Cat都继承了Animal类,其中:Animal类称为父类/基类或超类,Dog和Cat可以称为Animal的子类/派生类,继承之后,子类可以复用父类中成员,子类在实现时只需关心自己新增加的成员即可。
从继承概念中可以看出继承最大的作用就是:实现代码复用,还有就是来实现多态。
3. 继承的语法
修饰符 class 子类 extends 父类 {
// ...
}
使用继承后的代码:
Animal类:
public class Animal {public String name;public int age;public String color;public void eat(){System.out.println(this.name + "正在吃饭.....");}
}
Bird类:
public class Bird extends Animal{public void fly(){System.out.println(this.name + "正在飞.....");}public Bird(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}@Overridepublic String toString() {return "Bird{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}
}
Dog类:
public class Dog extends Animal{public void bark(){System.out.println(this.name + "正在汪汪叫.....");}public Dog(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}
}
4. 父类成员访问
4.1 子类中访问父类的成员变量
- 子类和父类不存在同名成员变量
Base类:
public class Base {public int a;public int b;
}
Derived类:
public class Derived extends Base{public int c;public void method(){System.out.println(a + " ," + b + " ," + c);}
}
- 子类和父类成员变量同名
Base类:
public class Base {public int a = 100;public int b = 200;
}
Derived类:
public class Derived extends Base{public int a = 101;public int c = 201;public void method(){System.out.println(a + " ," + b + " ," + c);}
}
Test类:
public class Test {public static void main(String[] args) {Derived derived = new Derived();derived.method();System.out.println(derived.a);}
}
输出结果:111 ,333 ,100111
当在继承关系中,父类 和 子类出现了同名的成员变量的时候,在子类当中,如果不做指定,默认访问的是子类自己的。当子类不存在该成员变量时,才去父类找,如果父类也没有,则编译报错。(体现子类优先被访问)
4.2 子类中访问父类的成员方法
1. 成员方法名字不同
Base类:
public class Base {public int a = 110;public int b = 333;public void method(){System.out.println("父类method()方法........");}
}
Derived类:
public class Derived extends Base{public int a = 111;public int c = 100;public void method1(){System.out.println("子类method1()方法........");}
}
Test类:
public class Test {public static void main(String[] args) {Derived derived = new Derived();derived.method1();derived.method();}
}
输出结果:子类method1()方法........父类method()方法........
总结:成员方法没有同名时,在子类方法中或者通过子类对象访问方法时,则优先访问自己的,自己没有时
再到父类中找,如果父类中也没有则报错。
2. 成员方法名字相同
Base类:
public class Base {public int a = 110;public int b = 333;public void method(){System.out.println("父类method()方法........");}
}
Derived类:
public class Derived extends Base{public int a = 111;public int c = 100;public void method1(){System.out.println(a + " ," + b + " ," + c);}public void method(){System.out.println("子类method()方法........");}
}
Test类:
public class Test {public static void main(String[] args) {Derived derived = new Derived();derived.method();}
}
输出结果:子类method()方法........
【说明】
-
通过子类对象访问父类与子类中不同名方法时,优先在子类中找,找到则访问,否则在父类中找,找到则访问,否则编译报错。
-
通过派生类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法适传递的参数选择合适的方法访问,如果没有则报错;
问题:如果子类中存在与父类中相同的成员时,那如何在子类中访问父类相同名称的成员呢?
5. 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()}
}
【注意事项】
- 只能在非静态方法中使用
- 在子类方法中,访问父类的成员变量和方法
super只能指代当前类的父类,不能指代父类的父类,甚至更“远”。
6. 子类的构造方法
父子父子,先有父再有子,即:子类对象构造时,需要先调用父类构造方法,然后执行子类的构造方法。
Animal类:
public class Animal {public String name;public int age;public void eat(){System.out.println(this.name + "正在吃饭...");}public Animal(String name, int age) {this.name = name;this.age = age;}
}
Dog类:
public class Dog extends Animal{//当子类继承父类以后,将来一定会构造子类对象,构造子类对象一定会调用子类的构造方法.//当在构造子类对象时,从父类继承过来的name,age要进行初始化,//怎么对父类继承过来的成员变量进行初始化呢?//下面这样不初始化吗?//不算!!!!
// public Dog(String name, int age){
// this.name = name;
// this.age = age;
// }public Dog(String name, int age) {super(name, age);}public void bark(){System.out.println(this.name + "正在汪汪叫......");}}
Test类:
public class Test {public static void main(String[] args) {Dog dog = new Dog("辣条", 1);}
}
- 子类构造方法中会默认调用父类的无参构造方法:super();用户没有写构造方法时,编译器会自动生成一个无参的构造方法,而且super()必须是子类构造方法中的第一条语句,并且只能出现一次。
- 在子类构造方法中,并没有写任何关于基类构造的代码,但是在构造子类对象时,先执行基类的构造方法,然后执行子类的构造方法,因为:子类对象中成员是有两部分组成的,基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子,所以在构造子类对象时候 ,先要调用基类的构造方法,将从基类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整 。
注意:
- 若父类显式定义无参或者默认的构造方法,在子类构造方法第一行默认有隐含的super()调用,即调用基类构造方法.
- 如果父类构造方法是带有参数的,此时需要用户为子类显式定义构造方法,并在子类构造方法中选择合适的父类构造方法调用,否则编译失败。
- 在子类构造方法中,super(…)调用父类构造时,必须是子类构造函数中第一条语句。
- super(…)只能在子类构造方法中出现一次,并且不能和this同时出现.
7. super和this
- this是当前对象的引用,当前对象即调用实例方法的对象,super相当于是子类对象中从父类继承下来部分成员的引用.
- 在非静态成员方法中,this用来访问本类的方法和属性,super用来访问父类继承下来的方法和属性.
- 在构造方法中:this(…)用于调用本类构造方法,super(…)用于调用父类构造方法,两种调用不能同时在构造方法中出现.
- 构造方法中一定会存在super(…)的调用,用户没有写编译器也会增加,但是this(…)用户不写则没有.
8. 再谈初始化
Animal类:
public class Animal {public String name;public int age;static{System.out.println("父类静态代码块执行了.......");}{System.out.println("父类实例代码块执行了.......");}public void eat(){System.out.println(this.name + "正在吃饭...");}public Animal(String name, int age) {this.name = name;this.age = age;System.out.println("父类构造方法执行了.......");}
}
Dog类:
public class Dog extends Animal{static{System.out.println("子类静态代码块执行了.......");}{System.out.println("子类实例代码块执行了.......");}public Dog(String name, int age) {super(name, age);System.out.println("子类构造方法执行了......");}public void bark(){System.out.println(this.name + "正在汪汪叫......");}
}
Test类:
public class Test {public static void main(String[] args) {Dog dog = new Dog("辣条", 1);System.out.println("===========================");Dog dog1 = new Dog("土豆", 6);}
}
输出结果:父类静态代码块执行了.......子类静态代码块执行了.......父类实例代码块执行了.......父类构造方法执行了.......子类实例代码块执行了.......子类构造方法执行了......===========================父类实例代码块执行了.......父类构造方法执行了.......子类实例代码块执行了.......子类构造方法执行了......
通过分析执行结果,得出以下结论:
- 静态代码块先执行,并且只执行一次,在类加载阶段执行
- 当有对象创建时,才会执行实例代码块,实例代码块执行完成后,最后构造方法执行
1、父类静态代码块优先于子类静态代码块执行,且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时,父类和子类的静态代码块都将不会再执行
9. protected 关键字
No | 范围 | private | default | protected | public |
---|---|---|---|---|---|
1 | 同一个包的同一类 | √ | √ | √ | √ |
2 | 同一个包中的不同类 | √ | √ | √ | |
3 | 不同包中的子类 | √ | √ | ||
4 | 不同包中的非子类 | √ |
10. 继承方式
Java支持单继承、多层继承和不同类继承同一个类这三种继承方式,不支持多继承,但是我们可以通过接口来实现多继承。
一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.如果想从语法上进行限制继承, 就可以使用 final 关键字。
11. final 关键字
final关键可以用来修饰变量、成员方法以及类。
1. 修饰变量或字段,表示常量(即不能修改)
final int a = 10;
a = 20; // 编译出错
2. 修饰类:表示此类不能被继承
final public class Animal {
...
}
public class Bird extends Animal {
...
}// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继承。
3. 修饰方法:表示该方法不能被重写
12. 继承与组合
继承表示对象之间是is-a的关系,比如:狗是动物,猫是动物。
组合表示对象之间是has-a的关系,比如:汽车有一个方向盘。
汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合,因为汽车是有这些部件组成的。
// 轮胎类
class Tire{
// ...
}
// 发动机类
class Engine{
// ...
}
// 车载系统类
class VehicleSystem{
// ...
}
class Car{private Tire tire; // 可以复用轮胎中的属性和方法private Engine engine; // 可以复用发动机中的属性和方法private VehicleSystem vs; // 可以复用车载系统中的属性和方法
// ...
}
// 奔驰是汽车
class Benz extend Car{
// 将汽车中包含的:轮胎、发送机、车载系统全部继承下来
}
一般建议:能用组合尽量用组合。