我们先来看看Java对类继承的一些特性描述：
```
子类拥有父类非 private 的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以用自己的方式实现父类的方法。

Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
```

### 继承关键字
java中类的继承通过使用 `extends` 和 `implements` 这两个关键字来实现继承。

而在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 `extends` 只能继承一个类。

其用法与PHP一致。

而 `implements` 则是用来继承多个接口类，从而实现了类似继承多个父类一样的功能。这个`implements` 会放在接口类相关的内容中再进行学习。

下面我们主要学习 `extends` 的使用。

简单案例：
```java
public class Test1 extends Test{
    // 解析器入口
    public static void main(String[] args) {
        // 父类静态的方法可以直接调用
        run();
        // 父类静态的成员属性可以直接调用
        System.out.println(age);

Test1 obj = new Test1();
        obj.A1();
    }
    public void A1() {
        // 通过super关键字，可以调用父类的对象
        super.run2();
        // 通过this关键字，可以调用自身的对象
        this.A2();
    }
    public void A2() {
        System.out.println(super.age);
        System.out.println(super.sex);
    }
}

class Test {
    // 我是静态父类成员属性
    protected static int age = 10;
    // 我是动态父类成员属性
    protected int sex = 1;

// 我是静态父类方法
    public static void run() {
        System.out.println("我是静态父类方法");
    }

// 我是动态父类方法
    public void run2() {
        System.out.println("我是动态父类方法");
    }
}
```
从上面的代码中我们可以看出以下几点:
```
1、在子类的静态方法中，无法使用this和super关键字
2、this关键字用于操作自身实例
3、super关键字用于操作父类实例
4、父类的静态方法可以通过方法名直接使用
5、父类的静态成员属性可以通过属性名直接使用
```

同时Java在类的继承中，对构造方法也会有所影响。

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。

如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 `super` 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 `super` 关键字调用父类构造器，系统会自动调用父类的无参构造器。

例如下面的案例：
```java
public class Test1{
    // 解析器入口
    public static void main(String[] args) {
        // 测试
        System.out.println("------Demo 类继承------");
        Demo obj1 = new Demo();
        System.out.println("------Demo 类继承------");
        Demo obj2 = new Demo(100);
    }
}

// 子类
class Demo extends Test {
    private int n;

// 自动调用父类的无参数构造器
    Demo() {
        System.out.println("子类无参数");
    }

Demo(int n) {
        // 调用父类中带有参数的构造器
        super(300);
        System.out.println("父类有参数：n="+n);
        n = n;
    }
}

// 父类
class Test {
    private static int n;
    Test(){
        System.out.println("父类无参数");
    }
    Test(int n) {
        System.out.println("父类有参数：n");
        n = n;
    }
}
```
最终结果：
```
------Demo 类继承------
父类无参数
子类无参数
------Demo 类继承------
父类有参数：n
父类有参数：n=100
```
有的朋友可能会疑惑，既然子类没办法覆盖父类的构造函数，那为什么还要使用`super(300)`呢，其实有疑惑的朋友可以自己注释掉这行代码，运行之后你就会发现，如果你不调用`super(n)`传递对应的构造参数给父类，那么父类执行的构造方法就会变成`Test()`了，所以实际开发中我们需要非常注意这点。

在类的继承中，通常情况下，构造函数的优先级执行顺序都是:
```
父类->子类A级->子类B级->更多下级
```

注意，在java中无法实现子类不调用父类的构造函数的办法。

但我们可以通过父类构造函数的场景控制，来达到与子类构造函数不冲突。

同时我们还需要注意，类的继承会造成严重的逻辑耦合，会让后期的代码更加难以维护，所以在选择类继承使用的时候需要额外小心。

### final关键字

在实际开发中，如果我们不想一个类被小组的其他成员误会为可以继承，那么我们可以使用`final`关键字，声明这个类是不允许被继承的。

格式如下:

声明类：
```
final class 类名 {
	//类体
}
```
声明方法：
```
修饰符(public/private/default/protected) final 返回值类型 方法名(){
	//方法体
}
```
当我们使用在方法时，表示该类的该方法，不能被子类重写。

已有0条评论

添加新评论☺

如果认为本文对您有所帮助请赞助本站

支付宝扫一扫赞助

已有0条评论

添加新评论☺