Java

代码块就相当于构造器的扩容弹匣。

看这篇文章
A:在类加载时只有静态才会分配内存空间，所以我们可以直接用类名来进行访问；
不是静态的话，它得等实例化对象后才会分配内存空间。

就是设计出了一个模版样式，这个模式可以解决一个固定的问题，比如棋谱就是一个设计模式。

就是类的单个的实例的设计模式，它只实例化出一个对象，因为它比较耗用资源。

在静态方法中必须要使用静态的成员，因为静态在类加载中就已经执行了。

如果那个方法不加static呢？那么我要得到那个对象又要创建一个对象，而我们将构造器的访问修饰符设为了private（只能在本类中访问），所以不能在其他类访问了。

package com.test;

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

class GirlFriend {
    private String name;

    private GirlFriend() {
        this.name = name;
    }

    private static GirlFriend gf = new GirlFriend();

    public static GirlFriend getInstanece() {
        return gf;
    }
}

我们重点分析这句：private static GirlFriend gf = new GirlFriend();
1、private是将其封装起来，不让其修改成其他的值，保证其安全性
2、static是保证在不实例化对象的情况下也能使用
3、GirlFriend gf = new GirlFriend()，在类中实例化一个对象，保证其单例设计模式（饿汉式）

A： 因为不管程序员需不需要这个类的实例，它总是在类加载中实例化一个对象出来。
就像一个人一样不管肚子饿不饿总是准备把吃的买好，就一个饿汉一样。

package com.test;

public class Single {
    public static void main(String[] args) {
        System.out.println(Cat.n);
        Cat.getInstance();
    }
}

class Cat {
    private String name;
    private static Cat cat;  // cat对象，指向为空
    public static int n = 666;

    private Cat(String name) {
        System.out.println("==========");
        this.name = name;
    }

    public static Cat getInstance() {
        if (cat == null) {
            cat = new Cat("小白");
        }
        return cat;
    }
}

步骤：

1. 构造器私有化
2. 定义一个static的静态属性对象，指向为默认的null
3. 提供一个public的static方法，让它返回一个Cat对象

A：如果一个对象的使用频率不高，占用了很多内存，这就不适合饿汉式了，这时需要使用一种懒加载的思想，当程序需要对象时才实例化一个。
就像一个懒汉，只有饿到不行了才会去吃东西。

懒汉式的线程安全问题