java类-CSDN博客

本文链接：https://blog.csdn.net/kopokliv/article/details/141038818

java类

一、类中的成员

类中主要包含静态代码块、实例代码块、构造方法、变量等。

执行顺序是：

首先执行静态初始化块，然后创建类的实例时，执行实例初始化块，接着执行构造方法。
在调用类中的方法时，首先执行该方法的局部变量初始化，然后执行方法体内的局部代码块.

class Dog {
    // 私有静态变量
    private static int age = 10;  // 静态变量初始化
    // 公有静态变量
    public static int count = 0;
    // 实例变量 实例变量初始化
    int weight = 50; 
    private static String color = "white";

    {
        System.out.println("Dog instance block"); // 实例代码块初始化实例变量用
    }

    static {
        age += 10;
        System.out.println("Dog static block"); // 静态代码块 初始化静态变量用
    }
  // 构造方法 实例化对象
    public Dog(){
        count++;
    }
    public void myMethod() {
        int localVar = 0; // 局部变量初始化
        {
            // 方法体内的局部代码块
            localVar += 1;
        }
    }
    public String eat() {
        return "dog is eating";
    }

    public static void setColor(String color) {
        Dog.color = color;
    }

    public static String getColor() {
        return color;
    }
}

1、变量

以下是一些示例：

public class MyClass {
    // 类变量（静态变量）
    public static int staticVar;

    // 实例变量（非静态变量）
    private int instanceVar;

    // 常量
    public static final int CONSTANT = 10;

    // 枚举变量
    public enum Day { MONDAY, TUESDAY, WEDNESDAY }

    // 注解变量（实际是注解的声明）
    public @interface MyAnnotation {
        String value();
    }

    // 泛型变量
    public static <T> List<T> getList() {
        return new ArrayList<T>();
    }

    // 方法内的局部变量
    public void myMethod() {
        int localVar = 0;
        {
            // 方法内的局部代码块变量
            int blockVar = 1;
        }
    }

    // 构造函数内的局部变量
    public MyClass() {
        int constructorVar = 2;
    }

    // 异常变量
    public void riskyMethod() {
        try {
            // ...
        } catch (Exception e) {
            // ...
        }
    }

    // 资源变量
    public void useResources() {
        try (Resource resource = new Resource()) {
            // ...
        }
    }
}

类变量（Static Variables）：

也称为静态变量，使用 static 关键字声明。
属于类本身，而不是类的任何特定实例。
在任何对象实例化之前或在静态上下文中访问。

共享性：
类变量的值在类的多个实例之间是共享的。对一个实例的类变量所做的更改将影响所有其他实例。

访问方式：
可以通过类名直接访问类变量，也可以通过类的实例访问。例如，MyClass.staticVar 或 myInstance.staticVar，其中 myInstance 是 MyClass 的一个实例。

初始化：
类变量通常在类加载时初始化，并且只会初始化一次。

使用场景：
类变量通常用于存储那些应该在所有实例之间共享的数据，例如配置信息或全局状态。

实例变量（Instance Variables）：

也称为成员变量或非静态变量，不使用 static 关键字声明。
属于类的每个特定实例。
必须通过类的实例来访问。

局部变量（Local Variables）：

定义在方法、构造函数或块中。可见下方举例。
只在该方法、构造函数或块的范围内可见。
必须在声明后被初始化才能使用。

常量（Constants）：

通常使用 static 和 final 关键字声明。
一旦赋值后，其值不能被再次修改。

类常量（Class Constants）：

类似于常量，但使用 static 关键字声明，属于类而不是实例。

枚举变量（Enum Variables）：

定义在枚举类型中，可以有实例变量和类变量。

注解变量（Annotation Variables）：

用于注解的方法或变量，不是传统意义上的变量，而是元数据。

泛型变量（Generic Variables）：

用于定义泛型类、接口或方法中的类型参数。
异常变量（Exception Variables）：

在 catch 块中定义，用于引用捕获的异常对象。

资源变量（Resource Variables）：

在 try 语句的资源声明中定义，用于自动管理资源。

2、静态代码块

