1.1创建型模式
AbstracktFacktory(抽象工厂) FactoryMethod(工厂方法) Singleton(单例模式) Builder(建造者模式) Prorotype(原型模式)
1.1.1 工厂方法（原型类和工厂类都是面向接口的） 定义一个用于创建对象的接口，让子类决定实例化哪个类，FactoryMethod使一个类的实例延迟到其子类。 适用性：
1.当一个类不知道他所必须创建的对象的类的时候
2.当一个类希望由它的子类来指定它所创建的对象的时候 3.当将创建对象的职责委托给多个帮助类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化的时候。
参与者：
product 定义工厂方法所创建的对象的接口
concreteproduct 实现product接口
creator 声明工厂方法，该方法返回一个product类型的对象
creator也可以定义一个工厂方法的缺省实现，他返回一个缺省的concreteproduct对象 可以调用工厂方法以创建一个product对象
concretecreator 重定义工厂方法返回一个concreteproduct实例 类图：
例子： Product:
public interface Work{ void doWork(); }
concreteProduct:
public class StudentWork implements Work{ System.out.println(“学生work”); }
Public class TeacherWork implements Work{ System.out.println(“老师work”); }
Creator:
Public interface IWorkFactory{ Work getWork(); }
concreteCreator:
public class studentWorkFactory implements IworkFactory{ public Work getWork(){ return new TeacherWork(); } }
Public class TeacherWorkFactory implements IWorkFactory{ Public Work getWork(){ Return new TeacherWork(); } } Test:
IWorkFactory studentWorkFactory=new StudentWorkFactory(); studentWorkFactory.getWork().doWork();
1.1.2抽象工厂
提供一个创建一系列相关或者相互依赖对象的接口，而无需制定他们具体的类。 1. 一个系统要于它的产品的创建，组合和表示时。 2. 一个系统要由多个产品系列中的一个来配置时。
3. 当你强调一系列相关的产品对象的设计以便进行联合使用时。 4. 当你提供一个产品类库，而只想显示他们的接口而不是实现时。
参与者:
AbstractFactory
声明一个创建抽象产品对象的操作接口。 Concretefactory
实现创建具体产品对象的操作
Abstractproduct
为一类产品对象生命一个接口
Cncreteproduct
定义一个将被相应的具体工厂创建的产品对象 实现abstractproduct接口
Client
仅使用由abstractfactory和abstractproduct类声明的接口 类图：
例子：
AbstractFactory:
Public interface IAnimalFactory{ ICat createCat(); IDog createDog(); }
concreteFactory:
public class BlackAnimalFactory implements IAnimalFactory{ public ICat createCat(){ return new BlackCat(); }
Public IDog createDog(){ Return new BlackDog(); } }
Public class WhiteAnimalFactory implements IAnimalFactory{ Public ICat createCat(){ Return new WhiteCat(); }
Public IDog createDog(){ Return new WhiteDog(); } }
abstractProduct:
public interface Icat{ void eat(); }
Public interface IDog{ Void eat(); }
Concreteproduct:
Public class blackcat implements Icat{ Public void eat(){
System.out.println(“the black cat is eating!”); } }
Public class WhiteCat implements ICat{ Public void eat(){
System.out.println(“the White eat is eating!”); } }
Public class BlackDog implements Idog{ Public void eat(){
System.out.println(“the Black dog is eating”); } }
Public class WhiteDog implements IDog{ Public void eat(){
System.out.println(“the white dog is eating!”); } }
Client:
IAnimalFactory blackanimalFactory=new BlackAnimalFactory(); ICat blackCat=blackAnimalFactory.createCat(); blackCat.eat();
IDog blackDog=blackAnimalFactory.createDog(); blackDog.eat():
1.1.3建造者模式
将一个复杂对象的构造与它的表示分离，使同样的构造过程可以创建不同的表示
适用性：
当创建复杂对象的算法应该于该对象的组成部分以及他们的装配方式时。 当构造过程必须允许被构造的对象有不同的表示时。
参与者： Builder
为创建一个product对象的各个部件指定抽象接口。
concreteBuilder
实现builder的接口以构造和装配该产品的各个部件。 定义并明确它所创建的表示 提供一个检索产品的接口
Director
构造一个使用builder接口的对象
Product
表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义他的装配过程 包含定义组成部件的类，包括将这些部件装配成最终产品的接口 类图：
例子：
新建地图接口:
public interface map_interface { public void create_weather(); public void create_house(); public void create_tree(); public void create_way(); }
新建晴天地图接口:
public class map_sun implements map_interface { public void create_weather() { System.out.println(\"晴天\"); }
public void create_house() {
System.out.println(\"房了上玻璃发亮\"); }
public void create_tree() {
System.out.println(\"树的颜色是浅绿色\"); }
public void create_way() {
System.out.println(\"路面有些干燥\"); }
新建阴天地图类：
public class map_cloudy implements map_interface{ public void create_weather() {
System.out.println(\"阴天\"); }
public void create_house() {
System.out.println(\"房了上玻璃发暗\"); }
public void create_tree() {
System.out.println(\"树的颜色是深绿色\"); }
public void create_way() {
System.out.println(\"路面有些潮湿\"); }
新建高画质builder建造者类： public class map_build_adv {
private map_interface map_interface_ref;
public map_build_adv(map_interface map_interface_ref) { super();
this.map_interface_ref = map_interface_ref; }
public void create_map() {
System.out.println(\"创建一个高画质的地图\"); // 创建的顺序很重要 从天空往路面创建 map_interface_ref.create_weather(); map_interface_ref.create_house(); map_interface_ref.create_tree(); map_interface_ref.create_way(); } }
新建低画质builder建造者类： public class map_build_low {
private map_interface map_interface_ref;
public map_build_low(map_interface map_interface_ref) { super();
this.map_interface_ref = map_interface_ref; }
public void create_map() {
System.out.println(\"创建一个低画质的地图\"); // 创建的顺序很重要 从天空往路面创建 map_interface_ref.create_weather(); map_interface_ref.create_house();
// map_interface_ref.create_tree();将创建树的过程去掉 map_interface_ref.create_way(); }
新建客户端运行类： public class run_main {
public static void main(String[] args) {
map_cloudy map_cloudy = new map_cloudy();
map_build_adv map_build_adv = new map_build_adv(map_cloudy); map_build_adv.create_map(); System.out.println();
map_sun map_sun = new map_sun();
map_build_low map_build_low = new map_build_low(map_sun); map_build_low.create_map(); } }
建造者模式将不变的创建过程进行封装，创建过程与main分发进行分离，这样内部的创建过程就和表示层的代码进行分开，有利于创建功能上的修改，另外发现，代码的设计和功能类似于façade外观模式，区别在于，建造者模式目的在于以相同的构建过程通过不同的建造者得到不同的结果，而外观模式并不需要不同的构造者，也不希望得到不同的结果，只是将几个接口合并成高级的一个接口，不影响原有的结果，目的是使调用变得更加容易。
本程序中有2个建造者，高画质 和低画质建造者，他们都封装了创建地图的过程，这个过程很固定，但通过不同的建造者类可以返回不样式的地图，建造者规定了对象创建的过
程，比如高画质的建造者的创建过程为：
map_interface_ref.create_weather(); map_interface_ref.create_house(); map_interface_ref.create_tree(); map_interface_ref.create_way();
必须要执行4个方法操可以创建一个高画质的地图，如果不使用建造者模式，直接调用map类的create_xxxx方法，若该方法有几十个，那么很可能把其中的某些方法忘记调用而影响最终地图的效果了，所以我们要使用建造者模式来规定地图的创建过程，这就是一个行为守则。
1.1.4 单例模式
保证一个类仅有一个实例，提供一个访问它的全局访问点 适用性：
1. 当一个类只能有一个实例而且客户可以从一个众所周知的访问点访问它时
2. 当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个
扩展的实例时。
参与者:
Singleton : 定义一个instance操作，允许客户访问它的唯一实例。
例子：
Public class Singleton{
Private static Singleton sing; Private Singleton(){}
Public static Singleton getInstance(){ If(sing==null){
Sing=new Singleton(); }
Return sing; } }
1.1.5 原型模式（就是类的拷贝复制）
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 适用性:
1.当一个系统应该于它的产品创建，构成和表示时。
2.当要实例化的类是在运行时刻指定时，例如，通过动态加载。 3为了避免创建一个与产品类层次平行的工厂层次时 4当一个类的实例只能有几个不同状态组合中的一种时。
建立相应数目的原型并克隆他们可能比每次用合适的状态手工实例化该类更方便。
参与者：
Protype:声明一个克隆自身的接口
Concreteprototype:实现一个克隆自身的操作
Client:让一个圆形克隆自身从而创建一个新的对象。
例子：
Prototype:
Public class prototype implements Cloneable{ Private String name;
Public void setName(String name){ This.name=name; }
Public String getName(){ Return this.name; }
Public object clone（）{ Try{
Return super.clone(); }catch(Exception e){ e.printStackTrace(); return null; } } }
concretePrototype :
public class ConcretePrototype extends prototype{ public ConcretePrototype(String name){ setName(name); } }
Client:
Public class Test{
Public static void main(String [] args){
Prototype pro=new ConcretePrototype(“prototype”); Prototype pro2=(Prototype)pro.clone(); System.out.println(pro.getName()); System.out.println(pro2.getName()); } }
