（三）抽象工厂模式(AbstractFactory)
最后更新于：2022-04-01 15:48:09
抽象工厂模式(AbstractFactory)原理图
初学uml不会排版，就这样凑合吧，展现大概就行了
抽象，果然挺让我理解的抽象的，其实一个挺简单的模式，但是这样乱乱的画出来其实就是通过工厂创建出对象而已，只不过是对于工厂的分类方式和对于产品的分类方式不一样了而已，上面是最合理的方式（起码这个书上我是这么理解的），其实我自己觉得可以有别的方法
比如我不是按照产品的种类分类，按照产品的级别分类，就是简单的把Product、AProductB替代1和2，这样也可以的，就是用下面的代码来说，非洲的狮子和美洲的狮子，都是狮子，但是非洲的狮子和非洲的海豚都是非洲的动物，一样可以说的同，这样就有多了一种方式去表达同一个模式，就像是上面的原理图到了工厂这里就编程了通过商品实例化不同的级别，就像是下面的代码，用非洲来实例化非洲的动物，这本身就是一种互相交互的东西，如果说把一类产品放到一起将来添加模块的时候好添加，那么如果我想增加的是种类，或者是个别，那么总会有不好重构的一个地方的，不过对于一个对象的抽象，还是按照上面的抽象出来的实力比较具体一些而已，同时只要是抽象的工厂和抽象的对象不是按照一个区别来分的，就完全可以达到效果，我看了一些网上的设计模式的解析大部分也是按照上面的图例做的，我觉得应该可以按照多种方式去考虑吧，只是不同人有不同的思路而已，大概是对于类的分类和继承没有像我这样钻缝子的。好吧，简单的做一下笔记开始下一个模式，等长大一点了在慢慢钻这个缝子（个人理解）：
~~~
package com.designpattern.abstractfactory;
public interface Animal {
public void eat();
}
~~~
~~~
package com.designpattern.abstractfactory;
public class Dolphin implements Animal {
@Override
public void eat() {
System.out.println("Dolphin is eating");
}
public void swim(){
System.out.println("Dolphin is swimming");
}
}
~~~
~~~
package com.designpattern.abstractfactory;
public class AfricaDolphin extends Dolphin {
public void eat(){
System.out.println("AfricaDolphin is eating");
}
public void swim(){
System.out.println("AfricaDolphin is swimming");
}
}
~~~
~~~
package com.designpattern.abstractfactory;
public class AsiaDolphin extends Dolphin {
public void eat(){
System.out.println("AsiaDolphin is eating");
}
public void swim(){
System.out.println("AsiaDolphin is swimming");
}
}
~~~
~~~
package com.designpattern.abstractfactory;
public class Tiger implements Animal {
@Override
public void eat() {
System.out.println("Tiger is eating");
}
public void run(){
System.out.println("Tiger is running");
}
}
~~~
~~~
package com.designpattern.abstractfactory;
public class AfricaTiger extends Tiger {
public void eat(){
System.out.println("AfricaTiger is eating");
}
public void run(){
System.out.println("AfricaTiger is running");
}
}
~~~
~~~
package com.designpattern.abstractfactory;
public class AsiaTiger extends Tiger {
public void eat(){
System.out.println("AsiaTiger is eating");
}
public void run(){
System.out.println("AsiaTiger is running");
}
}
~~~
~~~
package com.designpattern.abstractfactory;
public interface Factory {
public Animal createTiger();
public Animal createDolphin();
}
~~~
~~~
package com.designpattern.abstractfactory;
public class AsiaFactory implements Factory {
@Override
public Animal createDolphin() {
// TODO Auto-generated method stub
return new AsiaDolphin();
}
@Override
public Animal createTiger() {
// TODO Auto-generated method stub
return new AsiaTiger();
}
}
~~~
~~~
package com.designpattern.abstractfactory;
public class AfricaFactory implements Factory {
@Override
public Animal createDolphin() {
// TODO Auto-generated method stub
return new AfricaDolphin();
}
@Override
public Animal createTiger() {
// TODO Auto-generated method stub
return new AfricaTiger();
}
}
~~~
~~~
package com.designpattern.abstractfactory;
public class Client {
public static void main(String[] args) {
Factory factory = new AfricaFactory();
Animal tiger = factory.createTiger();
tiger.eat();
Animal dolphin = factory.createDolphin();
dolphin.eat();
factory = new AsiaFactory();
tiger = factory.createTiger();
tiger.eat();
dolphin = factory.createDolphin();
dolphin.eat();
}
}
~~~
在抽象工厂模式中，客户端不在负责对象的创建，而是把这个责任交给了具体的工厂类，客户端只负责对对象的调用，从而明确各个类的职责。
当一些类的互相关联的产品被设计到一个工厂类里后，客户端的调用将会变得非常简单，而且如果要更换这一系列的产品，只需要跟换一个工厂类即可。
但是如果新的产品添加进来，则需要修改抽象工厂类的设计，同时修改实现这个抽象工厂类的具体的实现，需要额外添加代码。