设计模式—三种工厂模式(JAVA)
Posted 刘大飞
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了设计模式—三种工厂模式(JAVA)相关的知识,希望对你有一定的参考价值。
一:简单工厂:
有一个实际工厂,这个工厂只能造一类的产品,这一类产品就是一个产品接口,会有多个具体产品实现这个接口,例 如,一个手机厂,生产苹果手机,三星手机;
缺点:在工厂类中集中了所有实例的创建逻辑,违反了高内聚责任分配原则,将全部创建逻辑集中到了一个工厂类中;对系统的维护和扩展不利;
使用场景:负责创建的对象比较少;客户只知道传入工厂类的参数,对于如何创建对象的逻辑不关心;容易违反高内聚责任分配原则,所以只在很简单的情况下应用;
package com.designPattern.simpleFactory;
public interface Shape { // 产品接口
public String toString();
}
package com.designPattern.simpleFactory;
public class ShapeA implements Shape { // 具体产品
@Override
public String toString()
{
return "shape A";
}
}
package com.designPattern.simpleFactory;
public class ShapeB implements Shape { // 具体产品
@Override
public String toString()
{
return "shape B";
}
}
package com.designPattern.simpleFactory;
public class ShapeFactory {
public static Shape createShape(String shapeStr)
{
switch(shapeStr)
{
case "ShapeA": return new ShapeA();
case "ShapeB": return new ShapeB();
}
return null;
}
public static void main(String[] args)
{
Shape A = ShapeFactory.createShape("ShapeA");
Shape B = ShapeFactory.createShape("ShapeB");
System.out.println(A);
System.out.println(B);
}
}
二:工厂方法:
比简单工厂高级一点了,一个工厂的接口,多个工厂实现这个工厂接口,一个产品接口,多个具体产品实现这个产品接口,例如,一个手机厂接口,有苹果手机厂,三星手机厂两个具体工厂,苹果手机厂生产苹果手机,三星手机厂生产三星手机;可以在不修改具体工厂角色的情况下引用新的产品,一个抽象工厂对应一个抽象产品,一个具体工厂对应一个具体产品。
使用场景:对于某个产品,调用者清楚知道应该使用哪个具体工厂服务,实例化该具体工厂,生产出具体的产品来;
package com.designPattern.factoryMethod;
public interface Car { // 产品接口
void gotowork();
}
package com.designPattern.factoryMethod;
public interface ICarFactory { // 生产产品的类厂接口
Car getCar();
}
package com.designPattern.factoryMethod;
public class Bike implements Car { // 具体产品
@Override
public void gotowork() {
// TODO Auto-generated method stub
}
}
package com.designPattern.factoryMethod;
public class Bus implements Car { // 具体产品
@Override
public void gotowork() {
}
}
package com.designPattern.factoryMethod;
public class BikeFactory implements ICarFactory { // 具体产品工厂
@Override
public Car getCar() {
// TODO Auto-generated method stub
return null;
}
}
package com.designPattern.factoryMethod;
public class BusFactory implements ICarFactory { // 具体产品工厂
@Override
public Car getCar() {
return null;
}
}
package com.designPattern.factoryMethod;
public class TestFactory {
public static void main(String[] args)
{
ICarFactory factory = null;
factory = new BikeFactory();
Car bike = factory.getCar();
bike.gotowork();
factory = new BusFactory();
Car bus = factory.getCar();
bus.gotowork();
}
}
三:抽象工厂:
前两种工厂,说到底都只能生产一类产品(都是手机),抽象工厂支持多种类型的产品。一个工厂接口,多个 具体工厂,多个产品接口,多个具体产品,例如,电器厂接口,有三星厂和苹果厂两个具体工厂,三星厂生产三星手机, 三星电脑,苹果厂生产苹果手机,苹果电脑。户端在不必指定产品的具体情况下,创建多个产品族中的产品对象。
package com.designPattern.abstractFactory;
public interface AbstractFactory { // 抽象工厂
public ProductA factoryA();
public ProductB factoryB();
}
package com.designPattern.abstractFactory;
public class ConcreateFacotry1 implements AbstractFactory { //具体工厂
@Override
public ProductA factoryA() {
return new ConcreateProductA1();
}
@Override
public ProductB factoryB() {
return new ConcreateProductB1();
}
}
package com.designPattern.abstractFactory;
public class ConcreateFactory2 implements AbstractFactory { //具体工厂
@Override
public ProductA factoryA() {
return new ConcreateProductA2();
}
@Override
public ProductB factoryB() {
// TODO Auto-generated method stub
return new ConcreateProductB2();
}
}
package com.designPattern.abstractFactory;
public interface ProductA { // 抽象产品
public void method1();
public void method2();
}
package com.designPattern.abstractFactory;
public interface ProductB { // // 抽象产品
public void method1();
public void method2();
}
package com.designPattern.abstractFactory;
public class ConcreateProductA1 implements ProductA { // 具体产品
@Override
public void method1() {
System.out.println("等级为1的A的method1");
}
@Override
public void method2() {
System.out.println("等级为1的A的method2");
}
}
package com.designPattern.abstractFactory;
public class ConcreateProductA2 implements ProductA { // 具体产品
@Override
public void method1() {
System.out.println("等级为2的A的method1");
}
@Override
public void method2() {
System.out.println("等级为2的A的method2");
}
}
package com.designPattern.abstractFactory;
public class ConcreateProductB1 implements ProductB { // 具体产品
@Override
public void method1() {
System.out.println("等级为1的B的method1");
}
@Override
public void method2() {
System.out.println("等级为1的B的method2");
}
}
package com.designPattern.abstractFactory;
public class ConcreateProductB2 implements ProductB { // 具体产品
@Override
public void method1() {
System.out.println("等级为2的产品B的method1()");
}
@Override
public void method2() {
System.out.println("等级为2的产品B的method2()");
}
}
package com.designPattern.abstractFactory;
public class test {
public static void main(String[] args) {
AbstractFactory ff = new ConcreateFacotry1();
ProductA aa = ff.factoryA();
ProductB bb = ff.factoryB();
aa.method1();
aa.method2();
bb.method1();
bb.method2();
AbstractFactory f2 = new ConcreateFactory2();
aa = f2.factoryA();
bb = f2.factoryB();
aa.method1();
aa.method2();
bb.method1();
bb.method2();
}
}
以上是关于设计模式—三种工厂模式(JAVA)的主要内容,如果未能解决你的问题,请参考以下文章