工厂模式抽象工厂模式区别
在设计模式中，工厂模式和抽象工厂模式是两种常用的创建型模式。虽然它们都试图隐藏具体对象的创建过程，但它们之间有许多区别。下面从多方面对这两种模式进行分析比较。
定义
工厂模式：工厂模式是一种创建型模式，它提供了一种创建对象的最佳方式，而无需指定要创建对象的确切类。工厂模式将其子类的实例化推迟到或委托到基类中。
抽象工厂模式：抽象工厂模式是一种创建型模式，它允许客户机创建对象族而无需指定其具体类。抽象工厂定义了一些方法来创建单个对象或对象系列，而子类或实例化工厂将具体工厂方法实现为对其类的实例化。
结构
工厂模式包含以下组件：
1. Creator：Creator类是一个包含factoryMethod（）方法的抽象类。
2. ConcreteCreator：具体 创建器是用于创建具体产品的子类。
3. Product：产品是工厂方法创建的对象。产品是一个抽象类或接口。
4. ConcreteProduct：ConcreteProduct是Product的实现类。
抽象工厂模式由以下组件组成：
1. AbstractFactory：抽象工厂是用于创建对象系列的接口。抽象工厂声明一组创建对象的方法，每种方法对应一种产品。
2. ConcreteFactory：ConcreteFactory是创建对象系列的实现类。ConcreteFactory实现由AbstractFactory定义的工厂方法。
3. AbstractProduct：抽象产品是每个产品系列的声明。抽象产品是一个接口，可以实现具体的产品或产品系列。
4. ConcreteProduct：具体产品是产品系列的实现。ConcreteProduct实现了AbstractProduct的接口。
转换难度
工厂模式是一种简单的创建型模式，因为它需要仅一个类和一个方法。利用工厂模式，可以使其他部分类共享面向对象的代码，因此更容易拓展系统。
抽象工厂模式是一种相当复杂的模式，因为它需要多个抽象类和接口。抽象工厂模式创建对象系列更加可扩展。
使用场景
工厂模式主要用于以下情况：
1. 当类不知道该创建哪个具体实现类时，可以使用工厂模式。
2. 当需要将对象的创建分离到其它应用程序或模块中时，可以使用工厂模式。
抽象工厂模式主要用于以下情况：
1. 当需要创建相关对象家族而无需是用特定类时，可以使用抽象工厂模式。
2. 当一组产品之间必须以特定方式进行交互时，可以使用工厂模式以保持一致性。
例子
工厂模式实例：
```java
// 抽象产品
public abstract class Animal {
public abstract void speak();
}
// 具体产品
public class Dog extends Animal {
@Override
public void speak() {
System.out.println("Woof!");
}
}
// 创建器
public abstract class AnimalFactory {
public abstract Animal createAnimal();
}
// 具体创建器
public class DogFactory extends AnimalFactory {
public Animal createAnimal() {
return new Dog();
}
}
// 测试
public class Test {
public static void main(String args[]) {
AnimalFactory factory = new DogFactory();
Animal dog = factory.createAnimal();
dog.speak();
}
}
```
抽象工厂模式实例：
```java
// 抽象产品
public interface Car {
String getBrand();
String getModel();
}
// 具体产品
public class BMW extends Car{
String brand = "BMW";
String model;
public BMW(String m) {
model = m;
}
public String getBrand() {
return brand;
}
public String getModel() {
return model;
}
}
public class Audi extends Car{
String brand = "Audi";
String model;
public Audi(String m) {
model = m;
}
public String getBrand() {
return brand;
}
public String getModel() {
return model;
}
}
// 抽象工厂
public interface CarFactory {
Car createSportsCar();
Car createSedanCar();
}
// 具体工厂
public class LuxuryCarFactory implements CarFactory {
public Car createSportsCar() {
return new BMW("5 Series");
}
public Car createSedanCar() {
return new Audi("A8");
}
}
// 测试
public class Test {
public static void main(String args[]) {
CarFactory factory = new LuxuryCarFactory();
Car sportsCar = factory.createSportsCar();
Car sedanCar = factory.createSedanCar();
System.out.println(sportsCar.getBrand() + " " + sportsCar.getModel()); // BMW 5 Series
System.out.println(sedanCar.getBrand() + " " + sedanCar.getModel()); // Audi A8
}
}
```
