静态（static）

1.静态(static)

1.1static修饰成员变量

类变量:有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享

实例变量(对象的变量):无static修饰，属于每个对象的。

-1.类变量:属于类，在内存中只有一份，用类名调用
-2.实例变量:属于对象，每一个对象都有一份，用对象调用

1.2static修饰成员方法

类方法:有static修饰的成员方法，属于类。

publicstaticvoid printHelloWorld(){
    System.out.println("Hello world!");
    System.out.println("Hello World!");
}
类名,类方法 (推荐)
对象名.类方法(不推荐)

实例方法 :无static修饰的成员方法，属于对象。

public void printPass(){
    ...
}
对象,实例方法

1.类方法:static修饰的方法，可以被类名调用，是因为它是随着类的加载而加载的:所以类名直接就可以找到static修饰的方法
2.实例方法:非static修饰的方法，需要创建对象后才能调用，是因为实例方法中可能会访问实例变量，而实例变量需要创建对象后才存在。
所以实例方法，必须创建对象后才能调用。

1.3工具类

如果一个类中的方法全都是静态的，那么这个类中的方法就全都可以被类名直接调用，由于调用起来非常方便，就像一个工具一样，所以把这样的类就叫做工具类

1.4static的注意事项

• 类方法中可以直接访问类的成员，不可以直接访问实例成员

• 实例方法中既可以直接访问类成员 ，也可以直接访问实例成员

• 实例方法中可以出现this关键字，类方法中不可以出现this关键字的

1.5static应用（代码块）

• 静态代码块: 格式:static{} 特点:类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。 作用:完成类的初始化，例如:对类变量的初始化赋值。

静态代码块，随着类的加载而执行，而且只执行一次

• 实例代码块: 格式:{} 特点:每次创建对象时，执行实例代码块，并在构造器前执行。 作用:和构造器一样，都是用来完成对象的初始化的，例如:对实例变量进行初始化赋值。

1.7static应用（单例设计模式）

什么是设计模式

• 一个问题有n种解法，其中肯定有一种解答是最优的，这个解法被人总结出啦，称为设计模式

• 设计模式有20多种，对应多种软件开发中会遇到的问题

单例设计模式：一个类有且仅有一个实例，并且自行实例化向整个系统提供

写法：

把类的构造器私有。

定义一个类变量记住类的一个对象。

定义一个类方法，返回对象。

单例有啥应用场景，有啥好处？

• 任务管理器对象，获取运行时对象

• 在这些任务场景下，使用单例模式，可以避免浪费内存。

多问一个为什么

此处，我们可能在潜意识中就这样让代码过去，也许是因为认为这就是规定或者认为是很基础的内容而无需解释过多，在许多文章中，也并未更加详细的解释这个问题.但是，如果是作为一个可能基础不那么稳固的初学者，在学习的时候，为加深理解，我们不妨多问一个为什么?为什么是这样设计呢?

1.成员变量 a 为什么是私有的?

最直接的原因就是防止外部直接访问，如果不声明为private，其他类将能直接访问和修改它，而这就违反了单例模式的原则，因为单例模式要求类只有一个实例化

2.成员变量 a 为什么是静态的?

使用 static 修饰后，意味着该变量是属于类的，而不是类的实例你可以通过“类名.变量名”的方式直接访问
同时，将只存在一个a
你可以像
A a1 =A.getobject;
A a2 =A.getobject;
这样创建两个实例化对象，但他们都共享一个a对象，确保只有一个单例

3.构造方法 A()为什么是私有的?

与成员变量相似，是为了防止外部实例化，防止其他类通过new关键字直接创建该类的实例(new 关键字本质是调用了类的构造方法)，而应该通过特定途径(通常是类提供的静态方法，也就是getobject())

4.getobject()方法为什么是公有的?

很显然，这是我们暴露给其他类调用来创建实例的方法，因此必须是公有的，如果是私有那不就是成黑盒搁这里圈地自萌了

5.getobject()方法为什么是静态的?

与成员变量相似，因为构造方法被私有化了，我们无法通过new关键字来实例化对象，而通过类名方法名的方式可以直接访问

1.static 核心认知

static 关键字的核心作用是将成员（变量、方法、代码块）与类本身绑定，而非与对象实例绑定。

