Java设计模式之工厂模式
内容整理自《大话设计模式》
1.简单工厂模式
属于创建型模式，又叫做静态工厂方法模式，不属于23种GOF设计模式之一。是由一个工厂对象决定创建出哪一种产品类的实例。实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。
作用：将“类实例化的操作”与“使用对象的操作”分开，让使用者不用知道具体参数就可以实例化出所需要的“产品”类，从而避免了在客户端代码中显式指定，实现了解耦。
优点：将创建使用工作分开，不必关心类对象如何创建，实现了解耦；
缺点：违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂。
public interface Resaurant {
void cook();}
public class Duck implements Resaurant{
public void cook() {
System.out.println("来一份烤鸭");
}}
public class Fish implements Resaurant{
public void cook() {
System.out.println("来一份红烧鱼");
}}
public class Meet implements Resaurant {
public void cook() {
System.out.println("来一份回锅肉");
}}
public class Wait {
public static final int MEAN_MEET = 1;
public static final int MEAN_FISH = 2;
public static final int MEAN_DUCK = 3;
public static Resaurant getMean(int meantype){
switch (meantype){
case MEAN_MEET :
return new Meet();
case MEAN_FISH :
return new Fish();
case MEAN_DUCK :
return new Duck();
default:
return null;
}
}}
public class Factory {
public static void main(String[] args) {
//简单工厂模式
Resaurant resaurant = Wait.getMean(Wait.MEAN_DUCK);
resaurant.cook();
}}
2.工厂方法模式
又称工厂模式、多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。一种常用的对象创建型设计模式,此模式的核心精神是封装 类中不变的部分。
工厂方法模式（Factory Method），定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
public abstract class CookFactory {
public abstract Resaurant createRestaurant();}
public class DuckFactory extends CookFactory {
@Override
public Resaurant createRestaurant() {
return new Duck();
}}
public class FishFactory extends CookFactory {
public Resaurant createRestaurant() {
return new Fish();
}}
public class Cook {
//工厂方法模式
public static void main(String[] args) {
Resaurant duck = new DuckFactory().createRestaurant();
duck.cook();
Resaurant fish = new FishFactory().createRestaurant();
fish.cook();
}}
3.抽象工厂模式
定义：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。
解决的问题：每个工厂只能创建一类产品（工厂方法模式）
抽象工厂模式与工厂方法模式最大的区别：抽象工厂中每个工厂可以创建多种类的产品；而工厂方法每个工厂只能创建一类
/**
* @ Product.java
* 抽象产品族 (食品)
*/abstract class Product {
//产品介绍
abstract void intro();}
/**
* @ ProductA.java
* 抽象产品 (饮料)
*/abstract class ProductA extends Product{
@Override
abstract void intro();}
/**
* @ ProductB.java
* 抽象产品 (零食)
*/abstract class ProductB extends Product{
@Override
abstract void intro();}
/**
* @ ProductAa.java
* 具体产品 (矿泉水)
*/
public class ProductAa extends ProductA{
@Override
void intro() {
System.out.println("矿泉水");
}}
/**
* @ ProductBb.java
* 抽象产品 (面包)
*/
public class ProductBb extends ProductB{
@Override
void intro() {
System.out.println("面包");
}}
/**
* @ Factory.java
* 抽象工厂
*/abstract class Factory {
//生产饮料
abstract Product getProductA();
//生产零食
abstract Product getProductB();}
/**
* @ FactoryA.java
* 具体工厂A
* 负责具体的A类产品生产
*/
public class FactoryA extends Factory{
@Override
Product getProductA() {
//生产矿泉水
return new ProductAa();
}
@Override
Product getProductB() {
//生产面包
return new ProductBb();
}}
public class Test {
public static void main(String[] args) {
//创建零食售卖机（具体工厂），
FactoryA factoryA = new FactoryA();
//获取矿泉水与面包（具体产品）
factoryA.getProductA().intro();
factoryA.getProductB().intro();
}}
优点：
- 降低耦合
- 符合开-闭原则
- 符合单一职责原则
- 不使用静态工厂方法，可以形成基于继承的等级结构。
缺点：难以扩展新种类产品
