Java中的类变量/静态变量和类方法/静态方法

深藏阁楼爱情的钟 2024-04-26 10:45 102阅读 0赞

## 一、类变量/静态变量 ##

### 1. 类变量引入 ###

*  **提出一个问题：**

>  *  **有一群小孩在玩堆雪人,不时有新的小孩加入,请问如何知道现在共有多少人在玩?，编写程序解决。**

*  用传统的方法解决：（创建一个 Child 类）![在这里插入图片描述][0416839760cf4d4aaa4e6ec2e5dd1db5.png]
 *  **思考：count 变量是一个独立于小孩对象存在的变量，在main 方法中定义该变量，如果想要在其他类中访问时，很麻烦。因此我们引出了类变量/静态变量的概念。**

### 2. 类变量快速入门 ###

*  思考: 在上题中，如果能在Child 类中设计一个变量 count 表示总人数，我们每次新建一个小孩对象时，就把 count 加 1，并且 count 是所有小孩对象共享的就可以了，所以我们可以使用类变量来解决。
 *  **代码实现：**

public class ChildGame {
        
        public static void main(String[] args) {
        
    
            Child child1 = new Child("白骨精");
            child1.join();
            child1.count++;// 通过对象名来访问类变量
    
            Child child2 = new Child("狐狸精");
            child2.join();
            child2.count++;
    
            Child child3 = new Child("老鼠精");
            child3.join();
            child3.count++;
    
            //类变量，可以通过类名来直接访问，也可以通过对象名来访问；
            System.out.println("共有" + Child.count  + " 小孩加入了游戏...");
            //下面的输出相同，因为所有对象都共用了类变量。
            System.out.println("child1.count=" + child1.count);//3
            System.out.println("child2.count=" + child2.count);//3
            System.out.println("child3.count=" + child3.count);//3
        }
    }
    
    class Child {
         //类
        private String name;
        //定义一个变量 count ,是一个类变量(静态变量)，static：静态
        //该变量最大的特点就是会被Child 类的所有的对象实例共享
        public static int count = 0;
        public Child(String name) {
        
            this.name = name;
        }
        public void join() {
        
            System.out.println(name + " 加入了游戏..");
        }
    }

*  **显而易见，将 count 设置为类变量后，解决了传统方法出现的问题，类变量可以通过类名被直接访问，在其他类中也可以方便地访问该变量了。**

### 3. 类变量的内存布局 ###

*  **类对象的创建过程：**
    
     *  在第一次创建一个类的对象时，在内存的方法区中会加载该类的信息（只会加载一次），与此同时伴随着类的加载在堆内存中会生成一个类对象 （类对象不是类的一个具体对象，而是类的一个映射）；
     *  类变量也伴随着类的加载而生成，并存储在类对象的尾部；
 *  **只需记住两点：**

> **（1）类变量是同一个类的所有对象共享的变量；**  
> **（2）类变量在类加载的时候就已经产生了，因此只需要通过类名便可以直接访问类变量。**

### 4. 类变量基本概念 ###

*  **类变量：也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值；同样，任何一个该类的对象去修改它时，修改的也是同一个变量。**
 *  **基本语法：**  
    ![在这里插入图片描述][8d8c5d8164e3457f910d57114395ae3c.png]
 *  **访问类变量：**  
    ![在这里插入图片描述][5a7587e61ba142bcb2edd593f0ccffe0.png]
 *  **注意：在访问类变量时，需要满足遵守修饰符的相关权限控制规则；类变量是随着类的加载而创建，因此即使没有创建对象实例也可以直接通过类名访问。**
 *  **代码实现：**

public class VisitStatic {
        
        public static void main(String[] args) {
        
            //类名.类变量名
            //说明：类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问；
            System.out.println(A.name);
            A a = new A();
            //通过对象名.类变量名
            System.out.println("a.name=" + a.name);
        }
    }
    
    class A {
        
        // 类变量/静态成员变量/静态属性
        public static String name = "韩顺平教育";
        // 普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量
        private int num = 10;
    }

*  **补充：**

> **变量的称谓：（称谓不同，但本质就是同一个东西）**
> 
> 1.  **类变量 = 静态成员变量 = 静态属性；**
> 2.  **普通成员变量 = 普通属性 = 非静态属性 = 非静态成员变量 = 实例变量；**

### 5. 类变量使用注意事项和细节 ###

*  **细节如下：**  
    ![在这里插入图片描述][d7550f3d366c4853ba2d782fba5341f5.png]  
    ![在这里插入图片描述][3e74d1a84c3947c48fb512d76ec43d6c.png]

## 二、类方法/静态方法 ##

### 1. 类方法基本概念 ###

*  **类方法：也叫静态方法，当一个普通的成员方法使用了 static 关键字修饰后，该方法就变成了静态方法。**
 *  **基本语法：**  
    ![在这里插入图片描述][8dbeb7e6d8f249c09311dd3e82bf08d5.png]
 *  **类方法的使用：**  
    ![在这里插入图片描述][57559cf38dfb40e987f5e0f93bd7bead.png]

