您现在的位置是：主页 > news > 产品网站用什么软件做/西安网站建设制作

产品网站用什么软件做/西安网站建设制作

admin2025/5/3 9:09:05【news】

简介产品网站用什么软件做,西安网站建设制作,成人大专有必要上吗,做网站白云区抽象工厂模式(AbstractFactory)原理图 初学uml不会排版，就这样凑合吧，展现大概就行了 抽象，果然挺让我理解的抽象的，其实一个挺简单的模式，但是这样乱乱的画出来其实就是通过工厂创建出对象而已，只不过是对…

产品网站用什么软件做,西安网站建设制作,成人大专有必要上吗,做网站白云区抽象工厂模式(AbstractFactory)原理图 初学uml不会排版，就这样凑合吧，展现大概就行了 抽象，果然挺让我理解的抽象的，其实一个挺简单的模式，但是这样乱乱的画出来其实就是通过工厂创建出对象而已，只不过是对…

抽象工厂模式(AbstractFactory)原理图


初学uml不会排版，就这样凑合吧，展现大概就行了

抽象，果然挺让我理解的抽象的，其实一个挺简单的模式，但是这样乱乱的画出来其实就是通过工厂创建出对象而已，只不过是对于工厂的分类方式和对于产品的分类方式不一样了而已，上面是最合理的方式（起码这个书上我是这么理解的），其实我自己觉得可以有别的方法

比如我不是按照产品的种类分类，按照产品的级别分类，就是简单的把Product、AProductB替代1和2，这样也可以的，就是用下面的代码来说，非洲的狮子和美洲的狮子，都是狮子，但是非洲的狮子和非洲的海豚都是非洲的动物，一样可以说的同，这样就有多了一种方式去表达同一个模式，就像是上面的原理图到了工厂这里就编程了通过商品实例化不同的级别，就像是下面的代码，用非洲来实例化非洲的动物，这本身就是一种互相交互的东西，如果说把一类产品放到一起将来添加模块的时候好添加，那么如果我想增加的是种类，或者是个别，那么总会有不好重构的一个地方的，不过对于一个对象的抽象，还是按照上面的抽象出来的实力比较具体一些而已，同时只要是抽象的工厂和抽象的对象不是按照一个区别来分的，就完全可以达到效果，我看了一些网上的设计模式的解析大部分也是按照上面的图例做的，我觉得应该可以按照多种方式去考虑吧，只是不同人有不同的思路而已，大概是对于类的分类和继承没有像我这样钻缝子的。好吧，简单的做一下笔记开始下一个模式，等长大一点了在慢慢钻这个缝子（个人理解）：

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public interface Animal {  
  4.     public void eat();  
  5. }  

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public class Dolphin implements Animal {  
  4.   
  5.     @Override  
  6.     public void eat() {  
  7.         System.out.println("Dolphin is eating");  
  8.     }  
  9.       
  10.     public void swim(){  
  11.         System.out.println("Dolphin is swimming");  
  12.     }  
  13.   
  14. }  

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public class AfricaDolphin extends Dolphin {  
  4.     public void eat(){  
  5.         System.out.println("AfricaDolphin is eating");  
  6.     }  
  7.       
  8.     public void swim(){  
  9.         System.out.println("AfricaDolphin is swimming");  
  10.     }  
  11. }  

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public class AsiaDolphin extends Dolphin {  
  4.     public void eat(){  
  5.         System.out.println("AsiaDolphin is eating");  
  6.     }  
  7.       
  8.     public void swim(){  
  9.         System.out.println("AsiaDolphin is swimming");  
  10.     }  
  11. }  

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public class Tiger implements Animal {  
  4.   
  5.     @Override  
  6.     public void eat() {  
  7.         System.out.println("Tiger is eating");  
  8.     }  
  9.       
  10.     public void run(){  
  11.         System.out.println("Tiger is running");  
  12.     }  
  13.   
  14. }  

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public class AfricaTiger extends Tiger {  
  4.     public void eat(){  
  5.         System.out.println("AfricaTiger is eating");  
  6.     }  
  7.       
  8.     public void run(){  
  9.         System.out.println("AfricaTiger is running");  
  10.     }  
  11. }  

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public class AsiaTiger extends Tiger {  
  4.     public void eat(){  
  5.         System.out.println("AsiaTiger is eating");  
  6.     }  
  7.       
  8.     public void run(){  
  9.         System.out.println("AsiaTiger is running");  
  10.     }  
  11. }  

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public interface Factory {  
  4.     public Animal createTiger();  
  5.     public Animal createDolphin();  
  6. }  

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public class AsiaFactory implements Factory {  
  4.   
  5.     @Override  
  6.     public Animal createDolphin() {  
  7.         // TODO Auto-generated method stub  
  8.         return new AsiaDolphin();  
  9.     }  
  10.   
  11.     @Override  
  12.     public Animal createTiger() {  
  13.         // TODO Auto-generated method stub  
  14.         return new AsiaTiger();  
  15.     }  
  16.   
  17. }  

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public class AfricaFactory implements Factory {  
  4.   
  5.     @Override  
  6.     public Animal createDolphin() {  
  7.         // TODO Auto-generated method stub  
  8.         return new AfricaDolphin();  
  9.     }  
  10.   
  11.     @Override  
  12.     public Animal createTiger() {  
  13.         // TODO Auto-generated method stub  
  14.         return new AfricaTiger();  
  15.     }  
  16.   
  17. }  

[java] view plaincopy
  1. package com.designpattern.abstractfactory;  
  2.   
  3. public class Client {  
  4.     public static void main(String[] args) {  
  5.         Factory factory = new AfricaFactory();  
  6.         Animal tiger =  factory.createTiger();  
  7.         tiger.eat();  
  8.         Animal dolphin = factory.createDolphin();  
  9.         dolphin.eat();  
  10.           
  11.         factory = new AsiaFactory();  
  12.         tiger = factory.createTiger();  
  13.         tiger.eat();  
  14.         dolphin = factory.createDolphin();  
  15.         dolphin.eat();  
  16.     }  
  17. }  

在抽象工厂模式中，客户端不在负责对象的创建，而是把这个责任交给了具体的工厂类，客户端只负责对对象的调用，从而明确各个类的职责。

当一些类的互相关联的产品被设计到一个工厂类里后，客户端的调用将会变得非常简单，而且如果要更换这一系列的产品，只需要跟换一个工厂类即可。

但是如果新的产品添加进来，则需要修改抽象工厂类的设计，同时修改实现这个抽象工厂类的具体的实现，需要额外添加代码。


相关文章

最新文章