super与final关键字

在Java编程中，`super`关键字是一个非常重要的概念。它主要用于在子类中访问父类的成员，包括方法和变量。理解`super`关键字的使用场景和作用，对于编写继承关系复杂的代码非常有帮助。

#### 1. `super`关键字的基本概念

`super`关键字用于在子类中引用父类的成员。它可以用来调用父类的构造方法、访问父类的成员变量以及调用父类的方法。`super`关键字的主要用途包括：

- 调用父类的构造方法。
- 访问父类的成员变量。
- 调用父类的方法。

#### 2. 使用`super`调用父类构造方法

在Java中，子类的构造方法会自动调用父类的无参构造方法。如果父类没有无参构造方法，或者你希望子类调用父类的有参构造方法，就需要使用`super`关键字显式地调用父类的构造方法。

```java
class Animal {
    String name;

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

class Dog extends Animal {
    String breed;

    public Dog(String name, String breed) {
        super(name); // 调用父类的有参构造方法
        this.breed = breed;
    }
}
```

在上面的例子中，`Dog`类的构造方法通过`super(name)`显式地调用了父类`Animal`的有参构造方法，从而初始化了父类的`name`属性。

#### 3. 使用`super`访问父类的成员变量

当子类和父类具有相同名称的成员变量时，子类中的变量会覆盖父类的变量。如果需要在子类中访问父类的成员变量，可以使用`super`关键字。

```java
class Vehicle {
    int speed = 100;
}

class Car extends Vehicle {
    int speed = 120;

    void displaySpeed() {
        System.out.println("Car speed: " + speed); // 输出子类的speed
        System.out.println("Vehicle speed: " + super.speed); // 输出父类的speed
    }
}
```

在这个例子中，`Car`类中的`speed`变量覆盖了父类`Vehicle`的`speed`变量。通过`super.speed`，我们可以在子类中访问父类的`speed`变量。

#### 4. 使用`super`调用父类的方法

当子类重写（Override）了父类的方法时，如果需要在子类中调用父类的方法，可以使用`super`关键字。

```java
class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        super.makeSound(); // 调用父类的makeSound方法
        System.out.println("Dog barks");
    }
}
```

在这个例子中，`Dog`类重写了`makeSound`方法，并在方法中通过`super.makeSound()`调用了父类的`makeSound`方法。

### 总结

`super`关键字在Java中扮演着重要的角色，它使得子类能够方便地访问父类的成员。通过`super`，我们可以调用父类的构造方法、访问父类的成员变量以及调用父类的方法。理解并正确使用`super`关键字，有助于编写更加清晰和高效的继承关系代码。

### Java中的final关键字

在Java编程中，`final`关键字是一个非常重要的修饰符，它可以应用于类、方法和变量。`final`关键字的使用场景和作用各不相同，理解其用法对于编写高质量的Java代码至关重要。

#### 1. `final`关键字的基本概念

`final`关键字在Java中有三种主要用途：

- **final变量**：表示该变量的值不能被修改。
- **final方法**：表示该方法不能被子类重写。
- **final类**：表示该类不能被继承。

#### 2. `final`变量

当一个变量被声明为`final`时，它的值在初始化后就不能再被修改。`final`变量通常用于表示常量，常量的命名规范通常是全大写字母，单词之间用下划线分隔。

```java
final int MAX_SPEED = 200;
```

在上面的例子中，`MAX_SPEED`被声明为`final`变量，其值为200，且不能被修改。

##### 2.1 类中的`final`变量

在类中声明的`final`变量必须在声明时或在构造方法中进行初始化。

```java
class Car {
    final int MAX_SPEED;

    public Car() {
        MAX_SPEED = 200; // 在构造方法中初始化final变量
    }
}
```

##### 2.2 方法中的`final`变量

在方法中声明的`final`变量必须在声明时进行初始化。

```java
void calculateSpeed() {
    final int MAX_SPEED = 200;
    // MAX_SPEED = 250; // 编译错误，final变量不能被修改
}
```

#### 3. `final`方法

当一个方法被声明为`final`时，它不能被子类重写。`final`方法通常用于确保某些核心功能在子类中不会被修改。

```java
class Animal {
    final void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    // void makeSound() { // 编译错误，不能重写final方法
    //     System.out.println("Dog barks");
    // }
}
```

在上面的例子中，`Animal`类的`makeSound`方法被声明为`final`，因此`Dog`类不能重写该方法。

#### 4. `final`类

当一个类被声明为`final`时，它不能被其他类继承。`final`类通常用于确保类的实现不会被修改或扩展。

```java
final class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
}

// class AdvancedMathUtils extends MathUtils { // 编译错误，不能继承final类
// }
```

在上面的例子中，`MathUtils`类被声明为`final`，因此不能有子类继承它。

### 总结

`final`关键字在Java中有着多重用途，它可以帮助我们编写更加安全和稳定的代码。通过将变量声明为`final`，我们可以确保其值不会被意外修改；通过将方法声明为`final`，我们可以防止其被重写；通过将类声明为`final`，我们可以防止其被继承。理解并正确使用`final`关键字，有助于编写更加清晰和高效的Java代码。

希望本文能够帮助你更好地理解super关键字和`inal关键字的用法，并在实际编程中灵活运用。