# design_pattern_23

**Repository Path**: yunwolf/design_pattern_23

## Basic Information

- **Project Name**: design_pattern_23
- **Description**: 23种设计模式
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-06-28
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 23种设计模式

## 单例模式

### 懒汉式1
```java

package com.yulang.design_pattern_23.singleton;

public class LazySingleton {

    private volatile static LazySingleton instance;

    private LazySingleton(){}

    /**
     * 采用double check的方式保证多线程下的单例模式可用
     * 但是改方式仍然存在空指针的问题(指令重排引起的所以要加volatile防止指令重排序)
     * @return
     */
    public static LazySingleton getInstance(){
        if(instance == null){
            synchronized (LazySingleton.class){
                if(instance==null){
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }


    public static void main(String[] args) {
        System.out.println(LazySingleton.getInstance().equals(LazySingleton.getInstance()));
    }


}

```

### 懒汉式2

```java
package com.yulang.design_pattern_23.singleton;

/**
 * 静态内部类的方式实现
 */
public class InnerClassSingleton {

    private InnerClassSingleton(){};

    public static InnerClassSingleton getInstance(){
        return InnserClassHolder.instance;
    }

    private static class InnserClassHolder{
        private static final InnerClassSingleton instance = new InnerClassSingleton();
    }

}

```

### 饿汉式

```java
package com.yulang.design_pattern_23.singleton;

/**
 * 饿汉式
 */
public class HungrySingleton {

    private static HungrySingleton instance = new HungrySingleton();

    private HungrySingleton(){};

    public static HungrySingleton getInstance(){
        return instance;
    }
}
```

### 枚举类型单例

```java
package com.yulang.design_pattern_23.singleton;

/**
 * 枚举类型的单例是线程安全的,且反射也不会存在问题
 */
public enum  EnumSingleton {
    INSTANCE;

    EnumSingleton() {}

    public void print(){
        System.out.println("0000000000000000000");
    }
    public static void main(String[] args) {
        System.out.println(EnumSingleton.INSTANCE == EnumSingleton.INSTANCE);
    }

}
```

```java

/**
     * 反序列化保证只有一个实例 注意需要增加序列化的号,要不反序列化会报错,
     * 枚举类型没有这样的问题
     * @return
     */
    Object readResolve(){
        return EnumSingleton.INSTANCE;
    }
```
## 工厂模式

### 工厂模式