静态static关键字

java中，static是一个修饰符，用于修饰类的成员方法、类的成员变量，还可以修饰代码块。被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

static修饰成员变量

如果一个成员变量使用了static关键字,那么这个变量不再属于自己,而属于所在的类,多个对象共享一份属性。

public class Student {
    private int id;         //学生id
    private String name;    //姓名
    private int age;        //年龄
    static String room;     //所在教室
    private static int idCounter = 0; //创建一个学号计数器,每当新增一名学生, 计数器++
    
    //每当new一个对象,就会调用构造方法,每次调用构造方法,计数器idCounter就 + 1
    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;
    }
}

public class Demo01StaticField {
    public static void main(String[] args) {

        Student one = new Student();    

        Student two = new Student("蔚",20);      //
        two.room = "三年一班";
        System.out.println("姓名：" + two.getName() + "，年龄：" + two.getAge()
                            + "，所在教室：" + two.room + "，学号：" + two.getId());

        Student three = new Student("爆爆",19);
        System.out.println("姓名：" + one.getName() + "，年龄：" + one.getAge()
                + "，所在教室：" + one.room + "，学号：" + one.getId());

    }
}

静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

static修饰成员方法

一旦使用static修饰成员方法，那么该方法就成为静态方法，静态方法不再属于对象，而是属于类，有多个对象共享。

public class Myclass {
    int num = 10 ;
    static int numStatic = 20;
    //成员方法
    public void method(){
        System.out.println("这是一个普通成员方法");
        System.out.println(num);
        System.out.println(numStatic);  //普通成员方法可以访问非静态变量,也可以访问静态变量
    }

    //静态方法
    public static void methodStatic(){
        System.out.println("这是一个静态成员方法");
        System.out.println(numStatic);
        //   System.out.println(num);  错误，静态方法只能访问静态变量
    }
}

public class Demo03StaticMethod {
    public static void main(String[] args) {
        Myclass.methodStatic();      //不需要创建对象就可以直接通过 类名称.静态方法名 调用
        System.out.println("===========");
        Myclass cla = new Myclass();        //首先创建对象
        //才能使用未被static修饰的成员方法
        cla.method();
        System.out.println("===========");
        cla.methodStatic();      //静态方法也可以通过对象名称.调用
    }
}

注意事项：

1. 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
2. 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。（用于区分静态方法和非静态方法）
   静态变量:类名称.静态变量
   静态方法:类名称.静态方法()
3. 静态不能直接访问非静态。原因:因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
4. 静态方法当中不能用this。
   原因:this代表当前对象,通过谁调用的方法,谁就是当前对象。

静态代码块

静态代码块格式

public class 类名称{
	static{
		静态代码块内容
	}
}

示例

public class Person {

    public Person(){
        System.out.println("构造方法执行");
    }

    //静态代码块
    static{
        System.out.println("静态代码块执行");
    }
}

public class Demo04Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}

特点:
当第一次调用本类时，静态内容总是先于非静态内容，所以静态代码块先与构造方法执行，并且只执行唯一的一次。

用途:
用于一次性的给静态成员变量进行赋值。