设计模式-工厂模式

目录

1 简单工厂方法

2 工厂方法

3 抽象工厂方法

4 抽象工厂方法+简单工厂方法

简单工厂方法

 

简单工厂的工厂类使用静态方法，通过不同的入参实例化不同的对象并返回（这里利用反射机制进行实例化对象）

能够横向的添加产品，而不改动源码

产品接口

package simple;
public interface Z {
    public void method1();
    public void method2();
}

 

A1产品

package simple;
public class A1 implements Z{
    @Override
    public void method1() {
        System.out.println("A--method1");
    }
    @Override
    public void method2() {
        System.out.println("A--method2");
    }
}

 

工厂类

public class Factory {
    public static Z getFunctionInstence(String type) throws Exception{
        Z z =null;
        z = (Z) Class.forName(type).newInstance();
        return z;
    } 
}

 测试类

@Test
    public void testFactory() {
        try {
            Factory.getFunctionInstence("simple.A1").method2();
            Factory.getFunctionInstence("simple.B1").method2();
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }

 

结果

A--method2
B--method2

 

 

 

工厂方法

 

工厂方法的工厂类实现了统一的控制接口，对于实例化不同的产品，只需要变换实现接口的工厂类即可

产品类及接口略

 

工厂接口

package standard;
public interface IFunctionFactory {
    public Z getInstence();
}

 

工厂A

package standard;
public class FactoryA implements IFunctionFactory{
    @Override
    public Z getInstence() {
        return new A1();
    }
}

 

工厂B

package standard;
public class FactoryB implements IFunctionFactory{
    @Override
    public Z getInstence() {
        return new B1();
    }
}

 

测试类

@Test
    public void testFactory() {
        IFunctionFactory factory;
         factory= new FactoryA();
         factory.getInstence().method1();
         
         factory = new FactoryB(); //通过改变工厂接口的实现
         factory.getInstence().method1();
    }

 

结果

A--method1
B--method1

 

 

抽象工厂方法

 

 

抽象工厂的管理模式与工厂模式类似，但由于工厂类中有多种方法，可以同时对不同组的产品进行管理

工厂接口

package abstractFactory;
public interface IFunctionFactory {
    public X getInstence1();
    public Y getInstence2();
}

 

工厂A

package abstractFactory;
public class FactoryA implements IFunctionFactory{
    @Override
    public X getInstence1() {
        return new A1();
    }
    @Override
    public Y getInstence2() {
        return new A2();
    }
}

 

工厂B

package abstractFactory;
public class FactoryB implements IFunctionFactory{
    @Override
    public X getInstence1() {
        return new B1();
    }
    public Y getInstence2() {
        return new B2();
    }
}

 

产品接口X,Y（略）

package abstractFactory;
public interface X {
    public void method1();
    public void method2();
}

继承产品接口X的产品A1,B1（略）

package abstractFactory;
public class A1 implements X{
    @Override
    public void method1() {
        System.out.println("A1--method1");
    }
    @Override
    public void method2() {
        System.out.println("A1--method2");
    }
}

 

继承产品接口Y的产品A2，B2（略）

package abstractFactory;
public class A2 implements Y{
    @Override
    public void method1() {
        System.out.println("A2--method1");
    }
    @Override
    public void method2() {
        System.out.println("A2--method2");
    }
}

 

测试类

package abstractFactory;


import org.junit.Before;
import org.junit.Test;

public class FunctionFactoryTest {

    @Before
    public void setUp() throws Exception {
    }

    @Test
    public void testFactoryA() {
        IFunctionFactory factory ;
        factory = new FactoryA();
        factory.getInstence1().method1();
        factory.getInstence2().method1();
        factory = new FactoryB();
        factory.getInstence1().method2();
        factory.getInstence2().method2();
    }

}

 

结果

A1--method1
A2--method1
B1--method2
B2--method2

 

 简单工厂方法改造抽象方法

 抽象工厂方法用于对产品组进行管理，但是修改的时候需要修改的类较多。

 通过简单工厂放方法对工厂类进行改造一定程度上可以实现开闭原则。

工厂类

package combination;
public class Factory {
    String type="";
    Factory(String type){
        this.type=type;
    }
    public X getFactoryX() throws Exception{
        return (X) Class.forName(type+"1").newInstance();
    }
    
    public Y getFactoryY(String type) throws Exception{
        return (Y) Class.forName(type+"2").newInstance();
    }
}

 

测试类

@Test
    public void test() throws Exception {
        Factory factory = new Factory("combination.B");
        factory.getFactoryX().method2();
    }

 

结果

B1--method2