软件常用设计模式（学习自用）

软件常用设计模式（学习自用）

学习资源：https://blog.youkuaiyun.com/wlddhj/article/details/131071730

单例模式

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。

懒汉式

线程不安全的懒汉式单例模式：

public class SingletonUnsafe {//线程不安全版
    private static SingletonUnsafe unsafe;
    private SingletonUnsafe(){};
    public static SingletonUnsafe getUnsafe(){
        if(unsafe==null){
            return new SingletonUnsafe();
        }
        return unsafe;
    }

    public static void main(String[] args){
        SingletonUnsafe u1=SingletonUnsafe.getUnsafe();
        SingletonUnsafe u2=SingletonUnsafe.getUnsafe();
        System.out.println(u1==u2);//输出false
    }
}

线程安全的懒汉式单例模式，使用了同步代码块synchronized保证并发安全

public class SingletonSafelazy {
    private static SingletonSafelazy instance;//比较完美的单例模式，懒汉式，使用同步代码块解决线程安全问题
    private SingletonSafelazy(){};
    public static synchronized SingletonSafelazy getInstance(){
        //synchronized的作用是保证在同一时刻， 被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果
        if(instance==null){
            synchronized (SingletonSafelazy.class){
                if(instance==null){
                    instance=new SingletonSafelazy();
                }
            }
        }   
        return instance;
    }

    public static void main(String[] args){
        SingletonSafelazy sl1 = SingletonSafelazy.getInstance();//调用方法每次获取的都是同一个对象
        SingletonSafelazy sl2= SingletonSafelazy.getInstance();
        System.out.println(sl1== sl2);//输出true
    }
}

通过内部静态类实现线程安全的懒汉式

public class SingletonStatic {//通过内部静态类来实现懒汉式线程安全同等效果
    private SingletonStatic(){};
    private static class SingletonStaticHolder{
        private static final SingletonStatic instance=new SingletonStatic();
    }
    public static SingletonStatic getInstance(){
        return SingletonStaticHolder.instance;
    }

    public static void main(String[] args){
        SingletonStatic s1=SingletonStatic.getInstance();
        SingletonStatic s2=SingletonStatic.getInstance();
        System.out.println(s1==s2);//输出true
    }
}

饿汉式

饿汉式在类加载时就创建对象

public class SingletonHungry {//单例模式，饿汉式，类加载时对象就创建好了
    private static SingletonHungry instance=new SingletonHungry();
    private SingletonHungry(){};
    public static SingletonHungry getInstance(){
        return instance;
    }

    public static void main(String[] args){
        SingletonHungry sh1=SingletonHungry.getInstance();
        SingletonHungry sh2=SingletonHungry.getInstance();
        System.out.println(sh1==sh2);//输出true
    }
}

枚举

直接创建枚举类

public enum SingletonEnum {//直接创建枚举类
    INSTANCE;
    public void run(){
        System.out.println("枚举");
    }
    public static void main(String[] args){
        SingletonEnum i1=SingletonEnum.INSTANCE;
        SingletonEnum i2=SingletonEnum.INSTANCE;
        System.out.println(i1==i2);//输出true
        i1.run();
    }
}

将现有的类转为枚举类

@Data
public class Student{
    private int StuId;
    private String name;
}

public enum SingletonToEnum {//将现有的Student类转为枚举类
    INSTANCE;
    private Student instance;
    private SingletonToEnum(){
        instance=new Student();
    }
    public Student getInstance(){
        return instance;
    }
    public static void main(String[] args){
        Student ste1=SingletonToEnum.INSTANCE.getInstance();
        Student ste2=SingletonToEnum.INSTANCE.getInstance();
        System.out.println(ste2==ste1);//输出true
    }
}

工厂模式

简单工厂模式

只有一个工厂类来创建不同的类对象，工厂可以根据需求来动态创建不同的对象，但是当类变多后工厂类会变得很臃肿

abstract class SVT {
    public abstract void sign();
}

class Singer extends SVT{
    public void sign(){
        System.out.println("seventeen is right here ----唱队");
    }
}

class Performence extends SVT{
    public void sign(){
        System.out.println("seventeen is right here ----婆队");
    }
}

class Hippop extends SVT{
    public void sign(){
        System.out.println("seventeen is right here ----黑泡队");
    }
}

class SVTFactory{//简单工厂模式
    public static SVT createSVTsquad(String type){
        if(type.equalsIgnoreCase("Singer")){
            return new Singer();
        }else if(type.equalsIgnoreCase("Performence")){
            return new Performence();
        }else if(type.equalsIgnoreCase("Hippop")){
            return new Hippop();
        }else{
            throw new RuntimeException("类型输入错误，傻克拉");
        }
    }

}

public class Main{
    public static void main(String[] args){
        SVT singer=SVTFactory.createSVTsquad("Singer");
        singer.sign();
    }
}

抽象工厂模式

抽象工厂模式会有一个抽象类还有一个抽象工厂类，要创建的对象类要继承那个抽象类，这个对象类的工厂也要继承抽象类工厂，抽象类工厂有一个抽象方法就是创建抽象类的对象。在主函数要创建对象时需要首先创建该对象的工厂类，然后调用工厂类的创建对象方法来创建对象。

abstract class SVT2{
    public abstract void sign();
}

class Singer2 extends SVT2{
    @Override
    public void sign(){
        System.out.println("seventeen is right here ----唱队");
    }
}

class Performence2 extends SVT2{
    @Override
    public void sign() {
        System.out.println("seventeen is right here ----婆队");
    }
}

class Hippop2 extends SVT2{
    @Override
    public void sign(){
        System.out.println("seventeen is right here ----黑泡队");
    }
}

abstract class SVTFactory2{
    public abstract SVT createSquad();
}

class SingerFactory extends SVTFactory2{
    @Override
    public SVT createSquad() {
        return new Singer();
    }
}

class PerformenceFactory extends SVTFactory2{
    @Override
    public SVT createSquad() {
        return new Performence();
    }
}

class HippopFactory extends SVTFactory2{
    @Override
    public SVT createSquad() {
        return new Hippop();
    }
}

public class AbstractFactoryMain {//抽象工厂模式
    public static void main(String[] args){
        SVTFactory2 singerfactory=new SingerFactory();
        SVT singer=singerfactory.createSquad();
        singer.sign();
    }
}