> (1) **推荐使用类名.类方法名来调用类方法。**  
> (2) **如果我们希望不创建对象，也可以调用某个方法（即仅把该方法当做一个工具来使用），那就把该方法定义为一个静态方法。把这些工具方法都放进一个类，这个类可以当做我们的工具类来使用。**

*  **类方法经典的使用场景：**  
    ![在这里插入图片描述][8e7c0f863c4e47ad86a2e72da19c82f0.png]

### 2. 类方法使用注意事项和细节 ###

*  **细节如下：**  
    ![在这里插入图片描述][6c4135b8fbde47ff841eadf4d9944bc1.png]
 *  **代码实现：**

public class StaticMethodDetail {
        
        public static void main(String[] args) {
        
    
            D.hi();// 静态方法，可以直接通过类名调用
    
            //非静态方法，不能通过类名调用
            //D.say();, 错误，需要先创建对象，再调用
            new D().say();// 通过对象调用
        }
    }
    
    class D {
        
    
        private int n1 = 100;
        private static int n2 = 200;
    
        public void say() {
        
            // 非静态方法,普通方法
        }
    
        public static void hi() {
        
            // 静态方法,类方法
            // 类方法中不允许使用和对象有关的关键字，
            // 比如this和super。
            // System.out.println(this.n1); 错误
        }
    
        // 类方法(静态方法)中 只能访问 静态变量 或静态方法
        // 口诀:静态方法只能访问静态成员。
        public static void hello() {
        
            System.out.println(n2);
            System.out.println(D.n2);
            //System.out.println(this.n2); 错误，不能使用this关键字
            
            hi();// 静态方法中可以访问静态方法
            //say(); 错误，静态方法中不能访问非静态方法和成员
        }
    
        // 普通成员方法，既可以访问 非静态成员，也可以访问静态成员；
        // 小结: 非静态方法可以访问 静态成员和非静态成员；
        public void ok() {
        
    
            //非静态成员
            System.out.println(n1);
            say();
    
            //静态成员
            System.out.println(n2);
            hello();
        }
    }

*  **注意：一切成员的访问前提是，要遵守访问修饰符限定的权限规则。**

## 三、main 方法 ##

### 1. 深入理解 main 方法 ###

*  **main 方法是一种特殊的静态方法，它由Java虚拟机调用。**
 *  **解释main 方法的形式：**  
    ![在这里插入图片描述][c72b6dfa0dd24dd7820c124d2b0e40bb.png]

### 2. 注意事项和细节 ###

> **1) 在 main()方法中，我们可以直接调用 main 方法所在类的静态方法或静态属性。**  
> **2) 但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。**

*  **代码举例：**

public class Main01 {
        
    
        // 静态的变量/属性
        private static String name = "韩顺平教育";
        // 非静态的变量/属性
        private int n1 = 10000;
    
        // 静态方法
        public static void hi() {
        
            System.out.println("Main01的 hi 方法");
        }
    
        // 非静态方法
        public void cry() {
        
            System.out.println("Main01的 cry 方法");
        }
    
        public static void main(String[] args) {
        
    
            // 1. 静态方法main 可以访问本类的静态成员
            // 可以直接使用 name，和 hi 方法； 
            System.out.println("name=" + name);
            hi();
    
            // 2. 静态方法main 不可以访问本类的非静态成员
            // System.out.println("n1=" + n1);  错误
            // cry(); 错误
    
            //3. 静态方法 main 要访问本类的非静态成员，需要先创建对象 , 再用对象调用
            Main01 main01 = new Main01();
            // 可以使用非静态成员了；
            System.out.println(main01.n1);
            main01.cry();
        }
    }

## 总结 ##

*  本文是小白博主在学习B站韩顺平老师的Java网课时整理总结的学习笔记，在这里感谢韩顺平老师的网课，如有有兴趣的小伙伴也可以去看看。
 *  本文详细解释了类变量和类方法的概念与使用，希望小伙伴们能有所收获！
 *  最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！我们下一篇博文见吧！

[0416839760cf4d4aaa4e6ec2e5dd1db5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/22f5b826c97f4da8ae5bacfcf4f9dd80.png
[8d8c5d8164e3457f910d57114395ae3c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/182fc13fe59c492db8ebbbec5f0595d4.png
[5a7587e61ba142bcb2edd593f0ccffe0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/594a2df664894c43aa6b0a86ac55550c.png
[d7550f3d366c4853ba2d782fba5341f5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/66e03adc4b2140d890c2bd048c6820c2.png
[3e74d1a84c3947c48fb512d76ec43d6c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/f91b87c5edc5494ea09f92f58fd93eb2.png
[8dbeb7e6d8f249c09311dd3e82bf08d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0475e5f4001e45b2b9922b173fc0a1f7.png
[57559cf38dfb40e987f5e0f93bd7bead.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7be8df31d03747f58c3826f49786e419.png
[8e7c0f863c4e47ad86a2e72da19c82f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e5d2a2b43b7b47aa89f448f2c9eb639b.png
[6c4135b8fbde47ff841eadf4d9944bc1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8910603e1a704a108b04a8a3c5a59050.png
[c72b6dfa0dd24dd7820c124d2b0e40bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/84f3a811a7964c3e8bbf886c143a2585.png