详述JavaSE中的static

static的三个作用：

1.static修饰成员变量

2.static修饰成员方法

3.static成员变量初始化

static修饰成员变量 

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

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生 ( 即：随类的加载而创建，随类的卸载而销毁 )

1. 假设三个同学所在一个班级，那么班级这个成员变量就需要用static来定义，只在类加载的时候创建一次，代码如下：

class Student {
    public String name;
    public int age;
    public static String classes = "901班";//假设学生所在班级都是901班

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println("姓名：" + name + " " + "年龄：" + age + " " + "班级：" + classes);
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",18);
        Student stu2 = new Student("李四",19);
        Student stu3 = new Student("王五",20);
        stu1.show();
        stu2.show();
        stu3.show();
    }
}

 2.静态成员变量可以通过类访问，也可以通过对象来访问，但是建议用类来访问

class Student {
    public String name;
    public int age;
    public static String classes = "901班";//假设学生所在班级都是901班

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println("姓名：" + name + " " + "年龄：" + age + " " + "班级：" + classes);
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",18);
        Student stu2 = new Student("李四",19);
        Student stu3 = new Student("王五",20);
        System.out.println(stu1.classes);
        System.out.println(stu2.classes);
        System.out.println(stu3.classes);//通过对象来访问静态成员变量
        System.out.println(Student.classes);//通过类来访问成员变量
    }
}

 通过编译结果可知，类和对象访问静态成员变量都可以，但是为了理解静态成员变量属于类对象，通常建议用类来访问

3. 当用户没有创建对象时，静态成员变量也会被执行，因为静态成员变量随类的加载而创建，不依赖对象

class Student {
    public String name;
    public int age;
    public static String classes = "901班";//假设学生所在班级都是901班
}

public class Test {
    public static void main(String[] args) {
        Student stu = null;//stu这个引用不指向任何对象
        System.out.println(Student.classes);//通过类来访问成员变量
    }
}

 我们定义了一个stu对象不指向任何对象，用类来访问静态成员变量，此时依然编译成功，充分证明了静态成员变量属于类对象，不依赖对象，即使没有对象也可以通过类来进行访问

static修饰成员方法

static修饰成员方法同static修饰成员变量一样，这里的成员方法也是属于类的方法，是所有类共有的，静态成员一般通过静态方法来访问

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名 . 静态方法名 (...) 方式调用，更推荐使用后者

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

1. 访问静态成员方法 

class Student {
    public String name;
    public int age;
    public static String classes = "901班";//假设学生所在班级都是901班

    public static String getClasses(){
        return classes;
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        System.out.println(stu.getClasses());//通过对象来访问静态成员方法
        System.out.println(Student.getClasses());//通过类来访问静态成员方法
    }
}

 编译结果可知，类名和对象都可以访问静态成员方法，但是我们更推荐用类名来进行访问

2. 不能在静态成员方法中访问非静态成员变量和非静态成员方法

 当在静态方法getClasses中，访问非静态的方法show以及非静态的成员变量name都会报错

static成员变量初始化

static成员变量初始化分为两种：就地初始化和静态代码块初始化

1. 就地初始化

上面的示例中我们定义的public static String classes = "901班"  就是一种就地初始化，在定义成员变量的时候直接给变量赋值

2. 静态代码块初始化

代码块的分类：

普通代码块      //较为简单不做赘述，就是定义在方法内的代码块

构造块

静态块

同步代码块（后续讲解多线程部分再谈）

构造块

定义在类中的代码块，就是构造方法时定义出来的代码块，用于初始化成员变量，也称为实例代码块

 

 静态代码块

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

 3. 代码块的执行顺序

class Student {
    public String name;
    public int age;
    public static String classes;//假设学生所在班级都是901班

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

    static{
        classes = "901班";
        System.out.println("静态代码块执行");
    }

    public Student(){
        System.out.println("普通代码块执行");
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student();
        System.out.println("==================");
        Student stu2 = new Student();
    }
}

这里我们实例化了两次对象，第一次执行顺序是静态代码块->实例代码块->普通代码块，因为静态成员方法在类加载的时候就创建，所有优先级最高，由于静态代码块只执行一次，所以第二次实例化对象时，静态代码块不再执行 

故我们可以在示例代码块中完成对静态成员变量的初始化