本文已参与「新人创作礼」活动，一起开启掘金创作之路。
Android中的工厂模式
工厂模式我们分为普通工厂（生产具体的产品，创建的产品是类）与抽象工厂（生产抽象的产品，创建的产品是接口）。
普通工厂模式(Factory Method)：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。从而使一个类的实例化延迟到其子类。
抽象工厂模式(Abstract Factory)：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
一、普通工厂模式
先定义一个Usb功能的接口
public interface Usb {
void store(); //存储功能
}
定义一个手机实现Usb功能
public class Phone implements Usb {
@Override
public void store() {
System.out.println("this is Phone usb!");
}
public void call() {
//TODO
}
public void sms() {
//TODO
}
}
定义一个相机实现Usb功能
public class Camera implements Usb {
@Override
public void store() {
System.out.println("this is Camera usb!");
}
public void takePhotos() {
//TODO
}
}
我们创建一个工厂来生成手机还是相机
public class UsbFactory1 {
public Usb produce(String type) {
if ("phone".equals(type)) {
return new Phone();
} else if ("camera".equals(type)) {
return new Camera();
} else {
System.out.println("请输入正确的类型!");
return null;
}
}
}
使用
UsbFactory1 factory1 = new UsbFactory1();
Usb usb1 = factory1.produce("camera");//+phone
usb1.store();
当然在工厂中我们还可以分开定义生产手机和相机的方法
public class UsbFactory2 {
public Usb producePhone() {
return new Phone();
}
public Usb produceCamera() {
return new Camera();
}
}
使用：
UsbFactory2 factory2 = new UsbFactory2();
Usb usb2 = factory2.producePhone();
usb2.store();
当然我们也可以通过反射的方式创建
public abstract class Factory {
public abstract <T extends Usb> T createNokia(Class<T> clz);
}
public class UsbFactory3 extends Factory {
@Override
public <T extends Usb> T createProdect(Class<T> clz) {
Usb usb = null;
try {
usb = (Usb) Class.forName(clz.getName()).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return (T) usb;
}
}
使用
UsbFactory3 usbFactory3 = new UsbFactory3();
Phone phone = usbFactory3.createProdect(Phone.class);
phone.store();
Camera camera = usbFactory3.createProdect(Camera.class);
camera.store();
可以看到普通的工厂创建的类就是之类的对象，不管是new出来还是通过反射创建，其本质都是之类的对象。
二、抽象工厂模式
接着上面的例子，我们修改一下把生产的方法抽取成接口
public interface Provider {
Usb produce();
}
让每个产品都有自己的工厂
public class PhoneFactory implements Provider {
@Override
public Usb produce() {
return new Phone();
}
}
public class CameraFactory implements Provider {
@Override
public Usb produce() {
return new Camera();
}
}
每一个产品可以根据自己的业务来去工厂生产产品，如要生产相机
Provider provider = new CameraFactory();
Usb usb4 = provider.produce();
usb4.store();
三、复杂的抽象工厂
接着上面的抽象工厂，再复杂一点，我们可以定义多个接口，接口里面返回接口对象，再定义抽象工厂方法来创建对象
比如我们生产一个笔记本电脑。
public interface component {
public interface CPU {
void showCpuName();
}
public interface Screen {
void showScreenSize();
}
}
再定义接口实现CUP的生产
public class I5 implements component.CPU {
@Override
public void showCpuName() {
Log.d("AbstractFactory","I5");
}
}
public class I7 implements component.CPU {
@Override
public void showCpuName() {
Log.d("AbstractFactory","I7");
}
}
再定义接口实现屏幕的生产
public class Screen15 implements component.Screen {
@Override
public void showScreenSize() {
Log.d("AbstractFactory","Screen size is 15");
}
}
public class Screen17 implements component.Screen {
@Override
public void showScreenSize() {
Log.d("AbstractFactory","Screen size is 17");
}
}
定义抽象工厂
public abstract class Factory {
public abstract component.CPU createCPU();
public abstract component.Screen createScreen();
}
使用工厂生产产品
public class HuaweiFactory extends Factory {
@Override
public component.CPU createCPU() {
return new I5();
}
@Override
public component.Screen createScreen() {
return new Screen15();
}
}
public class LenoverFactory extends Factory {
@Override
public component.CPU createCPU() {
return new I7();
}
@Override
public component.Screen createScreen() {
return new Screen17();
}
}
可以看到 HuaweiFactory 和 LenoverFactory 两个工厂模式他们创建的产品相同，都是创建 CPU 和 Screen 这两个抽象产品。而这两个抽象产品又可以是同接口不同子类实例。
到处工厂模式就讲到这里，其实如果让我选我选抽象工厂模式，因为扩展性更好。更值得推荐。
好啦，完结！
