☕目录☕

 🍕思维导图

  🍟一、引出继承

  🍔二、继承的概念

  🧇三、继承的语法

  🌭四、父类成员访问

              🍿🍿4.1 子类中访问父类的成员变量

              🥞🥞4.2 子类访问父类的成员方法

  🍞五、super 关键字

              🥐🥐5.1 super.成员变量

              🧀🧀5.2 super.成员方法

              🍖🍖5.3 super.构造方法

  🥩六、继承方式

  🍱七、final关键字

  🍰八、继承与组合

 🍚写在最后

思维导图

一、引出继承

       Java中 使用类 对 现实世界中的实体进行描述；

       类经过实例化以后的产物 对象，则可以用来表示现实中的实体；

       但是，在现实生活中，某些实体与实体之间 具有相同的属性；

       比如说，上面的小猫和小狗，就具有一个共性：它们都是动物；

       如果用Java语言来描述小猫和小狗，那么就可以这样来设计：

//定义一个Cat类

class Cat {
    public String name;
    public  int age;
    public String sex;

    public void eat() {
        System.out.println(this.name+"吃饭");
    }
    public void mew(){
        System.out.println(this.name+"喵喵叫");
    }
}

//定义一个Dog类

class Dog {
    public String name;
    public  int age;
    public String sex;

    public void eat() {
        System.out.println(this.name+"吃饭");
    }
    public void bark(){
        System.out.println(this.name+"汪汪叫");
    }
}

       很明显，Cat类 和 Dog类 有许多一样的属性；

       那么，能不能将这些共性给抽取出来呢？

       在面向对象的过程中，提出了 继承 的概念；

       专门用来进行 共性抽取，实现 代码复用。

二、继承的概念

继承机制：

       是面向对象程序设计 是代码可以复用的最重要的手段；

       它允许程序员在保持原有类的特性 的基础上 进行扩展，增加新功能，这样产生新的类，称为 派生类；

       继承体现了 面向对象程序设计的层次结构，体现了由简单到复杂的认知过程；

       继承 主要解决的问题是：共性的抽取，实现代码复用。

       例如，上面的小猫和小狗的例子，我们可以把它们的共性抽取出来，然后把这些抽取出来的共性重新放到一个类当中：

 public String name;
    public  int age;
    public String sex;

    public void eat() {
        System.out.println(this.name+"吃饭");
    }

 此时，可以通过 关键字extends 构成一个继承关系：

三、继承的语法

//修饰符可以省略，也可以不用省略

[修饰符] class 子类 extends 父类 {
        //继承的成员变量或方法
}

【注意】

1. 子类 会将父类中的成员变量或者成员方法 给继承到子类中；
2. 子类继承父类之后，需要添加自己特有的成员，体现出与父类的不同，否则就没有必要继承了。 

       所以，对上面的例子 可以使用 继承 的方式来设计：

class Animal {
    public String name;
    public  int age;
    public String sex;

    public void eat() {
        System.out.println(this.name+"吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

//Cat类
class Cat extends Animal{
    public void mew(){
        System.out.println(this.name+"喵喵叫");
    }
}

//Dog类
class Dog extends Animal{
    public void bark(){
        System.out.println(this.name+"汪汪叫");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "喵喵";
        cat.eat();
        cat.mew();

        Dog dog = new Dog();
        dog.name = "汪汪";
        dog.sleep();
        dog.bark();
    }
}

四、父类成员访问

       在继承体系中，子类将父类中的方法和字段继承下来了；

       那在子类中能否直接访问 父类中继承下来的成员呢？

4.1 子类中访问父类的成员变量

1.子类和父类 不存在 同名成员变量

class Base{
    public int a = 1;
    public int b = 2;
}

class Derived extends Base {
    public int c = 3;
    public int d = 4;

    public void test(){
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.test();
    }
}

画图示例：

结果示例：

2.子类和父类 成员变量存在同名情况

class Base3{
    public int a = 1;
    public int b = 2;
}

class Derived3 extends Base3 {
    public int a = 3;
    public int d = 4;

    public void test(){
        System.out.println("a = "+a);
        System.out.println("b = "+b);
        System.out.println("d = "+d);
    }
}
public class TestDemo3 {
    public static void main(String[] args) {
        Derived3 derived3 = new Derived3();
        derived3.test();
    }
}

结果示例：

【结论】

       由图可以看出，父类和子类都有相同的成员变量a，而最终打印的结果是 子类成员变量a 的值；

       这就说明：如果 子类和父类的成员变量重名，那么 优先访问子类的成员变量；

       这也可以理解，继承嘛，当自己的意志和父类的意志有冲突的时候，优先考虑一下自己的意志嘛！

       那么，如果实在想访问父类的成员变量，很简单，使用关键字super;

       这个会在下面详细的介绍。

4.2 子类访问父类的成员方法

1.子类和父类 成员方法 不存在同名的情况

class Base3{
    
    public void method(){
        System.out.println("Base3:method");
    }
}

class Derived3 extends Base3 {

    public void method2(){
        System.out.println("Derived3:method2");
    }

    public void test(){
        method();
        method2();
}

public class TestDemo3 {
    public static void main(String[] args) {
        Derived3 derived3 = new Derived3();
        derived3.test();
    }

结果示例：

【总结】成员方法没有同名时，子类优先访问；如果子类没有所需的成员变量和成员方法，而父类也没有，那么程序将会报错。 

2. 子类和父类 成员方法 存在同名的情况

class Base3{

    public void method(){
        System.out.println("Base3:method");
    }
}

class Derived3 extends Base3 {

    public void method(int a){
        System.out.println("Derived3:method2 "+a);
    }

    public void test(){
        method();
        method(100);
    }
}
public class TestDemo3 {
    public static void main(String[] args) {
        Derived3 derived3 = new Derived3();
        derived3.test();
    }
}

结果示例：

【说明】

1. 通过子类对象访问父类与子类中 不同名方法时，优先在子类中找，找到则访问；否则在父类中找，找到则访问；否则程序编译报错；
2. 通过 子类 访问 父类与子类同名方法时，如果父类和子类 同名方法的参数列表不同（重载），根据调用方法 适传递的参数选择合适的方法访问，如果没有则报错；如果父类和子类 同名方法的原型一致（重写-后面会介绍的），这只能访问到子类的，父类的无法通过子类对象直接访问到。 

五、super 关键字

       由于设计不好，或者因场景需要，子类和父类 可能会存在相同名称的成员；

       如果要在子类中访问父类同名成员时，那么应该怎么访问呢？

       直接访问是无法做到的；

       Java中提供了super关键字，该关键字的主要作用：在子类方法中访问父类的成员。

5.1 super.成员变量

5.2 super.成员方法

5.3 super.构造方法

 下面请看一段代码：

package Demo1;

class Animal {
    public String name;
    public int age;

    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }
}

class Cat extends Animal {
    public String hair;
    public void mew() {
        System.out.println(this.name + "正在叫");
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        cat1.name = "咪咪";
        cat1.mew();
        cat1.eat();
    }
}

代码运行结果： 

       当我们把 name和age的访问权限修改成private以后，子类就不去能访问了(注意是不能访问了，而不是没有被继承)：

       那么，此时可以去提供 getter和setter方法，再对代码进行修修改改：

package Demo1;

class Animal {
//    public String name;
    private String name;
//    public int age;
    private int age;

    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;
    }

    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }
}

class Cat extends Animal {
    public String hair;
    public void mew() {
        //System.out.println(this.name + "正在叫");
        //System.out.println(this.getAge());
    }
}

public class Test {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        //cat1.name = "咪咪";
        cat1.setName("咪咪");
        cat1.mew();
        cat1.eat();
    }
}

