Java入门-static

Static修饰成员变量：

static：叫静态，可以修饰成员变量、成员方法。

成员变量按照有无static修饰，分为两种:

1. 类变量：用static修饰，属于这个类，每个对象共享。
2. 实例变量：没有static修饰，属于每个对象。

举例：

public class person{
    static String name;
    //用static修饰，说明这个变量属于这个类，会被new出的所有对象共享，在内部只有一份。

    int age;
    //没有static，是一个普通的实例变量。每个new出的对象都持有一份。
}

类变量是共性，实例变量是特性。

访问类变量：

类名.类变量

访问实例变量：

对象名.实例变量

Static修饰成员变量的应用场景：

在开发中，如果某个数据只需要一份，且希望能够被共享(访问、修改），则该数据可以定义成类变量来记住。

举例：系统启动后，要求用户类可以记住自己创建了多少个用户对象了。

public person{
    public static int number;

    public person(){
        person.number++;
    }//访问自己类中的类变量，可以省略类名不写
}

先创建类，在类中定义类变量number。创建无参数构造器，使其每次创建对象时，number++。

static修饰成员方法:

同前文，成员方法可分成两种：

1. 类方法：有static修饰的成员方法，属于类。
2. 实例方法：无static修饰的成员方法，属于对象。

举例：

public static void printHelloWorld(){
    System.out.println("Hello World!");
}
//类方法

public void printPass(){
    ...
}
//实例方法

 访问类方法：

类名.类方法

访问实例方法：

对象名.实例方法

static修饰成员方法的应用场景:

类方法最常见的应用场景是设计工具类（将需要的方法封装成类）。

工具类是什么：工具类中的方法都是一些类方法，每个方法都是用来完成一个功能的，工具类是给开发人员共同使用的。

举例：生成验证码

public class myUtil {
    public static String createCode(int n){
        String code="";
        String data="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz123467890";
        Random r=new Random();
        for (int i = 0; i < n; i++) {
            int index=r.nextInt(data.length());
            code+=data.charAt(index);
        }
        return code;
    }
}

当需要使用createCode方法时，直接调用类名.类方法，节省代码量。

public class register {
    public static void main(String[] args) {
        System.out.println(myUtil.createCode(6));
    }
}

为什么工具类中的方法要用类方法，而不用实例方法？

1. 实例方法需要创建对象来调用，此时对象只是为了调用方法，对象占内存，会占用内存。
2. 类方法可以直接通过类名调用，更加方便且节省内存。

工具类没有创建对象的需求，建议将工具类的构造器进行私有。

Static的注意事项：

1. 类方法中可以直接访问类的成员，不可以直接访问实例成员。
2. 实例方法中既可以直接访问类成员，也可以直接访问实例成员。
3. 实例方法中可以出现this关键字，类方法中不可以出现this关键字。

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

public class student {
    public static String schoolName;
    public static void printName1(){
        
    }
    public static void printName2(){
        schoolName="schoolName";
        printName1();
        printName2();
    }//在类方法中，可以访问同为static修饰的类方法和类变量
}

public class student {
    public String schoolName;
    public void printName1(){

    }
    public static void printName2(){
        schoolName="schoolName";
        printName1();
    }//在类方法中，不可以访问没有static修饰的实例方法和实例变量
}

第二种写法会报错。

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

public class student {
    public static String schoolName;
    public static void printName1(){

    }
    public  void printName2(){
        schoolName="schoolName";
        printName1();
    }//在实例方法中，可以访问static修饰的类方法和类变量
}

3.实例方法中可以出现this关键字，类方法中不可以出现this关键字。

public class student {

    public static int age;

    public void printName1(){
        this.age=10;
    }//可以这么写
    public static void printName2(){
        this.age=10;
    }//不可以这么写
}

因为静态方法属于类本身，而不是某个具体的对象实例。由于 this指向的是当前对象实例，在静态上下文中没有特定的对象，因此编译器会报错。

static的应用知识：代码块

代码块是类的5大成分之一（成员变量、构造器、方法、代码块、内部类）

1.静态代码块：

格式：static { }

特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。

作用：完成类的初始化，例如：对类变量的初始化赋值。

举例：

public class block {
    static int number=80;
    static String name;
    static {
        name="kevin";
        System.out.println("静态代码块被调用了");
    }
}

2.实例代码块：

格式：{ }

特点：每次创建对象时，执行实例代码块，并在构造器前执行。

作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。

举例：

public class block {
    {
        System.out.println("实例代码块被执行了");
    }
}

static的应用知识：单例设计模式

一个问题通常有n种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。

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

单例设计模式是什么：

想象一下，你有一个非常特别的玩具，这个玩具只能有一个，不管你怎么尝试，都不能让这个玩具变成两个。每次你需要这个玩具的时候，你都得到的是同一个。这就是单例设计模式的核心思想：确保一个类只有一个实例，并提供全局访问点。

为什么要使用单例设计模式？

1. 节省资源：因为只创建一个对象，所以不会浪费内存。
2. 控制访问：所有地方都使用同一个实例，方便管理和控制。

如何在Java中实现单例设计模式？

我们来一步步写出一个简单的单例类，就像教小学生做手工一样。

步骤一：私有化构造方法

首先，我们不希望别人能随便创建这个类的对象，所以我们把构造器设为私有的。

public class MySingleton {
    // 私有化构造器
    private MySingleton() {}
}

步骤二：创建唯一实例

接下来，我们在类里面创建这个类的唯一实例，并且设为静态（static），这样它就属于整个类，而不是某个具体对象。

public class MySingleton {
    // 私有化构造方法
    private MySingleton() {}

    // 创建唯一实例
    private static MySingleton instance = new MySingleton();
}

步骤三：提供获取实例的方法

为了让其他人能够拿到这个唯一的实例，我们需要提供一个公共的方法，通过它来获取这个实例。注意，这个方法也是静态的，因为我们要通过类名直接调用它，而不是通过对象。

public class MySingleton {
    // 私有化构造方法
    private MySingleton() {}

    // 创建唯一实例
    private static MySingleton instance = new MySingleton();

    // 提供获取实例的方法
    public static MySingleton getInstance() {
        return instance;
    }
}
//这种单例设计模型，被称为饿汉式单例设计模型
//特点：在获取类的对象时，这个对象已经被创建好了

使用示例：

现在，如果你想使用 MySingleton 类，只需调用 getInstance() 方法，每次你都会得到同一个对象：

public class Main {
    public static void main(String[] args) {
        // 获取唯一实例并使用它
        MySingleton singleton1 = MySingleton.getInstance();
        MySingleton singleton2 = MySingleton.getInstance();

        if (singleton1 == singleton2) {
            System.out.println("这是同一个对象！");
        } else {
            System.out.println("这不是同一个对象！");
        }
    }
}

运行上面的代码，你会看到输出 "这是同一个对象！"，这证明无论你调用多少次 getInstance()，返回的都是相同的那个唯一实例。

懒汉式单例设计模型：

特点：在获取类的对象时，才创建这个对象。

写法：

1. 声明一个静态变量，但不初始化：这表示我们有一个地方可以存储我们的唯一实例，但暂时还没有把它放进去。
2. 私有化构造方法：这样别人就不能随便创建这个类的新对象了。
3. 提供一个公共的方法来获取这个实例：当第一次调用这个方法时，我们才创建那个唯一的实例，以后再调用，就直接返回已经创建好的实例。

实现：

public class Singleton {
    // 静态变量，但不立即初始化
    private static Singleton instance;

    // 私有化构造方法，防止外部直接创建实例
    private Singleton() {}

    // 提供获取实例的方法，并加锁保证线程安全
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}//单线程不需要synchronized，可以删去。