（2011年java基础）设计模式总结（简述）

设计模式

设计模式有的书籍分了三大类

1，创建型模式

2，结构型模式

3，行为型模式

今天主要总结四种在黑马视频里面涉及的设计模式

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

单例设计模式（Singleton）

————————————创建型模式 

概述

    保证一个类仅有一个实例，并提供一个访问它的全局访问点。

 适用性

    1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

    2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
			

 参与者

    Singleton
      定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作。
      可能负责创建它自己的唯一实例。

 类图

单例模式在什么时候使用？、

就拿银行调度系统来说，只有一个叫号机，我们只要拿到这个叫号机对象就可以拿到里面的号码管理器

这个叫号机我们值需要创建对象的时候创建，然后提供静态方法让调用者获取已经创建好的对象即可。

package cn.itcast.interview.bank;

public class NumberMachine {
	private NumberManager commonManger = new NumberManager();
	private NumberManager expressManger = new NumberManager();
	private NumberManager vipManger = new NumberManager();
	private static NumberMachine instance = new NumberMachine();
	
	//这部机器只有一部，所以设计成单例模式：
	//首先要构造方法私有化，其次是提供返回此对象的共有方法；
	private NumberMachine(){}
	public NumberManager getCommonManager() {
		return commonManger;
	}
	public NumberManager getExpressManager() {
		return expressManger;
	}
	public NumberManager getVipManager() {
		return vipManger;
	}
	public static NumberMachine getInstance(){
		return instance;
	}
	
}

装饰模式（Decorator）

——————————结构型模式 

 概述

    动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

 适用性

    1.在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

    2.处理那些可以撤消的职责。

    3.当不能采用生成子类的方法进行扩充时。
			

 参与者

    1.Component
      定义一个对象接口，可以给这些对象动态地添加职责。

    2.ConcreteComponent
      定义一个对象，可以给这个对象添加一些职责。

    3.Decorator
      维持一个指向Component对象的指针，并定义一个与Component接口一致的接口。

    4.ConcreteDecorator
      向组件添加职责。

 

类图

什么时候使用装饰模式？

上面已经说的很清楚了

就是动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

现在举个例子说明额外增加功能导致继承体系臃肿的情况吧

MyReader//专门用于读取数据的类
    |---MyTextReader
    		|---MyBufferTextReader
    |---MyMediaReader
    		|---MyBufferMediaReader
    |---MyDataReader
    		|---MyBufferDataReader
    		
   class MyBufferedReader{
   		MyBufferReader(MyTextReader r){}
   		MyBufferReader(MyDataReader r){}
   }
   上面这个类扩展性很差。
   找到其参数的共同类型，通过多态的形式。可以提高扩展性
   clss MyBufferReader extends MyReader {
   			private MyReader r;
   			MyBufferReader(MyReader r){}
   }
   
   MyReader //专门用于读取数据的类
   		|---MyTextReader
 		|---MyMediaReader
    	|---MyDataReader
    	|---MyBufferReader
    	
  装饰模式比继承要灵活，避免了继承体系的臃肿
 而且降低了类与类之间的关系。
 
 装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强大的功能
 所以装饰类和被装饰类通常都是属于一个体系中。（继承父类或者接口）
    		
不要为了个别的功能，而给每个类都做成继承，因为继承体系会变得很臃肿，要是涉及类比较多和某些功能的增强
这个时候用装饰设计模式就恰到好处
 * */

对于每个类都要创建其相同的功能，这样就可以采用装饰模式了，构造一个装饰类接受这些类的对象然后扩展其性能。

--------------------------------------------------------------------------------------------------------------------------------------

享元模式（Flyweight）

——————————结构型模式 

 概述

    运用共享技术有效地支持大量细粒度的对象。

 适用性

    当都具备下列情况时，使用Flyweight模式：

    1.一个应用程序使用了大量的对象。

    2.完全由于使用大量的对象，造成很大的存储开销。

    3.对象的大多数状态都可变为外部状态。

    4.如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。

    5.应用程序不依赖于对象标识。由于Flyweight对象可以被共享，对于概念上明显有别的对象，标识测试将返回真值。
			

 参与者

    1.Flyweight
      描述一个接口，通过这个接口flyweight可以接受并作用于外部状态。

    2.ConcreteFlyweight
      实现Flyweight接口，并为内部状态（如果有的话）增加存储空间。
      ConcreteFlyweight对象必须是可共享的。它所存储的状态必须是内部的；即，它必须独立于ConcreteFlyweight对象的场景。

    3.UnsharedConcreteFlyweight
      并非所有的Flyweight子类都需要被共享。Flyweight接口使共享成为可能，但它并不强制共享。
      在Flyweight对象结构的某些层次，UnsharedConcreteFlyweight对象通常将ConcreteFlyweight对象作为子节点。

    4.FlyweightFactory
      创建并管理flyweight对象。
      确保合理地共享flyweight。当用户请求一个flyweight时，FlyweightFactory对象提供一个已创建的实例或者创建一个（如果不存在的话）。

 类图

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

模板方法（TemplateMethod）

————————————行为型模式 

 概述

    定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
    
    TemplateMethod使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

 适用性

    1.一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。

    2.各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。
      首先识别现有代码中的不同之处，并且将不同之处分离为新的操作。
      最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。

    3.控制子类扩展。
			

 参与者

    1.AbstractClass
      定义抽象的原语操作（primitiveoperation），具体的子类将重定义它们以实现一个算法的各步骤。
      实现一个模板方法,定义一个算法的骨架。
      该模板方法不仅调用原语操作，也调用定义在AbstractClass或其他对象中的操作。

    2.ConcreteClass
      实现原语操作以完成算法中与特定子类相关的步骤。

 类图

public abstract class Template {

    public abstract void print();
    
    public void update() {
        System.out.println("开始打印");
        for (int i = 0; i < 10; i++) {
            print();
        }
    }
}

public class TemplateConcrete extends Template {

    @Override
    public void print() {
        System.out.println("这是子类的实现");
    }
}

public class Test {

    public static void main(String[] args) {
        Template temp = new TemplateConcrete();
        temp.update();
    }
}