大概
工厂模式是java设计模式中比较简单者，但却应用广泛，比如xml解析等，主要用于创建对象的时候，工厂模式的最终目的就是为了解耦，很好地诠释了“依赖倒置”。
工厂模式分为3种：
- 简单工厂
- 工厂方法
- 抽象工厂
这三种的抽象层次逐层提高，因而也有人将工厂方法当做抽象工厂的一种，理解上确实如此。
简单工厂
通俗地讲就是，一个工厂包揽了所有产品的创建，这样子就要求所有产品都需要实现同一个接口或者继承同一个抽象类（哪个方便用哪个），而有新的产品添加就需要修改工厂的“新增产品“方法
public interface Product{
void show();
}
public class Product1 implements Product{
@Override
public void show(){
System.out.println("product1");
}
}
public class Product2 implements Product{
@Override
public void show(){
System.out.println("product2");
}
}
public class Factory{
//参数只要指明是哪个物品即可
public static Product create(String name){
if(name.equals("Product1"))
return new Product1();
else
return new Product2();
}
}
工厂方法
跟简单工厂有点不同了，工厂方法极其符合“开放-封闭”原则，工厂方法将每个产品分割到不同的工厂内去生成，也就是一个工厂对应一个产品，这样子的话就要求在新增产品的时候需要增加产品类、对应的工厂类，但是对原来的工厂就不需要做修改，当然，为了统一使用工厂，所有工厂都需要实现统一接口或者继承统一抽象类
//以上的产品代码都还是可以使用，工厂的代码看如下
public interface FactoryInterface{
Product createProduct();
}
//生产Product1
public class Factory1 implements FactoryInterface{
@Override
public Product createPorduct(){
return new Product1();
}
}
//生产Product2
public class Factory2 implements FactoryInterface{
@Override
public Product createPorduct(){
return new Product2();
}
}
public static void main(){
FactoryInterface factory = null;
Product product = null;
factory = new Factory1();
product = factory.createProduct();
product.show();
factory = new Factory2();
product = factory.createProduct();
product.show();
}
抽象工厂
这个比工厂方法要再复杂一些，主要是为了适应这样子的情况，一般地，一个工厂会生产多种类的产品，也就是所谓的“产品族”（如一个工厂生产汽车，但汽车有很多种，家用、赛车等），而简单工厂只适合用于单一产品的工厂，当然了，为了同时满足最大化的“开放-封闭”原则，因而需要在工厂中为不同的产品添加生成方法
//来个具体的代码
public interface Car_family{
void show_family();
}
public interface Car_business{
void show_business();
}
public class Car1_family implements Car_family{
@Override
public void show_family(){
System.out.println("car1_family");
}
}
public class Car1_business implements Car_business{
@Override
public void show_business(){
System.out.println("car1_business");
}
}
public class Car2_family implements Car_family{
@Override
public void show_family(){
System.out.println("car2_family");
}
}
public class Car2_business implements Car_business{
@Override
public void show_business(){
System.out.println("car2_business");
}
}
public interface FactoryInterface{
Car_family create_car_family();
Car_business create_car_business();
}
public class FactoryForCar1 implements FactoryInterface{
@Override
public Car_family create_car_family(){
return new Car1_family();
}
@Override
public Car_business create_car_business(){
return new Car1_business();
}
}
public class FactoryForCar2 implements FactoryInterface{
@Override
public Car_family create_car_family(){
return new Car2_family();
}
@Override
public Car_business create_car_business(){
return new Car2_business();
}
}
public static void main(){
FactoryInterface factory = null;
Car_family car_family = null;
Car_business car_business = null;
factory = new FactoryForCar1();
factory.create_car_family().show_family();
factory.create_car_family().show_family();
factory = new FactoryForCar2();
factory.create_car_family().show_family();
factory.create_car_family().show_family();
}
是不是感觉上面的代码实在太繁杂，没关系，java还有反射
//以上产品的代码继续使用，工厂的见下面
public interface FactoryInterface{
Car_family create_car_family(String name);
Car_business create_car_business(String name);
}
public class FactoryForAll implements FactoryInterface{
//
@Override
public Car_family create_car_family(String name){
return Class.forName(name).newInstance();
}
@Override
public Car_business create_car_business(String name){
return Class.forName(name).newInstance();
}
}
public static void main(){
FactoryForAll factory = new FactoryForAll();
factory.create_car_family("com.kindol.Car1_family");
factory.create_car_family("com.kindol.Car2_family");
factory.create_car_business("com.kindol.Car1_business");
factory.create_car_business("com.kindol.Car2_business");
}
然而，抽象工厂模式的缺点很致命：产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。
网友评论