Java设计模式-2、⼯⼚模式

⼯⼚模式

工厂模式是对简单工厂的一个衍生，解决了许多简单工厂模式的问题。

一、说⼀说简单⼯⼚模式

简单⼯⼚模式指由⼀个⼯⼚对象来创建实例，客户端不需要关注创建逻 辑，只需提供传⼊⼯⼚的参数。

 适⽤于⼯⼚类负责创建对象较少的情况，缺点是如果要增加新产品，就需 要修改⼯⼚类的判断逻辑，违背开闭原则，且产品多的话会使⼯⼚类⽐较 复杂。 Calendar 抽象类的 getInstance ⽅法，调⽤ createCalendar ⽅法根据不同 的地区参数创建不同的⽇历对象。

Spring 中的 BeanFactory 使⽤简单⼯⼚模式，根据传⼊⼀个唯⼀的标识来 获得 Bean 对象。这也是事先定义好bean标识和bean的关联关系。

代码：

1定义接口

/**
 * 形状接口
 */
public interface Shape {
     void draw();
}

2 实现类

public class Circle implements Shape {

	public Circle() {
		System.out.println("Circle");
	}
	
	public void draw() {
		System.out.println("画圆");
	}
}

public class Rectangle implements Shape {

	public Rectangle() {
		System.out.println("Rectangle");
	}
	
	public void draw() {
		System.out.println("画长方形");
	}
}

public class Square implements Shape {

	public Square() {
		System.out.println("Square");
	}
	
	public void draw() {
		System.out.println("画正方形");
	}
}

3. 定义简单工厂

public class ShapeFactory {
	public static Shape getShape(String shapeType) {
		if (shapeType == null) {
			return null;
		}
		if (shapeType.equalsIgnoreCase("CIRCLE")) {
			return new Circle();
		} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
			return new Rectangle();
		} else if (shapeType.equalsIgnoreCase("SQUARE")) {
			return new Square();
		}
		return null;
	}
}

4. 测试类

	public static void main(String[] args) {
		//违反开闭原则
		 Shape circle = ShapeFactory.getShape("CIRCLE");
		 circle.draw(); Shape rectangle = ShapeFactory.getShape("RECTANGLE");
		 rectangle.draw(); Shape square = ShapeFactory.getShape("SQUARE");
		 square.draw();
}

5 ：结果

二、⼯⼚⽅法模式了解吗？ 

和简单⼯⼚模式中⼯⼚负责⽣产所有产品相⽐，⼯⼚⽅法模式将⽣成具体 产品的任务分发给具体的产品⼯⼚。不再是单一工厂。

代码：

1、之前代码基础上加上 工厂接口

/**
 *  
 * @author WHM
 *
 */
public interface Factory {
	public Shape getShape();
}

2 实现工厂类，生成A产品

public class CircleFactory implements Factory {

	@Override
	public Shape getShape() {
		return new Circle();
	}

}

生产B产品

public class RectangleFactory implements Factory {

	public Shape getShape() {
		return new Rectangle();
	}

}

 C产品

public class SquareFactory implements Factory {

	public Shape getShape() {
		return new Square();
	}

}

 3. 测试类

public class updateMain {
	public static void main(String[] args) {
		//画圆工厂
	    Factory circleFac = new CircleFactory();
	    //不需要指导谁执行
	    Shape circle = circleFac.getShape();
	    //直接ִ执行画圆方法
	    circle.draw();
	}
}

总结:

这里这样设计的好处，就是如果需要加新产品，只需要新增实现类就行了，不需要去改原来的代码了。这就易于扩展，解决了简单工厂的缺点。

 三、抽象⼯⼚模式了解吗？

 简单⼯⼚模式和⼯⼚⽅法模式不管⼯⼚怎么拆分抽象，都只是针对⼀类产 品，如果要⽣成另⼀种产品，就⽐较难办了！

抽象⼯⼚模式通过在 AbstarctFactory 中增加创建产品的接⼝，并在具体⼦ ⼯⼚中实现新加产品的创建，当然前提是⼦⼯⼚⽀持⽣产该产品。否则继 承的这个接⼝可以什么也不⼲。

从上⾯类图结构中可以清楚的看到如何在⼯⼚⽅法模式中通过增加新产品 接⼝来实现产品的增加的。抽象工厂跟工厂方法模式一个本质就是，抽象工厂模式有一个超级工厂。 

代码：

1. 产品接口

/**
 * 生产可乐
 * @author WHM
 *
 */
public interface Cole {
	public void cl();
}

/**
 * 生产汉堡包
 * @author WHM
 *
 */
public interface Humburg {
    public void hb();
}

2. 工厂接口

/**
 * 工厂（组合生产对象）
 * @author WHM
 *
 */
public interface Factory {
	//生产汉堡包
	public Humburg scHbb();
	//生产可乐
    public Cole scKl();
}

3.产品实现类

public class KdjHbb implements Humburg {

	public void hb() {
		System.out.println("肯德基的汉堡包");
	}

}

public class KdjKl implements Cole {

	public void cl() {
		System.out.println("肯德基的可乐");
	}
}

     

public class MDLCole implements Cole {

	public void cl() {
		System.out.println("麦当劳的可乐");
	}

}

public class MdlHbb implements Humburg {

	public void hb() {
		System.out.println("麦德劳的汉堡包");
	}

}

 4 工厂实现类

package designpattern.factory.abstrac;

public class MdlFactory implements Factory {

	public Humburg scHbb() {
		return new MdlHbb();
	}
	
	public Cole scKl() {
		return new MDLCole();
	}
}

package designpattern.factory.abstrac;

/**
 *  抽象工厂实现
 * @author WHM
 *
 */
public class KdjFactory implements Factory {

	public Humburg scHbb() {
		return new KdjHbb();
	}

	public Cole scKl() {
		return new KdjKl();
	}
}

 5 测试类

package designpattern.factory.abstrac;

/**
 * 生产一组产品。交由谁生产      
 * 区别：
 * 工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）   
 * 抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族） 
 * @author WHM
 *
 */
public class TMain {
	
	public static void main(String[] args) {
		KdjFactory Kdj=new KdjFactory();
        Humburg hb1= Kdj.scHbb();
        hb1.hb();
        Cole cole= Kdj.scKl();
        cole.cl();
        MdlFactory mdl=new MdlFactory();
        Humburg hb2=mdl.scHbb();
        hb2.hb();
        Cole cole2 =mdl.scKl();
        cole2.cl();
	}
}

 6 结果

四、总结：

       本文主要对于工厂模式进行了介绍主要介绍了简单工厂模式，工厂方法模式以及抽象工厂模式。