• 静态成员属于类，由所有对象共享，不依赖于对象存在。

• 典型场景：全局计数器、工具类方法、常量定义等。

2.static 修饰的成员

1. 静态变量（类变量）

• 定义：用 static 修饰的变量，也叫类变量。

• 特点：

  1. 类加载时初始化，且只加载一次，内存中仅存一份。

  2. 属于类本身，所有对象共享同一个静态变量。

  3. 推荐通过 类名.静态变量 直接访问，不推荐通过对象访问（易混淆）。

• 示例：

public class Counter {
    // 静态变量：全局计数器
    public static int count = 0;
​
    public Counter() {
        count++; // 每次创建对象，计数器加1
    }
}
​
// 使用
Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.count); // 输出：2（所有对象共享）

1. 静态方法（类方法）

• 定义：用 static 修饰的方法，也叫类方法。

• 特点：

  1. 属于类，无需通过对象调用，直接用 类名.静态方法() 调用。

  2. 不能访问非静态成员（实例变量 / 实例方法），因为静态方法不依赖对象，而非静态成员需要对象存在。

  3. 不能使用 this 或 super 关键字（这两个关键字指向对象实例，静态方法与对象无关）。

• 示例：

public class MathUtil {
    // 静态方法：计算两数之和
    public static int add(int a, int b) {
        return a + b;
    }
}
​
// 使用
int sum = MathUtil.add(5, 3); // 直接通过类名调用，无需创建对象

1. 静态代码块

• 定义：用 static 修饰的代码块，类加载时执行，且只执行一次。

• 特点：

  1. 执行时机：类加载后自动执行，优先于构造方法和实例代码块。

  2. 只能访问静态成员，不能访问非静态成员。

  3. 常用于初始化静态资源（如加载配置文件、初始化常量）。

• 执行顺序

  示例：静态代码块→实例代码块→构造方法

public class StaticBlockDemo {
    // 静态代码块
    static {
        System.out.println("静态代码块执行");
    }
​
    // 实例代码块
    {
        System.out.println("实例代码块执行");
    }
​
    // 构造方法
    public StaticBlockDemo() {
        System.out.println("构造方法执行");
    }
}
​
// 使用
new StaticBlockDemo();
// 输出顺序：
// 静态代码块执行
// 实例代码块执行
// 构造方法执行

3.非静态成员（无 static 修饰）

1. 实例变量

• 定义：无 static 修饰的变量，属于对象。

• 特点：每个对象独立拥有一份，通过 对象.实例变量 访问。

• 示例：

public class Person {
    private String name; // 实例变量，每个对象的name独立
}

1. 实例方法

• 定义：无 static 修饰的方法，属于对象。

• 特点：必须通过对象调用，能访问静态和非静态成员，可以使用 this 关键字。

• 示例：

public class Person {
    private String name;
​
    // 实例方法
    public void setName(String name) {
        this.name = name; // 使用this访问实例变量
    }
}

4.静态与非静态的核心区别

5.核心规则总结

1. 静态方法访问规则：静态方法只能访问静态成员（变量 / 方法），不能访问非静态成员。

2. 非静态方法访问规则：非静态方法可以访问静态和非静态成员。

3. this 关键字：静态方法中没有 this（因为与对象无关），非静态方法中有 this（指向当前对象）。

4. 工具类设计：如果一个类的方法全是静态方法，可设计为工具类（如 Math、Arrays），调用时无需创建对象，非常便捷。

6.完整示例

public class StaticDemo {
    // 静态变量
    public static String staticVar = "静态变量";
    // 实例变量
    public String instanceVar = "实例变量";

    // 静态方法
    public static void staticMethod() {
        System.out.println(staticVar);
        // 错误：静态方法不能访问非静态变量
        // System.out.println(instanceVar);
    }

    // 实例方法
    public void instanceMethod() {
        System.out.println(staticVar); // 可以访问静态变量
        System.out.println(instanceVar); // 可以访问实例变量
    }

    // 静态代码块
    static {
        System.out.println("静态代码块初始化静态资源");
    }

    public static void main(String[] args) {
        // 静态方法直接调用
        StaticDemo.staticMethod();

        // 实例方法需要通过对象调用
        StaticDemo obj = new StaticDemo();
        obj.instanceMethod();
    }
}