彻底填平Static坑——细节决定成败

2023-02-27

name 成员静态

学习的过程就是填坑的过程，可不要偷懒想着跳过去，你现在跳过去，就相当于给自己挖了一个坑，你迟早会掉进去的，为了避免不掉坑，所以，努力填坑吧!如果没有static会怎样?需求：1、定义Student类姓名、国籍，说话行为多个构造，重载形式体现2、学生的国籍都是确定的国籍可以进行显示初始化复制publi

学习的过程就是填坑的过程，可不要偷懒想着跳过去，你现在跳过去，就相当于给自己挖了一个坑，你迟早会掉进去的，为了避免不掉坑，所以，努力填坑吧!

如果没有static会怎样?

需求：

1、定义Student类

姓名、国籍，说话行为
多个构造，重载形式体现

2、学生的国籍都是确定的

国籍可以进行显示初始化

public class Student { 
    String name;//姓名 
    String country;//国籍 
    public Student(String name, String country) { 
        this.name = name; 
        this.country = country; 
    } 
    public void speak(){ 
        System.out.println("姓名:"+this.name+" "+"国籍:"+this.country); 
    } 
} 
class Test{ 
    public static void main(String[] args) { 
        Student student = new Student("何道昌","中国"); 
        Student student1 = new Student("孙双双","中国"); 
        student.speak(); 
        student1.speak(); 
    } 
} 
 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

运行结果：

姓名:何晶晶国籍:中国

姓名:孙双双国籍:中国

目前存在的问题：

现在我们已知学生都是中国人，现在我们每创建一个学生对象，就要给所有学生的国籍属性赋相同的值，这样造成堆内存空间资源浪费

目前方案：

把“中国”这个数据移动到数据共享区中，共享这个数据给所有的Student对象使用即可

疑问：如何才能把这个数据移动到数据共享区中共享呢?

解决方案：

只需要用static修饰该数据即可

静态的成员变量只会在数据共享区中维护一份，而非静态成员变量的数据会在每个对象中都维护一份

public class Student { 
    String name;//姓名 
    //使用了static修饰country，那么这时候country就是一个共享的数据 
    static String country = "中国";//国籍 
    //构造函数 
    public Student(String name) { 
        this.name = name; 
    } 
     //说话行为 
    public void speak(){ 
        System.out.println("姓名:"+this.name+" "+"国籍:"+country); 
    } 
} 
 
class Test{ 
    public static void main(String[] args) { 
        Student student = new Student("何道昌"); 
        Student student1 = new Student("孙双双"); 
 
        student.speak(); 
        student1.speak(); 
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

运行结果：

姓名:何晶晶国籍:中国

姓名:孙双双国籍:中国

下面我来详细解说static

static(静态修饰符)

1.static修饰静态变量

如果有数据需要被共享给所有对象使用时，那么就可以使用static修饰

静态成员变量的访问方式：

方式一：可以使用对象进行访问

格式：对象.变量名

方式二：可以使用类名进行访问

格式：类名.变量名

注意：

1). 非静态的成员变量只能使用对象进行访问，不能使用类命进行访问

public class Student { 
    String name;//姓名     非静态成员变量 
    //使用了static修饰country，那么这时候country就是一个共享的数据 
    static String country = "中国";//国籍    静态成员变量 
    //构造函数 
    public Student(String name) { 
        this.name = name; 
    } 
     //说话行为 
    public void speak(){ 
        System.out.println("姓名:"+this.name+" "+"国籍:"+country); 
    } 
} 
 
class Test{ 
    public static void main(String[] args) { 
        Student student = new Student("何道昌"); 
 
        System.out.println(student.name);//用对象访问非静态变量<br>        Systen.out.println(student.country);//用对象访问静态变量 
        System.out.println(Student.country);//用类命访问静态变量 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

运行结果：

何道晶中国

中国

2). 千万不要为了方便访问数据而使用static修饰成员变量，只有成员变量的数据真正需要被共享的时候，才使用static修饰

static修饰成员变量的应用场景：如果一个数据需要被所有对象共享使用的时候，用static修饰

2.static修饰成员函数(静态的成员方法)

静态成员函数的访问方式：

方式一：可以使用对象进行访问

格式：对象.静态的函数名

方式二：可以使用类名进行访问

格式：类名.静态的函数名

推荐使用类名直接访问静态的成员

原因：

1.方便

2.节省内存

静态函数要注意的事项：

1.静态函数是可以调用类名或者对象进行调用的，而非静态函数只能使用对象进行调用

2.静态的函数可以访问静态的成员，但是不能直接访问非静态的成员

3.非静态的函数是可以直接访问静态与非静态的成员

4.静态函数不能出现this或者super关键字

public class Student { 
    String name;//姓名     非静态成员变量 
    //使用了static修饰country，那么这时候country就是一个共享的数据 
    static String country = "中国";//国籍    静态成员变量 
    //构造函数 
    public Student(String name) { 
        this.name = name; 
    } 
     //说话行为 
    //静态成员方法 
    public static void speak(){ 
        System.out.println("国籍:"+country); 
    } 
    //学习行为 
    //非静态成员方法 
    public  void study(){ 
        System.out.println(name+"好好学习"); 
    } 
} 
 
class Test{ 
    public static void main(String[] args) { 
        Student student = new Student("何道昌"); 
 
        System.out.println(student.name);//用对象访问非静态变量 
        System.out.println(student.country);//用对象访问静态变量 
        System.out.println(Student.country);//用类命访问静态变量 
 
        student.study();//用对象访问非静态方法 
        student.speak();//用对象访问静态方法 
        Student.speak();//用类名访问静态方法 
    } 
} 
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.

运行结果：

何道晶

中国

何道晶好好学习

国籍:中国

静态的成员变量与非静态的成员变量的区别：

1)、作用上的区别：

1.静态的成员变量的作用是共享一个数据给所有的对象使用

2.非静态的成员变量的作用是描述一类事物的公共属性

2)、数量和存储位置上的区别：

1.静态成员变量是在存储方法区内存中，而且只会存在一份数据

2.非静态的成员变量是存储在堆内存中，有n个对象就有n份数据

3)、生命周期的区别：

1.静态的成员变量数据是随着类的加载而存在，随着类文件的消失而消失

2.非静态的成员变量数据是随着对象的创建而存在，随着对象被垃圾回收器回收而消失

静态函数不能访问非静态的成员?

静态函数只要存在有对象，那么也可以访问非静态的数据，只是不能直接访问。

最后，继续用这个例子穿插一下静态代码块的知识

静态代码块是在Student.class文件加载到内存的时候就马上执行的

public class Student { 
    String name;//姓名     非静态成员变量 
    //使用了static修饰country，那么这时候country就是一个共享的数据 
    static String country = "中国";//国籍    静态成员变量 
    //静态代码块 
    static{ 
        System.out.println("静态代码块执行了！！"); 
    } 
    //构造函数 
    public Student(String name) { 
        this.name = name; 
    } 
     //说话行为 
    //静态成员方法 
    public static void speak(){ 
        System.out.println("国籍:"+country); 
    } 
    //学习行为 
    //非静态成员方法 
    public  void study(){ 
        System.out.println(name+"好好学习"); 
    } 
} 
 
class Test{ 
    public static void main(String[] args) { 
        Student.speak(); 
    } 
} 
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.