java静态变量调用动态变量

一、类变量/静态变量

1. 类变量引入

• 提出一个问题：

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

• 用传统的方法解决：（创建一个 Child 类）
• 思考：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. 类变量基本概念

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

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. 类变量使用注意事项和细节

• 细节如下：
  

二、类方法/静态方法

1. 类方法基本概念

• 类方法：也叫静态方法，当一个普通的成员方法使用了 static 关键字修饰后，该方法就变成了静态方法。
• 基本语法：
• 类方法的使用：

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

• 类方法经典的使用场景：

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

• 细节如下：
• 代码实现：

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 方法的形式：

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