1. 引入
工厂模式根据抽象程度的不同分为三种：简单工厂模式（也叫静态工厂模式）、工厂方法模式、以及抽象工厂模式。
工厂模式的主要优点有：
- 可以使代码结构清晰，有效地封装变化。在编程中，产品类的实例化有时候是比较复杂和多变的，通过工厂模式，将产品的实例化封装起来，使得调用者根本无需关心产品的实例化过程，只需依赖工厂即可得到自己想要的产品。
- 对调用者屏蔽具体的产品类。如果使用工厂模式，调用者只关心产品的接口就可以了，至于具体的实现，调用者根本无需关心。即使变更了具体的实现，对调用者来说没有任何影响。
- 降低耦合度。产品类的实例化通常来说是很复杂的，它需要依赖很多的类，而这些类对于调用者来说根本无需知道，如果使用了工厂方法，我们需要做的仅仅是实例化好产品类，然后交给调用者使用。对调用者来说，产品所依赖的类都是透明的。
2. 简单工厂模式
简单工厂模式中定义一个抽象类，抽象类中声明公共的特征及属性，抽象子类继承自抽象类，去实现具体的操作。工厂类根据外界需求，在工厂类中创建对应的抽象子类实例并传给外界，而对象的创建是由外界决定的。外界只需要知道抽象子类对应的参数即可，而不需要知道抽象子类的创建过程，在外界使用时甚至不用引入抽象子类。
简单工厂模式将抽象子类的创建，和关于抽象子类相关的业务逻辑分离，降低对象间的耦合度。由于工厂类只是为外界创建对象，所以并不需要实例化工厂类对象，只需要为外界提供类方法即可。外界需要什么类型的抽象子类，只需要传递对应的参数即可。外界不需要知道具体的抽象子类，只需要使用抽象类即可。
简单工厂模式主要包含三部分：
- 工厂类：根据外界的需求，决定创建并返回哪个具体的抽象子类。
- 抽象类：定义抽象子类所需的属性和方法，子类通过继承自抽象类获得这些方法。
- 抽象子类：继承自抽象类，是具体操作的实现者，根据需求重写父类继承过来的方法。
代码示例（这里使用接口的形式，关于抽象类和接口的选择可以根据具体情况而定，抽像类更侧重于属性的继承，接口更侧重于实现相同的方法，因为java的单继承问题，所以尽量多使用接口，这更利于设计中的组合原则。）：
抽象类和接口的区别（语法区别）：
- 抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；
- 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
- 接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
- 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
// 动物接口
public interface IAnimal {
//品种
public void kind();
}
// 猫类
public class Cat implements IAnimal {
@Override
public void kind() {
System.out.println("I am cat!");
}
}
//狗类
public class Dog implements IAnimal {
@Override
public void kind() {
System.out.println("I am dog!");
}
}
// 动物工厂类
public class AnimalFactory {
/**
* 这里采用反射的机制
* @param clz
* @return
*/
public static <T extends IAnimal> chooseAnimal(Class<T> clz) {
try {
return (IAnimal) Class.forName(clz.getName()).newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
}
//主类
public class Main {
public static void main(String[] args) {
IAnimal animal = AnimalFactory.chooseAnimal("Cat");
if (null != animal) {
animal.kind();
} else {
System.out.println("没有此动物！");
}
}
}3. 工厂方法模式
工厂方法模式和简单工厂模式十分类似，大致结构是基本类似的。不同在于工厂方法模式对工厂类进行了进一步的抽象，将之前的一个工厂类抽象成了抽象工厂和工厂子类，抽象工厂定义一个创建抽象子类的接口，抽象工厂的子类实现这些接口并决定实例化哪个抽象子类。工厂子类决定着创建哪个抽象子类，外界决定着创建哪种工厂子类，抽象子类和工厂子类是一一对应的。
在工厂方法模式中，和简单工厂模式一样，对外隐藏了抽象子类的创建过程，外界只需要关心工厂类即可，负责实例化的工厂子类决定着最后的结果。
工厂方法模式主要包含四部分：
- 工厂抽象类：定义创建抽象子类的接口，通过接口返回具体的抽象子类。
- 工厂子类：继承自工厂抽象类，并重写父类的方法来创建对应的抽象子类。
- 抽象类：定义抽象子类所需的属性和方法，子类通过继承自抽象类获得这些方法。
- 抽象子类：继承自抽象类，实现具体的操作。
代码示例：
//产品类
public abstract class Iphone {
public abstract void camera();
public abstract void screen();
}
//具体的产品类 Iphone7
public class Iphone7 extends Iphone {
@Override
public void camera() {
Log.e("Iphone7", "Iphone7的单摄");
}
@Override
public void screen() {
Log.e("Iphone7", "Iphone7的4.7寸屏幕");
}
}
//具体的产品类 Iphone7Plus
public class Iphone7Plus extends Iphone {
@Override
public void camera() {
Log.e("Iphone7Plus", "Iphone7Plus的双摄");
}
@Override
public void screen() {
Log.e("Iphone7Plus", "Iphone7Plus的5.5寸屏幕");
}
}
//抽象的工厂类：
public abstract class IphoneFactory {
public abstract Iphone createPhone();
}
//具体的工厂类：
public class Iphone7Factory extends IphoneFactory {
@Override
public Iphone createPhone() {
return new Iphone7();
}
}
public class Iphone7PlusFactory extends IphoneFactory {
@Override
public Iphone createPhone() {
return new Iphone7Plus();
}
}
// 测试类
public class Client {
public static void test() {
IphoneFactory factory = new Iphone7Factory();
Iphone7 iphone7 = factory.createPhone();
iphone7.camera();
iphone7.screen();
IphoneFactory factory1 = new Iphone7PlusFactory();
Iphone7Plus iphone7Plus= factory1.createPhone();
iphone7Plus.camera();
iphone7Plus.screen();
}
}
4. 抽象工厂模式
抽象工厂模式和工厂方法模式很相似，但是抽象工厂模式将抽象发挥的更加极致，是三种工厂模式中最抽象的一种设计模式。抽象工厂模式，也叫做Kit模式，提供了创建一系列相关抽象子类的接口，而无需指定它们具体的类型。
抽象工厂模式中定义了抽象工厂类，抽象工厂类中定义了每个系列的抽象子类创建所需的方法，这些方法对应着不同类型的抽象子类实例化过程。每个工厂子类都对应着一个系列，工厂子类通过重写这些方法来实例化当前系列的抽象子类。
工厂方法模式中抽象子类都是基于同一个抽象类的，是同一个类型的抽象子类，例如加、减、乘、除都属于运算类型。而抽象工厂模式可能会有多个类型的抽象类，抽象子类分别继承自对应类型的抽象类，相同类型的抽象子类都是属于不同系列的。
抽象工厂模式包含四部分：
- 抽象工厂类：定义创建抽象子类的具体行为，根据系列中不同类型的抽象子类可能会有多种行为。
- 工厂子类：继承自抽象工厂类，根据当前抽象子类对应的系列，重写父类定义的对应行为。对应的抽象子类系列不同，行为的实现方式也不同。
- 抽象类：定义当前类型抽象子类的操作，子类继承父类完成具体的操作。在抽象工厂模式中，可能会有多种抽象类的定义。
- 抽象子类：根据当前类型继承自对应的抽象类，并根据系列的不同重写抽象类定义的实现
代码示例：
// 产品 Plant接口
public interface Plant {
}
//具体产品PlantA，PlantB
public class PlantA implements Plant {
public PlantA () {
System.out.println("create PlantA !");
}
public void doSomething() {
System.out.println(" PlantA do something ...");
}
}
public class PlantB implements Plant {
public PlantB () {
System.out.println("create PlantB !");
}
public void doSomething() {
System.out.println(" PlantB do something ...");
}
}
//产品Fruit接口
public interface Fruit { }
//具体产品FruitA，FruitB
public class FruitA implements Fruit {
public FruitA() {
System.out.println("create FruitA !");
}
public void doSomething() {
System.out.println(" FruitA do something ...");
}
}
public class FruitB implements Fruit {
public FruitB() {
System.out.println("create FruitB !");
}
public void doSomething() {
System.out.println(" FruitB do something ...");
}
}
//抽象工厂方法
public interface AbstractFactory {
public Plant createPlant();
public Fruit createFruit();
}
//具体工厂方法
public class FactoryA implements AbstractFactory {
public Plant createPlant() {
return new PlantA();
}
public Fruit createFruit() {
return new FruitA();
}
}
public class FactoryB implements AbstractFactory {
public Plant createPlant() {
return new PlantB();
}
public Fruit createFruit() {
return new FruitB();
}
}
// 主类调用测试
public class Main {
public static void main(String[] args) {
AbstractFactory instance = new FactoryA();
instance.createPlant();
}
}5. 总结
1.什么时候会去用工厂模式？（简单工厂，工厂方法，抽象工厂）。
- 为了不再需要直接创建对象，降低代码耦合度。对于创建多种具有同一系列行为的物体，使用工厂方法。对于产品族使用抽象工厂。
2.简单工厂的缺点。
- 简单工厂主要违反了开闭原则：对扩展开放，对修改关闭。添加一种对象，就要去修改简单工厂中的获取对象方法。
扫一扫
2863
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
