24、类变量和类方法

Love The Way You Lie 2024-04-01 18:40 62阅读 0赞

一、问题引入

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

2、思路：

（1）在main方法中定义一个变量count

（2）当一个小孩加入游戏后

3、分析：

（1）count是一个独立于对象/类变量，不好操作

（2）以后我们访问count很麻烦，没有使用到OOP

（3）因此我们引出类变量/静态变量

4、解决：

设计一个int count表示总人数，我们在创建一个小孩时，把count加1，且count是所有对象共享的

package static_;
    
    public class ChildGame {
        public static void main(String[] args) {
            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+"个小孩加入了游戏...");
            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+"加入了游戏...");
        }
    }
    /*输出：
    白骨精加入了游戏...
    狐狸精加入了游戏...
    老鼠精加入了游戏...
    共有3个小孩加入了游戏...
    child1.count=3
    child2.count=3
    child3.count=3
    */

jdk8以后的，静态变量是放在堆里；jdk8以前的，静态变量是放在方法区里。

但不管静态变量在哪里，共识：

*（1）静态变量是所有对象共享的（同一个类中的所有对象）*

*（2）静态变量在类加载时就生成了*

二、类变量

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

2、定义语法：

访问修饰符 static 数据类型 变量名;(推荐)
    static 访问修饰符 数据类型 变量名;

3、访问类变量：

类名.类变量名（推荐）
    对象名.类变量名

package static_;
    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{
        static public String name="韩顺平教育";
    }

4、细节：

（1）什么时候需要用类变量：

当我们需要让某个类的所有对象共享一个变量时，就可以考虑使用类变量

比如：定义学生类，统计所有学生共交多少钱Student(name,fee)

（2）类变量与实例变量（普通属性）区别：

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

（3）加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量

（4）java设计者推荐我们使用*类名.类变量名*方式访问（前提是满足访问修饰符的访问权限和范围）

（5）实例变量不能通过*类名.类变量名*访问

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

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

三、类方法

1、基本介绍：

类方法也叫静态方法

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

2、类方法的调用：

类名.类方法名
    //或
    对象名.类方法名（前提是满足访问修饰符的访问权限和范围）

普通方法加上static就变成静态方法了

package static_;
    
    public class StaticMethod {
        public static void main(String[] args) {
            Stu tom=new Stu("tom");
            tom.payFee(100);
            Stu marry=new Stu("marry");
            tom.payFee(200);
            Stu.showFee();
        }
    }
    class Stu{
        private String name;
    
        private static double fee=0;//累积学生的学费
        public Stu(String name){
            this.name=name;
        }
        //静态方法可以访问静态变量
        public static void payFee(double fee){
            Stu.fee+=fee;
        }
        public static void showFee(){
            System.out.println("总学费："+Stu.fee);
        }
    }
    //输出：总学费：300.0

3、类方法经典的使用场景：

当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法（当成工具使用），提高开发效率

*（在实际开发中，程序员往往会将一些通用的方法设计成静态方法，这样我们不需要创建对象就可以使用了，比如打印一维数组，冒泡排序，完成某个计算任务……）*

4、细节：*（静态非静态的访问等等，一句话就是创建时间早晚的问题）*

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

（类方法中无this的参数，普通方法中隐含着this的参数）

（2）类方法可以通过类名调用，也可以通过对象名调用

（3）普通方法和对象有关，需要通过对象名调用，比如*对象名.方法名（参数）*，不能通过类名调用

（4）类方法中不允许使用和对象有关的关键字，比如this和super，普通方法可以

*因为类变量和类方法随着类的加载而加载，类的加载比对象的创建要早，如果使用this或super，会找不到对象，普通方法是实例化对象后使用的*

（5）类方法中只能访问静态变量（方法）

（6）普通成员方法，既可以访问普通变量（方法），也可以访问静态变量（方法）