1.设计模式-单例

设计模式概述

设计模式：是一套用来提高代码可复用性、可维护、可读性、稳健性以及安全性的解决方案
设计模式的本质：是面向对象设计原则的实际运用，是对类的分装、继承、多态以及类的关联关系和组合关系的充分理解
设计模式的基本要素：模式名称、问题、解决方案、效果

分类

创建型模式：()

OOP七大原则

开闭原则：对扩展开发，对修改关闭（当需求需要改变的时候，尽量去扩展）

**里氏替换原则： **继承必须确保超类所拥有的性质在子类中仍然成立（尽量不重写父类的方法）

**依赖倒置原则： **要面向接口编程，不要面向实现编程

单一职责原则： 控制类的粒度大小，将对象解耦，提高其内聚性（一个对象不应该担任太多的职责，原子性，单一的方法做单一的事情）

接口隔离原则： 要为各个类建立他们需要的专用接口（保证接口的精简和单一）

迪米特法则： 只与你的直接朋友交谈，不跟“陌生人”说话，降低代码之间的耦合度（降低程序间的耦合性）

合成复用原则： 尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现点击查看聚合/合成的解释

用C语言来讲，合成是值的聚合(Aggregation by Value)，聚合是则是引用的聚合(Aggregation by Reference)。
（1）聚合用来表示“拥有”关系或者整体与部分的关系。代表部分的对象有可能会被多个代表整体的对象所共享，而且不一定会随着某个代表整体的对象被销毁或破坏而被销毁或破坏，部分的生命周期可以超越整体。例如，班级和学生，当班级删除后，学生还能存在，学生可以被培训机构引用。
class Student {
}
class Classes{
privateStudent student;
publicClasses(Student student){
this.student=student;
}
}
2）合成用来表示一种强得多的“拥有”关系。在一个合成关系里，部分和整体的生命周期是一样的。一个合成的新对象完全拥有对其组成部分的支配权，包括它们的创建和湮灭等。使用程序语言的术语来说，合成而成的新对象对组成部分的内存分配、内存释放有绝对的责任。
一个合成关系中的成分对象是不能与另一个合成关系共享的。一个成分对象在同一个时间内只能属于一个合成关系。如果一个合成关系湮灭了，那么所有的成分对象要么自己湮灭所有的成分对象（这种情况较为普遍）要么就得将这一责任交给别人（较为罕见）。
例如，一个人由头、四肢和各种器官组成，人与这些具有相同的生命周期，人死了，这些器官也就挂了。房子和房间的关系，当房子没了，房间也不可能独立存在。
class Room{
public Room createRoom(){
System.out.println(“创建房间”);
returnnew Room();
}
}
class House{
private Room room;
public House(){
room=new Room();
}
public void createHouse(){
room.createRoom();
}
}

1.单例模式

核心作用：保证一个类一个jvm只有一个实例，并且提供一个访问该实例的 全局访问点

饿汉式单例:

//饿汉式单例
public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }
    /** Don't let anyone else instantiate this class */
    // 单例模式核心思想：构造器私有
    private Runtime() {}

DCL懒汉式单例模式：

// 懒汉式单例
public class LazyMan {
    private LazyMan() {
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private  volatile static LazyMan lazyMan; // volatile 为了避免指令重排

    // 双重检测锁模式的懒汉式单例  DCL 懒汉式
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();// 不是一个原子性操作
                    /*
                    1、分配内存空间
                    2、执行构造方法，初始化对象
                    3、把这个对象指向这个空间

                    123
                    132 A
                        B // 此时B线程进来会认为lazyman不为null
                          // 直接返回 此时lazyman 还没有完成构造
                          // 为了避免指令重排
                       */
                }
            }
        }

        return lazyMan;
    }
//
//    public static LazyMan getInstance() {
//        if (lazyMan == null) {
//            lazyMan = new LazyMan();
//        }
//        return lazyMan;
//    }

    // 单线程下确实单例ok,但是多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }
    }
}

反射 可以破环这种单例

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

    private static  boolean qinjiang = false;

    private LazyMan() {
        if(qinjiang == false){
            qinjiang=true;
        }else{
            throw new RuntimeException("不要试图使用反射破坏异常");
        }
//        synchronized (LazyMan.class){
//            if (lazyMan!=null){
//                throw new RuntimeException("不要试图使用反射破坏异常");
//            }
//        }
//        System.out.println(Thread.currentThread().getName() + "ok");
    }

    private  volatile static LazyMan lazyMan; // volatile 为了避免指令重排

    // 双重检测锁模式的懒汉式单例  DCL 懒汉式
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            synchronized (LazyMan.class) {
                if (lazyMan == null) {
                    lazyMan = new LazyMan();// 不是一个原子性操作
                    /*
                    1、分配内存空间
                    2、执行构造方法，初始化对象
                    3、把这个对象指向这个空间

                    123
                    132 A
                        B // 此时B线程进来会认为lazyman不为null
                          // 直接返回 此时lazyman 还没有完成构造
                          // 为了避免指令重排
                       */
                }
            }
        }

        return lazyMan;
    }

    // 单线程下确实单例ok,但是多线程并发
    public static void main(String[] args) throws Exception {
        // 反射 可以破环这种单例
//        LazyMan instance = LazyMan.getInstance();
        Field qinjiang = LazyMan.class.getDeclaredField("qinjiang");
        qinjiang.setAccessible(true);


        Constructor<LazyMan> declaredConstructor =LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);//无视私有构造器
        LazyMan  instance=declaredConstructor.newInstance();

        qinjiang.set(instance,false);

        LazyMan  instance2=declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance2);
    }
}

