Java——三个关键字 this final

关键字this

一、基本概念

在 Java 中，“this” 是一个关键字，它代表当前对象的引用。可以在类的方法中使用 “this” 来引用当前正在调用该方法的对象。

 二、为什么可以代表当前对象的引用？

this.属性

class Person {
    public String name;

    public void run(int name) {
        this.name= name;//this.变量
    }
}

我们在主方法中这样写道:

Person p1 = new Person();
p1.run("aaa");


Person p2 = new Person();
p2.run("bbb");

 这里的this.name相当于指向了实例对象中的变量name，和在局部函数中的参数是两回事。

this.方法

易错点：

static修饰的方法中不能出现this关键字，因为类是构建对象的模板，有类不一定有对象

static修饰的代码被所有的对象共享，所以this可以调用static方法

this()  //了解

①thisO)不能在普通方法中使用，只能在构造方法中使用

②this()在构造方法中使用必须是第一条语句

③在一个类下两个构造方法中不能通过this()相互调用

④不能与super()同时使用

二、主要用途

1.区分成员变量和局部变量

当方法的参数或局部变量与类的成员变量同名时，可以使用 “this” 来明确引用成员变量。例如：

class Person {
    private int age;

    public void setAge(int age) {
        this.age = age;
    }
}

• 在上述例子中，参数 “age” 与成员变量 “age” 同名，“this.age” 明确表示引用的是成员变量，而不是局部变量。

2.调用构造方法

在一个构造方法中可以使用 “this” 来调用同一类中的其他构造方法，以实现代码的复用和减少重复。例如：

class Person {
    private int age;
    private String name;

    public Person() {
        this(0, "Unknown");
    }

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

• 在无参构造方法中，使用 “this (0, "Unknown")” 调用了有参构造方法，初始化了成员变量。

3.作为方法的返回值

“this” 可以作为方法的返回值，返回当前对象的引用，使得可以在方法调用链中连续调用多个方法。例如：

class Person {
    private int age;
    private String name;

    public Person setAge(int age) {
        this.age = age;
        return this;
    }

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

• 可以这样使用：Person person = new Person().setAge(20).setName("Tom");

三、注意事项

1. “this” 只能在非静态方法中使用，因为静态方法是属于类的，而不是属于特定的对象。
2. 在构造方法中调用其他构造方法时，“this” 语句必须放在构造方法的第一行。

关键字 final

一、概述

在 Java 中，final关键字用于限制变量、方法和类的行为。它表示不可改变或最终的状态。

二、作用于变量

final所修饰的变量叫做常量（常量是只能赋值一次的变量）

public class Test01 {
    public static void main(String[] args) {
        final int NUM= 10;
        // NUM= 20; // 会报错，因为 final 变量不能被重新赋值。
        System.out.println("Final variable num: " + num);
    }
}

注意：常量的变量名要大写

按照作用域区分：

        1.全局变量：final修饰的全局变量必须赋值（因为final只能赋值一次）

         2.局部变量：

按照类型区分：      

1. 1基本类型变量

   • 当用final修饰基本类型变量时，该变量一旦被初始化，其值就不能再被改变。
   • 例如：final int num = 10;，之后任何试图改变num值的操作都会导致编译错误。

public class FinalPrimitiveExample {
    public static void main(String[] args) {
        final int num = 10;
        // num = 20; // 编译错误，不能重新赋值
        System.out.println("Final primitive variable: " + num);
    }
}

1. 2.引用类型变量

   • 对于引用类型变量，final表示该引用不能再指向其他对象。但被引用的对象本身的内容是可以改变的。
   •  例如：final List<Integer> list = new ArrayList<>();，不能再将list指向另一个新的集合对象，但可以对list中的元素进行添加、删除或修改操作。

public class Test{
    public static void main(String[] args) {
        
        final int[] arr1 = new int[]{1,2,3};
        final int[] arr2 = new int[]{12,22,32};
        final int a = 10;
        public void fun(){
            a=11;//error
        }
        public void changge(){
            arr1=arr2;//error
        }


    }
}

三、作用于方法

class Test02 {
    final void finalMethod() {
        System.out.println("This is a final method and cannot be overridden.");
    }
}

class SubClass extends Test02 {
    // 不能重写父类的 final 方法
    // void finalMethod() {}
}

1. 当一个方法被声明为final时，这个方法不能在子类中被重写。
   • 这可以确保该方法在继承体系中的行为是固定的，不会被意外修改。
   • 例如：class Parent { final void method() { // 方法体 } }，如果有一个子类Child试图重写method方法，会导致编译错误。

四、作用于类

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

// class SubFinalClass extends Test03{} // 会报错，因为 final 类不能被继承。

1. 当一个类被声明为final时，这个类不能被继承。
   • 这可以确保该类的实现是完整的，不会被其他类修改或扩展。
   • 例如：final class FinalClass { // 类的成员 }，任何尝试继承FinalClass的类都会导致编译错误。

五、优点

1. 安全性
   • 确保变量的值或方法的行为不会被意外改变，增强了程序的安全性和稳定性。
2. 性能优化
   • 在某些情况下，编译器可以进行优化，因为它知道被final修饰的内容是不可变的。

六、注意事项

1. 谨慎使用
   • 过度使用final可能会导致代码灵活性降低，在设计时需要权衡可维护性和安全性。
2. 理解引用类型的限制
   • 对于final引用类型变量，要清楚只是引用不能改变，而被引用对象的内容可能是可变的。

七、同样是不可修改，final关键字和private看似有些相似，他们又有什么区别？

一、作用对象不同

1. final：

   • 可以修饰变量、方法和类。
   • 修饰变量时表示变量的值不可改变；修饰方法时表示该方法不能被重写；修饰类时表示该类不能被继承。

2. private：

   • 主要用于修饰成员变量、成员方法和内部类。
   • 表示被修饰的成员只能在当前类中被访问，对其他类不可见。

二、限制范围不同

1. final：

   • 限制的是可变性和可继承性等方面的行为。
   • 对于变量，限制了其值的更改；对于方法，限制了其在子类中的重写；对于类，限制了其被继承。

2. private：

   • 主要限制的是访问权限。
   • 确保被修饰的成员只能在定义它们的类内部使用，外部类无法直接访问。

三、继承和重写方面

1. final：

   • 阻止方法被重写和类被继承。
   • 如果一个方法被声明为final，子类不能重写该方法；如果一个类被声明为final，则不能有子类。

2. private：

   • private方法不能被重写，因为它们在子类中不可见。但是，这并不是因为明确禁止重写，而是由于访问限制导致的。同时，private修饰的类成员不会影响类的继承关系，子类可以继承父类中private修饰的成员变量和方法，只是不能直接访问。

四、使用场景不同

1. final：

   • 当你希望确保某个变量的值在初始化后不再改变，或者某个方法的行为在子类中不被修改，或者一个类不应该有子类时，可以使用final。
   • 例如，在定义常量时可以使用final修饰变量。

2. private：

   • 当你希望隐藏类的实现细节，只暴露必要的公共接口时，可以使用private修饰成员变量和方法。
   • 比如，一些内部的辅助方法或者不希望被外部类直接访问的变量可以使用private修饰。