设计模式之创建型模式（一）
设计模式的六大原则
1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
3、依赖倒转原则（Dependence Inversion Principle）
这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
5、迪米特法则（最少知道原则）（Demeter Principle）
为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则（Composite Reuse Principle）
原则是尽量使用合成/聚合的方式，而不是使用继承。
（上面是摘录的0。0）创建型模式包括：
Fctory（工厂模式）
Abstract Factory （抽象工厂模式）
Prototype（原型模式）
Builder（建造者模式）
单例模式
Factory（工厂模式）
1.意图
定义一个工厂类，对实现同一接口的类进行实例化。
这里我们以计算为例
1.2普通工厂方法
首先建立一个公共接口：
public interface Calculate{
public int calcualte(int a,int b);
}public class Add implments Calculate{
public int calculate(int a ,int b){
return a+b;
}
}public class Minus implments Calculate{
public int calculate(int a,int b){
return a-b;
}
}创建生产类的工厂
public class CalculateFactory{
public Calculate create(String type){
if("add".equals(type)){
return new Add();
}
else if ("minus".equals(type)){
return new Minus();
}
eles
{
System.out.println("请输入正确的操作");
}
}
}1.3多个工厂方法
则上面的代码可以改成如下的，对于公共接口以及实现类都不用改变值需改变Factory就可以
public class CalculateFactory{
public Calculate createAdd(){
return new Add();
}
public Calculate createMinus(){
return new Minus();
}
}public class CalculateFactory{
public static Calculate createAdd(){
return new Add();
}
public static Calculate createMinus(){
return new Minus();
}
}AbstractFactory（抽象工厂）
测试类
package org.lei.abstractfactory;
public class Test {
public static void main(String []args){
//美国牌汽车生产工厂
AbstractVehicleFactory aFactory = new AmericaFatory();
//生产美国牌小轿车
Vehicle acar = aFactory.createCar();
acar.buildDoor();
acar.buildEngine();
//生产美国牌卡车
Vehicle atrunck = aFactory.creaTrunck();
//中国牌汽车生产工厂
AbstractVehicleFactory chinaFactory = new ChinaFactory();
//中国牌小轿车
Vehicle chinaCar = chinaFactory.createCar();
//中国牌卡车
Vehicle chinaTrunck = chinaFactory.creaTrunck();
}
}
Prototype 原型模式
原型模式定义:
用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。
以勺子为例：
package org.lei.server;
public abstract class AbstractSpoon implements Cloneable{
private String spoonName;
public void setSpoonName(String spoonName) {this.spoonName = spoonName;}
public String getSpoonName() {return this.spoonName;}
public Object clone(){
Object object =null;
try {
object = super.clone();
} catch (Exception e) {
System.out.println("error");
}
return object;
}
@Override
public String toString() {
return "AbstractSpoon [spoonName=" + spoonName + "]";
}
}public class SoupSpoon extends AbstractSpoon{
SoupSpoon(){
setSpoonName("soup spoon");
}
}
public static void main(String []args){
AbstractSpoon abstractSpoon = new SoupSpoon();
System.out.println(abstractSpoon.toString());
AbstractSpoon abstractSpoon2 = (AbstractSpoon)abstractSpoon.clone();
System.out.println(abstractSpoon2.toString());
abstractSpoon2.setSpoonName("change spoon");
System.out.println(abstractSpoon.toString());
}结果：
AbstractSpoon [spoonName=soup spoon]AbstractSpoon [spoonName=soup spoon]
AbstractSpoon [spoonName=soup spoon]
建造者模式Builder
将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。如何使用：
首先假设一个复杂对象是由多个部件组成的,Builder模式是把复杂对象的创建和部件的创建分别开来,分别用Builder类和Director类来表示.
这里以制造汽车为例
首先定义一个接口用来定义如何创建车的各个部件
public interface Builder {
//创建车门
void builderDoor();
//创建车轮
void builderWheel();
//创建
void builderEngine();
//返回最后组装成品结果 (返回最后装配好的汽车)
//成品的组装过程不在这里进行,而是转移到下面的Director类中进行.
//从而实现了解耦过程和部件
Product getResult();
}复杂对象部件
public interface Part{}public class Engine implements Part{}public class Wheel implements Part{}public class Door implements Part{}复杂对象的产品：
public interface Product{}public class Car implements Product{
private Engine engine;
private Wheel wheel;
private Door door;
public Engine getEngine() {
return engine;
}
public void setEngine(Engine engine) {
this.engine = engine;
}
public Wheel getWheel() {
return wheel;
}
public void setWheel(Wheel wheel) {
this.wheel = wheel;
}
public Door getDoor() {
return door;
}
public void setDoor(Door door) {
this.door = door;
}
}Builder的具体实现ConcreteBuilder
public class ConcreteBuilder implments Builder{
Part engine,wheel,door;
public void builderEngine(){
//builderEngine的具体实现
engine = new Engine();
}
public void builderWheel(){
//builderWheel的具体实现
wheel = new Wheel();
}
public void builderDoor(){
//builderDoor的具体实现
door = new Door();
}
public Product getResult(){
//
Product product = new Car();
product.setWheel(wheel);
product.setDoor(door);
product.setEngine(engine);
return product;
}
}
public class Director{
private Builder builder;
Director(builder){
this.builder = builder;
}
//这里是将车轮 方向盘和发动机组装成汽车的过程
public void construct(){
builder.builderDoor();
builder.builderWheel();
builder.builderEngine();
}
}调用
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new director(builder);
director.construct();
Product product = builder.getResult();singleton（单例模式）
单例定义：
singleton的主要作用是在程序中，一个Class只有一个实例存在在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。
还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务。
一般使用Singleton的几种方式
public class Singleton {
private Singleton(){}
//注意这里的private只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance(){
return instance;
}
}第二种形式
public class Singleton{
private static Singleton instance = null;
//注意下面的synchronized很重要，如果没有synchronized
//,那么使用getInstance()是有可能得到多个Singleton的实例
public static synchronized Singleton getInstance (){
if(instance== null){
instance = new Singleton();
}
return instance;
}
}一般认为第一种形式更加安全一点。