【Java基础小记】082401

this、final、值传递

让我们来逐一解释 this、final 和值传递这三个概念，它们在编程中尤其是在 Java 语言中非常重要。

1. this 关键字

this 是一个引用变量，指向当前对象的实例。在对象的方法或构造函数中，this 关键字用于引用调用该方法或构造函数的对象本身。

使用场景：

区分实例变量和方法参数：当局部变量（如方法参数）和实例变量（类成员）同名时，使用 this 关键字来区分实例变量。

public class Person {
    private String name;

    public Person(String name) {
        this.name = name; // this.name 是实例变量，name 是构造函数参数
    }
}

• 在实例方法中访问当前对象的其他方法：

public class Person {
    private String name;

    public void printName() {
        System.out.println(this.name); // 访问当前对象的 name 属性
    }
}
* 链式调用：通过返回 this，可以实现方法链。

```java
public class Person {
    private String name;

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

// 使用链式调用
new Person().setName("Alice").printName();

2. final 关键字

final 关键字用于声明不可变的实体。它可以用于变量、方法和类的定义。

使用场景：

• 最终变量：用 final 声明的变量在初始化后不可更改。可以用于常量的定义。

public class Constants {
    public static final int MAX_SIZE = 100;
}

• 最终方法：用 final 声明的方法不能被子类重写。

public class Animal {
    public final void sound() {
        System.out.println("Animal sound");
    }
}

• 最终类：用 final 声明的类不能被继承。

public final class ImmutableClass {
    // 类内容
}

3. 值传递

值传递 是一种参数传递方式，其中方法接收到的是传递参数的值的副本，而不是原始值的引用。所有的原始数据类型（如 int、float、char 等）以及对象的引用都采用值传递。

原始数据类型的值传递：

当你将一个基本数据类型的变量传递给方法时，方法接收到的是该变量的副本，对副本的修改不会影响原始变量。

public class ValuePassExample {
    public void modifyValue(int value) {
        value = 10; // 修改的是值的副本
    }

    public static void main(String[] args) {
        ValuePassExample example = new ValuePassExample();
        int number = 5;
        example.modifyValue(number);
        System.out.println(number); // 输出 5，原始变量没有改变
    }
}

对象引用的值传递：

当你将一个对象传递给方法时，传递的是对象引用的副本。虽然引用是副本，但它指向原始对象，因此可以通过该引用修改对象的状态。

public class Person {
    public String name;

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

public class ReferencePassExample {
    public void changeName(Person person) {
        person.name = "Alice"; // 修改的是原始对象的状态
    }

    public static void main(String[] args) {
        Person person = new Person("Bob");
        ReferencePassExample example = new ReferencePassExample();
        example.changeName(person);
        System.out.println(person.name); // 输出 Alice，原始对象被修改
    }
}

总结

• this 用于引用当前对象的实例，在对象的构造函数和方法中非常有用。
• final 用于声明不可更改的变量、方法或类，确保其在程序中的不变性。
• 值传递 是 Java 中参数传递的方式，原始类型传递的是值的副本，对象引用传递的是引用的副本，原始对象的状态可以被修改但引用本身不可变。

示例

1. this 关键字

示例 1: 区分实例变量和方法参数

public class Car {
    private String model;

    public Car(String model) {
        this.model = model; // this.model 是实例变量，model 是构造函数参数
    }

    public void displayModel() {
        System.out.println("Car model: " + this.model); // 使用 this 访问实例变量
    }

    public static void main(String[] args) {
        Car myCar = new Car("Toyota");
        myCar.displayModel(); // 输出: Car model: Toyota
    }
}

在这个示例中，this.model 用于区分构造函数参数 model 和类中的实例变量 model。

示例 2: 链式调用

public class Rectangle {
    private int width;
    private int height;

    public Rectangle setWidth(int width) {
        this.width = width;
        return this; // 返回当前对象，支持链式调用
    }

    public Rectangle setHeight(int height) {
        this.height = height;
        return this; // 返回当前对象，支持链式调用
    }

    public void printDimensions() {
        System.out.println("Width: " + width + ", Height: " + height);
    }

    public static void main(String[] args) {
        Rectangle rect = new Rectangle();
        rect.setWidth(10).setHeight(20).printDimensions(); // 链式调用
    }
}

在这个示例中，this 使得链式调用变得可能，通过返回当前对象来实现连续调用方法。

2. final 关键字

示例 1: final 变量

public class MathConstants {
    public static final double PI = 3.141592653589793; // 常量 PI，不能修改

    public static void main(String[] args) {
        System.out.println("Value of PI: " + PI);
    }
}

在这个示例中，PI 被声明为 final，意味着它的值在初始化后不能再被改变。

示例 2: final 方法

public class BaseClass {
    public final void display() {
        System.out.println("This is a final method.");
    }
}

public class DerivedClass extends BaseClass {
    // 试图重写 display 方法会导致编译错误
    // @Override
    // public void display() {
    //     System.out.println("Trying to override");
    // }
}

public class Main {
    public static void main(String[] args) {
        DerivedClass obj = new DerivedClass();
        obj.display(); // 输出: This is a final method.
    }
}

在这个示例中，BaseClass 中的 display 方法被声明为 final，因此 DerivedClass 无法重写它。

3. 值传递

示例 1: 原始数据类型的值传递

public class ValuePassExample {
    public void modifyValue(int value) {
        value = 10; // 修改的是值的副本
    }

    public static void main(String[] args) {
        ValuePassExample example = new ValuePassExample();
        int number = 5;
        example.modifyValue(number);
        System.out.println("Number: " + number); // 输出: Number: 5，原始变量没有改变
    }
}

在这个示例中，modifyValue 方法接受一个 int 类型的参数，对它的修改不会影响到 number 变量。

示例 2: 对象引用的值传递

public class Person {
    public String name;

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

public class ReferencePassExample {
    public void changeName(Person person) {
        person.name = "Alice"; // 修改的是原始对象的状态
    }

    public static void main(String[] args) {
        Person person = new Person("Bob");
        ReferencePassExample example = new ReferencePassExample();
        example.changeName(person);
        System.out.println("Person's name: " + person.name); // 输出: Person's name: Alice
    }
}

在这个示例中，changeName 方法接受一个 Person 对象的引用，修改了该对象的 name 属性，影响了原始对象的状态。