java中的设计模式

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。


Factory(简单工厂)
定义：用一个方法去代替构造器或者是new关键字，把对象的创建隐藏起来。
优点：
1.隐蔽了new关键字和构造器
2.降低了这个对象与别的类之间的耦合度，提高了程序的可扩展性
原因:当子类被别的类替换，或者构造器的参数发生变化的时候，只需改动工厂方法内的new即可，改动量降到了最低，而如果不用工厂模式，而是直接用new关键字的话，需要改动的地方就很多了
3.把对象的设计和实现分割开来，从而代码扩展性强、灵活性更高。

解决问题：用来解决一个一个类的生成方式过多，容易发生变动，或者是父类和子类之间容易替换的地方。


Singleton(单例模式)
定义：确保一个类只有唯一的一个实例。
分类：
懒汉式： 1.声明一个私有的，静态的本类对象，但并不在声明的时候就初始化，因此，它的值为null
2.私有化构造器
3.对外提供一个全局的，公有的，静态的，唯一的方法，用来获得该实例，但注意的是：必须要手动保持线程同步（synchronized）
4.在该方法里，判断对象是否为null，如果是null的话，表示这个类还没有被实例化，就会初始化这个对象，再返回 如果不是null的话，就直接返回
饿汉式：
1.声明一个私有的，静态的本类对象，并在声明的时候就初始化
2.私有化构造器
3.对外提供一个全局的，公有的，静态的，唯一的方法，用来获得该实例（饿汉模式线程本身就是同步的）
4.在该方法里，直接返回该对象即可 从资源利用效率角度来讲，这个比懒汉式单例类稍差些。从速度和反应时间角度来讲， 则比懒汉式单例类稍好些。

解决问题:一个类在Java虚拟机只有一个实例.使一个类只有一个对象，整个系统共享这个对象。

代码演示：public class Singleton {
private static Singleton singleton;
private Singleton(){
}
public static synchronized Singleton getSingle(){
if(singleton==null){
singleton=new Singleton();
}
return singleton;
}
}


AbstaractFactory(抽象工厂模式)
定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
用途：
一个系统要独立于它的产品的创建、组合和表示时。
一个系统要由多个产品系列中的一个来配置时。
当你要强调一系列相关的产品对象的设计以便进行联合使用时。
当你提供一个产品类库，而只想显示它们的接口而不是实现时。


Template(模板模式)
定义:定义一个操作中算法的骨架,将一些步骤的执行延迟到其子类中.

解决问题：重要是解决子类之间代码或者是流程的重复问题。

常用地方：DAO模式里面的模板类，Spring里面的常用模板，包括JdbcTemplate等等


strategy(策略模式)
定义：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

解决问题：某个具体的解决方法有很多种可选择的实现。

常用地方：以不同的格式保存文件，以不同的算法压缩文件;以不同的格式输出同样数据的图形,比如曲线 或框图bar等


Observer(观察者模式)

定义：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

解决问题：解决多个对象间相互依赖关系的相互通知。

常用地方：一些数据有多个视图的表示，譬如Java中自带的图形事件应用。

意图：
1. 当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自 独立地改变和复用。
2.当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
3.当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的


Composite(组合模式)
定义:将对象以树形结构组织起来,以达成“部分－整体” 的层次结构，使得客户端对单个对象和组合对象的使用具有一致性.

解决问题:树形数据结构的方案

适用性:
1.你想表示对象的部分-整体层次结构。

你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象


Facade(外观模式，门面模式)

定义：为子系统中的一组接口提供一个一致的界面，F a c a d e 模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

解决问题：子接口繁多，调用复杂，内部交互地方比较多

适用性：

1.当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给那些不需要定制子系统 的用户带来一些使用上的困难。F a c a d e 可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够， 而那些需要更多的可定制性的用户可以越过f a c a d e 层。

2.客户程序与抽象类的实现部分之间存在着很大的依赖性。引入facade 将这个子系统与客户以及其他的子系统分离， 可以提高子系统的独立性和可移植性。

3. 当你需要构建一个层次结构的子系统时，使用f a c a d e 模式定义子系统中每层的入口点。如果子系统之间是相互依赖的， 你可以让它们仅通过f a c a d e 进行通讯，从而简化了它们之间的依赖关系。


Adapter(适配器模式)
定义：将一个类的接口转换成客户希望的另外一个接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类
可以一起工作。
解决问题：已经存在类似功能的类或接口，但是方法签名不一样。

适用性：

1.你想使用一个已经存在的类，而它的接口不符合你的需求。
2.你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。（仅适用于对象 Adapter ）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。
3.对象适配器可以适配它的父类接口。


Decorator(装饰器模式)
定义：动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。
解决问题：一个对象需要经常动态增加属性或职责

适用性：
在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
处理那些可以撤消的职责。

当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，
使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。


状态模式（State）:对象的不同状态有不同的行为，每一个状态都有不同的行为
代码例子：
//手机是一个对象
public interface Phone {
void phone();
}
//状态
public class State {
private Phone phone;
void execute(){
phone.phone();
}

public void setState(Phone supermarket) {
this.phone=supermarket;
}
}
//开机状态
public class OpenEngine implements Phone{

@Override
public void phone() {
System.out.println("手机处于开机状态");
}

}
//关机状态
public class Shutdown implements Phone {

@Override
public void phone() {
System.out.println("手机处于关机状态");
}

}
//待机
public class StayEngine implements Phone {

@Override
public void phone() {
System.out.println("处于待机状态");
}

}
//main方法
public class Client {
public static void main(String[] args) {
State state=new State();

state.setState(new OpenEngine());
state.execute();

state.setState(new Shutdown());
state.execute();

state.setState(new StayEngine());
state.execute();
}
}