第一章：OOP：继承-Java语言基础6-面向对象高级

当前位置:　首页>> 技术小册>> Java语言基础6-面向对象高级

1.1 继承的由来

![](/uploads/images/20230724/cc6c74829837e77b78e16fce9ef0be76.png)

多个类中存在相同属性和行为的时候，将这些内容抽取到单独的一个类中，那么多个类中无需再定义这些属性和行为，只需要继承那个类即可。

![](/uploads/images/20230724/519a4a5685d0182091ca712d44251478.png)

- 此处的多个类称为 子类（派生类） ，单独的这个类称为 父类（基类或超类） 。
- 继承描述的是事物之间的所属关系，这种关系是： is a 的关系。例如：图中的猫属于动物，狗也属于动物。由此可见，父类更通用，子类更具体。通过继承，可以使得多种事物之间形成一种关系体系。

1.2 继承的好处

- ① 继承的出现，减少了代码的冗余（重复），提供了代码的复用性。
- ② 继承的出现，有利于功能的扩展。
- ③ 继承的出现，让类和类之间产生了关系，提供了多态的前提。

注意：不要为了获取其它类中的某个功能而去继承。

1.3 语法格式

-  在 Java 中，继承是通过 extends 关键字，声明一个子类继承一个父类。 
-  语法：

```bash
修饰符 class 父类{
    ...
}
修饰符 class 子类 extends 父类 {
    ...
}
```
示例：
```bash
package com.github.inherit.demo2;

/**
 * 动物
 * 
 * @author maxiaoke.com
 * @version 1.0
 */
public class Animal {
    /**
     * 姓名
     */
    String name;
    /**
     * 年龄
     */
    int age;

/**
     * 吃
     */
    public void eat() {
        System.out.println(this.name + "在吃饭，年龄是：" + this.age);
    }
}
```

```bash
package com.github.inherit.demo2;

/**
 * 猫
 * 
 * @author maxiaoke.com
 * @version 1.0
 */
public class Cat extends Animal {
    /**
     * 抓老鼠
     */
    public void catchMouse() {
        System.out.println("抓老鼠");
    }

}
```

```bash
package com.github.inherit.demo2;

/**
 * 狗
 * 
 * @author maxiaoke.com
 * @version 1.0
 */
public class Dog extends Animal {

/**
     * 看家
     */
    public void lookHome() {
        System.out.println("看家护院");
    }

}
```

```bash
package com.github.inherit.demo2;

/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "Jerry";
        cat.age = 3;
        cat.eat();
        cat.catchMouse();

System.out.println("********************");

Dog dog = new Dog();
        dog.name = "Tom";
        dog.age = 4;
        dog.eat();
        dog.lookHome();
    }
}
```

1.4 继承的特点之一：成员变量

1.4.1 父类成员变量私有化

- 父类的成员，无论是公有（ public ）还是私有（ private ），均为被子类所继承。
- 子类虽然会继承父类私有的（ private ）的成员，但是子类不能对继承的私有成员直接进行访问，却可以通过继承的 setter 和 getter 方法进行范访问。

示例：

```bash
package com.github.inherit.demo3;

/**
 * 动物
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class Animal {
    /**
     * 年龄
     */
    int age;
    /**
     * 姓名
     */
    private String name;

public String getName() {
        return this.name;
    }

public void setName(String name) {
        this.name = name;
    }

/**
     * 吃
     */
    public void eat() {
        System.out.println(this.name + "在吃饭，年龄是：" + this.age);
    }
}
```

```bash
package com.github.inherit.demo3;

}
```

```bash
package com.github.inherit.demo3;

/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        // cat.name = "Jerry"; 编译报错
        cat.setName("Jerry");
        cat.age = 3;
        cat.eat();
        cat.catchMouse();
    }
}
```

1.4.2 父类和子类成员变量重名
子类会继承父类所有的成员变量，那么如果子类出现和父类同名的成员变量会怎么样？
父类代码：

```bash
package com.github.inherit.demo4;

/**
 * 动物
 *
 * @author maxiaoke.com
 * @version 1.0
 */
public class Animal {
    /**
     * 年龄
     */
    int age = 88;
    /**
     * 姓名
     */
    private String name;

public String getName() {
        return this.name;
    }

public void setName(String name) {
        this.name = name;
    }

}
```
子类代码：
```bash
package com.github.inherit.demo4;

/**
 * 猫
 * 
 * @author maxiaoke.com
 * @version 1.0
 */
public class Cat extends Animal {

int age = 5;

public void showAge() {
        System.out.println("Cat的年龄是：" + this.age + "，Animal的年龄是：" + super.age);
    }

}
```

测试代码：
```bash
package com.github.inherit.demo4;

/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.setName("Jerry");
        cat.showAge();
    }
}
```

- 总结： 
  - ① 当父类的成员变量私有化的时候，在子类中是无法直接访问的，所以是否重名没有任何影响；但是，如果想访问父类的私有成员变量，只能通过父类提供的 setter 和 getter 访问。
  - ② 当父类的成员变量非私有化的时候，在子类中是可以直接访问的，所以如果有重名，就需要加上 super.父类成员变量名 来进行区分。

