Java 入门探索者11（final，super关键字，构造方法，方法重写，继承）

Java中的`final`是一个关键字，可以用来修饰类、方法和变量。

1. 修饰类：当一个类被声明为`final`时，表示该类不能被其他类继承。

   ```java
   final class FinalClass {
       // Class content...
   }
   ```

2. 修饰方法：当一个方法被声明为`final`时，表示该方法不能被子类重写（覆盖）。

   ```java
   class ParentClass {
       final void finalMethod() {
           // Method content...
       }
   }
   ```

3. 修饰变量：当一个变量被声明为`final`时，表示该变量的值不能被修改。在Java中，用`final`修饰的变量称为常量，一旦被赋值，就无法在后续改变其值。

   ```java
   final int constantValue = 10;

   final double PI;
   PI = 3.14159265359;
   ```

使用`final`修饰的变量有以下特点：
- `final`变量必须在声明时进行初始化，否则编译错误。
- `final`变量的值不能被修改，即不能再次赋值。
- `final`变量通常使用大写命名，以增加其可读性。
- `final`变量可以在类的成员变量、局部变量（方法内部）和静态变量中使用。

`final`关键字在Java中的使用场景有很多，其中最常见的是用来声明常量或防止继承和方法重写。通过使用`final`关键字，可以增加代码的可读性、维护性和安全性。


public class FinalTest {
    //final可以修饰变量，修饰完的变量称为常量
    public void doSomething(final Student student){
        //在方法调用的时候会进行第一次赋值，所以在通过new创建对象就是给
        //Student对象进行二次赋值，所以报错
        //student = new Student();
    }
    //final可以修饰方法，但是final修饰的方法不可以被重写
    public final void saySomething(){
        System.out.println("final修饰的方法");
    }
}
//final可以修饰类，但是final修饰的类没有子类只有父类
final class Text01 extends Text02{}
class Text02 extends FinalTest{
    public void method(){
        //final修饰的方法可以被继承到
        saySomething();
    }
}
//class Text03 extends Text01{}
class Text04{}

Java的方法是指在类中定义的一段可执行的代码块，用于完成特定的任务。方法通常被用来将一些功能或操作封装起来，可以通过调用方法来执行这些功能或操作。方法由方法名、参数列表、返回类型和方法体组成。

方法名是方法的唯一标识符，用于在其他地方调用该方法。参数列表是一组用逗号分隔的参数，用于向方法传递数据。返回类型指定了方法返回的数据类型，可以是基本数据类型或对象类型。方法体包含了方法的具体实现，即方法要执行的代码。

构造方法是一种特殊的方法，用于创建和初始化对象。每个类都可以有一个或多个构造方法，与类名相同。构造方法在创建对象时被调用，用于设置对象的初始状态。构造方法没有返回类型，且不能被显式调用。如果没有定义构造方法，编译器会默认为类提供一个无参构造方法。

构造方法可以有参数，用于在创建对象时传递值。这些参数可以用于初始化对象的属性。构造方法也可以重载，即定义多个具有不同参数列表的构造方法，以满足不同的创建对象的需求。

总结来说，Java的方法和构造方法都是用于封装一段可执行的代码块，但构造方法是用于创建和初始化对象的特殊方法。

好的，先来演示一个Java方法的代码示例：

```java
public class Example {
    // 定义一个方法，该方法用于计算两个整数的和并返回结果
    public int add(int a, int b) {
        int sum = a + b;
        return sum;
    }

    // 主函数，用于测试add方法
    public static void main(String[] args) {
        Example example = new Example();
        int result = example.add(3, 5);
        System.out.println(result);
    }
}
```

上述代码定义了一个名为`Example`的类，其中包含了一个名为`add`的方法。`add`方法接收两个整数作为参数，计算它们的和并返回结果。

在`main`函数中，我们实例化了`Example`类的一个对象`example`，然后调用`add`方法，传入参数3和5，将返回结果打印输出。

接下来，让我们来演示一个Java构造方法的代码示例：

```java
public class Example {
    private int number;

    // 构造方法，用于初始化对象的属性
    public Example(int number) {
        this.number = number;
    }

    // getter方法，用于获取number属性的值
    public int getNumber() {
        return number;
    }

    // setter方法，用于设置number属性的值
    public void setNumber(int number) {
        this.number = number;
    }

    // 主函数，用于测试构造方法和getter、setter方法
    public static void main(String[] args) {
        Example example = new Example(10);
        System.out.println(example.getNumber());

        example.setNumber(20);
        System.out.println(example.getNumber());
    }
}
```

上述代码定义了一个名为`Example`的类，其中包含了一个私有的整型属性`number`。类中还定义了一个带有一个整型参数的构造方法，用于初始化`number`属性。

在`main`函数中，我们实例化了`Example`类的一个对象`example`，并通过构造方法传入参数10进行初始化。然后，通过`getNumber`方法获取`number`属性的值，并将其打印输出。

接着，我们调用`setNumber`方法将`number`属性的值设置为20，并再次通过`getNumber`方法获取`number`属性的值，并将其打印输出。


public class Person {
    String name = "张飞";
    private int age;
    public Person(int a ){
        System.out.println("父类的构造方法");
    }
    public void method(){
        System.out.println("父类中的方法");
    }
    public void work(){
        System.out.println("父亲的工作是挣钱养家");
    }
}

在Java中，继承是一种对象之间的关系，通过继承可以创建一个新的类（称为子类），该类继承了已存在的类（称为父类）的属性和方法。子类可以继承父类的非私有的属性和方法，并且可以在不修改父类的情况下扩展或修改其功能。

