static，final的细节应用.7

---

一、static

随着类的加载而存在，被所有的类/成员所共享
可以直接被类或者对象调用，但推荐类名调用

static变量（静态变量/类变量）

可以直接被类或者对象调用，但也要遵守修饰符范围。
普通变量只能被对象调用

static方法

可以直接被类或者对象调用，要遵守修饰符范围，但是静态方法中不能调用普通方法
静态方法只能访问静态变量
普通方法只能被对象调用，但是可以调用静态方法，访问静态变量

二、代码块

随类的加载而隐式调用
创建一个对象时调用的顺序：
父类的静态代码块
子类的静态代码块
父类的代码块
父类构造器
子类的代码块
子类构造器

静态代码块

随类的加载而执行，而且只执行一次。
实例化对象(new)，实例化子类对象，使用类的静态成员（静态属性，静态方法）

非静态代码块

创建对象实例时被调用，创建一个对象就调用一次。
使用静态成员（静态属性，静态方法）时不被调用

三、单例模式

饿汉和懒汉只能创建一个对象

饿汉式

饿汉模式:在类加载时就创建好对象但存在浪费资源可能

package com.hspedu.poly_.polyparameter_;

public class Single_ {
    /*
    饿汉模式:在被调用之前就创建好对象
    1，将构造器私有化
    2，在类的内部直接创建好对象
    3，提供一个公开的static的方法，返回对象
    4，在需要使用的时候直接调用方法
     */
    public static void main(String[] args) {
        GirlFriend instance = GirlFriend.getInstance();
        System.out.println(instance);
    }

}
class GirlFriend{
    private String name;
    private static GirlFriend gf = new GirlFriend("GF");
    private GirlFriend(String name) {
        this.name = name;
    }
    public static GirlFriend getInstance(){
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}

懒汉式

懒汉模式：使用的时候才创建对象但存在线程安全的可能

package com.hspedu.poly_.polyparameter_;

public class Single_0 {
    /*
    懒汉式
    1,将构造器私有化
    2，定义一个静态属性对象
    3，提供一个公开的静态方法，可以返回对象
    4，当调用getInstance()方法时，才返回cat对象
     */
    public static void main(String[] args) {
        Cat instance = Cat.getInstance();
    }
}
class Cat{
    private String name;
    private static Cat cat;
    private Cat(String name) {
        this.name = name;
    }
    public static Cat getInstance(){
        if (cat == null){
            cat = new Cat("cat");
        }
        return cat;
    }
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

四、final

修饰不想被继承的类，不想被重写的方法，常量，不想被修改的局部变量。

final使用细节

Integer，Double,Float,Boolean,String都是final类，不能被继承
final类不能被继承，但是能被实例化
final方法不能被重写，但是能被继承
final不能修饰构造器
final一般和static搭配使用，使类不加载

public class FinalDetail {
    public static void main(String[] args) {
        System.out.println(ABA.i);//输出10//静态代码块被加载
    }
}
class ABA{
    public static  int i = 10;
    static {
        System.out.println("静态代码块被加载");
    }
}

public class FinalDetail {
    public static void main(String[] args) {
        System.out.println(ABA.i);//输出10
    }
}
class ABA{
    public final static int i = 10;
    static {
        System.out.println("静态代码块被加载");
    }
}