在Java中，静态代码块（Static Block）是一种特殊的代码块，它在类被加载到JVM（Java虚拟机）时执行，且仅执行一次。静态代码块主要用于初始化静态变量或执行仅需执行一次的静态初始化操作。

public class MyClass {  
    // 静态变量  
    static int staticVar = 0;  
  
    // 静态代码块  
    static {  
        System.out.println("静态代码块执行");  
        staticVar = 10; // 初始化静态变量  
        // 这里可以执行其他静态初始化操作  
    }  
  
    public static void main(String[] args) {  
        System.out.println("静态变量值：" + staticVar);  
        // 创建MyClass的实例  
        new MyClass();  
        new MyClass();  
        // 注意：静态代码块只会在类加载时执行一次  
    }  
}

静态代码块的主要特点和作用包括：

初始化静态变量：
静态代码块通常用于初始化静态变量，尤其是当初始化逻辑较为复杂，不适合在声明时直接初始化时。
执行静态初始化操作：
除了初始化静态变量外，静态代码块还可以执行任何静态初始化操作，如加载配置文件、初始化数据库连接等。
执行时机：
静态代码块在类被JVM加载时执行，且仅执行一次。这意味着，无论创建多少个类的实例，静态代码块都只在类首次被加载到JVM时执行一次。
执行顺序：
如果有多个静态代码块，它们将按照在类中出现的顺序执行。静态代码块的执行顺序还优先于静态变量的初始化（如果静态变量在声明时未初始化，则会在静态代码块执行完毕后进行初始化），并且也优先于构造代码块和构造函数的执行。
访问权限：
由于它属于类级别，因此可以访问类的静态成员（静态变量和静态方法），但不能直接访问类的实例成员（非静态变量和非静态方法）。
用途：
静态代码块常用于那些需要在类加载时就进行初始化，且初始化操作只需执行一次的场景。

3、实例代码块

在Java中，实例初始化块（Instance Initialization Block）是一种特殊的代码块，它在对象的构造器执行之前执行。实例初始化块的主要作用是对类的实例变量进行初始化，或者执行一些在对象创建时需要进行的操作。

public class MyClass {  
    // 实例变量  
    int instanceVar = 0;  
  
    // 实例初始化块  
    {  
        System.out.println("实例初始化块执行");  
        instanceVar = 10; // 初始化实例变量  
        // 这里可以执行其他初始化操作  
    }  
  
    // 构造器  
    public MyClass() {  
        System.out.println("构造器执行");  
        // 注意：实例初始化块已经在此之前执行  
    }  
  
    public static void main(String[] args) {  
        new MyClass(); // 输出：实例初始化块执行，构造器执行  
    }  
}

实例初始化块的具体作用：

初始化实例变量
实例初始化块可以用于初始化类的实例变量，尤其是当这种初始化逻辑需要在多个构造器之间共享时。通过在实例初始化块中编写初始化代码，可以避免在每个构造器中重复相同的初始化逻辑。
执行对象创建时的操作
实例初始化块可以包含任何在对象创建时需要执行的语句。这些语句在构造器之前执行，因此可以在对象完全构造之前进行一些准备工作，如资源分配、条件检查等。
提高代码复用性和可维护性
通过将公共的初始化代码放在实例初始化块中，可以减少在多个构造器中重复相同代码的需要，从而提高代码的复用性。此外，这也使得初始化逻辑更加集中，有助于代码的阅读和维护。
执行顺序
实例初始化块的执行顺序是按照它们在类中出现的顺序来的。它们总是先于构造器的代码执行，并且如果有多个实例初始化块，它们将按照在类中定义的顺序依次执行。
与继承的关系
在继承关系中，子类的实例初始化块会在子类的构造器执行之前执行，但在此之前，会先执行父类的静态初始化块（如果有的话）、父类的实例初始化块和父类的构造器。这意味着在子类对象完全构造之前，会先完成父类对象的构造和初始化。
访问权限
可以访问类的静态成员和实例成员。但是，由于它在实例创建时执行，因此更常用于初始化实例变量或执行与实例相关的操作。