设计模式：工厂设计模式

工厂模式

用于创建对象的接口，交给子类去实现

• 普通工厂模式：生产具体的产品，创建的产品是类(Class)。
• 抽象工厂模式：生产抽象的产品，创建的产品是接口(Interface)。

普通工厂模式举例

我们举一个生产Nokia的例子

public abstract class NokiaPhone{
        public abstract void powerOnPhone(); 
}

先试定义了一个抽象类，抽象出方法powerOnPhone()，模拟手机开机的动作

public class Nokia5200 extends NokiaPhone{
@Override
    public void powerOnPhone() {
        Log.d("Factory","Nokia5200 power on");
    }
}

public class NokiaN97 extends NokiaPhone{
    @Override
    public void powerOnPhone() {
        Log.d("Factory","NokiaN97 power on");
    }
}

然后我们定义了具体的手机Nokia5200和NokiaN97两款手机。并实现了抽象方法powerOnPhone
现在产品定义好了，我们就要定义工厂了，首先我们也抽象出工厂的方法

public abstract class Factroy{  
      public abstract <T extends Nokia>T createNokia(Class<T> clazz);
}

工厂的方法无非就是生产手机，所以我们抽象出来了createNokia方法，现在我们来定义工厂

public class NokiaFactory extends Factroy{
 @Override
    public <T extends NokiaPhone> T createNokia(Class<T> clz) {
           NokiaPhone nokiaPhone = null;
        try {
            nokiaPhone = (NokiaPhone) Class.forName(clz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return (T) nokiaPhone;
    }
}

使用

NokiaFactory nokiaFactory = new NokiaFactory();
Nokia5200 nokia5200 = nokiaFactory.createNokia(Nokia5200.class);
NokiaN97 nokiaN97 = nokiaFactory.createNokia(NokiaN97.class);

抽象工厂举例

抽象工厂我们举例一个生产Iphone零件的例子。
我们先定义产品，这里是生产零件，我们定义两个抽象产品，一个CPU

public interface component{
   public interface CPU {
        void showCpuName();
    }

    public interface Battery {
        void showBatteryCapacity();
    }
}

然后我们定义CPU的具体产品，一个A9，一个A10

public class A9 implements component.cpu{
@Override
    public void showCpuName() {
        Log.d("AbstractFactory","A9");
    }
}
public class A10 implements component.cpu{
@Override
    public void showCpuName() {
        Log.d("AbstractFactory","A10");
    }
}

然后是两种电池产品，一个1000ma，一个1200ma
public class Battery1000ma implements component.Battery {
    @Override
    public void showBatteryCapacity() {
        Log.d("AbstractFactory","battery is 1000ma");
    }
}
public class Battery1200ma implements component.Battery {
    @Override
    public void showBatteryCapacity() {
        Log.d("AbstractFactory","battery is 1200ma");
    }
}

产品定义好了，我们来定义工厂了,依旧先用抽象类，抽象出工厂类的方法

public abstract class Factory{
   public abstract component.cpu  createCPU();
    public abstract component.Battery createBattery();
}

工厂创建完了，改生产了

public class IPhone6Factory extends Factory {
    @Override
    public component.CPU createCPU() {
        return new A9();
    }

    @Override
    public component.Battery createBattery() {
        return new Battery1000ma();
    }
}
public class Iphone7Factory extends Factory {
    @Override
    public component.CPU createCPU() {
        return new A10();
    }

    @Override
    public component.Battery createBattery() {
        return new Battery1200ma();
    }
}

工厂模式降低了对象之间的耦合度，由于工厂模式依赖抽象的架构，实例化的任务交由子类去完成，所以有很好的扩展性。但是工厂模式的缺点也比较明显，就是不太容易扩展新的产品类，需要去改具体的产品类和工厂类