Java系列文章目录

---

Write once,Runanywhere.🔥🔥🔥

💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!
💥 💥 💥

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

🚀🚀🚀 新的知识开始喽🚀🚀🚀

---

---

1.static成员

我们来看定义一个学生类：

class Student{
    //成员变量
    public String name;
    public int age;
    public double score;
    //构造方法
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    //成员方法
    public void goclass(){
        System.out.println("去上课");
    }
}
public class Tset {
    Student student0 = new Student("张三", 19,60.0);
    Student student1 = new Student("李四",29,90.0);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

张三的信息：

李四的信息：

张三、李四是同一个班的同学，假设都是2022班的同学，当然我们可以又创建一个变量名为classes的普通成员变量。

通过引用来访问这个成员变量。

不过没实例化一个对象都要创建一个classes，但是他们都是一个班的同学，classes都是一样的，所以能不能把这个公共的classes单独拿出来放在一个块区域让大家共享呢？
在Student类写入一条static修饰的代码，由此引出静态成员变量：
被static修饰的成员变量就是静态成员变量。

static修饰的成员变量不存在任何一个对象里，它是所有对象所共享的，比如：张三、李四都是2022班的学生。
看下面这张图片：

static修饰的成员变量为静态成员变量，静态成员变量最大的特性：不归某个具体的对象所有，而是所有对象所共享的。
静态成员变量的属性：

1. 是类的属性，生命周期：随着类的加载而加载，随着类的销毁而销毁。
2. 不属于某个具体的对象，而是用该所实例化的对象所共有的，不存在某个具体的对象空间里，而是存储在方法区当中。
3. 可以通过引用来访问，但是更加推荐使用类名来访问，因为静态成员对象不依赖对象。

5. final修饰的static成员的值无法修改且必须赋值
   

2.static成员方法

被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

静态成员方法的特性：

1. 不属于某个具体对象，是类的方法。
2. 可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者。
3. 静态方法里没有this引用
3. 不能直接在静态方法中访问任何非静态成员变量，但是可以间接(1.在静态方法里实例化出对象 2.传对象的参数)

1.实例化出对象：

2.传引用参数：

非静态的成员方法里是可以直接访问静态成员和静态成员方法的，因为静态的属性不依赖于对象。

到这里你应该可以理解为什么之前写方法时，都先默认用static修饰了，因为static是类的属性，不需要依赖对象的，可以直接调用，而不需要再先创建对象了。
如果你观察的够仔细的话，你可能会问，为什么main也是用static修饰呢？
具体原因是有JVM的实现者决定的，但是我们可以猜测一点：如果main不用static修饰，那么main方法的调用这需要创建对象，而使用static修饰则不要创建对象而是直接调用main方法。

3.static成员变量初始化

静态成员变量初始化有两种：就地初始化和静态代码块初始化。
注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中的初始化是与对象相关的实例属性。
就地初始化：

3 .1代码块

代码块：由{}括起来的代码称之为代码块。
代码块分为：

1. 普通代码块(本地代码块)
2. 实例代码块(构造代码块)
3. 静态代码块

1.普通代码块
定义在方法中的代码块。
不建议写普通代码块

2.实例代码块
在类的内部，方法的外部。一般用于初始化实例成员变量。

注意：不能去掉{}。

3.静态代码块
在类中用static定义的代码块，用于初始化静态成员变量。

3.2代码块的执行顺序

看下面代码：

class Student{
    //普通成员变量
    public String name;
    public int age;
    public static String classes = "2022班";
   //构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造方法执行了");
    }

    //实例代码块
    {
        this.name = "122";
        this.age = 120;
        System.out.println("实例代码块执行了");
    }

    //静态代码块
    static{
        classes = "2023";
        System.out.println("静态代码块执行了");
    }
    //成员方法
    public void print(){
        System.out.println(this.name+" "+this.age);
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student("csdn",12);
        student.print();

    }
}

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
34
35
36
37

运行结果：

观察运行结果我们发现执行顺序依次是：静态代码块、实例代码块、构造方法。
静态代码块先执行的原因是：static是类属性，在类加载的时候开辟空间并且初始化。
不实例化对象，只访问静态成员变量：

class Student{
    //普通成员变量
    public String name;
    public int age;
    public static String classes = "2022班";
   //构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造方法执行了");
    }

    //实例代码块
    {
        this.name = "122";
        this.age = 120;
        System.out.println("实例代码块执行了");
    }

    //静态代码块
    static{
        classes = "2023";
        System.out.println("静态代码块执行了");
    }
    //成员方法
    public void print(){
        System.out.println(this.name+" "+this.age);
    }
}
public class Test {
    public static void main(String[] args) {
//        Student student = new Student("csdn",12);
//        student.print();
        System.out.println(Student.classes);

    }
}

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
34
35
36
37
38

运行结果：

观察结果我们发现：如果不实例化对象就不会调用实例代码块。
当然静态成员的结果是由静态代码块的执行顺序决定的：

实例化多个对象：

class Student{
    //普通成员变量
    public String name;
    public int age;
    public static String classes = "2022班";
   //构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("构造方法执行了");
    }

    //实例代码块
    {
        this.name = "122";
        this.age = 120;
        System.out.println("实例代码块执行了");
    }

    //静态代码块
    static{
        classes = "2023";
        System.out.println("静态代码块执行了");
    }
    //成员方法
    public void print(){
        System.out.println(this.name+" "+this.age);
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student("csdn",12);
        student.print();
        System.out.println("===========================");
        Student student1 = new Student("133",21);
        student1.print();


    }
}


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
34
35
36
37
38
39
40
41
42

运行结果：

观察结果可知：静态代码块只执行了一次，而实例代码块和构造方法在每次实例化对象的时候都会被执行。
代码块执行顺序总结：

1. 静态代码块先执行(在类加载的时候就开辟空间并且初始化)，不管实例化多少个对象也执行一次，执行的结果看静态的代码书写顺序(如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并)。
2. 如果不实例化对象则实例代码块和构造方法都不会执行。
3. 实例代码块的执行结果也是看实例代码块的书写顺序。
4. 最后执行构造方法

---

🌏🌏🌏今天的你看懂这里又学到了很多东西吧🌏🌏🌏

🌔 🌔 🌔下次见喽🌔 🌔 🌔