静态内部类

// 静态内部类实现单例模式 不安全
public class Holder {
    private Holder(){

    }

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

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

单例不安全，因为有反射

枚举

// enum 本身也是一个 class 类
public enum  EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(null);
        // 枚举没有无参构造，只有有参构造
        Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        // java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.<init> 没有空参的构造方法
        // java.lang.IllegalArgumentException: Cannot reflectively create enum objects  反射不能破坏枚举的单例
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

枚举没有无参构造，只有有参构造

单例总结：

单例模式中，我们期望的是在一个jvm中只存在一个对象实例，并且提供一个全局访问点
- 1.私有的构造方法，防止被直接new 实例化，
- 2.在类的内部实例化对象
- 3.对外提供一个公共的方法

饿汉式：
项目启动时直接类装载的时候直接实例化对象，这样避免了线程同步的问题，但是其没有打到lazy loading的效果，如果此类一直没有，那就会造成浪费
2.懒汉式：不等于null时再去实例化对象，这样是起到了lazy loading的效果，但是只能单线程使用，多线程，new Singleton() 和 instance = ,是两个步骤，线程1可能先赋值 = 还没new ，然后线程2进来一看instance不是null直接返回，还有可能在if判断是，线程1还未来得及往下执行，另一个线程也通过此判断进入语句，就会有多个实例
3.懒汉式（线程同步）：使用synchronized，同步处理，虽然jdk1.6有了锁升级的过程，偏向锁->有线程竞争就会升级轻量级锁cas自旋8次->不行在升级重量级锁排队，但是每次都去加锁，违背了我们使用初衷，只有第一次使用是才需要实例化，不需要每次实例化
4.双重检查锁：在synchronized方法快外面加ifnull判断，只有第一次才需要实例化，之后就不再是null，不需要加锁实例化了，其也具有lazy loading，加volatile 关键字后避免了指令重排
5.静态内部类：在getinstance()是才去实例化此静态内部类，初始化内部实例对象，此法使用是由jvm类加载机制是线程互斥来保证其 new Singleton()和 = 赋值完毕，返回对象，其也具有lazy loading
6.双重监察所DCL和静态内部类都可以被反射破坏单例，只有枚举不可以，此法避免了线程同步问题，还能防止反序列化重新创建对象：
-因为枚举本身也是个class类，没有无参构造器，只有有参构造，在getDecleardConstuctor().setAccessible(true).newInstance(),在源码中会判断public和枚举类，抛出异常

工厂设计模式

作用：
实现了创建者和调用者的分离
详细分类：
简单工厂模式：用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）
工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品）
抽象工厂模式：围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
工厂设计模式的原则（OOP七大原则）：

开闭原则：一个软件的实体应当对扩展开放，对修改关闭
依赖倒转原则：要针对接口编程，不要针对实现编程
迪米特法则：只与你直接的朋友通信，而避免和陌生人通信
核心本质：

实例化对象不使用new，用工厂方法代替 factory
将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

简单工厂模式（静态工厂模式）

用来生产同一等级结构中的任意产品（对于增加新的产品，需要扩展已有代码）

public interface Car {
    void name();
}

public class WuLing implements Car{

    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

public class Tesla implements Car{

    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

// 静态工厂模式
// 开闭原则
public class CarFactory {

    // 方法一： 不满足开闭原则
    public static Car getCar(String car){
        if(car.equals("wuling")){
            return new WuLing();
        }else if(car.equals("tesila")){
            return new Tesla();
        }else {
            return null;
        }
    }

    // 方法二：
    public static Car geyWuling(){
        return new WuLing();
    }
    public static Car geyTesla(){
        return new Tesla();
    }


}

public class Consumer {
    public static void main(String[] args) {
        // 接口，所有的实现类
        // Car car = new WuLing();
        // Car car1 = new Tesla();

        // 2、使用工厂创建
        Car car = CarFactory.getCar("wuling");
        Car car1 = CarFactory.getCar("tesila");

        car.name();
        car1.name();
    }
}

弊端：

增加一个新的产品，做不到不修改代码。

工厂方法模式：

用来生产同一等级结构中的固定产品（支持增加任意产品）

public interface Car {
    void name();
}

public class WuLing implements Car {

    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

public class Tesla implements Car {

    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}

// 工厂方法模式
public interface CarFactory {
    Car getCar();
}

public class WulingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesla();
    }
}

public class Consumer {
    public static void main(String[] args) {
        Car car = new WulingFactory().getCar();
        Car car1 = new TeslaFactory().getCar();

        car.name();
        car1.name();

        Car car2 = new MoBaiFactory().getCar();
        car2.name();
    }
}

对比简单工厂模式

1、结构复杂度：simple>method

2、代码复杂度：simple>method

3、编程复杂度：simple>method

4、管理上的复杂度：simple>method

根据设计原则，使用工厂方法模式；根据实际业务，使用简单工厂模式

抽象工厂模式：

围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂

定义：

抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定他们的具体的类（针对整个产品族，产品等级数量相对固定的产品族）

适用场景：

客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体实现

// 手机产品接口
public interface IphoneProduct {

