static相关知识点详解

文章目录

• [一. 修饰成员变量](#一. 修饰成员变量)
• [二. 修饰成员方法](#二. 修饰成员方法)
• [三. 修饰代码块](#三. 修饰代码块)
• [四. 修饰类](#四. 修饰类)

一. 修饰成员变量

static 修饰的成员变量，称为静态成员变量，该变量不属于某个具体的对象，是所有对象所共享的。

public class Student {
    private String name;
    private static String classRoom="106";

    public static void main(String[] args) {
        // 方法一：静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);

        //方法二：静态成员变量也可以通过对象访问,但是classRoom是三个对象共享的
        Student s1=new Student();
        Student s2=new Student();
        Student s3=new Student();
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);

    }
}

由以上代码可知：

【静态成员变量特性】:

1. **不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。
2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问。
3. 类变量存储在方法区当中。
4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)。

二. 修饰成员方法

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

public class Student {
    private String name;
    private static String classRoom="106";

    public static String getClassRoom(){
        return classRoom;
    }
}
class TestStudent{
    public static void main(String[] args) {
        Student s1=new Student();
        System.out.println(Student.getClassRoom());

    }
}

由以上代码可知：

【静态方法特性】:

1. 不属于某个具体的对象，是类方法。
2. 可以通过对象调用，也可以通过**类名.静态方法名(...)**方式调用，更推荐使用后者。

3. 不能在静态方法中访问任何非静态成员变量

4. 静态方法中不能调用任何非静态方法。
5. 静态方法无法重写，无法实现多态。

三. 修饰代码块

静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性。那么静态成员变量该如何实现初始化呢？

1. 就地初始化：在定义时直接给出初始值

private static String classRoom="106";

2. 静态代码块初始化

使用 static 定义的代码块称为静态代码块。一般用于初始化静态成员变量。

public class Student {
    private String name;
    private static String classRoom;

    static {
        classRoom="106";
    }

    public static void main(String[] args) {
        System.out.println(Student.classRoom);
    }
}

这里有几点需要注意：

• 静态代码块不管生成多少个对象，其只会执行一次。
• 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的。
• 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)实例代码块只有在创建对象时才会执行。

四. 修饰类

被 static 修饰的内部成员类称为静态内部类。

public class OutClass {
    private int a;
    private static int b;
    public void methodA(){
        a=10;
        System.out.println(a);
    }
    public static void methodB(){
        System.out.println(b);
    }

    //静态内部类
    static class InnerClass{
        public void methodInner(){

            //a=100;//编译失败，在内部类中只能访问外部类的静态成员变量
            b=200;
            //methodA();//编译失败，因为methodB()不是静态成员方法
            methodB();

        }
    }

    public static void main(String[] args) {
        //静态内部类对象创建
        OutClass.InnerClass innerClass=new OutClass.InnerClass();
        innerClass.methodInner();
    }
}

这里有几点需要注意：

• 在静态内部类中只能访问外部类中的静态成员。
• 创建静态内部类对象时，不需要先创建外部类对象。

如果我们一定要访问外部类中的非静态成员呢？

我们可以通过在静态内部类内创建外部类对象，然后通过该对象去访问。

代码示例如下：

static class InnerClass{
        public void methodInner(){
           OutClass outClass=new OutClass();
           outClass.a=10;
           outClass.methodA();

  		}
}