单例模式(singleton)与static

单例（singleton）模式，本质上，就是给一个静态变量赋值，而静态变量在程序的整个内存空间有且仅有1个副本，并且是对外可见的；所以其他的class都可以调用这个副本。
比如下面，在任何地方调用：S10.getInstance() 都会得到同一个S10

方法一

public class S10{

     private SingletonLazy() {

     }
        public static S10 getInstance(){
            return GetS10.instance;
        }
       static class GetS10{
            private static S10 instance=new S10();
        }
    }

方法二

public class S10{
 public static S10 mS10=new S10()
private SingletonLazy() {

    }
 public static S10  getInstance(){
      return mS10
     }
   }

方法三，多线程并发时，容易创建多个不同对象；当然最后一个对象会覆盖前面的

public class S10{
  public static S10 mS10=null;
  private SingletonLazy() {

   }
   public static S10  getInstance(){
         if(mS10==null){
            mS10=new S10()
          }
        return mS10
      }
    }

下面详细说一下static及相关的执行顺序

先看下这个例子，代码逻辑：在main里面，调用s1和s2

public class A1 {
    A1(){
        System.out.printf("\n 构造函数");
        System.out.printf("\n 构造函数 "+str1);
    }

    public static String strStatic1="\n静态成员变量1";
    public  String str1="   000";

    public static void main(String[] str){
        System.out.printf("\n 开始执行main");
//        System.out.printf(strStatic1);
//        System.out.println(str1);
//        s1();
//        new A1().s1();
        s2();

        A1 aaa1=null;
        System.out.printf("\n 第1次new A");
        aaa1=new A1();
        aaa1.s1();

        System.out.printf("\n----------");


        System.out.printf("\n 第2次new 1");
        A1 aaa2=null;
        System.out.printf("\n 第2次new 2");
        aaa2=new A1();
        System.out.printf("\n 第2次new 3");
        aaa2.s1();

        System.out.printf("\n 分割线----------");
        S8 ss=null;
        System.out.println(S8.sss8);
        S9 ss9=null;
    }

    public void s1(){
        System.out.println("\n 开始执行s1");
        String str="\n s1 局部变量";
        System.out.printf(str);
        System.out.printf(str1);

    }
    public static void s2(){
        System.out.println("\n 开始执行s2");
//        String strStatic="";
//        String strStatic1=strStatic1;
        String strStatic="\n s2 局部变量";
        System.out.printf(strStatic);
    }

    static class S8 {
        public static String sss8="\n 静态变量sss8";
        {

            System.out.println("\n静态类S8 普通代码块");
        }
        static {
            System.out.println("\n静态类S8 静态代码块");
        }
    }
    class S9 {
        {
            System.out.println("普通类S9 普通代码块");
        }
        public String sss8="\n 普通变量sss9";
    }

    {
        System.out.println("\n 普通代码块 "+str1);
        str1="  001";
        System.out.println("\n 普通代码块 "+str1);
    }

    static {
        System.out.println("\n 静态代码块");
    }

}

//日志 如下

静态代码块

开始执行main
开始执行s2
s2 局部变量

第1次new A
普通代码块    000
普通代码块   001
构造函数
构造函数   001
开始执行s1
s1 局部变量  001

----------

第2次new 1
第2次new 2
普通代码块    000
普通代码块   001
构造函数
构造函数   001
第2次new 3
开始执行s1
s1 局部变量  001

分割线----------
静态类S8 静态代码块
静态变量sss8

可以看到：
1、静态代码块是在main执行之前执行，并且只执行了这一次。
2、初始化，必然会先执行普通代码块，然后才是构造函数
3，new 100次，就会执行100次普通代码块，与构造函数
4，定义一个类的变量，并不会执行这个类里面的任何代码块
5, 调用内部类的静态成员变量，会先执行静态代码块
6、定义一个内部类的变量，不会执行其任何代码块
7、非静态内部类不能存在静态成员变量，和静态成员方法

我们稍微描述一下，一些相关的变量有什么意思。
一、静态方法
⚠️一个类里面的静态方法，不能访问非静态成员变量和非静态成员方法，只能访问静态成员变量和静态成员方法
在static方法中，没有this这个概念。
1、静态方法里面不能调用this，如下面S1的写法是错误的，S2才是正确的

public  String str="string 1";
//
public static void s1(){
        String str=this.str;
}
public void s2(){
        String str=this.str;
}

二、静态变量
静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
静态成员变量初始化的顺序：按照定义的顺序，顺序初始化
三、静态代码块
全局，不管new多少次，只会初始化1次

四、普通代码块
全局，new 多少次，就会初始化多少次

五、默认构造函数
只是一个普通的function，new 一个Class，它会执行在普通代码块之后

拓展：