常用的设计模式

1.单例模式（面试有被问到）

• 单例模式 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
• 单例模式只有一个实例
• 单例类必须自己创建一个唯一的实例
• 单例类必须给所有其他对象提供这一实例

单例模式创建的目的

• 保证一个类仅有一个实例，并提供一个访问它的全局访问点。
• 解决了 一个全局使用的类频繁的创建和销毁
• 想控制实例数目，节省系统资源的时候
• 构造函数是私有的

单例模优缺点

• 优点

• 在内存中只有一个实例，减少了内存的开销，尤其是频繁的床键和销毁实例
• 避免资源的多重占用

• 缺点

• 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎样来实例化。

以下是java实现的单例模式

饿汉单例(线程安全的)

package com.yang.single;
@SuppressWarnings("all")
//饿汉式单例 有可能会浪费内存 因为一上来就会加载对象  static
//单例模式必须构造器私有; 创建对象
public class Hungry {
    private  byte[] data1 = new byte[1024*1024];
    private  byte[] data2 = new byte[1024*1024];
    private  byte[] data3 = new byte[1024*1024];
    private  byte[] data4 = new byte[1024*1024];
    Hungry(){
        System.out.println("1");
    }
    private  final  static Hungry HUNGRY = new Hungry();
    public  static  Hungry getInstance(){
        return HUNGRY;
    }
}

懒汉单例（需要自己加锁）

package com.yang.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

//懒汉式单例 道高一尺魔高一丈
public class Lazeman {

    private  static boolean ymh = false;

    private Lazeman(){
        synchronized (Lazeman.class){
            if(lazeman==null){
                if(ymh == false){
                    ymh = true;
                    System.out.println(Thread.currentThread());
                }else
                throw new RuntimeException("不要试图用反射来破坏异常");
            }
        }
    }
    private volatile static  Lazeman lazeman;
    public static Lazeman getInstance(){
        //双重检测 锁模式 DCL懒汉式
        if(lazeman==null) {
            synchronized (Lazeman.class) {
                if (lazeman == null) {
                    lazeman = new Lazeman();//不是原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 123
                     * 132 A线程 在cpu中可以出现这种操作
                     *     B线程 在A还没进行构造的时候就执行return lazeman操作了
                     */
                }
            }
        }
            return lazeman;//此时这个lazyman 还没有完成构造
    }
    //反射！
    public static void main(String[] args) throws Exception {
//        Lazeman instance  = Lazeman.getInstance();
        Field ymh = Lazeman.class.getDeclaredField("ymh");
        ymh.setAccessible(true);
        Constructor<Lazeman> declaredConstructor = Lazeman.class.getDeclaredConstructor(null);//得到空参构造器
        declaredConstructor.setAccessible(true); //暴力反射;
        Lazeman instance = declaredConstructor.newInstance();
        System.out.println(instance);
        ymh.set(instance,false);
        Lazeman instance2 = declaredConstructor.newInstance();
        System.out.println(instance2);
    }
}

2. 工厂模式

• 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象
• 意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式，使其创建过程延迟到子类进行。
• 主要解决接口选择的问题
• 何时使用： 我们明确地计划不同条件下创建不同实例时
• 关键实现： 创建过程在其子类中执行
• 开闭原则，对于扩展开放，对于修改关闭

工厂模式优缺点

优点

• 一个调用者想创建一个对象，只要知道其名称就可以了。
• 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
• 屏蔽产品的具体实现，调用者只关心产品的接口。

缺点

• 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

实现的代码

• 接口

package com.yang.factory.simple;

public interface Car {
    public void name();
}

• 工厂

package com.yang.factory.simple;
//静态工厂模式
//增加一个新的产品，如果你不修改代码 ，做不到！
//开闭原则 对于扩展开放，对于修改关闭
public class Carfatory {
    // 方法一:
    public  static  Car getCar(String car){
        if(car.equals("wuling")){
            return new wuling();
        }else if (car.equals("tesla")){
            return new tesla();
        }else{
            return null;
        }
    }
    // 方法二
    public static Car getwuling(){
        return new wuling();
    }
    public static Car gettesla(){
        return new tesla();
    }
    public static Car getdazhong(){
        return new dazhong();
    }
}

• 子类

package com.yang.factory.simple;

public class dazhong implements Car{
   @Override
   public void name() {
       System.out.println("dazhong");
   }
}

package com.yang.factory.simple;

import java.util.Date;

public class tesla implements Car {

    @Override
    public void name() {
        Date a = new Date();
        System.out.println(a);
        System.out.println("tesla");
    }
}

package com.yang.factory.simple;

public class wuling implements Car{
    @Override
    public void name() {
        System.out.println("wuling");
    }
}

• 用户类

package com.yang.factory.simple;
//工厂模式
public class Consumer {
   public  static void main(String [] args){
//      接口实现所用的实现类，工厂
//        Car car1 = new wuling();
//        Car car2 = new tesla();
//      2.使用工厂创建
       Car  car1 = Carfatory.getCar("wuling");
       Car  car2 = Carfatory.getCar("tesla");
       car1.name();
       car2.name();
   }
}