static关键字

static是一个声明程序结构的关键字，可用于全局属性和全局方法的声明，主要特点是避免对象实例化的限制（变成公共属性），在没有实例化对象的时候可以直接进行此结构的访问（即使用static后，该数据不再属于对象自己，而是属于类）。

static修饰成员变量（静态变量）

static修饰成员变量后，该对象属于类，而不属于自己。

static修饰成员方法（静态方法）

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是于类的。
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
无论是成员变量，还是成员方法。如果有了static,都推荐使用类名称进行调用。
静态变量。类名称.静态变量
静态方法:类名称.静态方法()
注意事项:
1.静态不能直接访问非静态。
原因:因为在内存当中是[先]有的静态内容，[后] 有的非静态内容。
“先人不知道后人，但是后人知道先人。”
2.静态方法当中不能用this。
原因: this代表当前对象，通过谁调用的方法，谁就是当前对象。
（详情见代码和注释）

学生类

public class Student {
    private int id;
    private String name;
    private int age;
    //static修饰成员变量
    private static int idCounter=0;
    static String room;

    public Student(){
        this.id=++idCounter;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

方法类

import java.sql.SQLOutput;

public class DemoMethod {

    private int num;
    private static String SL;

    public void method(){
        System.out.println("这是成员方法。");
        //成员方法可以访问成员变量
        System.out.println(num);
        //成员方法可以访问静态变量
        System.out.println(SL);
    }
    public static void staticMethod(){
        System.out.println("这是静态方法。");
        //静态方法不可以访问非静态
        //System.out.println(num);
        //静态方法可以访问静态变量
        System.out.println(SL);
    }
}

主函数

public class DemoStaticField {
    public static void main(String[] args) {
        Student st1=new Student("黄蓉",25);
        Student st2=new Student("郭靖",28);
       /*room通过static修饰，可以直接通过类进行调用，也可以通过对象经行调用，
        但在执行是，会被翻译成通过类经行调用*/
        Student.room="竹五523";

        System.out.println("学号"+st1.getId()+"姓名："+st1.getName()+
                "; 年龄："+st1.getAge()+"; 教室："+Student.room);
        System.out.println("学号"+st2.getId()+"姓名："+st2.getName()+
                "; 年龄："+st2.getAge()+"; 教室："+Student.room);


        //创建一个对象
        DemoMethod obj=new DemoMethod();

        //成员方法只能通过对象进行调用
        obj.method();

        //对静态方法来说，可以通过对象进行调用，也可以通过类直接调用
        obj.staticMethod();//通过对象进行调用，不推荐
        DemoMethod.staticMethod();//通过类直接调用，推荐，
                                 //不会混淆成员方法和静态方法
    }

}package Chapter3;

public class DemoStaticField {
    public static void main(String[] args) {
        Student one=new Student("郭靖",20);
         Student two=new Student("黄蓉",18);
       /*room通过static修饰，可以直接通过类进行调用，也可以通过对象经行调用，
        但在执行是，会被翻译成通过类经行调用*/
        Student.room="101教室";

        System.out.println("学号"+two.getId()+"姓名："+two.getName()+
                "; 年龄："+two.getAge()+"; 教室："+Student.room);
        System.out.println("学号"+one.getId()+"姓名："+one.getName()+
                "; 年龄："+one.getAge()+"; 教室："+Student.room);


        //创建一个对象
        DemoMethod obj=new DemoMethod();

        //成员方法只能通过对象进行调用
        obj.method();

        //对静态方法来说，可以通过对象进行调用，也可以通过类直接调用
        obj.staticMethod();//通过对象进行调用，不推荐
        DemoMethod.staticMethod();//通过类直接调用，推荐，不会混淆成员方法和静态方法
    }

}

结果：

static 内存图

静态代码块

静态代码块的格式是:
public class 类名称{
static {
// 静态代码块的内容
}
}
特点:当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
静态代码块的典型用途:
用来一次性地对静态成员变量进行赋值。

代码示例：
静态代码块：

public class DemoStaticCodeBlock {
  //静态代码块
    static {
        System.out.println("这是静态代码块");
    }
    public DemoStaticCodeBlock(){
        System.out.println("构造方法执行");
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        DemoStaticCodeBlock ome=new DemoStaticCodeBlock();
        System.out.println("===============================");
        DemoStaticCodeBlock two=new DemoStaticCodeBlock();
    }
}

结果：