設計模式—三種工廠模式(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)