注意：在实际开发中，虽然我们可以通过 super 关键字来实现区分父子类重名成员变量，但是不建议这么干。

1.5 继承的特点之二：成员方法

1.5.1 方法重写（ override ）

- 定义：在子类中可以根据需要对从父类中继承而来的方法进行改造，也称为方法的 重置 、 覆盖 。在程序执行的时候，子类的方法将覆盖父类的方法。
- 要求： 
  - ① 子类重写的方法 必须 和父类被重写的方法具有相同的 方法名称 、 参数列表 。
  - ② 子类重写的方法的返回值类型 不能大于 父类被重写的方法的返回值类型（这对于返回值类型为引用数据类型来说的，如果返回值类型是基本数据类型和 void 类型必须相同，换言之，只有继承，才会有父类和子类）。
  - ③ 子类重写的方法使用的访问权限 不能小于 父类被重写的方法的访问权限（ 注意：子类不能重写父类中声明为privat权限的方法或final修饰的方法 ）。
  - ④ 子类方法抛出的异常不能大于父类被重写方法的异常。

注意： 子类和父类中同名同参数的方法必须同时声明为非 static的（重写），或者同时声明为 static 的（不是重写，因为 static 方法是属于类的，子类无法覆盖父类的方法。

- 示例：

```bash
package com.github.inherit.demo5;

/**
 * 手机类
 * 
 * @author maxiaoke.com
 * @version 1.0
 */
public class Phone {

public void sendMessage() {
        System.out.println("发送短信");
    }

public void call() {
        System.out.println("打电话");
    }

public void showNum() {
        System.out.println("显示来电号码");
    }
}
```

```bash
package com.github.inherit.demo5;

/**
 * 智能手机
 * 
 * @author maxiaoke.com
 * @version 1.0
 */
public class SmartPhone extends Phone {

/**
     * 重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
     */
    @Override
    public void showNum() {
        // super.父类成员方法，表示调用父类的成员方法。
        super.showNum();
        // 增加自己的显示姓名和图片功能
        System.out.println("显示来电姓名");
        System.out.println("显示头像");
    }
}
```

```bash
package com.github.inherit.demo5;

/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class SmartPhoneTest {
    public static void main(String[] args) {
        SmartPhone smartPhone = new SmartPhone();
        // 调用父类继承而来的方法
        smartPhone.call();
        // 调用子类重写的方法
        smartPhone.showNum();
    }
}
```

1.5.2 方法重载（ overload ）

- 在同一类中：

```bash
package com.github.inherit.demo;

/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class Overload {

public int max(int a, int b) {
        return a > b ? a : b;
    }

public double max(double a, double b) {
        return a > b ? a : b;
    }

public int max(int a, int b, int c) {
        return max(this.max(a, b), c);
    }
}
```

在父子类中：

```bash
package com.github.inherit.demo;

/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class Father {
    public int max(int a, int b) {
        return a > b ? a : b;
    }
}
``````bash
package com.github.inherit.demo;

/**
 * @author maxiaoke.com
 * @version 1.0
 */
public class Son extends Father {
    public double max(double a, double b) {
        return a > b ? a : b;
    }
}
```

1.6 继承的特点之三：单继承

- ① Java 只支持单继承，不支持多继承。

```bash
// 一个类只能有一个父类
class C extends A{}
```
```
class A{}
```
```
class B extends A{}
```
```
class C extends B{}
```

注意：顶层父类是 Object 类，所有类默认继承 Object 类作为父类。

- ③ 子类和父类是一种相对概念。比如：B 类相对于 A 类来说是子类，但是相对于 C 类来说是父类。
- ④ 一个父类可以同时有多个子类。

1.7 继承的特点之四：构造方法

- 构造方法的定义： 
  - ① 构造方法的名称和类名是一致的。
  - ② 构造器不声明返回值类型（和声明 void 不同）。
  - ③ 构造器不能被 static 、final 、synchronized 、abstract 、native 修饰，不能有 return 语句返回值。
  - 所以，子类是无法 继承 父类的构造方法的。
- 构造方法的作用：初始化实例变量的。但是，子类又会从父类那边继承所有成员变量，所以子类在初始化的过程中，必须先执行父类的初始化动作（子类的构造方法中默认有一个 super() ，表示调用父类的实例初始化方法，父类成员变量初始化后，才可以给子类使用），才能执行自己的初始化动作。

该分类下的相关小册推荐：

Java语言基础8-Java多线程

Java语言基础4-数组详解

SpringBoot合辑-初级篇

JAVA 函数式编程入门与实践

Java语言基础16-JDK8 新特性

Java语言基础11-Java中的泛型

手把手带你学习SpringBoot-零基础到实战

深入拆解 Java 虚拟机

Java并发编程

Mybatis合辑1-Mybatis基础入门

Java语言基础10-Java中的集合

Mybatis合辑3-Mybatis动态SQL