工厂模式
就是工厂---生产-->产品
在设计模式中,分为 简单工厂模式, 工厂方法模式,抽象工厂模式.
工厂模式,就是:
提供创建对象的功能,不需要关心具体实现.
类似于,接口隔离(模块和模块):不需要知道具体的构建过程,就能得到相应的结果.
例如,
Bitmap bitmap=BitmapFactory.decodeXXX();
decodeXXX 其实是创建了不同的bitmap.不用关心如何生产出bitmap
简单工厂:
以生产 二维图形 为例.
工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
类图
代码实现
1.产品抽象类
public class Shape {
/** @pdOid 6679a38e-beee-4da3-8749-c03329cfd976 */
public void sayHello() {
// TODO: implement
}
}
2.产品实体类
public class Circle extends Shape {
/** @pdOid 2abc7174-03ad-4365-8fff-3265612a3185 */
private int radium;
/** @pdOid b39ccef4-0987-473b-8e7d-1b8959c50985 */
public void sayHello() {
System.out.println("Hello, I am Circle from ShapeFactory!My address is "+this.hashCode());
}
}
public class Traingle extends Shape {
/** @pdOid 4911552c-ce2f-41e3-8a8f-d342dd482e50 */
private int high;
/** @pdOid 519ef847-62d8-435b-89a7-234c2fb5fcba */
private int bottom;
/** @pdOid 433ff6ef-9fbc-44f2-b159-97d17c6153a6 */
public void sayHello() {
// TODO: implement
System.out.println("Hello, I am Traingle from ShapeFactory! My address is "+this.hashCode());
}
}
3.图形工厂类(包括缓存模式)
public class ShapeFactory {
private static HashMap<String,Shape> shapeMap=new HashMap<>();
/**
* 简单工厂创建
* @param type Traingle创建三角形traingle,Circle创建圆形Circle
* @return Shape
*/
public static Shape create(String type) {
Shape shape = null;
switch (type) {
case "Traingle":
//
shape=new Traingle();
break;
case "Circle":
shape=new Circle();
break;
default:
break;
}
return shape;
}
/**
* 简单工厂创建---单例缓存
* @param type Traingle创建三角形traingle,Circle创建圆形Circle
* @return Shape
*/
public static Shape createSingle(String type) {
Shape shape = null;
switch (type) {
case "Traingle":
shape = getSingleFromMap(type);
break;
case "Circle":
shape = getSingleFromMap(type);
break;
default:
break;
}
return shape;
}
private static Shape getSingleFromMap(String type) {
Shape shape;
if(shapeMap.get(type)==null){
shape=new Traingle();
shapeMap.put(type, shape);
}else{
shape=shapeMap.get(type);
}
return shape;
}
}
测试类
public class Test {
public static void main(String[] args) {
System.out.println("============简单工厂模式==================");
Shape traingle =ShapeFactory.create("Traingle");
traingle.sayHello();
Shape circle =ShapeFactory.create("Circle");
circle.sayHello();
Shape traingle3 =ShapeFactory.create("Traingle");
traingle3.sayHello();
Shape circle3 =ShapeFactory.create("Circle");
circle3.sayHello();
System.out.println("============简单工厂---缓存模式==================");
Shape traingle1 =ShapeFactory.createSingle("Traingle");
traingle1.sayHello();
Shape circle1 =ShapeFactory.createSingle("Circle");
circle1.sayHello();
Shape traingle2 =ShapeFactory.createSingle("Traingle");
traingle2.sayHello();
Shape circle2 =ShapeFactory.createSingle("Circle");
circle2.sayHello();
}
}
工厂方法模式
是简单工厂模式的优化版,
有一个工厂抽象类,然后有很多具体的工厂.
当有新的产品需要生产时候,只需要新建一个具体工厂,就能生产,而不是在原来的工厂中,进行修改. 每个具体工厂类只能创建一个具体产品类的实例。 体现了修改关闭原则.
抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
类图举例
代码实现
1.抽象产品类(同简单工厂)
2.具体产品类(同简单工厂)
3.一个抽象工厂类
public abstract class ShapeFactory {
/** @pdOid 4a15aecb-010c-4d48-811a-92b793f6612b */
public abstract Shape create();
}
4.多个具体工厂类
public class CircleFactory extends ShapeFactory {
/** @pdOid ffffb088-9334-47a3-bfb8-f99ddd6c77a1 */
public Shape create() {
// TODO: implement
return new Circle();
}
public class TraingleFactory extends ShapeFactory {
/** @pdOid 50f4544e-9c7a-407b-9478-247f45072997 */
public Shape create() {
// TODO: implement
return new Traingle();
}
}
5.测试类
public class Test {
public static void main(String[] args) {
System.out.println("==========工厂方法模式=========");
ShapeFactory factory=new TraingleFactory();
Shape shape=factory.create();
shape.sayHello();
ShapeFactory factory1=new CircleFactory();
Shape shape1=factory1.create();
shape1.sayHello();
}
}
==========工厂方法模式=========
Hello, I am Traingle from ShapeFactory! My address is 366712642
Hello, I am Circle from ShapeFactory!My address is 1829164700
抽象工厂模式
抽象工厂模式： 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类可以创建多个具体产品类的实例。
类图
代码实现
1.抽象产品
public interface Color {
/** @pdOid a12f0089-9a07-4426-8f7e-af49aa2a79bb */
int fill();
}
public interface Shape {
/** @pdOid 5a0c95e5-55e1-471e-a61a-740a673aece8 */
int draw();
}
2.抽象工厂
public abstract class AbstractFactory {
/** @pdOid 11ac6789-7964-4e4a-87a9-a64a69a506e5 */
public abstract Color getColor(String type);
/** @pdOid 3a57f707-a85a-4703-a3ff-084c6dd11587 */
public abstract Shape getShape(String type);
}
3.实体工厂
public class ColorFactory extends AbstractFactory {
/** @pdOid 4fb42edd-3722-4c38-9e14-86435450ccc1 */
public Color getColor(String shapeType) {
// TODO: implement
if (shapeType.equals("Red")) {
return new Red();
} else if (shapeType.equals("Blue")) {
return new Blue();
}
return null;
}
@Override
public Shape getShape(String type) {
// TODO Auto-generated method stub
return null;
}
}
/** @pdOid 5f64c413-67bb-4255-9197-9fb9f9a6d502 */
public class ShapeFactory extends AbstractFactory {
/** @pdOid 4e659634-78f7-48ae-9751-d3beaf5cc550 */
public Shape getShape(String shapeType) {
if (shapeType.equals("Traingle")) {
return new Traingle();
} else if (shapeType.equals("Circle")) {
return new Circle();
}
return null;
}
@Override
public Color getColor(String shapeType) {
// TODO Auto-generated method stub
return null;
}
}
4.创建工厂的驱动
public class FactoryCreator {
public static AbstractFactory createFactory(String type){
if (type.equals("Color")) {
return new ColorFactory();
} else if (type.equals("Shape")) {
return new ShapeFactory();
}
return null;
}
}
测试
public class Test {
public static void main(String[] args) {
System.out.println("==========抽象工厂模式=========");
AbstractFactory factory = FactoryCreator.createFactory("Color");
factory.getColor("Red").fill();
System.out.println("==========极限调用.感觉好帅...=========");
FactoryCreator.createFactory("Shape").getShape("Circle").draw();
}
}
==========抽象工厂模式=========
Hello, I am Red from ColrFactory!My address is 366712642
==========极限调用.感觉好帅...=========
Hello, I am Circle from ShapeFactory!My address is 1829164700
工厂总结
简单工厂模式:
0.实体产品:产品是什么,能抽象成什么.
1.要知道要什么产品,将产品抽象话,作为抽象产品(产品抽象类),
2.建一个实体工厂,准备开工.
3.生产同一类产品的不同型号(就像同一种猪不同的大小,重量等).
优点:灵活,简单
工厂方法:
0.实体产品:产品是什么,能抽象成什么.
1.抽象产品:目前有一种类型,不同型号的产品(图形),
2.抽象工厂:工厂要做生产不同图形.
3.建立实体工厂:分别将要生产的同类型的产品,按照不同型号(三角形,圆形)分别创建工厂.由实 体工厂提供产品.
优势:以后如果想要生产一个不同的产品,就可以直接 创建产品实体,继承抽象工厂创建实体工厂,进行生产,而不修改其他,体现开闭原则
抽象工厂模式:
抽象二字,体现在 抽象工厂,抽象出要生产的产品种类.
当有多种产品的时候(多个产品族),可以考虑用抽象工厂模式,用一个抽象工厂(抽象出所需要的产品种类),然后用多个实体工厂(建造同族中不同的产品).
当有新的产品进入的时候,只需要添加抽象产品到抽象工厂,然后创建相应的工厂即可,
体现了依赖倒置原则 :依赖于抽象,依赖于抽象,即程序中所有的依赖关系都应该终止于抽象类或者接口.要针对接口编程，不针对实现编程。
优势:针对于多种产品,抽象出所需产品即可.
缺点:模式过于臃肿,添加产品要修改抽象工厂.
区别： 工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。 工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。
总而言之,
工厂模式,是利用封装,继承和多态属性,实现父类引用指向子类对象,进行依赖倒置,面向抽象和接口编程,实现同一父类下各个子类的互换，而客户端可以毫不察觉。进而达到 不需要知道具体的构建过程,就能得到相应的结果.并尽量保持对扩展开放,对修改关闭.
模式,就是模式,没有必要完全遵守,适时适地,灵活运用,才是根本..
自己愚见,未能深刻领悟,有不足之处,希望能一起探讨.