       于是，这些成员就被赋初值了：

       当然，我们曾经介绍过，赋初值的方法 除了setter和getter方法以外，还可以使用构造方法：

可是，当我们就直接加上构造方法的时候，代码就会报错啦：

       这是为什么呢？

       ——原来，当构造子类的时候，一定要先帮助父类构造，再帮助子类构造。

       所以说，还需要创建子类的构造方法，同时，要想先帮助父类构造，那可以用super关键字来进行调用：

 【注意】

1. 在调用构造方法的时候，和this一样，super必须放在第一行；
2. 父子父子，先有父再有子，在子类当中可以通过super关键字来调用父类的构造方法；
3. super不能在 静态方法中使用：

当然，我们也可以这样来写代码：

package Demo1;

class Animal {
    private String name;
    private int age;

    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;
    }

    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }

    public Animal() {

    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Cat extends Animal {
    public String hair;
    public void mew() {
        System.out.println(this.getName() + "正在叫");
    }
    public Cat() {
        super();
    }

    public Cat(String name,int age,String hair){
        super(name, age);
        this.hair = hair;
    }

}

public class Test {
    public static void main(String[] args) {
        Cat cat1 = new Cat("咪咪",8,"black");
        cat1.mew();
        cat1.eat();
    }
}

 代码编译结果：

六、继承方式

       在现实生活中，事物之间的关系是非常复杂、灵活多样的，比如：

       但是，在Java中，只存在以下几种继承方式：

【注意】Java是不支持多继承的，即：不支持 一个子类有多个父类。

       从上面来看，父类一层一层的被继承下去；

       但是，如果不想被继承了，那到底该怎么做呢？

       很简单，这就需要又引出了final关键字......

七、final关键字

当一个类被final关键字修饰以后，这个类就不能继承了：

【注意】

       被final修饰的类，我们把它叫做密封类(说明 当前的类不能被继承)；

       以前也介绍过，被final修饰的成员不能被修改(变成了常量）；

       当然，final还可以修饰方法...... 

八、继承与组合

       和继承类似，组合也是一种表达类之间关系的方式，也是可以达到代码复用的效果；

       组合并没有涉及到特殊的语法(比如说 extends 这样的关键字)，仅仅是将一个类的实例 作为另外一个类的字段；

       继承 表示对象之间是 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{
    // 将汽车中包含的：轮胎、发送机、车载系统全部继承下来 
}

       组合和继承都可以实现代码复用；

       应该使用继承还是组合，需要根据应用场景来选择；

       一般建议：能用组合尽量用组合。 

       如果大家对这个有很大兴趣的话，可以点击这个传送门：

深入理解Java中的组合和继承-传送门时刻准备中......

写在最后

       那么，现在 Java的第二个特性——继承 也到此告一段落了；

       由于博主水平有限，可能会出现一些表达不清楚，或者出现一些其他的情况，

       欢迎各位铁汁们指出来，让博主一起改正，

       一起努力，共同进步；

       好了，如果这篇博客对铁汁们有帮助的话，可以送一个免费的 赞 嘛；

       当然，顺手点个关注是再好不过的了......