本文将主要介绍类变量和类方法知识点，帮你解决困惑已久的静态问题。学而不思则罔，思而不学则殆！


类变量和类方法

  • 📚1. 类变量
  • 🍀1.1 类变量-提出问题
  • 🍀1.2 类变量内存布局
  • 🍀1.3 类变量的介绍和定义
  • 🍀1.4 如何访问类变量
  • 🍀1.5 类变量使用注意事项和细节讨论
  • 📚2. 类方法
  • 🍀1.1 类方法基本介绍
  • 🍀1.2 类方法的调用
  • 🍀1.3 类方法应用案例
  • 🍀1.4 类方法经典的使用场景
  • 🍀1.5 类方法使用注意事项和细节讨论
  • 🍀1.6 练习


📚1. 类变量

🍀1.1 类变量-提出问题

java 变量名 作为字符串使用 java变量名有什么意义_java


使用现有技术去解决，代码如下：

package com.hj.第十章面向对象编程下.ststic_;

/**
 * @author Baridhu
 */
public class ChildGame {
    public static void main(String[] args) {
        //定义一个变量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++;
        //==============
        System.out.println("共有"+count+"加入了游戏...");
    }
}
class Child{
    private String name;
    public Child(String name){
        this.name=name;
    }
    public void join(){
        System.out.println(name+"加入了游戏..");
    }
}

大家看看上面代码觉得有什么问题？

  1. count是一个独立于对象，并不是Child类的属性;
  2. 以后我们访问count会非常的麻烦，没有使用到OOP;
  3. 因此我们引入类变量（静态变量）。

⚡️改进：
如果设计一个count表示总人数,我们在创建一个小孩时，就把 count 加 1,并且 count 是所有对象共享的就 ok 了!，我们使用类变量来解决 ChildGame.java 改进。

package com.hj.第十章面向对象编程下.ststic_;

/**
 * @author Baridhu
 */
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+"加入了游戏..");
    }
}

🚀运行结果：

白骨精加入了游戏..
狐狸精加入了游戏..
老鼠精加入了游戏..
共有3人加入了游戏...
child1.count=3
child2.count=3
child3.count=3

🍀1.2 类变量内存布局

视频讲解：韩顺平Java_类变量内存剖析JDK7以上版本，静态域存储于定义类型的Class对象中，Class对象如同堆中其他对象一样，存在于GC堆中。也就是说：
☀️JDK7以上版本的静态变量存在于堆中，而不是元空间。

补充：
☀️JDK7以下的静态变量储存在静态域中，静态域储存在方法区中。

java 变量名 作为字符串使用 java变量名有什么意义_开发语言_02

1.类加载时，.class文件被加载到内存中，并构建了一个Class对象，在堆中。
2. 静态变量经过追踪，发现其和Class对象绑定在一起，由 1 可知其存在于堆中（都说静态变量在方法区，只能说.class文件的信息都在方法区，所以静态变量的信息存在于方法区，静态变量本身并不在）。
3. 它的对象实体（new出来的对象）也存在于堆中（java8）。补充：java8 将 静态变量 、StringTable 都从方法区移动到 堆中，主要是想进行GC，方法区也能GC，但只能full GC，频率会很低。

⭐️总结：不管static变量在哪里，都有以下共识
(1) static类变量是同一个类所有对象共享；
(2) static类变量，在类加载的时候就生成了。

🍀1.3 类变量的介绍和定义

⚡️介绍：
类变量也叫静态变量/静态属性，是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。这个从前面的图也可看出来。
⚡️定义：

定义语法:
访问修饰符static 数据类型变量名;[推荐]
static访问修饰符数据类型变量名;

🍀1.4 如何访问类变量

类名.类变量名;
或者
对象名.类变量名;【静态变量的访问修饰符的访问权限和范围和普通属性是一样的。】
推荐使用:类名.类变量名;

⚡️示例代码：

public class VisitStatic {
    public static void main(String[] args) {
        //类名.类变量名
        //说明：类变量是随着类的加载而创建的，所以即使没有创建对象实例也可以访问
        System.out.println(A.name);
        A a = new A();
        //通过对象名.类变量名a
        System.out.println(a.name);
    }
}
class A{
    //类变量
    public static String name="BaridHU";
}

大家还要注意一点：类变量的访问，必须遵守相关的访问权限！

比如我将public改为private的话就会报错：

java 变量名 作为字符串使用 java变量名有什么意义_开发语言_03


java 变量名 作为字符串使用 java变量名有什么意义_java 变量名 作为字符串使用_04

🍀1.5 类变量使用注意事项和细节讨论

⚡️1.什么时候需要用类变量?
当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态变量)。
比如:定义学生类，统计所有学生共交多少钱。

Student (name, static fee)

⚡️2.类变量与实例变量(普通属性)区别：

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

java 变量名 作为字符串使用 java变量名有什么意义_java 变量名 作为字符串使用_05

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

普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量
private int num = 10;

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

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

