static关键字

static说明

static: 静态的，使用static修饰的成员称为静态成员、类成员
static修饰的属性称为静态属性，类属性
static修饰的方法称为静态方法，类方法
static不能修饰类，不能修饰方法内的局部变量
静态成员随类加载产生，直至类销毁才回收

看个栗子

设置一个静态属性，分别创建两个对象，并修改其静态属性值

public class Cat {
    // 省略getter和setter
    private String name;// 昵称
    //静态属性
    public static int price; //价格
    
    public static void main(String[] args) {
        Cat one = new Cat();
        //设置属性
        one.setName("花花");
        one.price = 1500;
        Cat two = new Cat();
        two.setName("凡凡");
        //推荐使用类名.静态属性
        Cat.price = 300;
        //访问属性
        System.out.println(one.getName() + "的售价是：" + one.price); //花花的宠物猫的售价是：300
        System.out.println(two.getName() + "的售价是：" + one.price); //凡凡的宠物猫的售价是：300
    }
}

通过上述示例可以看出第二个对象对静态成员的修改也影响了第一个对象。因为静态成员是对象共享的。

静态成员特征

1. 类对象共享
   无论这个类实例化多少个对象，都会共用同一块静态空间
2. 类加载时产生，销毁时释放，生命周期长

静态成员访问方式

1. 对象.静态成员
2. 类名.静态成员(推荐)

静态方法

• 普通成员方法可以调用静态方法及静态属性
• 静态方法中不能直接调用同类中的非静态成员，只能直接调用同类中的静态成员
• 可以通过实例化对象后，对象调用的方式(对象.成员)完成非静态成员调用
• 静态方法中不能使用this

举个栗子

public class Cat {
    private String name;// 昵称
    private int month;// 年龄
    private double weight;// 体重
    private String species;// 品种
    
    public static int price; //价格
    
    //在成员方法中，可以直接访问类中静态成员
    public void run() {
        eat(); //调用静态方法
        this.name="妞妞";
        this.price=20; //调用静态属性
        System.out.println("售价是"+Cat.price+"的"+this.name+"快跑");
    }
    //静态方法中不能直接访问同一个类中的非静态成员，只能直接调用同一个类中的静态成员
    public static void eat() {
        //只能通过对象实例化后，对象.成员方法的方式访问非静态成员
        Cat temp=new Cat();
        temp.run();
        temp.name="小胖";
        price=1500; //直接访问静态成员，不能使用this
        System.out.println("小猫吃鱼");
    }
}

代码块

• 通过{ }可以形成代码块
• 方法内的代码块称为：普通代码块(按顺序执行，先出现，先执行)
• 类内的代码块称为：构造代码块
• static修饰的构造代码块称为：静态代码块

构造代码块

创建对象时调用，优先于构造方法执行
构造代码块也可以有多个，也是按顺序执行的

静态代码块

类加载时调用，优先于构造代码块执行
静态代码块也可以有多个，也是按顺序执行的

二者区别

构造代码块每次实例化对象时都会执行一次，而静态代码块只在类加载时执行一次，无论产生多少类实例。
同时静态代码块和静态方法一样只能直接访问静态成员，而构造代码块则可以直接访问静态成员和普通成员。

举个栗子

各个代码块的执行效果

public class Cat {
    private String name;// 昵称

    //构造方法
    public Cat() {
        System.out.println("构造方法");
    }
    
    {
        System.out.println("构造代码块");
    }
    
    static{
        price = 20; //只能直接访问静态成员，通过对象实例化后，对象.成员方法的方式访问非静态成员
        System.out.println("静态代码块");
    }

    public void run(String name) {
        System.out.println(name + "快跑");
        {
            System.out.println("我是普通代码块");
        }
    }
    //测试
    public static void main(String[] args) {
        Cat one = new Cat();
        //静态代码块 (只执行一次)
        //构造代码块
        //构造方法
        one.run("圆圆");
        //圆圆快跑
        //我是普通代码块
        Cat two = new Cat();
        //构造代码块
        //构造方法
    }
}

代码块作用域

一个代码块就形成了一个作用域，在代码块中定义的变量作用范围只在该代码块区域，当代码块执行完毕，定义的变量也就失效了会被回收。

    //代码块作用域示例
    public void run() {
        {
            int test = 12;
            int temp=12;
            System.out.println("我是普通代码块1，temp="+temp);
        }
        int test = 14; //作用范围是从当前行开始到方法体结束
        //System.out.println(temp);  这里无法访问到temp
        {
            //int test = 13;  不能定义同名变量
            int temp=13;
            System.out.println("我是普通代码块2，temp="+temp);
        }
    }