23种设计模式 no.1

1.单例模式

• 饿汉式—线程安全

package com.example.demo.singleton;

/**
 * 饿汉式
 * 类加载到内存后，就实列化一个单例，JVM保证线程安全
 * 简单使用，推荐使用！
 * 唯一缺点：不管用到与否，类加载时就完成实列化
 */
public class Singleton01 {

    private static final Singleton01 INSTANCE=new Singleton01();

    private Singleton01(){};

    public static Singleton01 getINSTANCE(){
        return INSTANCE;
    }

    public static void main(String[] args){
        Singleton01 singleton01=Singleton01.getINSTANCE();
        Singleton01 singleton02=Singleton01.getINSTANCE();
        System.out.println(singleton01==singleton02);
    }


}

打印ture

• 懒汉式—线程不安全的写法

package com.example.demo.singleton;

/**
 * 懒汉式
 * 等到要用得时候在加载到内存
 * 虽然达到了按需初始化目的，单带来了线程不安全的问题
 */
public class Singleton02 {

    private static Singleton02 INSTANCE;

    private Singleton02(){

    }

    public static Singleton02 getInstance(){
        if (INSTANCE==null){
            INSTANCE=new Singleton02();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {

        Singleton02 singleton01=Singleton02.getInstance();
        Singleton02 singleton02=Singleton02.getInstance();
        System.out.println(singleton01==singleton02);
        
        }
    }

}

打印ture

• 懒汉式—模拟上面线程不安全的写法

package com.example.demo.singleton;

/**
 * 懒汉式
 * 等到要用得时候在加载到内存
 * 虽然达到了按需初始化目的，单带来了线程不安全的问题
 */
public class Singleton02 {

    private static Singleton02 INSTANCE;

    private Singleton02(){

    }

    public static Singleton02 getInstance(){
        if (INSTANCE==null){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE=new Singleton02();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {

//        Singleton02 singleton01=Singleton02.getInstance();
//        Singleton02 singleton02=Singleton02.getInstance();
//        System.out.println(singleton01==singleton02);
        for (int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(Singleton02.getInstance().hashCode());
            }).start();
        }
    }

}

输出

• 懒汉式—线程安全的科学写法（双重检查）

package com.example.demo.singleton;

/**
 * 懒汉式
 * 等到要用得时候在加载到内存
 * 虽然达到了按需初始化目的，单带来了线程不安全的问题
 */
public class Singleton02 {

    private static Singleton02 INSTANCE;

    private Singleton02(){

    }
    /**
     * 线程安全的完美写法
     * 双重检查
     * @return
     */
    public static Singleton02 getInstance(){

        if (INSTANCE==null){
            synchronized (Singleton02.class){
                if (INSTANCE==null){
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE=new Singleton02();
                }
            }

        }
        return INSTANCE;
    }


    public static void main(String[] args) {
        for (int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(Singleton02.getInstance().hashCode());
            }).start();
        }
    }

}

打印

• 饿汉式-匿名内部类实现方式完美写法之一

package com.example.demo.singleton;

/**
 * 饿汉式
 * 线程安全的匿名内部类
 * JVM保证类只加载一个
 */
public class Singleton03 {

    private Singleton03(){
    }

    private static class Singleton03Holder{
        private final static Singleton03 INSTANCE=new Singleton03();
    }
    public static Singleton03 getInstance(){
        return Singleton03Holder.INSTANCE;
    }
    public static void main(String[] args) {

        for (int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(Singleton03.getInstance().hashCode());
            }).start();
        }
    }
}

打印

• 枚举的写法

package com.example.demo.singleton;

/**
 * 枚举实现
 * 解决线程同步，可以防止反序列化
 */
public enum Singleton04 {

    INSTANCE;

    public static void main(String[] args) {
        for (int i=0;i<100;i++){
            new Thread(()->{
                System.out.println(Singleton04.INSTANCE.hashCode());
            }).start();
        }
    }
}

打印：

2.策略模式

如下比如写了一个排序

package com.example.demo.strategy;

import java.util.Arrays;

public class Strategy01 {

    public static void main(String[] args) {
        int []a={4,6,12,3,56,12};
        Sorter sorter=new Sorter();
        sorter.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

Sorter .java

package com.example.demo.strategy;

public class Sorter {
    public void sort(int[] a) {
        for (int i=0;i<a.length-1;i++){
            int minPos=i;
            for (int j=i+1;j<a.length;j++){
                minPos=a[j]<a[minPos]?j:minPos;
            }
            swap(a,i,minPos);
        }
    }

    static void swap(int[] a, int i, int j) {
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

可以正常

但是假如要对double float排序就是重载写多个sort方法，这样显然是不合理的。
对三只猫进行排序：

package com.example.demo.strategy;

import java.util.Arrays;

public class Strategy01 {

    public static void main(String[] args) {
//        int []a={4,6,12,3,56,12};
       Cat []a={new Cat(3,3),new Cat(5,5),new Cat(1,1)};
        Sorter sorter=new Sorter();
        sorter.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

package com.example.demo.strategy;

public class Sorter {
    public void sort(Cat[] a) {
        for (int i=0;i<a.length-1;i++){
            int minPos=i;
            for (int j=i+1;j<a.length;j++){
                minPos=a[j].compareTo(a[minPos])==-1?j:minPos;
            }
            swap(a,i,minPos);
        }
    }

    static void swap(Cat[] a, int i, int j) {
        Cat temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

package com.example.demo.strategy;

public class Cat {
    int weight,height;
    public Cat(int weight,int height){
        this.weight=weight;
        this.height=height;
    }
    public int compareTo(Cat cat){
        if (this.weight<cat.weight) return -1;
        else if (this.weight>cat.weight) return 1;
        else return 0;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "weight=" + weight +
                ", height=" + height +
                '}';
    }
}

打印：

3.工厂模式

• 任意定制出行工具

main

package com.example.demo.factory;

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

        People people=new Car();
        people.travel();

        People people1=new Flying();
        people1.travel();
    }
}

package com.example.demo.factory;

public class Car implements People{

    public void travel(){
        System.out.println("Car...");
    }
}

package com.example.demo.factory;

public class Flying implements People{

    public void  travel(){
        System.out.println("Fly.....");
    }
}

package com.example.demo.factory;

public interface People {

    void travel();
}

打印：

• 任意定义生产过程

package com.example.demo.factory;

public class CarFactory {

    public Car createCar(){
        return new Car();
    }
}

package com.example.demo.factory;

public interface People {

    void travel();
}

package com.example.demo.factory;

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

//        People people=new Car();
//        people.travel();
//
//        People people1=new Flying();
//        people1.travel();

        People people2=new CarFactory().createCar();
        people2.travel();
    }
}

打印：

• 任意定制产品一族

4.调停者模式

5.门面模式

6.装饰模式

7.责任链模式