常用设计模式
设计模式的分类：
设计模式可以分为三大类，分别是创建型设计模式、行为型设计模式以及结构型设计模式。
创建型的设计模式：
单例模式(Singleton)
构建模式(Builder)
原型模式(Prototype)
抽象工厂模式(Abstract Factory)
工厂方法模式(Factory Method)
行为设计模式：
策略模式(Strategy)
状态模式(State)
责任链模式(Chain of Responsibility)
解释器模式(Interpreter)
命令模式(Command)
观察者模式(Observer)
备忘录模式(Memento)
迭代器模式(Iterator)
模板方法模式(Template Method)
访问者模式(Visitor)
中介者模式(Mediator)
结构型设计模式：
装饰者模式(Decorator)
代理模式(Proxy)
组合模式(Composite)
桥连接模式(Bridge)
适配器模式(Adapter)
蝇量模式(Flyweight)
外观模式(Facade)
各种模式的表述：
单例模式(Singleton)：确保有且只有一个对象被创建。
抽象工厂模式(Abstract Factory)：允许客户创建对象的家族，而无需指定他们的具体类。
工厂方法模式(Factory Method)：由子类决定要创建的具体类是哪一个。
装饰者模式(Decorator)：包装一个对象，以提供新的行为。
状态模式(State)：封装了基于状态的行为，并使用委托在行为之间切换。
迭代器模式(Iterator)：在对象的集合之中游走，而不暴露集合的实现。
外观模式(Facade)：简化一类的接口。
策略模式(Strategy)：封装可以互换的行为，并使用委托来决定要使用哪一个。
代理模式(Proxy)：包装对象，以控制对此对象的访问。
适配器模式(Adapter)：封装对象，并提供不同的接口。
观察者模式(Observer)java单例模式懒汉和饿汉：让对象能够在状态改变时被通知。
模板方法模式(Template Method)：有子类决定如何实现一个算法中的步骤。
组合模式(Composite)：客户用一致的方法处理对象集合和单个对象。
命令模式(Command)：封装请求成为对象。
1、装饰模式
装饰模式是对对象功能增强时，平时使用继承的一种替代方案
二．组成部分 ：
1. 抽象构件：原始的功能接口
2. 具体构件：具体的原始功能类
3. 装饰角：持有具体构件类的对象，以便执行原有功能
4. 具体装饰：具体扩展的功能在这里
三．例子代码 : 使用装饰模式来演示一个对”行走”功能扩展的例子(听音乐+行走和唱歌+行走)
1． 抽象构件
[java] view plaincopyprint?
1. package kq.decorator;
2.
3. public interface Component {
4. /** 原始接口 */
5. public void go();
6. }
2． 具体构件
[java] view plaincopyprint?
1. package kq.decorator;
2.
3. public class ConcreteComponent implements Component {
4.
5. public void go() {
6. System. out .println( "行走" );
7. }
8.
9. }
3．装饰角来了
[java] view plaincopyprint?
1. package kq.decorator;
2.
3. public class Decorator implements Component {
4. /** 持有私有的原始构件 */
5. private Component component ;
6.
7. /** 构造子，委派给原始构件 */
8. protected Decorator(Component component) {
9. this . component = component;
10. }
11.
12. /**调用原始构件功能，通常就可直接把扩展功能加在此方法中*/
13. public void go() {
14. this . component .go();
15. }
16.
17. }
4．具体装饰（这里演示了两种扩展的情况，走路+听音乐和唱歌s）
(1).
[java] view plaincopyprint?
1. package kq.decorator;
2.
3. public class ConcreteDecoratorListen extends Decorator {
4.
5. /** 构造子，相关初始化 */
6. public ConcreteDecoratorListen(Component component) {
7. super (component);
8. // code is here
9. }
10.
11. /** 商业逻辑，对原始构件功能的扩展 */
12. public void go() {
13. listen( "听音乐" ); //执行扩展功能
14. super .go();
15. }
16.
17. private void listen(Object obj){
18. System. out .println(obj);
19. }
20.
21. }
(2).
[java] view plaincopyprint?
1. package kq.decorator;
2.
3. public class ConcreteDecoratorSing extends Decorator {
4.
5. /** 构造子，相关初始化 */
6. public ConcreteDecoratorSing(Component component) {
7. super (component);
8. // code is here
9. }
10.
11. /** 商业逻辑，对原始构件功能的扩展 */
12. public void go() {
13. super .go();
14. System. out .println(sing());; // 执行扩展功能
15. }
16.
17. private String sing() {
18. return "唱歌" ;
19. }
20. }
5．客户端调用
[java] view plaincopyprint?
1. package kq.decorator;
2.
3. public class Main {
4.
5. public static void main(String[] args) {
6. /** 原始构件 */
7. Component component = new ConcreteComponent();
8. /**边听音乐，边走路*/
9. ConcreteDecoratorListen cdl = new ConcreteDecoratorListen(component);
10. ();
11. System. out .println();
12. /**边走路，边唱歌*/
13. ConcreteDecoratorSing cds = new ConcreteDecoratorSing(component);
14. ();
15. }
16.
17. }
四．总结
优点：装饰模式和继承都是对功能的扩展,而装饰模式使用的是组合,可以不用继承而达到这一效果.使用过多的继承会增加系统的复杂性和偶合性
缺点：装饰模式要产生一些辅助性的对象,但这些对象看上去都比较像,不是很容易检查(好的命名应该是提高检查的一个办法)
2、单例子(Singleton)模式
单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。
一、懒汉式单例子
在类被加载的时候，唯一实例已经被创建。这个设计模式在Java中容易实现，在别的语言中难以实现。
[java] view plaincopyprint?
1. public class EagerSingleton {
2. /**
3. * 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象
4. */
5. private static final EagerSingleton m_instance = new EagerSingleton();
6.
7. /**
8. * 私有构造方法,避免外部创建实例
9. */
10. private EagerSingleton() {
11. }
12.
13. /**
14. * 静态工厂方法,返回此类的唯一实例.
15. * @return EagerSingleton
16. */
17. public static EagerSingleton getInstance() {
18. return m_instance;
19. }
20. }
21.
二、饿汉式单例
在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。
[java] view plaincopyprint?
1. public class LazySingleton {
2. /**
3. * 私有静态对象,加载时候不做初始化
4. */
5. private static LazySingleton m_intance=null;
6.
7. /**
8. * 私有构造方法,避免外部创建实例
9. */
10. private LazySingleton(){
11.
12. }
13.
14. /**
15. * 静态工厂方法,返回此类的唯一实例.
16. * 当发现实例没有初始化的时候,才初始化.
17. * @return LazySingleton
18. */
19. synchronized public static LazySingleton getInstance(){
20. if(m_intance==null){
21. m_intance=new LazySingleton();
22. }
23. return m_intance;
24. }
25. }
三、登记式单例
登记式单例类是针对上面两种单例类不能被继承的特点而设计的。
这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对
于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。
[java] view plaincopyprint?
1. public class RegSingleton {
2. /**
3. * 登记薄,用来存放所有登记的实例

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。