下面是一个简单的示例，展示了Java中继承的基本用法：

```java
// 定义父类
class Animal {
    protected String name;

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

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 定义子类
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    public void meow() {
        System.out.println(name + " is meowing.");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat("Tom");
        cat.eat();   // 继承自父类 Animal 的方法
        cat.meow();  // 子类 Cat 自己的方法
    }
}
```

在上面的示例中，父类 `Animal` 有一个属性 `name` 和一个方法 `eat()`。子类 `Cat` 继承了父类 `Animal`，并添加了自己的方法 `meow()`。在 `Main` 类中，我们创建了一个 `Cat` 对象，并调用了继承自父类的方法 `eat()`，以及子类自己的方法 `meow()`。

在继承中，子类可以重写父类的方法，实现自己特定的功能。这被称为方法的重写或覆盖。例如，我们可以在子类 `Cat` 中重写父类的 `eat()` 方法：

```java
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(name + " is eating fish.");
    }

    public void meow() {
        System.out.println(name + " is meowing.");
    }
}
```

通过 `@Override` 注解，我们告诉编译器我们打算重写父类的方法。在子类中重写父类的方法时，可以使用 `super` 关键字引用父类的方法。

Java中的继承是单继承的，意味着一个子类只能继承一个父类。然而，一个父类可以有多个子类。如果一个类不指定任何父类，则其默认继承自Java中的所有类的根类 `Object`。

方法重写（Method Overriding）是指在子类中定义与父类中相同名称、相同参数列表、相同返回类型的方法，从而覆盖（重写）父类的方法。重写方法的目的是对父类的行为进行修改，并且使得子类对象调用该方法时执行的是子类的行为。

方法重写必须满足以下条件：

1. 子类中定义的方法与父类中方法的名称、参数列表、返回类型都必须完全一致。
2. 子类中定义的方法不能缩小父类方法的可见性范围。例如，如果父类方法为public，子类方法必须也为public。
3. 子类中定义的方法不能抛出比父类方法更多的异常。如果父类方法抛出异常，子类方法可以不抛出异常，但不能抛出更多或不兼容的异常。

在Java中，方法重写的实现方式是通过在子类中使用`@Override`注解来标注覆盖的方法。这样可以使得编译器在编译时对方法进行验证，确保正确地重写了父类的方法。

使用方法重写可以实现多态性，即在编译时无法确定具体调用的是父类还是子类的方法，而是在运行时动态地确定。这样可以根据对象的实际类型来调用相应的方法，实现灵活的对象行为。

在Java中，`super`是一个关键字，用于引用父类的成员变量和方法。可以将`super`看作是一个特殊的对象，它表示当前对象所属的父类对象。

`super`可以在子类中的构造方法、实例方法和实例变量中使用。

1. 在构造方法中，`super`用于调用父类的构造方法。通过`super()`可以调用父类的无参构造方法，也可以通过`super(参数列表)`调用父类的有参构造方法。使用`super()`必须是构造方法的第一行代码。

```java
public class Child extends Parent {
    public Child() {
        super(); // 调用父类的无参构造方法
    }

    public Child(int num) {
        super(num); // 调用父类的有参构造方法
    }
}
```

2. 在实例方法中，`super`用于调用父类的实例方法。可以使用`super.方法名()`来调用父类的方法。

```java
public class Parent {
    public void print() {
        System.out.println("父类方法");
    }
}

public class Child extends Parent {
    public void print() {
        super.print(); // 调用父类的print方法
        System.out.println("子类方法");
    }
}
```

3. 在实例变量中，`super`用于引用父类的成员变量。通过`super.变量名`可以访问父类的成员变量。

```java
public class Parent {
    protected int num = 10;
}

public class Child extends Parent {
    public void print() {
        System.out.println(super.num); // 访问父类的成员变量
    }
}
```

通过使用`super`关键字，可以方便地访问父类的构造方法、实例方法和实例变量，增强了类的灵活性和可扩展性。



package lesson12;
//extends 表示继承关系，关键字左侧的是子类，右侧的是父类
//子类又叫派生类，父类又叫基类或超类
//继承之后子类会自动拥有父类的成员
//java是单继承，只有一个父类
public class Student extends Person {
    //方法重写就是当父类方法不能满足子类需要的时候,可以通过方法重写，解决
    //重写方法的名字，直接回车
    //方法重写的注意事项
    //1.要有继承，并且在子类中重写
    //2.方法名相同
    //3.参数的个数，类型，顺序要完全一致
    //4.返回值类型要求一致或者可以协变
    //协变返回值类型就是，父类方法是父类对象，子类方法可以是子类对象
    //5.子类方法不能缩小父类方法的访问权限
    @Override
    public void work(){
        System.out.println("孩子的工作是努力学习");
    }
    public Student(){
        //在子类的构造方法中可以调用父类的构造方法，用于初始化父类属性
        //如果父类是无参的构造方法，那么子类可以省略显示调用父类的构造方法，但是如果
        //父类没有无参的构造方法，子类必须显示调用父类的构造方法，否则编泽报错
        super(10);//必须放在方法的第一行
        System.out.println("子类的构造方法");
    }
    String name = "张楠";
    public void doSomething(){
        //当父类中的成员跟子类中的成员名字相同的时候，在子类中会将父类的成员屏蔽掉，
        //可以通过super调用父类的成员，解决屏蔽问题
        System.out.println(super.name);
        System.out.println(name);
    }
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.name);
        //父类中用private修饰的成员，属于父类独有的，子类不能在继承到了
        //System.out.println(s.age);
        s.method();
        s.work();
        s.doSomething();

    }
}