设计模式总结，持续更新。。。

1. 什么是设计模式？

　　　　设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。设计模式不是一种技术，是一种思想。

2. 设计模式类型

　　●　　创建型（5种）：简单工厂模式、工厂方法模式、单例模式、原型模式、构建者模式

　　●　　结构型（7种）：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式

　　●　　行为型（11种）：模板方法模式、策略模式、观察者模式、中介者模式、状态模式、责任链模式、命令模式、迭代器模式、访问者模式、解释器模式、备忘录模式

3. 常用设计模式介绍

　　　　1. 简单工厂模式

　　　　　　就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

　　　　优点：工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

　　　　缺点：由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

　　　简单工厂模式demo

package com.hwua.simplefactory;
// 接口
public interface Human {
    void say();
}
// man类
package com.hwua.simplefactory;
public class Man implements Human {

    @Override
    public void say() {
        System.out.println("我是男人");
    }
}
// woman类
package com.hwua.simplefactory;
public class Woman implements Human {
    @Override
    public void say() {
        System.out.println("我是女人");
    }

}
// 简单工厂
package com.hwua.simplefactory;
public class SampleFactory {
    //根据传入的类型去创建对应的对象
    public static Human makeHuman(int type) {
        if(type==1) {
            return new Man();
        }else if(type == 0) {
            return new Woman();
        }else {
            return null;
        }
    }
}
//测试类
package com.hwua.simplefactory;
public class HumanTest {
    public static void main(String[] args) {
        Human human = SampleFactory.makeHuman(0);
        if(human!=null) {
            human.say();
        }else {
            System.out.println("没有你要的产品");
        }
    }
}

2. 工厂方法模式

　　　　工厂方法模式（FACTORY METHOD）是一种常用的对象创建型设计模式,此模式的核心精神是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂；具体工厂；抽象产品；

　　　　　应用场景:第一种情况是对于某个产品，调用者清楚地知道应该使用哪个具体工厂服务，实例化该具体工厂，生产出具体的产品来。

package com.hwua.singledemo1;
//饿汉式:不管用不用的到都会先创建对象
class SingleTon{
    private static SingleTon singleTon =new SingleTon();
    private SingleTon() {
        System.out.println("singleton");
    }
    
    public static SingleTon getInstance() {
        return singleTon;
    }
    
}
public class SingleTomDemo1 {
    public static void main(String[] args) {
        SingleTon.getInstance();
        SingleTon.getInstance();
        SingleTon.getInstance();
        SingleTon.getInstance();
    }

}

package com.hwua.singledemo2;

//懒汉式:用的时候再创建
class SingleTon {
    private static SingleTon singleTon = null;

    private SingleTon() {
        System.out.println("singleton");
    }
        // 加锁,静态方法获取实例
    public static synchronized SingleTon getInstance() {
        if (singleTon == null) {
            singleTon = new SingleTon();
        }
        return singleTon;
    }

}
public class SingleTomDemo1 {
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread() {
                @Override
                public void run() {
                    SingleTon.getInstance();
                }
            }.start();
        }
    }
}

package com.hwua.singledemo3;

//双重检测机制
class SingleTon {
    private static SingleTon singleTon = null;

    private SingleTon() {
        System.out.println("singleton");
    }

    public static SingleTon getInstance() {
        if (singleTon == null) {// 第一层检测
            synchronized (SingleTon.class) {
                if (singleTon == null) {
                    singleTon = new SingleTon();
                }
            }

        }
        return singleTon;
    }

}

public class SingleTomDemo1 {
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread() {
                @Override
                public void run() {
                    SingleTon.getInstance();
                }
            }.start();
        }
    }

}

package com.hwua.singledemo4;
//静态内部类
class SingleTon {
    private SingleTon() {
        System.out.println("singleton");
    }
    //静态内部类不会自动加载,只有当使用这个静态内部类的时候才加载
    private static class SingleTonHolder{
         private static SingleTon singleTon = new SingleTon();
    }
    public static SingleTon getInstance() {
        return SingleTonHolder.singleTon;
    }    
    public static void show() {
        
    }
}

public class SingleTomDemo1 {
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread() {
                @Override
                public void run() {
                    SingleTon.getInstance();
                }
            }.start();
        }
    }
}

　　3. 构建者模式

　　　　建造者模式是属于创建型模式。建造者模式使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。简单的来说就是将一个复杂的东西抽离出来，对外提供一个简单的调用，可以在同样的构建过程创建不同的表示。和工厂模式很相似，不过相比而言更加注重组件的装配。

　　　　我们其实根本就不会知道具体是怎么造房子的，因为这个过程让director给代劳了。然后，我们的 HutBuilder类中才是真正的造房子的方法。director其实只是执行了这个过程。这样子，达到了分离模块的功能。有了一些模块化的感觉，这样维护和扩展都是很方便的。适用一些基本组件不变，但是组合经常变化的时候。比如超市促销的大礼包。所以设计模式的精髓还是那几个原则。感觉原则才是法则，而这么多模式就是具体的招式。

　　　　demo

　　4. 责任链模式

　　　　责任链模式顾名思义，就是为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

　　　　优点:耦合度低，请求者和执行者并没有必然的联系；灵活度高，可以通过内部成员来进行更改它们执行的次序；扩展性好.

　　　　缺点:会在某程度上降低程序的性能，设置不当的话可能会出现循环调用。在链过长时，会降低代码的阅读性以及增加代码的复杂度。

　　　　使用场景:需要动态指定处理某一组请求时，在不确定接受者的的情况下，向多个对象发送请求时。

5. 代理模式

　　　　代理模式概念：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用

　　　　动态代理

　　　　　　动态代理类：在程序运行时，通过反射机制动态生成。

　　　　　　动态代理类通常代理接口下的所有类。

　　　　　　动态代理事先不知道要代理的是什么，只有在运行的时候才能确定。

　　　　　　动态代理的调用处理程序必须事先InvocationHandler接口，及使用Proxy类中的 newProxyInstance方法动态的创建代理类。

　　　　　　Java动态代理只能代理接口，要代理类需要使用第三方的CLIGB等类库。

posted @ 2020-07-07 17:55 AnthonyWang 阅读(120) 评论(0) 收藏举报

刷新页面返回顶部