java 变量名 作为字符串使用 java变量名有什么意义_开发语言_06

java 变量名 作为字符串使用 java变量名有什么意义_类变量_07

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

/**
 * @author Baridhu
 */
public class StaticDetail {
    public static void main(String[] args) {
        //静态变量是类加载的时候，就创建了,所以我们没有创建对象实例
        //也可以通过类名.类变量名来访问
        System.out.println(C.address);
    }
}
class C {
    public static String address = "北京";
}

⚡️7.类变量的生命周期是随类的加载开始,随着类消亡而销毁。

📚2. 类方法

🍀1.1 类方法基本介绍

类方法也叫静态方法。

⚡️形式如下:

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

🍀1.2 类方法的调用

使用方式:类名.类方法名或者对象名.类方法名前提是满足访问修饰符的访问权限和范围。

🍀1.3 类方法应用案例

定义学生类，统计所有学生共交多少钱。
使用对象.静态方法：

public class StaticMethod {
    public static void main(String[] args) {
        Stu tom=new Stu("tom");
        tom.payFee(100);
        Stu mary=new Stu("tom");
        mary.payFee(200);

        //输出当前收到的总学费
        Stu.showFee();
    }
}
class Stu{
    private String name;//456swd
    //定义一个静态变量，来累计学生的学费
    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);
    }
}

使用类名.静态方法：

Stu tom=new Stu("tom");
Stu.payFee(100);
Stu mary=new Stu("tom");
Stu.payFee(200);
//输出当前收到的总学费
Stu.showFee();

⚡️运行结果：

总学费有：300.0

🍀1.4 类方法经典的使用场景

当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法,提高开发效率。
比如:工具类中的方法utils
Math类、Arrays类、Collections集合类

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

⚡️小结

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

开发自己的工具类时，可以将方法做成静态的，方便调用。

public class StaticMethod {
    public static void main(String[] args) {
        System.out.println(MyTools.calSum(10,20));
    }
}
//开发自己的工具类时，可以将方法做成静态的，方便调用
class MyTools {
    //求出两个数的和
    public static double calSum(double n1, double n2) {
        return n1 + n2;
    }
    //可以写出很多这样的工具方法...
}

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

1.类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区。
⚡️注意：
类方法中无this的参数
 普通方法中隐含着this的参数

2.类方法可以通过类名调用，也可以通过对象名调用。

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

public class StaticMethodDetail {
    public static void main(String[] args) {
        D.hi();//ok
        //非静态方法，不能通过类名调用
        //D.say();, 错误，需要先创建对象，再调用
        new D().say();//可以
    }
}
class D {
    public void say() {//非静态方法,普通方法
    }
    public static void hi() {//静态方法,类方法 
    }
}

4.类方法中不允许使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以。

使用下面代码会报错：

class D {
	private int n1 = 100;
	
    public void say() {//非静态方法,普通方法
    }
    
    public static void hi() {/静态方法,类方法
    //类方法中不允许使用和对象有关的关键字，
    //比如 this 和 super。普通方法(成员方法)可以。
    System.out.println(this.n1);
    }
}

java 变量名 作为字符串使用 java变量名有什么意义_java 变量名 作为字符串使用_08

5.类方法(静态方法)中只能访问静态变量或静态方法。

//类方法(静态方法)中 只能访问 静态变量 或静态方法
//口诀:静态方法只能访问静态成员.
public static void hello() {
    System.out.println(n2);
    System.out.println(D.n2);
    //System.out.println(this.n2);不能使用
    hi();//OK
    //say();//错误
}

6.普通成员方法,既可以访问非静态成员,也可以访问静态成员。
⚡️小结:
静态方法，只能访问静态的成员，非静态的方法，可以访问静态成员和非静态成员(必须遵守访问权限)

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

还可以看看：Java关键字之static

🍀1.6 练习

视频讲解：韩顺平Java_类成员课堂练习 ⚡️T1：请判断下面代码的输出结果：

java 变量名 作为字符串使用 java变量名有什么意义_后端_09


⚡️答案：

java 变量名 作为字符串使用 java变量名有什么意义_类变量_10


⚡️T2:看看下面代码有没有错误,如果有错误，就修改，看看输出什么?

java 变量名 作为字符串使用 java变量名有什么意义_后端_11


⚡️答案：

类方法(静态方法)中只能访问静态变量或静态方法,所以将i++注销。

java 变量名 作为字符串使用 java变量名有什么意义_java_12


⚡️T3:看看下面代码有没有错误,如果有错误，就修改，看看 total 等于多少 ?

java 变量名 作为字符串使用 java变量名有什么意义_java 变量名 作为字符串使用_13


⚡️答案：

java 变量名 作为字符串使用 java变量名有什么意义_开发语言_14

🍀小结：
(1) 静态方法，只能访问静态成员
(2) 非静态方法，可以访问所有的成员
(3) 在编写代码时，仍然要遵守访问权限规则