JAVA 静态变量，静态方法，main方法详解（韩顺平）

我是康康康

已于 2022-04-16 20:39:17 修改

阅读量2.1k

点赞数 3

文章标签： java 开发语言

于 2022-04-08 20:14:50 首次发布

本文链接：https://blog.csdn.net/wztmds/article/details/124048789

版权

一.类变量

1.类变量的引入

问题描述：设计一个 int count 表示总人数,我们在创建一个小孩时，就把 count 加 1

代码如下

class Child { //类
    private String name;
    public void join() {
        System.out.println(name + " 加入了游戏..");
    }
}


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

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

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

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

我们用传统的方法可以很轻易的写出这串代码，但是这串代码的缺点是count是一个独立的变量，并没有使用到oop，所以我们在这里引入类变量（静态变量）

对上述代码进行修改

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 + " 加入了游戏..");
    }
}

 int count = 0;

        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  + " 小孩加入了游戏...");

2.类变量的定义

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

3.类变量的特点

1）static变量时同一个类所有对象共享（重点理解）

2）static类变量在类加载的时候生成了

4.如何定义类变量

定义语法：

访问修饰符 static 数据类型变量名；（推荐）

static 访问修饰符数据类型变量名；

5.如何访问类变量

类名.类变量名或者对象名.类变量名

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

6.类变量使用细节

1）什么时候使用类变量

当我们需要让某个类的所有对象都共享一个变量时，

就可以考虑使用类变量。比如定义学生类，统计所有学生共交多少钱：Student（name ， static fee）

2）类变量和实例变量区别

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

3）实例变量不能通过类名.类变量名方式访问

4）类变量是在类加载时就初始化，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量

5）类变量的生命周期是随类的加载开始，随着类消亡而销毁

代码案例，帮助大家理解类变量使用细节


    public static void main(String[] args) {
        B b = new B();
        //System.out.println(B.n1);
        System.out.println(B.n2);

        //静态变量是类加载的时候，就创建了,所以我们没有创建对象实例
        //也可以通过类名.类变量名来访问
        System.out.println(C.address);
    }


class B {
    public  int n1 = 100;
    public static int n2 = 200;
}

class C {
    public static String address = "北京";
}

二.类方法

1.基本介绍

类方法也叫静态方法

2.定义类方法

访问修饰符 static 数据返回类型方法名（）{}【推荐】

static 访问修饰符数据返回类型方法名（）{}

3.类方法的访问

类名.类方法名或者对象名.类方法名（前提：满足访问修饰符的访问权限和普通方法一致）

public class StaticMethod {
    public static void main(String[] args) {
        //创建2个学生对象，收学费
        Stu tom = new Stu("tom");
        //tom.payFee(100);
        Stu.payFee(100);

        Stu mary = new Stu("mary");
        //mary.payFee(200);
        Stu.payFee(200);//两种方法均可


        //输出当前收到的总学费
        Stu.showFee();//300

        System.out.println(MyTools.calSum(10, 30));
    }
}
//开发自己的工具类时，可以将方法做成静态的，方便调用
class MyTools  {
    //求出两个数的和
    public static double calSum(double n1, double n2) {
        return  n1 + n2;
    }
    //可以写出很多这样的工具方法...
}
class Stu {
    private String name;
    //定义一个静态变量，来累积学生的学费
    private static double fee = 0;

    public Stu(String name) {
        this.name = name;
    }
    //说明
    //1. 当方法使用了static修饰后，该方法就是静态方法
    //2. 静态方法就可以访问静态属性/变量
    public static void payFee(double fee) {
        Stu.fee += fee;//累积到
    }
    public static void showFee() {
        System.out.println("总学费有:" + Stu.fee);
    }
}

4.类方法的使用场景

当方法中不涉及到任何和对象相关的成员，则可以将方法设计为静态方法，提供开发效率

这里大家可以看我写的房屋出租系统中调用的Utility工具类，该类中大部分方法都是静态方法

将方法设计为静态方法，这样我们不需要创建对象就可以使用，比如

//如果我们希望不创建实例，也可以调用某个方法(即当做工具来使用)
        //这时，把方法做成静态方法时非常合适
        System.out.println("9开平方的结果是=" + Math.sqrt(9));

5.类方法使用细节

1）类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区

类方法不能出现this，super

普通方法中隐含着this参数，也可出现super

2）普通方法必须由对象调用

3）类方法只能访问静态变量或静态方法（重点理解）

4）普通成员方法，既可以访问非静态成员，也可以访问静态成员

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);不能使用
        hi();//OK
        //say();//错误
    }
    //普通成员方法，既可以访问  非静态成员，也可以访问静态成员
    //非静态方法可以访问 静态成员和非静态成员
    public void ok() {
        //非静态成员
        System.out.println(n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();

    }
}


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

三.main方法

1.深入理解main方法

1）main方法是虚拟机的调用

2）java虚拟机需要调用类的main（）方法，所以该方法的访问权限必须是public

3）java虚拟机在执行main（）方法时不必创建对象，所以该方法必须时static

4）该方法接受Stri类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数

5）java 执行的程序参数1 参数 2 参数 3

在DOS系统中可以看到调用的参数

在idea中

点击光标在Program argumens中添加参数

2.特别提醒

1）在main（）方法中，我们可以直接调用main方法所在类的静态方法或静态属性

2）但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象象去访问类中的非静态成员

我是康康康

关注

3
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
JAVA 静态变量，静态方法，main方法详解（韩顺平）

一.类变量1.类变量的引入问题描述：设计一个 int count 表示总人数,我们在创建一个小孩时，就把 count 加 1代码如下class Child { //类 private String name; public void join() { System.out.println(name + " 加入了游戏.."); }}//定义一个变量 count, 统计有多少小孩加入了游戏 int count = 0;
复制链接

扫一扫