目录

前言

一、设计模式七大规则？

二、常用设计模式理解

1.单例模式

懒汉式

饿汉式

2.工厂模式

总结

前言

这是我的设计模式笔记

---

以下是本篇文章正文内容，下面案例可供参考

一、设计模式七大规则？

开闭原则：对扩展开放，对修改关闭单一职责原则：一个类只负责一个功能相应区域里氏代换原则：一个父类可以透明使用子类的所有方法（子类可以去扩展父类的方法，但是不要去修改父类的方法）依赖倒转：依赖抽象不能依赖具体实现（通俗解释就是面向接口编程，把不同的模块抽象成接口，使两个模块能同时进行开发）接口隔离：类之间的关系应该建立在最小的接口(在写接口时如果写的非常多，那么你实现一个接口就要实现大量方法，所以一定要最小接口，方法够用就行）合成聚合复用：尽量使用合成聚合复用而不是继承复用迪米特法则：一个软件的实体类应该尽可能的与其他实体少接触（降低耦合性）

二、常用设计模式理解

1.单例模式

单例模式讲究的就是只能new一个出来，但是这种看起来很简单的只能new一个，里面却复杂的一批，涉及多线程，jvm虚拟机等等

懒汉式

public class sing {
    private static sing sing;
    private sing(){}
    public static sing getSing(){
        if(sing != null){
            return sing;
        } else {
                  sing = new sing();
                    System.out.println("new了的单例："+sing);
                }

            }
        }
        return sing;
    }

    public static void main(String[] args) {
        sing sing1 = sing.getSing();
        sing sing2 = sing.getSing();
        System.out.println(sing1);
        System.out.println(sing2);
    }
}

这个单例在单线程情况下的确是正常的，可是java本来就是拿来做后端的，一旦引入多线程：

new Thread(() -> {
            System.out.println("线程1得到的单例："+sing.getSing());
        }).start();
        new Thread(() -> {
            System.out.println("线程2得到的单例："+sing.getSing());
        }).start();

 这时候你感觉也没问题，但是它已经出问题了。由于我们处理的数据量少，所以第一个线程一下就执行完毕，当第二个线程再进来是判断到的确有了单例就不会继续创建，所以得到的结果是正确的。但是如果处理的数据量大呢？

else {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sing = new sing();
            System.out.println("new了的单例："+sing);
            }

这里模拟sleep一秒，表述正在处理数据，看看结果：

 

结果就是由于两个线程由于上一个线程还在处理东西，没及时new出来，第二个线程就进来了。第二个线程判断null于是也new了一个，单例单例肯定是只能new一个出来，这里new了两个肯定是有问题，解决问题也很简单，直接把他变成同步方法+个synchronized关键字：

public synchronized static sing getSing(){

好家伙正常了，但是问题来了，要是每个人每个方法都要过来拿锁，那不是人人都要等着，你已经new了也要等？显然不合理，那么就让new一次的有锁就行了，new完了，这把锁就放掉：

    public static sing getSing(){
        if(sing != null){
            return sing;
        }else {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (sing.class){
                if(sing == null){
                    sing = new sing();
                    System.out.println("new了的单例："+sing);
                }
            }
            }
        return sing;
    }

 最后为了防止jvm的重排列，我们再在sing前加一个volatile万无一失

private volatile static sing sing;

饿汉式

饿汉式比较简单，是线程安全的，但是就是无论如何都会new一个对象，消耗性能。

public class Person {
    //饿汉式单例
    private static Person person = new Person();
    private Person(){}

    public static Person getInstance(){
    return person;
    }
}

2.工厂模式 简单工厂：

是一种暴露生产逻辑的生成方式，比较简单：

 

public class SimpleFactory {
    TvFactory tf = new TvFactory();
    TV xiaomi = tf.getTv("xiaomi",27);
    TV haier = tf.getTv("haier",30);
}

interface TV{
    public void showTv();
}

class xiaomiTV implements TV{
    protected String name;
    protected int size;
    public xiaomiTV(String name,int size){
        this.name = name;
        this.size = size;
    }

    @Override
    public void showTv() {
        System.out.println(name+","+size);
    }
}

class haierTV implements TV{

    protected String name;
    protected int size;
    public haierTV(String name,int size){
        this.name = name;
        this.size = size;
    }
    @Override
    public void showTv() {
        System.out.println(name+","+size);
    }
}

class TvFactory{
    public static TV getTv(String name,int size){
        TV tv = null;
        if("xiaomi".equals(name)){
            tv = new xiaomiTV("xiaomi",size);
        }else if("haier".equals(name)){
            tv = new haierTV("haier",size);
        }
        return tv;
    }
}

工厂方法：

把暴露生产逻辑的交给子类处理：

 

---

总结

以后会刻意去按照设计模式去编写代码