抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类
抽象工厂模式(Abstract Factory)
MM身子都比较娇贵,不像我们那么能忍受的了寒冷的天气和炎热的天气,所以一到冬天和夏天就是怕热或怕冷。你为了体现你对她得关心,所以又得破费了,夏天的话就老老实实去买点凉饮料,或者请吃个冰激凌什么的,是脑子让门给挤了,或是出门药吃多了,结果大冬天的给MM买了个冰激凌吃,夏天给MM喝了杯热茶,呵呵,后果。。要是MM温柔点还好,最多就是不理你几天半个月的。要是不温柔的。。你这会可能在医院躺着呢(男人不打女人,没有反过来),为了避免这种情况,也就是季节和要买得东西有关联,结合到模式中,就是可能产品有某些关联的情况下,也就是需要创建一系列的相管得对象时,可以采用抽象工厂。下面我们看看代码:
首先,我们有季节产品的接口,并实现了夏天和冬天两个产品:
- package dp.abstractfactory;
- /**
- * 季节产品接口
- *
- */
- public interface SeasonProduct {
- /**
- *<p>打印当前的季节</p>
- */
- public void season();
- }
- package dp.abstractfactory;
- /**
- * 具体的产品
- *
- */
- public class Summer implements SeasonProduct{
- @Override
- public void season() {
- System.out.println("夏天来了,酷热难耐!!!(<_>)!!!");
- }
- }
- package dp.abstractfactory;
- public class Winter implements SeasonProduct{
- @Override
- public void season() {
- System.out.println("冬天来了,寒风刺骨{{{(>_<)}}}");
- }
- }
package dp.abstractfactory;
/**
* 季节产品接口
*
*/
public interface SeasonProduct {
/**
*<p>打印当前的季节</p>
*/
public void season();
}
package dp.abstractfactory;
/**
* 具体的产品
*
*/
public class Summer implements SeasonProduct{
@Override
public void season() {
System.out.println("夏天来了,酷热难耐!!!(<_>)!!!");
}
}
package dp.abstractfactory;
public class Winter implements SeasonProduct{
@Override
public void season() {
System.out.println("冬天来了,寒风刺骨{{{(>_<)}}}");
}
}
其次,我们有饮料产品的接口,并实现了热饮和冷饮两个产品:
- package dp.abstractfactory;
- /**
- * 喝冷饮还是热饮的接口
- *
- */
- public interface DrinkProduct {
- /**
- *<p>打印喝冷饮还是热饮</p>
- */
- public void drink();
- }
- package dp.abstractfactory;
- public class HotDrink implements DrinkProduct{
- @Override
- public void drink() {
- System.out.println("给MM拿了一杯热咖啡~");
- }
- }
- package dp.abstractfactory;
- public class ColdDrink implements DrinkProduct {
- @Override
- public void drink() {
- System.out.println("给MM拿了一杯雪顶咖啡~");
- }
- }
package dp.abstractfactory;
/**
* 喝冷饮还是热饮的接口
*
*/
public interface DrinkProduct {
/**
*<p>打印喝冷饮还是热饮</p>
*/
public void drink();
}
package dp.abstractfactory;
public class HotDrink implements DrinkProduct{
@Override
public void drink() {
System.out.println("给MM拿了一杯热咖啡~");
}
}
package dp.abstractfactory;
public class ColdDrink implements DrinkProduct {
@Override
public void drink() {
System.out.println("给MM拿了一杯雪顶咖啡~");
}
}
然后有抽象工厂方法:
- package dp.abstractfactory;
- /**
- * 抽象工厂方法
- *
- */
- public interface AbstractFactory {
- /**
- *<p>获取季节产品</p>
- * @return
- */
- public SeasonProduct seasonFactory();
- /**
- *<p>获取饮料产品</p>
- * @return
- */
- public DrinkProduct drinkFactory();
- }
package dp.abstractfactory;
/**
* 抽象工厂方法
*
*/
public interface AbstractFactory {
/**
*<p>获取季节产品</p>
* @return
*/
public SeasonProduct seasonFactory();
/**
*<p>获取饮料产品</p>
* @return
*/
public DrinkProduct drinkFactory();
}
针对抽象工厂方法的具体实现,注意是冬天和热饮,夏天和冷饮:
- package dp.abstractfactory;
- /**
- * 夏天
- *
- */
- public class SummerFactory implements AbstractFactory {
- @Override
- public DrinkProduct drinkFactory() {
- return new ColdDrink();
- }
- @Override
- public SeasonProduct seasonFactory() {
- return new Summer();
- }
- }
- package dp.abstractfactory;
- /**
- * 冬天
- *
- */
- public class WinterFactory implements AbstractFactory {
- @Override
- public DrinkProduct drinkFactory() {
- return new HotDrink();
- }
- @Override
- public SeasonProduct seasonFactory() {
- return new Winter();
- }
- }
package dp.abstractfactory;
/**
* 夏天
*
*/
public class SummerFactory implements AbstractFactory {
@Override
public DrinkProduct drinkFactory() {
return new ColdDrink();
}
@Override
public SeasonProduct seasonFactory() {
return new Summer();
}
}
package dp.abstractfactory;
/**
* 冬天
*
*/
public class WinterFactory implements AbstractFactory {
@Override
public DrinkProduct drinkFactory() {
return new HotDrink();
}
@Override
public SeasonProduct seasonFactory() {
return new Winter();
}
}
定义一个类,获取抽象工厂接口并调用方法
- package dp.abstractfactory;
- public class Prepare {
- /**
- *<p>传入抽象工厂的对象,根据具体传入的实现决定调用</p>
- * @param abstractFactory
- */
- public void prepare(AbstractFactory abstractFactory){
- abstractFactory.seasonFactory().season();
- abstractFactory.drinkFactory().drink();
- }
- }
package dp.abstractfactory;
public class Prepare {
/**
*<p>传入抽象工厂的对象,根据具体传入的实现决定调用</p>
* @param abstractFactory
*/
public void prepare(AbstractFactory abstractFactory){
abstractFactory.seasonFactory().season();
abstractFactory.drinkFactory().drink();
}
}
测试类:
- package dp.abstractfactory;
- public class Client {
- public static void main(String[] args) {
- //现在是冬天
- new Prepare().prepare(new WinterFactory());
- }
- }
package dp.abstractfactory;
public class Client {
public static void main(String[] args) {
//现在是冬天
new Prepare().prepare(new WinterFactory());
}
}
输出:
冬天来了,寒风刺骨{{{(>_<)}}}
给MM拿了一杯热咖啡~
是不是也特别简单哈
看看工厂方法模式和抽象工厂模式的区别(参数化的工厂方法模式退化了就是一个简单工厂)
工厂方法模式:
一个抽象产品类,可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式:
多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别:
工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。