设计模式之三：抽象工厂设计模式（AbstractFactory）

设计模式之抽象工厂设计模式

抽象工厂即提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类

• 工厂方法模式和抽象工厂模式的区别
  • 工厂方法模式
    1. 一个抽象产品类，可以派生出多个具体产品类
    2. 一个抽象工厂类，可以派生出多个具体工厂类
    3. 每个具体工厂类只能创建一个具体产品类的实例
  • 抽象工厂模式
    1. 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类
    2. 一个抽象工厂类，可以派生出多个具体工厂类
    3. 每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产品
  • 具体区别：
    1. 工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个
    2. 工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个
    3. 工厂方法创建 “一种” 产品，他的着重点在于"怎么创建"，也就是说如果你开发，你的大量代码很可能围绕着这种产品的构造，初始化这些细节上面。也因为如此，类似的产品之间有很多可以复用的特征，所以会和模版方法相似；抽象工厂需要创建一些列产品，着重点在于"创建哪些"产品上，也就是说，如果你开发，你的主要任务是划分不同差异的产品线，并且尽量保持每条产品线接口一致，从而可以从同一个抽象工厂继承
  • 对于 java 来说，你能见到的大部分抽象工厂模式都是这样的：它的里面是一堆工厂方法，每个工厂方法返回某种类型的对象
    • 比如说：工厂可以生产鼠标和键盘。那么抽象工厂的实现类（它的某个具体子类）的对象都可以生产鼠标和键盘，但可能工厂 A 生产的是罗技的键盘和鼠标，工厂 B 是微软的。这样 A 和 B 就是工厂，对应于抽象工厂；每个工厂生产的鼠标和键盘就是产品，对应于工厂方法；用了工厂方法模式，你替换生成键盘的工厂方法，就可以把键盘从罗技换到微软。但是用了抽象工厂模式，你只要换家工厂，就可以同时替换鼠标和键盘一套。如果你要的产品有几十个，当然用抽象工厂模式一次替换全部最方便（这个工厂会替你用相应的工厂方法）所以说抽象工厂就像工厂，而工厂方法则像是工厂的一种产品生产线

    // 公共接口
    public interface ICat {
		void eat();
	}
	public interface IDog {
		void eat();
	}

    // 创建实现类
	public class BlackCat implements ICat {
		public void eat() {
			System.out.println("The black cat is eating!");
		}
	}
	public class WhiteCat implements ICat {
		public void eat() {
			System.out.println("The white cat is eating!");
		}
	}
	public class BlackDog implements IDog {
		public void eat() {
			System.out.println("The black dog is eating");
		}
	}
	public class WhiteDog implements IDog {
		public void eat() {
			System.out.println("The white dog is eating!");
		}
	}


    // 创建工厂公共接口
	public abstract class IAnimalFactory {
		public abstract  ICat createCat();
		public abstract  IDog createDog();
	}

    // 创建工厂实现类
    public class BlackAnimalFactory implements IAnimalFactory {
        @Override
        public ICat createCat() {
            return new BlackCat();
        }
        @Override
        public IDog createDog() {
            return new BlackDog();
        }
    }   
	public class WhiteAnimalFactory implements IAnimalFactory {
        @Override
		public ICat createCat() {
			return new WhiteCat();
		}
        @Override
		public IDog createDog() {
			return new WhiteDog();
		}
	}

    // 测试
	public static void main(String[] args) {
		IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();
		ICat blackCat = blackAnimalFactory.createCat();
		blackCat.eat();
		IDog blackDog = blackAnimalFactory.createDog();
		blackDog.eat();
		IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();
		ICat whiteCat = whiteAnimalFactory.createCat();
		whiteCat.eat();
		IDog whiteDog = whiteAnimalFactory.createDog();
		whiteDog.eat();
	}
	
    // 输出：
	// The black cat is eating!
	// The black dog is eating!
	// The white cat is eating!
	// The white dog is eating! 

本文地址：https://blog.csdn.net/lbh_paopao/article/details/107702598