【Java】：类变量、类方法（static在类中的用法）及main函数细节

前言

经过一个多月的学习，终于进入了学习Java的第二阶段，本篇博客主要介绍Java面向对象高级部分中 类变量、类方法 的使用，以及 main函数语法 剖析，主要设计 static关键字 在类中的使用。

很有意思的一句话， 一个数如果没有前面的1，后面跟再多的0也是没有意义，我们应该继续努力，把1的位置往前挪 ！

目录

类变量

类变量的定义

访问修饰符 static 数据类型 变量名;//推荐使用
static 访问修饰符 数据类型 变量名;//也可以
1
2

在定义时也可以赋予初始值！

什么是类变量

用static关键字修饰的成员变量即类变量，也叫 静态变量/静态属性，是该类的所有对象共享的变量 ，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它的值，修改的也是同一个变量。而 static变量在类加载时就生成了 ，下面以ChildGame类来演示类变量的使用并分析类变量在内存中的布局：

package com.lww.study_static_;

public class ChildGame {

    public static void main(String[] args) {

        //定义一个变量count，统计有多少个小孩加入了游戏
        //int count = 0;

        //注释快捷键，多行注释（每行都要） ctrl + /
        //注释快捷键，多行注释（首尾行） ctrl + shift + /

        Child child1 = new Child("白骨精");
        child1.join();
        //count++;
        child1.count++;

        Child child2 = new Child("狐狸精");
        child2.join();
        //count++;
        child2.count++;

        Child child3 = new Child("老鼠精");
        child3.join();
        //count++;
        child3.count++;

        //游戏结束
        //System.out.println("共有" + count + "小孩加入了游戏");
        //类变量可以通过类名访问
        System.out.println("共有" + Child.count + "小孩加入了游戏");
        //下面的代码输出结果相同
        System.out.println("child1.count = " + child1.count);
        System.out.println("child2.count = " + child2.count);
        System.out.println("child3.count = " + child3.count);
    }
}

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 + "加入了游戏..");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

经过上面的代码测试，我们发现同一个类定义的不同对象，所访问到的static修饰的成员变量均是同一个，下面给出它在内存中的布局：

有些书上说static修饰的count变量是在方法区中的静态域，而这里提供的是存在于堆区上，这里不做过多分析，感兴趣的可以自己找找网上的文章。不管是哪一种布局，这里主要想说明的点是， 类变量在类加载时就产生了，该类的每一个实例对象都使用的是同一个类变量！

如何访问类变量

类名.类变量名//推荐使用！
对象名.类变量名
1
2

静态变量的访问修饰符的访问权限范围和普通成员变量是一样（遵循的访问规则一样）！

类变量的细节总结

1. 什么时候需要使用类变量：当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）
2. 类变量与实例变量（普通属性）的区别： 类变量是该类的所有对象共享的，而实例变量是每个对象独享的
3. 加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
4. 类变量可以通过 类名.类变量名 或者 对象名.类变量名 来访问，但Java设计者推荐我们使用 类名.类变量名 方式去访问。访问规则遵循修饰符的访问权限和范围
5. 实例变量不能通过 类名.普通成员变量名 访问 ，因为还未创建对象实例，内存中没有该普通成员变量
6. 类变量是在类加载时就初始化了，也就是说，即使没有创建对象，只要类加载了，就可以使用类变量了 ，这也就是为什么能够通过 类名.类变量名 方式去访问
7. 类变量的生命周期是随类的加载开始，随着类的消亡而销毁

类方法

类方法的定义

类方法也称为静态方法，定义形式如下：

访问修饰符 static 数据返回类型 方法名() {……}//推荐使用
static 访问修饰符 数据返回类型 方法名() {……}//也可
1
2

经过上面类变量的介绍，这里的类方法理解起来会相对容易。

类方法的调用

类名.类方法名//推荐使用
对象名.类方法名
1
2

调用/访问规则同样遵循访问修饰符的访问权限和范围！下面是一段测试代码，供学习和思考：

package com.lww.study_static_;

public class StaticMethodDetail {
    public static void main(String[] args) {

        D.hi();
        //非静态方法，不能通过类名调用
        //D.say();//error，需要先创建对象，再通过对象调用
        new D().say();
        new D().ok();
    }
}

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);//error
    }

    //类方法（静态方法）中，只能访问静态变量 或者 静态方法
    //即静态方法中只能访问静态成员
    public static void hello() {
        System.out.println(n2);
        System.out.println(D.n2);
        //System.out.println(this.n2);//error
        hi();
        //say();//error
    }

    //普通成员方法，既可以访问非静态成员，也可以访问静态成员
    public void ok() {
        //非静态成员
        System.out.println(n1++);
        System.out.println(this.n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

常见使用场景

1. 当方法中不涉及到任何和对象相关的成员时，可以将方法设计成静态方法，提高开发效率，比如util中的Math类、Array类中的方法很多都是设计为静态方法，他们都是可以直接通过 类名.类方法名 调用，避免创建对象的消耗
2. 在程序员实际开发过程中，往往会将一些通用的方法，设计成静态方法，这样我们不需要创建对象就可以使用了，比如打印一堆数组，冒泡排序，完成某个计算任务等

类方法的细节总结

1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区
2. 类方法中无this的参数，普通方法中隐含着this的参数
3. 类方法可以通过类名调用，也可以通过对象名调用
4. 普通方法和对象有关，需要通过对象名调用，不能通过类名调用
5. 类方法中不允许使用和对象有关的关键字，比如this和super 。普通方法可以
6. 类方法（静态方法）中只能访问静态成员，即只能 静态变量 或者 静态方法
7. 普通成员方法，既可以访问 非静态成员，也可以访问 静态成员

main方法语法

深入理解main方法

main方法的形式：

public static void main(String[] args) {……}
1

1. main方法是由虚拟机调用的
2. Java虚拟机需要调用main()方法，所以该方法的访问权限必须是public
3. Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static修饰的
4. 该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数
5. java 执行的程序 参数1 参数2 参数3……参数由args数组接收

main()方法属于静态方法，所以在main()方法中，可以直接调用main所在类的静态方法或者静态属性，但是不能访问该类中的非静态成员，必须创建该类的实例对象后，才可以通过对象去访问，下面是一段测试代码：

import sun.applet.Main;

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) {

        //可以直接使用name，
        //1\. 静态方法main 可以访问本类的静态成员
        System.out.println("name = " + name);
        hi();
        //2\. 静态方法main 不可以访问本类的非静态成员
        //System.out.println(n1);//error
        //cry();//error
        //3\. 静态方法main 要访问本类的非静态成员，必须要先创建对象，再调用即可
        Main01 main01 = new Main01();
        System.out.println(main01.n1);
        main01.cry();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

关于args数组，这里也可以通过下面的操作进行演示，在IDEA中执行下面代码：

package com.lww.study_main_;

public class Main02 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9

我们会发现没有任何输出结果，那是因为我们还没有给执行过程传递参数，通过下面步骤设置执行该代码时要传递的参数

如果没有显示有Main02，可以先运行一遍再设置，点击进去后出现以下界面

在Program arguments栏输入要传递的运行参数，比如我这里输入的是北京 上海 西安，最后Apply后OK退出该界面，重新运行代码，会发现输出以下结果

当然这部分内容了解一下即可，实际开发过程中不需要我们去传递参数，但为了应付面试，我们还是要了解一下有这么个内容即可！