设计模式（单利和工厂）

设计模式

工厂模式

定义一个工厂类 其他的类用的时候直接调用这个工厂类 不需要再去自己new一个

public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
}

单利模式

分为懒汉式和饿汉式 还有一个静态内部类
饿汉式 该模式在被类加载的时候就会实例化一个对象

单利模式都是线程不安的

//饿汉式  单利
public class hungry {
    //上来就会把这些对象存在内存 但是现在还没有被使用这些对象
    private byte[] date1 = new byte[1024 *1024];
    private byte[] date2 = new byte[1024 *1024];
    private byte[] date3 = new byte[1024 *1024];
    private byte[] date4 = new byte[1024 *1024];

    private hungry(){}

    private static final hungry HUNGRY = new hungry();

    public static hungry getInstance(){
        return HUNGRY;
    }

}

懒汉式 就是用到的对象的时候才会生成一个单例对象
双重检测懒汉式锁 也叫DCL

//懒汉式 单利
public class LazyMn {

    private LazyMn() {
        System.out.println(Thread.currentThread().getName()+"ok");
    }

    private volatile static LazyMn lazyMn;

    public static LazyMn getInstance() {

        if (lazyMn==null){
            synchronized (LazyMn.class){
                if (lazyMn == null) {
                    lazyMn = new LazyMn();
                }
            }
        }

        return lazyMn;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMn.getInstance();
            }).start();
        }
    }

}

静态内部类

// 静态内部类 单利
public class Holder {

    private Holder(){

    }

    private static Holder getInstance(){
        return InnerClass.HOLDER;
    }

    private static class InnerClass{
        private static final Holder HOLDER = new Holder();
    }

}

三重锁 通过反射破坏单利

//懒汉式 单利
public class LazyMn {

    private LazyMn() {
        if (lazyMn!=null){
            throw new RuntimeException("不要来破坏我的单利");
        }
    }

    private volatile static LazyMn lazyMn;

    public static LazyMn getInstance() {

        if (lazyMn==null){
            synchronized (LazyMn.class){
                if (lazyMn == null) {
                    lazyMn = new LazyMn();
                }
            }
        }

        return lazyMn;
    }

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        LazyMn lazyMn = LazyMn.getInstance();
        Constructor<LazyMn> lazyMnConstructor = LazyMn.class.getDeclaredConstructor(null);
        lazyMnConstructor.setAccessible(true);
        LazyMn lazyMn1 = lazyMnConstructor.newInstance();

        System.out.println(lazyMn);
        System.out.println(lazyMn1);
    }

两种创建对象都是用的反射

通过定义一个标识符来判断是否创建对象
如果通过逆向编译来改变标识符 就可以通过枚举来解决 枚举是不能通过反射来改变的

//懒汉式 单利
public class LazyMn {
    private static boolean btp = false;
    private LazyMn() {
        if (btp == false){
            btp = true;
        }else {
            throw new RuntimeException("不要来破坏我的单利");
        }

    }

    private volatile static LazyMn lazyMn;

    public static LazyMn getInstance() {

        if (lazyMn==null){
            synchronized (LazyMn.class){
                if (lazyMn == null) {
                    lazyMn = new LazyMn();
                }
            }
        }

        return lazyMn;
    }

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//        LazyMn lazyMn = LazyMn.getInstance();
        Constructor<LazyMn> lazyMnConstructor = LazyMn.class.getDeclaredConstructor(null);
        lazyMnConstructor.setAccessible(true);
        LazyMn lazyMn = lazyMnConstructor.newInstance();
        LazyMn lazyMn1 = lazyMnConstructor.newInstance();

        System.out.println(lazyMn);
        System.out.println(lazyMn1);
    }

}