Android设计模式---工厂方法模式和抽象工厂模式

工厂模式:

定义:
定义一个用于创建对象的接口，让子类决定实例化那个类。
使用场景
在任何需生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，用new就可以完成创建的对象无需使用工厂模式。
工厂模式的通用代码

/**
 * 产品类的抽象方法
 * 由具体产品去实现
 */
public abstract class Product {
    public abstract void method();
}


/**
 * 具体产品类 
 */

public class ConcreteProduct extends Product {
    @Override
    public void method() {
        //实现具体的方法
    }
}

public abstract class Factor {
    /**
     * 抽象工厂方法
     * 具体生产什么由子类去实现
     */
    public abstract Product createProduct();
}
/**
 * 具体工厂类
 */
public class ConcreteFactor extends Factor {
    @Override
    public Product createProduct() {
        return new ConcreteProduct();
    }
}
//我们使用Activity作为客户类
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //创建一个具体工厂
        Factor factor=new ConcreteFactor();
        //通过具体工厂创建产品
        Product p=factor.createProduct();
        p.method();
    }
}

静态工厂模式

/**
 * 静态工厂模式,是工厂模式的一个弱化版本
 */

public class StaticFactor {
    public static Product createProduct(){
        return new ConcreteProduct();
    }
}

工厂方法的模拟实例

模拟一个NOKIA手机工厂的一个例子:
首相我们创建一个诺基亚的工厂(此工厂可以生产手机)

public abstract class NokiaFactory {
    /**
     * 诺基亚某型号的工厂方法
     */
    public abstract <T extends NokiaPhone > T createNOKIAPhone (Class<T> clas);
}

然后创建一个手机的生产线

public class NOKIAPhoneFactor extends NokiaFactory {
    @Override
    public <T extends NokiaPhone> T createNOKIAPhone(Class<T> clas) {
        NokiaPhone phone=null;
        try {
            phone= (NokiaPhone) Class.forName(clas.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) phone;
    }
}

手机的抽象产品类 手机可以打电话和发信息

public abstract class NokiaPhone {
    //手机可以打电话
    public abstract void call();
    //手机可以发短信
    public abstract void send_sms();
}

具体手机的型号 N85和N97

public class NokiaN85 extends NokiaPhone {
    @Override
    public void call() {
        Log.e("nokia","N85打电话");
    }

    @Override
    public void send_sms() {
        Log.e("nokia","N85发信息");

    }
}
public class NokiaN97 extends NokiaPhone {
    @Override
    public void call() {
        Log.e("nokia","N97打电话");
    }

    @Override
    public void send_sms() {
        Log.e("nokia","N97发信息");
    }
}

最后组装起来成为一个完整的流水线:

public class Client  extends AppCompatActivity{
    @Override
    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);
        //先实例一个诺基亚制作手机的Phone工厂
        NokiaFactory nokiaFactory= new NOKIAPhoneFactor();
        //从这个工厂中生产N85
        NokiaN85 nokiaN85=nokiaFactory.createNOKIAPhone(NokiaN85.class);
        nokiaN85.call();
        nokiaN85.send_sms();
        //从这个工厂中生产N97
        NokiaN97 nokiaN97=nokiaFactory.createNOKIAPhone(NokiaN97.class);
        nokiaN97.call();
        nokiaN97.send_sms();
    }
}

源码中的工厂方法:

ArrayList和HashSet中的iterator方法就是一个工厂的方法,专门为new对象而生,这里iterator方法是构造并返回一个具体的迭代器.

抽象工厂模式

定义:
为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定他们的具体实现类。

通用代码

两个抽象产品

public abstract class AbstractProductA {
    //每个具体的产品子类需要实现的方法:
    public abstract void method();
}
public abstract class AbstractProductB {
    //每个具体的产品子类需要实现的方法:
    public abstract void method();
}

4个具体产品

public class ConcreteProductA1 extends AbstractProductA {
    @Override
    public void method() {
        Log.e("--ConcreteProductA--", "实现的具体产品A1" );
    }
}
public class ConcreteProductA2 extends AbstractProductA {
    @Override
    public void method() {
        Log.e("--ConcreteProductA--", "实现的具体产品A2" );
    }
}

public class ConcreteProductB1 extends AbstractProductB {
    @Override
    public void method() {
        Log.e("--ConcreteProductB--", "实现的具体产品B1" );
    }
}
public class ConcreteProductB2 extends AbstractProductB {
    @Override
    public void method() {
        Log.e("--ConcreteProductB--", "实现的具体产品B2" );
    }
}

抽象工厂

public abstract class AbstractFactory {
    //创建产品A的方法
    public abstract AbstractProductA createProductA();
    //创建产品B的方法
    public abstract AbstractProductB createProductB();
}

2个具体工厂

public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

总结

抽象工厂在使用中出现的很少,除非要建立多个产品种类的情况,一般情况用工厂方法即可解决.
优点
分离接口与实现,从具体的产品实现中解耦,同时基于接口与实现的分离,使抽象工厂方法模式在切换产品类的时候更加灵活容易
缺点:
类的文件过于多和不太容易扩展新的产品类,因为每当我们增加一个产品就要修改抽象工厂,那么具体的工厂类都会被修改.