【Java SE】面向对象三大特性之继承
作者：月亮嚼成星~
博客主页：月亮嚼成星~的博客主页
专栏：Java SE基础
工欲善其事必先利其器，给大家介绍一款超牛的斩获大厂offer利器——牛客网
点击免费注册和我一起刷题吧
面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。
何为继承？
继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。
例如：狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。
狗：
public class Dog {
String name;
int age;
float weight;
public void eat() {
System.out.println(name + "正在吃饭");
}
public void sleep() {
System.out.println(name + "正在睡觉");
}
void Bark() {
System.out.println(name + "汪汪汪~~~");
}
}猫：
public class Cat{
String name;
int age;
float weight;
public void eat(){
System.out.println(name + "正在吃饭");
}
public void sleep()
{
System.out.println(name + "正在睡觉");
}
void mew(){
System.out.println(name + "喵喵喵~~~");
}
}在猫和狗中含有相同的字段和行为，同时也可能含有不同的字段和行为，所以我们可以将相同的部分提取出来，然后让猫和狗来继承相同的部分：
那能否将这些共性抽取呢？面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。
在Java中如果要表示类之间的继承关系，需要借助extends关键字，具体如下：
//Cat.java
public class Cat extends Animal{
void mew(){
System.out.println(name + "喵喵喵~~~");
}
}
//Dog.java
public class Dog extends Animal{
void Bark() {
System.out.println(name + "汪汪汪~~~");
}
}
//Animal.java
public class Animal {
String name;
int age;
float weight;
public void eat(){
System.out.println(name + "正在吃饭");
}
public void sleep()
{
System.out.println(name + "正在睡觉");
}
}
//Test.java
public class Test {
public static void main(String[] args) {
Dog dog=new Dog();
Cat cat=new Cat();
cat.name="mimi";
dog.name="wangcai";
cat.eat();
dog.eat();
dog.Bark();
}
}
猫和狗的name和eat都是从Animal类中继承下来的。
注意：
1. 子类会将父类中的成员变量或者成员方法继承到子类中了
2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了。
如何从子类中访问父类成员呢？
1. 子类和父类不存在同名成员变量：
//Car.java
public class Car {
int a;
int b;
String name;
public void music(){
System.out.println(name+"正在播放音乐");
}
}
//BMW.java
public class BMW extends Car{
int c;
public void method(){
a=10;// 访问从父类中继承下来的a
b=20;// 访问从父类中继承下来的b
name="aodi";// 访问从父类中继承下来的name
c=30;// 访问自己的c
}
}
2. 子类和父类成员变量同名：
成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。
//Car.java
public class Car {
int a;
int b;
String name;
public void music(){
System.out.println(name+"正在播放音乐");
}
}
//BMW.java
public class BMW extends Car{
int b;
int c;
public void method(){
a=10;// 访问从父类中继承下来的a
b=20;// 访问自己的b
name="aodi";// 访问从父类中继承下来的name
c=30;// 访问自己的c
}
}
注意：在子类方法中 或者 通过子类对象访问成员时：
如果访问的成员变量子类中有，优先访问自己的成员变量。
如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
如果访问的成员变量与父类中成员变量同名，则优先访问自己的
子类中访问父类的成员方法：
//Car.java
public class Car {
int a;
int b;
String name;
public void music(){
System.out.println(name+"正在播放音乐");
}
}
//BMW.java
public class BMW extends Car{
int b;
int c;
public void A(){
System.out.println("子类的A行为");
}
public void method(){
a=10;// 访问从父类中继承下来的a
b=20;// 访问自己的b
name="aodi";// 访问从父类中继承下来的name
c=30;// 访问自己的c
A();//子类的A成员方法
music();//父类的music方法
}
}
总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。
成员方法名字相同：
//Car.java
public class Car {
int a;
int b;
String name;
public void A(){
System.out.println("父类的A行为");
}
public void B(){
System.out.println("父类的B行为");
}
public void getB(){
System.out.println(b);
}
public void music(){
System.out.println(name+"正在播放音乐");
}
}
//BMW.java
public class BMW extends Car{
int b;
int c;
public void A(){
System.out.println("子类的A行为");
}
public void B(){
System.out.println("子类的B行为");
}
public void getB(int a,int b){
this.a=a;
this.b=b;
}
public void method(){
a=10;// 访问从父类中继承下来的a
b=20;// 访问自己的b
name="aodi";// 访问从父类中继承下来的name
c=30;// 访问自己的c
A();//子类的A成员方法
music();//父类的music方法
B();//访问的子类的B方法
getB();//访问父类的getB方法
}
}总结：通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错。
super关键字：
如果子类中存在与父类中相同的成员时，那如何在子类中访问父类相同名称的成员呢？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。
//Car.java
public class Car {
int a;
int b;
String name;
public void A(){
System.out.println("父类的A行为");
}
public void B(){
System.out.println("父类的B行为");
}
public void getB(){
System.out.println(b);
}
public void music(){
System.out.println(name+"正在播放音乐");
}
}
//BMW.java
public class BMW extends Car{
int b;
int c;
public void A(){
System.out.println("子类的A行为");
}
public void B(){
System.out.println("子类的B行为");
}
public void getB(int a,int b){
this.a=a;
this.b=b;
}
public void method(){
a=10;// 访问从父类中继承下来的a
b=20;// 访问自己的b
super.b=50;//访问从父类中继承下来的b
name="aodi";// 访问从父类中继承下来的name
c=30;// 访问自己的c
A();//子类的A成员方法
music();//父类的music方法
B();//访问的子类的B方法
super.B();//访问父类的B方法
getB();//访问父类的getB方法
}
}在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可
注意事项：
1. super和this一样只能在非静态方法中使用
2. super可以在在子类方法中，访问父类的成员变量和方法。
子类构造方法：
子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。
//Car.java
public class Car {
int a;
int b;
String name;
public Car(){
System.out.println("基类构造方法");
}
}
//BMW.java
public class BMW extends Car{
int b;
int c;
public BMW(){
System.out.println("子类构造方法");
}
}
//Test.java
public class Test {
public static void main(String[] args) {
BMW bmw=new BMW();
}
}
子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。
注意：
1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现
super和this的区别：
代码块在继承关系中的执行顺序：
//Car.java
public class Car {
int a;
int b;
String name;
{
System.out.println("父类实例代码块执行");
}
static {
System.out.println("父类静态代码块执行");
}
public Car(){
System.out.println("基类构造方法执行");
}
}
//BMW.java
public class BMW extends Car{
int b;
int c;
String name;
{
System.out.println("子类实例代码块执行");
}
static {
System.out.println("子类静态代码块执行");
}
public BMW(){
System.out.println("子类构造方法");
}
}
//Test.java
public class Test {
public static void main(String[] args) {
BMW bmw=new BMW();
}
}
当我们第二次实例化对象的时候，我们可以清楚的看到：
public class Test {
public static void main(String[] args) {
BMW bmw=new BMW();
System.out.println("第二次实例化子类对象：");
System.out.println("==================================");
BMW bmw1=new BMW();
}
}
通过分析执行结果，得出以下结论：
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
protected 关键字
在封装的那一篇开头介绍了访问控制修饰符：【Java SE】面向对象三大特性之封装
感兴趣的可以再去了解一下。
这边建立了2个不同的包：
其中一个是同一个包中的2个类，另一个类在另一个包中：
首先在同一个包中：
package TestDemo;
//A.java
public class A {
public int a;
private int b;
protected int c;
int d;
}
//B.java
package TestDemo;
public class B extends A{
public void method(){
super.a=20;
super.b=100;
super.c=30;
super.d=40;
}
}
虽然不能访问，但是也继承了父类的b成员变量。
现在是两个包中的：
package TestDemo;
//A.java
public class A {
public int a;
private int b;
protected int c;
int d;
}
//C.java
package TestDemo1;
import TestDemo.A;
public class C extends A {
public void method(){
super.a=20;
super.b=100; //编译报错，父类中private成员在不同包子类中不可见
super.c=30;// 父类中protected修饰的成员在不同包子类中可以直接访问
super.d=40;// 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
}
}
注意：我们在使用的时候应该尽可能的使用 比较严格的访问权限. 例如如果一个方法能用 private, 就尽量不要用 public.
继承方式
继承方式有单继承，多层继承和不同类继承同一个类。
一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.
如果想从语法上进行限制继承, 就可以使用 final 关键字
final 关键字
final关键可以用来修饰变量、成员方法以及类
1. 修饰变量或字段，表示常量(即不能修改)
2. 修饰类：表示此类不能被继承
3. 修饰方法：表示该方法不能被重写
重写
当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。
要想调用父类中被重写的方法，则必须使用关键字 super。
public class Animals {
public void call(){
System.out.println("动物叫...");
}
}
public class Cat extends Animals{
@Override
public void call() {
System.out.println("喵喵喵...");
}
}
public class Dog extends Animals{
@Override
public void call() {
super.call();
}
public static void main(String[] args) {
Animals dog = new Dog();
dog.call();//动物叫...
Animals cat = new Cat();
cat.call();//喵喵喵...
}
}
继承与组合
继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物
组合表示对象之间是has-a的关系，比如：汽车有发动机，轮胎等等组成
class D{
}
class E{
}
//F由D，E构成（组合）
class F{
private D d; // 可以复用D的属性和方法
private E e; // 可以复用E的属性和方法
}组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合。