工厂模式

工厂模式

抽象工厂模式

工厂方法模式

定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到其子类。
UML类图：标准工厂模式
综合分析：

优点：
1. 封装性好（隐藏具体代码的实现），代码结构清晰。
2. 扩展性优秀。
3. 屏蔽产品类，产品类的实现与调用方无关，调用方只关心工厂接口。
缺点：
1. 代码臃肿，增加代码复杂度。
适用场景：
1. 需要灵活，可扩展的框架。
2. 产品类过多，需要统一管理。
3. 测试系统中。
拓展：

简单工厂
简单工厂模式

工厂方法模式实践

产品类

    publi abstract class Produce {
        public abstract void dosomething();
    }
    
    public class ConcreteProduceA extends Produce {
        @Override
        public void dosomething() {
            System.out.println("I am ProduceA!");
        }
    }
    
    public class ConcreteProduceB extends Produce {
        @Override
        public void dosomething() {
            System.out.println("I am ProduceB!");
        }
    }

工厂类

    public abstract class Creator {
        public abstract <T extends Produce>T createProduce(Class<T> c);
    }
    
    public class ConcreteCreator extends Creator {
        @Override
        public <T extends Produce>T createProduce(Class<T> c) {
            Produce produce = null;
            try {
                produce = (Produce)Class.forName(c.getName()).newInstance();
            } catch (Exception e) {
                // TODO: handle exception
            }
            return (T)produce;
        }
    }

客户端

public class client {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        Produce A = creator.createProduce(ConcreteProduceA.class);
        A.dosomething();
        Produce B = creator.createProduce(ConcreteProduceB.class);
        B.dosomething();
    }
}

抽象工厂模式

定义：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。
UML类图：抽象工厂模式
综合分析：

缺点：
1. 产品族拓展困难，修改产品族（例如添加一个产品3）必须要对AbstractCreator和其子类修改，严重违反了“开闭原则”。
适用场景：
1. 一个对象族有相同的约束。即类图中的，produce1和2都有A和B的约束。
2. 横向拓展容易，纵向拓展困难。（图中produce1、2拓展困难，A和B拓展简单）

抽象工厂模式实践

产品类

    public abstract class Produce1 {
        public abstract void dosomething();
    }
    
    public class ConcreteProduceA1 extends Produce1 {
        @Override
        public void dosomething() {
            System.out.println("I am ProduceA1!");
        }
    }
    
    public class ConcreteProduceB1 extends Produce1 {
        @Override
        public void dosomething() {
            System.out.println("I am ProduceB1!");
        }
    }
    
    public abstract class Produce2 {
        public abstract void dosomething();
    }
    
    public class ConcreteProduceA2 extends Produce2 {
        @Override
        public void dosomething() {
            System.out.println("I am ProduceA2!");
        }
    }
    
    public class ConcreteProduceB2 extends Produce2 {
        @Override
        public void dosomething() {
            System.out.println("I am ProduceB2!");
        }
    }

工厂类

    public abstract class Creator {
        public abstract Produce1 createProduce1();
        public abstract Produce2 createProduce2();
    }
    
    public class ConcreteCreatorA extends Creator {
        @Override
        public Produce1 createProduce1(){
            return new ConcreteProduceA1();
        }
        
        @Override
        public Produce2 createProduce2() {
            return new ConcreteProduceA2();
        }
    }
    
    public class ConcreteCreatorB extends Creator {
        @Override
        public Produce1 createProduce1(){
            return new ConcreteProduceB1();
        }
        
        @Override
        public Produce2 createProduce2() {
            return new ConcreteProduceB2();
        }
    }

客户端

public class client {
    public static void main(String[] args) {
        Creator creatorA = new ConcreteCreatorA();
        Creator creatorB = new ConcreteCreatorB();
        Produce1 A1 = creatorA.createProduce1();
        A1.dosomething();
        Produce2 A2 = creatorA.createProduce2();
        A2.dosomething();
        Produce1 B1 = creatorB.createProduce1();
        B1.dosomething();
        Produce2 B2 = creatorB.createProduce2();
        B2.dosomething();
    }
}

源代码