一、设计模式
1.创建型模式
其中创建型模式分为: FactoryMethod ( 工厂方法 )、AbstractFactory ( 抽象工厂 )、Singleton ( 单态模式 )、Builder ( 建造者模式 )、Prototype ( 原型模式 )
1.1、FactoryMethod ( 工厂方法 )
概述
定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。
适用性
1.当一个类不知道它所必须创建的对象的类的时候。
2.当一个类希望由它的子类来指定它所创建的对象的时候。
3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
参与者
1.Product
定义工厂方法所创建的对象的接口。
2.ConcreteProduct
实现Product接口。
3.Creator
声明工厂方法，该方法返回一个Product类型的对象。 Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。 可以调用工厂方法以创建一个Product对象。
4.ConcreteCreator
重定义工厂方法以返回一个ConcreteProduct实例。
例子
// Product public interface Work { void doWork(); } //ConcreteProduct public class StudentWork implements Work { public void doWork() { System.out.println("学生做作业!"); } } public class TeacherWork implements Work { public void doWork() { System.out.println("老师审批作业!"); } } //Creator public interface IWorkFactory { Work getWork(); } //ConcreteCreator public class StudentWorkFactory implements IWorkFactory { public Work getWork() { return new StudentWork(); } } public class TeacherWorkFactory implements IWorkFactory { public Work getWork() { return new TeacherWork(); } } //Test public class Test { public static void main(String[] args) { IWorkFactory studentWorkFactory = new StudentWorkFactory(); studentWorkFactory.getWork().doWork(); IWorkFactory teacherWorkFactory = new TeacherWorkFactory(); teacherWorkFactory.getWork().doWork(); } } //result 学生做作业! 老师审批作业!
1.2、AbstractFactory ( 抽象工厂 )
概述
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性
1.一个系统要独立于它的产品的创建、组合和表示时。
2.一个系统要由多个产品系列中的一个来配置时。
3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。
4.当你提供一个产品类库，而只想显示它们的接口而不是实现时。
参与者
1.AbstractFactory
声明一个创建抽象产品对象的操作接口。
2.ConcreteFactory
实现创建具体产品对象的操作。
3.AbstractProduct
为一类产品对象声明一个接口。
4.ConcreteProduct
定义一个将被相应的具体工厂创建的产品对象。 实现AbstractProduct接口。
5.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 cat 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 public static void main(String[] args) { IAnimalFactory blackAnimalFactory = new BlackAnimalFactory(); ICat blackCat = blackAnimalFactory.createCat(); blackCat.eat(); IDog blackDog = blackAnimalFactory.createDog(); blackDog.eat(); IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory(); ICat whiteCat = whiteAnimalFactory.createCat(); whiteCat.eat(); IDog whiteDog = whiteAnimalFactory.createDog(); whiteDog.eat(); } //result The black cat is eating! The black dog is eating! The white cat is eating! The white dog is eating!
1.3 Singleton ( 单态模式 )
概述
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
适用性
1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。 2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
参与者
Singleton 定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作。 可能负责创建它自己的唯一实例。
类图
例子
//Singleton public class Singleton { private static Singleton sing; private Singleton() { } public static Singleton getInstance() { if (sing == null) { sing = new Singleton(); } return sing; } } //Test public class Test { public static void main(String[] args) { Singleton sing = Singleton.getInstance(); Singleton sing2 = Singleton.getInstance(); System.out.println(sing); System.out.println(sing2); } } //result singleton.Singleton@1c78e57 singleton.Singleton@1c78e57
1.4 Builder ( 建造者模式 )
概述
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
适用性
1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2.当构造过程必须允许被构造的对象有不同的表示时。
参与者
1.Builder
为创建一个Product对象的各个部件指定抽象接口。
2.ConcreteBuilder
实现Builder的接口以构造和装配该产品的各个部件。 定义并明确它所创建的表示。 提供一个检索产品的接口。
3.Director
构造一个使用Builder接口的对象。
4.Product
表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。 包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
类图
例子
//Builder public interface PersonBuilder { void buildHead(); void buildBody(); void buildFoot(); Person buildPerson(); } //ConcreteBuilder public class ManBuilder implements PersonBuilder { Person person; public ManBuilder() { person = new Man(); } public void buildBody() { person.setBody("建造男人的身体"); } public void buildFoot() { person.setFoot("建造男人的脚"); } public void buildHead() { person.setHead("建造男人的头"); } public Person buildPerson() { return person; } } //Director public class PersonDirector { public Person constructPerson(PersonBuilder pb) { pb.buildHead(); pb.buildBody(); pb.buildFoot(); return pb.buildPerson(); } } //Product public class Person { private String head; private String body; private String foot; public String getHead() { return head; } public void setHead(String head) { this.head = head; } public String getBody() { return body; } public void setBody(String body) { this.body = body; } public String getFoot() { return foot; } public void setFoot(String foot) { this.foot = foot; } } public class Man extends Person { } //Test public class Test{ public static void main(String[] args) { PersonDirector pd = new PersonDirector(); Person person = pd.constructPerson(new ManBuilder()); System.out.println(person.getBody()); System.out.println(person.getFoot()); System.out.println(person.getHead()); } } //result 建造男人的身体 建造男人的脚 建造男人的头
1.5、Prototype ( 原型模式 )
概述
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
适用性
1.当一个系统应该独立于它的产品创建、构成和表示时。
2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。
3.为了避免创建一个与产品类层次平行的工厂类层次时。
4.当一个类的实例只能有几个不同状态组合中的一种时。
建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
参与者
1. Prototype
声明一个克隆自身的接口。
2. ConcretePrototype
实现一个克隆自身的操作。
3. 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()); } } //result prototype prototype
