java抽象工厂模式（JAVA抽象工厂模式中，类图里具体工厂类和具体产品类之间的关系为什么是依赖关系）

本文目录

• JAVA抽象工厂模式中，类图里具体工厂类和具体产品类之间的关系为什么是依赖关系
• Java 什么是抽象工厂,请举个例子
• java中抽象工厂模式和原型模式之间的区别
• java这句要怎么理解啊（工厂模式的）抽象的工厂模式

JAVA抽象工厂模式中，类图里具体工厂类和具体产品类之间的关系为什么是依赖关系

是的吧，我感觉就是这么回事，关联关系不如依赖那么紧毕竟。A本身没有B的引用，却需要B，那么A必须要有B的引用作为参数。要是A本身有B的引用，那么B是A的一个组成部分了，在程序中A就不需要B作为参数来提供给A了。

Java 什么是抽象工厂,请举个例子

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

举一个电脑产品的例子吧：

IBM，Dell都是著名的计算机生产厂家，他们采用的主板、硬盘及CPU是不相同的，但是配件间、主板与CPU一定要相互兼容，例如下面例子中的微星MSIK7N2G配AMD的CPU；微星MSI865PE配Intel的CPU。

如图中所示，ComputerFactory是抽象工厂，Dell和IBM是生产产品的工厂；CPU、HardDisk、MainBoard是抽象产品，CPU的型号又分许多种。具体实现见代码：

首先，定义CPU的接口：

public interface CPU{

    public String getCPU();

}

定义AMD类，实现CPU接口：

public class AMD implements CPU{

    public String getCPU(){

        return “Athlon XP 2008+”;

    }

定义Intel类，实现CPU接口：

public class Intel implements CPU{

    public String getCPU(){

        return “奔腾4 3.2C”;

    }

}

定义硬盘接口：

public interface HardDisk{

    public String getSize();

}

定义Maxtor类，实现硬盘接口：

public class Maxtor implements HardDisk{

    public String getSize(){

        return “MaXLine Plus II 200G”;

    }

}

定义WestDigit，实现硬盘接口：

public class WestDigit implements HardDisk{

    public String getSize(){

        return “WD2500JD 250G”;

    }

}

定义主板的接口，包含参数为CPU的公共方法Attach():

public interface MainBoard{

    public void Attach(CPU cpu) throws Exception;

}

主板微星MSI865PE，支持Intel的CPU：

public class MSI865PE implements MainBoard{

    public void Attach(CPU cpu) throws Exception{

        if(cpu.getClass ().toString ().endsWith(“Intel”)){

            System.out.println(“MSI865PE”);

        }

         else{

            throw new Exception(“主板MSI865PE只能配Intel的                                        CPU”)；

        }

    }

}

主板微星MSIK7N2G，支持AMD的CPU：

public class MSIK7N2G implements MainBoard{

    public void Attach(CPU cpu) throws Exception{

        if(cpu.getClass ().toString ().endsWith(“AMD”)){

            System.out.println(“MSIK7N2G”);

        }

        else{

            throw new Exception(“主板MSIK7N2G只能配AMD的CPU”);

        }

    }

}

定义抽象电脑工厂类：

public abstract class ComputerFactory{

    CPU cpu;

    HardDisk hd;

    MainBoard mb;

public void show(){

        try{

            System.out.println(this.getClass().getName() .toString () + (“生产的电脑配置”);

            System.out.println (“CPU:” + cpu.getCPU ());

            System.out.println (“HardDisk:” + hd.getSize ());

            System.out.print (“MainBoard:”);

            mb.Attach.(cpu);

        }

catch(Exception e){

            System.err.println(e.getMessage());

        }

    }

}

抽象电脑工厂类派生类IBM，定义其返回的系列配件产品：

public class IBM extends ComputerFactory{

    IBM(){

        cpu = new Intel();

        hd = new WestDigit();

        mb = new MSI865PE();

    }

}

抽象电脑工厂类派生类Dell，定义其返回的系列配件产品：

public class Dell extends ComputerFactory{

    Dell(){

        cpu = new AMD();

        hd = new Maxtor();

        mb = new MSIK7N2G();

    }

}

客户程序调用：

Public class Client{

    public static void main(String argv){

        IBM ibm = new IBM();

        ibm.show();

        Dell dell = new Dell();

        dell.show();

    }

}

输出结果为：

Computerworld.IBM生产的电脑配置

CPU:奔腾4 3.2C

HardDisk:WD2500JD 250G

MainBoard:MSI865PE

Computerworld.Dell生产的电脑配置

CPU:Athlon XP 2800+

HardDisk:MaXLine Plus II 200G

MainBoard:MSIK7N2G

java中抽象工厂模式和原型模式之间的区别

工厂模式的好处就在于将工厂和产品之间的耦合降低，将具体产品的构造过程放在了具体工厂类里面。在以后扩展产品的时候方便很多，只需要添加一个工厂类，一个产品类，就能方便的添加产品，而不需要修改原有的代码。而在简单工厂中，如果要增加一个产品，则需要修改工厂类，增加if/else分支，或者增加一个case分支，工厂模式符合软件开发中的OCP原则（open close principle），对扩展开放，对修改关闭。
抽象工厂模式：这个模式我总是感觉和builder模式非常相似。
工厂方法模式提供的是对一个产品的等级模式，，而抽象工厂方法提供的是对多个产品的等级模式，注意，这里的多个具体产品之间是相互耦合的，也就是说这里的抽象工厂提供的产品之间是存在某种联系的。
有人做如下的比较：
工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

java这句要怎么理解啊（工厂模式的）抽象的工厂模式

Provider接口是抽象工厂，具体的工厂实现这个接口，接口里定义的public Sender produce(); 这句说明生成出来的对象是实现了Sender接口的对象，而不是具体的对象(这里是抽象工厂的重要体现)。