this、static、block

this

在 Java 中，this是一个关键字，用于表示当前对象的引用，可以用来引用对象的属性和方法。当方法内部引用到与类成员变量重名的局部变量时，使用 this 关键字可以明确指定访问类的成员变量，而不是访问局部变量。

在 Java 类中，每个实例对象都有自己的一组属性，而这些属性在使用时需要通过对象来访问，而 this 关键字就提供了一种方便的方式来引用当前对象。例如：

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;   // 使用 this 关键字指定访问类的成员变量
        this.age = age;     // 使用 this 关键字指定访问类的成员变量
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + this.name + ", I am " + this.age + " years old.");  // 使用 this 关键字引用对象的属性
    }
}

在上面的代码中，Person 是一个类，它有两个属性 name 和 age，还有一个方法 sayHello()。在构造方法中，使用 this 关键字来引用对象的 name 和 age 属性，以便完成对它们的初始化。在 sayHello() 方法中，也使用 this 关键字来引用对象的属性，以便输出它们的值。

除了用于引用对象的属性，this 关键字还可以用于以下情况：

• 调用当前类中的其他构造方法。例如：

public class Person {
  private String name;
  private int age;

  public Person() {
	  this("Tom", 20);   // 调用带参数的构造方法
  }

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

在上面的代码中，在无参构造方法中使用 this 关键字来调用另一个带参构造方法，以便完成对对象的初始化。

static

在 Java 中，static 是一个关键字，它可以修饰变量、方法和代码块。static 的主要作用有以下几个方面：

1. 静态变量

使用 static 修饰的变量称为静态变量（或类变量），属于类的属性，而不是对象的属性，只会在类加载时被初始化一次。静态变量可以通过类名来访问，也可以通过实例对象来访问。例如：

public class Person {
    static int count;  // 静态变量
    
    public Person() {
        count++;  // 每创建一个对象，计数器加 1
    }
    
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        System.out.println(Person.count);  // 输出：2
    }
}

在这个示例中，定义了一个静态变量 count，表示 Person 对象被创建的次数。在每次创建对象时，都会将计数器 count 加 1。在 main() 方法中，通过类名访问静态变量 count，输出其值，结果为 2。

需要注意的是，静态变量在内存中只有一份，它们的值对所有同一个类的对象都是共享的。

2. 静态方法

使用 static 修饰的方法称为静态方法，属于类的方法，而不是对象的方法。静态方法执行时不需要依赖于类的实例对象，因此静态方法不能访问非静态成员变量和非静态成员方法。静态方法可以通过类名来调用，也可以通过实例对象来调用。例如：

public class MathUtil {
    public static int add(int x, int y) {
        return x + y;
    }
    
    public static void main(String[] args) {
        int sum = MathUtil.add(2, 3);
        System.out.println(sum);  // 输出：5
    }
}

在这个示例中，定义了一个静态方法 add()，它接受两个参数并返回它们的和。在 main() 方法中，直接通过类名调用静态方法 add()，将结果输出。

需要注意的是，静态方法中不能使用 this 关键字，因为 this 指代的是当前对象，而静态方法并不属于任何对象，它属于类。如果需要在静态方法中访问当前类的属性或调用当前类的方法，可以使用类名来限定。

3. 静态代码块

使用 static 修饰的代码块称为静态代码块，它只会在类加载时执行一次，并且优先于实例构造函数执行。静态代码块常用于初始化静态成员变量或执行一些只需执行一次的操作。例如：

public class StaticBlock {
    static {
        System.out.println("执行静态代码块");
    }
    
    public static void main(String[] args) {
        System.out.println("执行 main 方法");
    }
}

在这个示例中，定义了一个含有静态代码块的类 StaticBlock，它只输出一句话。在程序运行时，先执行静态代码块，再执行 main() 方法中的内容。

需要注意的是，静态代码块只会在类加载时执行一次。如果加载同一个类的多个对象，则静态代码块也只会执行一次。

block

在 Java 中，block（块）是指一段被一对大括号 {} 包围的代码，可以包含任意数量的语句和声明。块可以用在多种场合，比如控制流、作用域和同步等。具体来说，Java 中常见的块有以下几种类型：

1. 普通块

普通块是最基本的块，它通常用于控制程序的流程或者局部变量的作用域。例如：

public class BlockDemo {
    public static void main(String[] args) {
        int x = 10;
        {
            int y = 20;
            System.out.println(x + y);  // 输出：30
        }
        // System.out.println(y);  // 编译错误：y 未定义
    }
}

在这个示例中，通过一个普通块引入了局部变量 y，并在块内部使用了它。由于普通块具有自己的作用域，因此在块外部无法访问变量 y。

2. 初始化块

初始化块是类中的一个特殊块，用于初始化实例变量。初始化块在每次实例对象被创建时都会执行，并且在构造函数之前执行。例如：

public class Person {
    int age;
    
    // 初始化块
    {
        age = 20;
    }
    
    public Person() {
        // 构造函数
    }
    
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.age);  // 输出：20
    }
}

在这个示例中，定义了一个 Person 类，它包含一个实例变量 age 和一个初始化块，用于给变量 age 赋初值。在创建 Person 对象时，初始化块会先于构造函数被执行，从而保证了变量 age 在对象创建时已经被正确初始化。

需要注意的是，初始化块可以出现多次，并且会按照它们在类中出现的顺序依次执行。

3. 静态块

静态块也是类中的一个特殊块，用于初始化静态变量或执行一些只需执行一次的操作。静态块在类加载时执行，并且在所有方法和构造函数之前执行。例如：

public class StaticBlock {
    static int count;
    
    // 静态块
    static {
        count = 10;
        System.out.println("执行静态块");
    }
    
    public static void main(String[] args) {
        System.out.println("count=" + count);
    }
}

在这个示例中，定义了一个 StaticBlock 类，它包含一个静态变量 count 和一个静态块，用于给变量 count 赋初值。在程序运行时，静态块会先于 main() 方法被执行，从而保证了变量 count 在使用之前已经被正确初始化。

需要注意的是，静态块可以出现多次，并且会按照它们在类中出现的顺序依次执行。

总的来说，块在 Java 中是一个非常灵活和常用的语法结构，它可以用于控制流、作用域和同步等多个方面。掌握块的使用技巧可以提高 Java 开发的效率和代码的可读性。