本文已参与「新人创作礼」活动，一起开启掘金创作之路。

static关键字: 在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

代码块： 使用{} 定义的一段代码称为代码块。

一、static关键字

---

在Java中static关键字有四种应用场景。

1、static成员变量

static修饰的成员变量，称为静态成员变量。

静态成员变量的特性：

• 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。（==这是最重要的特性==）
• 一般推荐使用类名进行访问。也可以通过对象访问。
• 伴随着类的加载而创建，卸载而销毁。与类共存亡。

静态成员变量可以通过类名访问到

package com.csdn.animal1; //类和对象(二)中有介绍

public class Dog{
    //狗的属性
    private String name;//狗的名字
    public String color;//狗的颜色
    public String sex;//狗的性别
    String breed;//狗的品种
    private static String master = "野原新之助";//狗的主人

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

也可以通过对象进行访问，但是master是共享的

public class Dog{
    //狗的属性
    private String name;//狗的名字
    public String color;//狗的颜色
    public String sex;//狗的性别
    String breed;//狗的品种
    private static String master = "野原新之助";//狗的主人
    
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        Dog dog2 = new Dog();
        Dog dog3 = new Dog();

        System.out.println(dog1.master);
        System.out.println(dog2.master);
        System.out.println(dog3.master);
    }
}

2、static修饰成员方法

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。

class Dogs {
    //狗的属性
    private String name;//狗的名字
    private String color;//狗的颜色
    private String sex;//狗的性别
    private String breed;//狗的品种
    private static String master = "野原新之助";//狗的主人
}

public class Dog{
    public static void main(String[] args) {
        System.out.println(Dogs.master);
    }
}

静态成员一般是通过静态方法来访问的。

class Dogs {
    //狗的属性
    private String name;//狗的名字
    private String color;//狗的颜色
    private String sex;//狗的性别
    private String breed;//狗的品种
    private static String master = "野原新之助";//狗的主人

    public static String getMaster() { //加入静态方法访问静态成员变量
        return master;
    }
}

public class Dog{
    public static void main(String[] args) {
        System.out.println(Dogs.getMaster());
    }
}

静态方法的特性：

• 不属于某个具体的对象，是类方法。
• 可以通过对象调用，也可以通过 “类名.静态方法名(...)” 方式调用，更加推荐后者。
• 静态方法没有隐藏的this引用参数，因此静态方法不能访问任何非静态成员变量。
• 静态方法不能调用非静态方法，因为非静态方法中有this参数。
• 静态方法无法进行重写，不能用来实现多态。

	//没有隐藏的this引用参数
    public static String getMaster() {
        System.out.println(this);
        return master;
    }

//不能在静态方法中访问非静态成员变量
class Dogs {
    //狗的属性
    private static String name;//狗的名字
    private String color;//狗的颜色
    private static String master = "野原新之助";//狗的主人

    public static String getMaster() {
        //color = "白色"; //报错
        name = "小白";
        System.out.println(name);
        return master;
    }
}

public class Dog{
    public static void main(String[] args) {
        System.out.println(Dogs.getMaster());
    }
}

3、static成员变量初始化

静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性

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

3.1 就地初始化

在定义的时候就直接给出了初始值。

//不能在静态方法中访问非静态成员变量
class Dogs {
    //狗的属性
    private static String name;//狗的名字
    private String color;//狗的颜色
    private static String master = "野原新之助";//狗的主人
}

3.2 静态代码块初始化

class Dogs {
    //狗的属性
    private static String name;//狗的名字
    private String color;//狗的颜色
    private String sex;//狗的性别
    private String breed;//狗的品种
    private static String master;//狗的主人
    
    static {
        master = "野原新之助";  //静态代码块初始化
    }
    
    public static String getMaster() {
        return master;
    }
}

二、代码块

---

使用{}定义的一段代码称为代码块。可以分为以下四类：普通代码块、构造块、静态块、同步代码块（多线程部分）。

1、普通代码块

定义在方法内的代码块，较少这样使用。

public class Test {
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println(a);
        }
        int b = 100;
        System.out.println(b);

    }
}

2、构造代码块

定义在类中的（不加修饰符）代码块，也叫实例代码块。构造代码块一般用于初始化实例成员变量。

class Dogs {
    //狗的属性
    private String name;//狗的名字
    private String color;//狗的颜色
    private String sex;//狗的性别
    private String breed;//狗的品种
    private static String master;//狗的主人

    public Dogs(){
        System.out.println("狗的初始化！");
    }

    {
        this.name = "小白";
        this.color = "白色";
        this.sex = "公";
        this.breed = "中华田园犬";
        System.out.println("构造代码块");
    }

    public void printDog(){
        System.out.println("狗的名字："+name);
        System.out.println("颜色："+color);
        System.out.println("性别："+sex+"");
        System.out.println("品种："+breed);
    }
}

public class Dog{
    public static void main(String[] args) {
        Dogs dog1 = new Dogs();
        dog1.printDog();
    }
}

由上可知，构造代码块会先于构造方法执行。从其字节码文件中可以看出。

3、静态代码块

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

    static {
        master = "野原新之助";  //静态代码块初始化
    }    

• 静态代码块不论生成多少个对象，只会执行一次。

class Dogs {
    //狗的属性
    private String name;//狗的名字
    private String color;//狗的颜色
    private String sex;//狗的性别
    private String breed;//狗的品种
    private static String master;//狗的主人

    public Dogs(){
        System.out.println("狗的初始化！");
    }

    {
        this.name = "小白";
        this.color = "白色";
        this.sex = "公";
        this.breed = "中华田园犬";
        //System.out.println("构造代码块");
    }

    static {
        master = "野原新之助";
        System.out.println("静态代码块");
    }

    public String toString() {
        return "Dogs{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", sex='" + sex + '\'' +
                ", breed='" + breed + '\'' +
                '}';
    }
}

public class Dog{
    public static void main(String[] args) {
        Dogs dog1 = new Dogs();
        Dogs dog2 = new Dogs();
        Dogs dog3 = new Dogs();
        System.out.println(dog1.toString());
    }
}

• 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的。
• 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并，最终放在生成 的<>方法中，该方法在类加载时调用，并且只调用一次。

三、内部类（该部分后续会单独介绍）

---

Java中可以将一个类定义在另一个类或者一个方法里面，这样的类称为内部类。内部类一般包括这四种：静态内部类、匿名内部类、成员内部类和局部内部类。