    void start();
    void shutdown();
    void callup();
    void sendSMS();
}

// 小米手机
public class XiaomiPhone implements IphoneProduct{
    @Override
    public void start() {
        System.out.println("开启小米手机");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米手机");
    }

    @Override
    public void callup() {
        System.out.println("小米手机打电话");
    }

    @Override
    public void sendSMS() {
        System.out.println("小米手机发短信");
    }
}


// 华为手机
public class HuaweiPhone implements IphoneProduct{
    @Override
    public void start() {
        System.out.println("开启华为手机");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为手机");
    }

    @Override
    public void callup() {
        System.out.println("华为手机打电话");
    }

    @Override
    public void sendSMS() {
        System.out.println("华为手机发短信");
    }
}

// 路由器产品接口
public interface IRouterProduct {

    void start();
    void shutdown();
    void openWifi();
    void setting();
}

// 小米路由器
public class XiaomiRouter implements IRouterProduct{
    @Override
    public void start() {
        System.out.println("启动小米路由器");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭小米路由器");
    }

    @Override
    public void openWifi() {
        System.out.println("打开小米Wi-Fi");
    }

    @Override
    public void setting() {
        System.out.println("小米设置");
    }
}

// 华为路由器
public class HuaweiRouter implements IRouterProduct{
    @Override
    public void start() {
        System.out.println("启动华为路由器");
    }

    @Override
    public void shutdown() {
        System.out.println("关闭华为路由器");
    }

    @Override
    public void openWifi() {
        System.out.println("打开华为Wi-Fi");
    }

    @Override
    public void setting() {
        System.out.println("华为设置");
    }
}

// 抽象产品工厂
public interface IProductFactory {

    // 生产手机
    IphoneProduct iphoneProduct();

    // 生产路由器
    IRouterProduct irouterProduct();

}

public class XiaomiFactory implements IProductFactory{
    @Override
    public IphoneProduct iphoneProduct() {
        return new XiaomiPhone();
    }

    @Override
    public IRouterProduct irouterProduct() {
        return new XiaomiRouter();
    }
}

public class HuaweiFactory implements IProductFactory{
    @Override
    public IphoneProduct iphoneProduct() {
        return new HuaweiPhone();
    }

    @Override
    public IRouterProduct irouterProduct() {
        return new HuaweiRouter();
    }
}

public class Client {
    public static void main(String[] args) {
        System.out.println("小米系列产品--------------------");
        // 小米工厂
        XiaomiFactory xiaomiFactory = new XiaomiFactory();

        IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();
        iphoneProduct.callup();
        iphoneProduct.sendSMS();

        IRouterProduct iRouterProduct = xiaomiFactory.irouterProduct();
        iRouterProduct.openWifi();

        System.out.println("华为系列产品--------------------");
        // 小米工厂
        HuaweiFactory huaweiFactory = new HuaweiFactory();

        iphoneProduct = huaweiFactory.iphoneProduct();
        iphoneProduct.callup();
        iphoneProduct.sendSMS();

        iRouterProduct = huaweiFactory.irouterProduct();
        iRouterProduct.openWifi();
    }
}

优点

具体产品在应用层的代码隔离，无需关心创建的细节

将一个系列的产品统一到一起创建

缺点：

规定了所有可能被创建的产品集合，产品族中扩展新的产品困难；

增加了系统的抽象性和理解难度

工厂模式小结：
简单工厂模式：虽然某种程度上不符合设计原则，但实际使用最多

工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展

抽象工厂模式：不可以增加产品，可以增加产品族

应用场景：

jdk中calendar的getInstance方法
JDBC中的Connection对象的获取
Spring中的IOC容器创建管理bean对象
反射中Class对象的newInstance方法

工厂模式总结

简单工厂（静态工厂）：，
//1.一个通用的getcar接口
public interface Car {
void name();
}
//2.不同的实现
public class WuLing implements Car{
@Override
public void name() {
System.out.println(“五菱宏光”);
}
}
//3.一个对外提供的工厂方法
public static Car geyWuling(){
return new WuLing();
}
public static Car geyTesla(){
return new Tesla();
}
工厂方法模式
1.公共的接口方法
public interface Car {
void name();
}
//2.不同的实现
public class WuLing implements Car {
@Override
public void name() {
System.out.println(“五菱宏光”);
}
}
//3.抽象的工厂接口方法
public interface CarFactory {
Car getCar();
}
//4.工厂接口不同的实现
public class WulingFactory implements CarFactory{
@Override
public Car getCar() {
return new WuLing();
}
}
//抽象工厂模式
产品等级factory huaweifactory/xiaomifactory
产品族factory phoneFactory/IrouterFactory