20类变量&类方法

> 引入

问：有一群小孩在玩推雪人，时不时有新的小孩加入，请问如何知道现在共有多少人在玩？

代码

```java
package com.static_;

public class ChildGame {
    public static void main(String[] args) {
        int count = 0;
        Child child1 = new Child("666");
        child1.join();
        count++;
        Child child2 = new Child("6661");
        child2.join();
        count++;
        Child child3 = new Child("6664 ");
        child3.join();
        count++;

System.out.println("共有" + count + "小孩");
    }

}

class Child{
    private String name;

public Child(String name) {
        this.name = name;
    }

public void join(){
        System.out.println(name + "加入了游戏");
    }
}
```

![image-20240325111017655](https://oss.maolin101.com/202501070055505.png-101.webp)

> 思考

如果设计int count标识总人数，在创建小孩时，就把count+1，并且count是所有对象共享的

static变量所有对象共享（同一个类中的对象），类变量static是在类加载的时候就生成了

使用类变量

```java

```

## 类变量

> 什么是类变量

- 类变量也叫静态变量或者静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值。
- 同样任何一个该类的对象去修改它时，修改的也是同一个变量

> 类变量的定义

语法（二选一）

- 访问修饰符 static 数据类型 变量名;
- static 访问修饰符 数据类型 变量名l;

> 类变量的访问

语法（二选一）

- 类名.类变量名
- 对象名.类变量名

注意：静态变量的访问修饰符的访问权限和范围 与普通属性一致

> 类变量细节

- 当需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）

- 类变量与实例变量的区别：

类变量是该类的所有对象共享的，而实例变量是每个对象独享的

- 变量前加上static 称为类变量或者静态变量，否则成为实例变量或者普通变量或者非静态变量

- 类变量可以通过类名.类变量名 或者 对象名.类变量名 来访问

> 实例代码

```java
package com.static_;

public class Test {
    public static void main(String[] args) {
        Student.name = "abc";

Student s1 = new Student();
        s1.name = "def";
        s1.age = 10;

Student s2 = new Student();
        s2.name = "xbxaq";
        s2.age = 20;

System.out.println(Student.name);
        System.out.println("name:" + s1.name + ", age:" + s1.age);
        System.out.println("name:" + s2.name + ", age:" + s1.age);

}
}

class Student{
    public static String name;

int age;
}
```

![image-20240325205921166](https://oss.maolin101.com/202501070055506.png-101.webp)

## 类方法

##

> 语法

- 访问修饰符 static 数据返回类型 方法名(){}
- static 访问修饰符 数据返回类型 方法名(){}

> 类方法调用

- 类名.类方法名
- 对象名.类方法名

> demo

main

```java
package com.static_method;

public class Test1_method {
    public static void main(String[] args) {
        Student.printHello();
    }
}

```

student

```
package com.static_method;

public class Student{
    public static void printHello(){
        System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("Hello World");
    }

}

```

![image-20240326123448405](https://oss.maolin101.com/202501070055507.png-101.webp)

> 注意事项

- 类方法中可以直接访问类的成员，但不可以直接访问实例成员
- 实例方法中既可以直接访问类成员，也可以直接访问实例成员
- 实例方法中可以出现this关键词，类方法中不可以出现this关键词

## 代码块

代码块分为静态代码块与实例代码块

> 静态代码块

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

demo

```java
package com.static_;

public class Test {
    public static void main(String[] args) {
        System.out.println(Student.num);

}
}

class Student{
    static int num = 10086;
    static {
        System.out.println("静态代码块执行啦");
    }
}
```

![image-20240326131118442](https://oss.maolin101.com/202501070055508.png-101.webp)

> 实例代码块

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

demo

```java
package com.static_;

import com.sun.org.apache.xalan.internal.xsltc.trax.XSLTCSource;

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        System.out.println("----------------");
        Student student2 = new Student("xbxaq");

}
}

class Student{

public Student() {
        System.out.println("无参构造器执行了");
    }

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

public Student(String name){
        System.out.println("有参构造器执行了");
    }
}
```

![image-20240326132145663](https://oss.maolin101.com/202501070055509.png-101.webp)

## 设计模式

> 定义

- 一个问题通常有n中解法，其中的最优解被称之为设计模式

> 单例设计模式

- 确保一个类只有一个对象

> 语法

- 把类的构造器私有化
- 定义一个类变量记住类的一个对象
- 定义一个类方法，返回对象

demo

```java
package com.static_;

import com.sun.org.apache.xalan.internal.xsltc.trax.XSLTCSource;

public class Test {
    public static void main(String[] args) {
        A a1 = A.getObject();
        A a2 = A.getObject();
        System.out.println(a1);
        System.out.println(a2);

}
}

class A{
    private static A a = new A();
    private A(){

}
    public static A getObject(){
        return a;
    }
}
```

![image-20240326152237767](https://oss.maolin101.com/202501070055510.png-101.webp)