设计模式之创建型模式(一)

设计模式的六大原则

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();
	}
}
1.4静态方法模式,也是我们常用的因为不用产生实例化工厂类
public class CalculateFactory{
	public static Calculate createAdd(){
		return new Add();
	}
	public static Calculate createMinus(){
		return new Minus();
	}
}


AbstractFactory(抽象工厂)

额, 这个模式研究了半天才最终明白的, 希望能互相学习。
工厂模式中有:工厂方法(Factory Method)和抽象工厂(Abstract Factory),这两个模式区别在于需要创建对象的复杂程度上,如果我们创建对象的方法变得复杂了,此时就用到了抽象工厂例如我们现在要生产美国小汽车,美国卡车,和中国小汽车,中国卡车。
先看看我画的类图

设计模式之创建型模式(一)_第1张图片

测试类

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();
		
	}
}
测试结果

设计模式之创建型模式(一)_第2张图片
中间代码太多,我传成资源文件了,不过相信通过上面的类图应该能够明白。如果需要源码可以通过下面的链接去下载
这里就不贴出抱歉。
抽象工厂

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;
	}
}


用Director构建最后的复杂对象,而在上面的Builder接口封装的是如何创建一个个部件(复杂对象是有这些部件组成的),也就是说Director的内部是如何将不见最后组装成成品的

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;
	}
}

一般认为第一种形式更加安全一点。


你可能感兴趣的:(设计模式)