java类变量和类方法

免责声明：java基础资料均来自于韩顺平老师的《循序渐进学Java零基础》教案，具体视频内容可以去B站观看，这些资料仅用于学习交流，不得转载用于商业活动

1.1 类变量

1.1.1 引子

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

1.1.2 传统的方法来解决

思路

1. 在main方法中定义一个变量count
2. 当一个小孩加入后count++,最后这个count就记录有多少个小孩玩游戏

问题分析

1. count是一个独立的对象，很尴尬
2. 以后我们访问count很麻烦，没有使用到oop
3. 因此，我们引出类变量/静态变量

public class ChildGame {
    public static void main(String[] args){
        //定义一个变量count,统计有多少小孩加入游戏
        int count = 0;

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

1.1.3 类变量内存布局

static变量是对象共享，不管static变量存储在哪里

• static变量是同一个类所有对象共享
• static类变量，在类加载的时候就生成了

1.1.3 什么是类变量

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象

去访问它时，取到的读书相同的值，

任何一个该类的对象去修改它时，修改的也是同一个变量

1.1.4 如何去定义类变量

定义语法：

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

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

1.1.5 如何访问类变量

类名.类变量名  【推荐使用】

或者 对象.对象名 【静态变量的访问修饰符的访问权限和范围 和 普通属性是一样的】

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

1.什么时候需要用类变量

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

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

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

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

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

4.类变量可以通过类名.类变量名 或者 对象名.类变量名来访问，但java设计者推荐我们使用类名.类变量名方式访问【前提是 满足访问修饰符的访问权限和范围】

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

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

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

public class StaticDetail {
    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.类方法

1.2.1 类方法基本介绍

类方法也叫做静态方法

形式如下：

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

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

1.2.2 类方法的调用

使用方式：类名.类方法名 或者 对象名.方法名【前提 满足访问修饰符的访问权限】

1.2.3 类方法应用案例

 

public class StaticMethod {
    public static void main(String[] args) {
        Stu tom = new Stu("tom");
        //tom.payFee(100);
        Stu.payFee(100);
        
        Stu mary = new Stu("mary");
        //mary.payFee(200);
        Stu.payFee(200);
        
        //输出当前收到的总学费
        Stu.showFee();
        
        //如果我们希望不创建实例，也可以调用某个方法（即当作工具来使用）
        //这时，把方法做成静态方法时非常合适
        System.out.println("9开平方的结果是="+Math.sqrt(9));
        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);
    }
}

1.2.4 类方法经典的使用场景

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

比如：工具类钟的方法utils

Math类，Arrays类，Collections集合类

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

1.2.5 类方法使用注意事项和细节讨论

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

小结：静态方法，只能访问静态成员，非静态方法，可以访问静态成员和非静态成员（必须遵守访问权限）

public class StaticMethodDetail {
    public static void main(String[] args) {
        D.hi();
        //非静态方法，不能通过类名调用
        //D.say(); 错误，需要先创建对象再调用
        D d = new D();
        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);不能使用
        hi();
        //say();//错误
    }

    //普通成员方法，既可以访问 非静态成员，也可以访问静态成员
    //小结：非静态方法可以访问静态成员和非静态成员
    public void ok(){
        //非静态成员
        System.out.println(n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();
    }
}

2.1 理解main方法语法

2.1.1 深入理解main方法

1. 解释main方法的形式：public static void main(String[] args){}
2. main方法时虚拟机调用
3. java虚拟机需要调用类的main方法，所以该方法的访问权限必须是public
4. java虚拟在执行main()方法时不必创建对象，所以该方法必须是static
5. 该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数，案例颜色，接收参数

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

2.1.2 特别提示

在main()方法中，我们可以直接调用main方法所在类的静态方法或静态熟悉

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

 

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="+n1);//错误
        //cry();
        //3.静态方法main要访问本类的非静态成员，需要先创建对象，再调用即可
        Main01 main01 = new Main01();
        System.out.println(main01.n1);//ok
        main01.cry();
    }
}