ファクトリメソッドは、工場出荷時のモード、Abstract Factoryパターンは簡単です

簡単な比較

• コンピュータの工場、異なるコンピュータの生産のための責任：シンプルなファクトリメソッドはプログラミング習慣ではなく、デザインパターンです。
• Factoryパターン：生産（実際のファクトリクラス）を担当するレノボ、デル、デルコンピュータの工場の生産を担当するレノボの工場、彼らは生産のコンピュータ方法（共通インタフェースの実現を）持っています。
• 抽象ファクトリー：Lenovoの両方のコンピュータを生産する工場が、また、マウスの生産を、両方のコンピュータを製造するためのデルの工場だけでなく、マウス（実際のファクトリクラス）の生産。彼らは、コンピュータとマウスの製造方法は、（一般的なインターフェイスを実装しています）があります。マウスとコンピュータの製造工場出荷時のパターンを達成するために使用される前記（ファクトリーモードの複数を含みます）。
• Abstract Factoryパターンの利点は、同じ植物のみロジクールロジクールのマウスとキーボードを生産する、そのような植物を使用すると、同じ製品ファミリのリターンを保証することができます。欠点は、インタフェース規格は、すべてのサブクラスは、変更へのインタフェースのニーズを実装し、法により増加しており、その拡大がより困難です。

ファクトリメソッドは単純です：クラスへのオブジェクトのセットを生成するために、厳密に言えば、それはデザインパターンが、プログラミングの練習ではありません。（通常は静的に作成する方法として定義されます）

クラス図

例

パブリック インターフェースコンピュータ{ 
} 

パブリック クラス DellComputer 実装するコンピュータ{
     パブリックDellComputer（）{ 
        System.out.printlnは（ "戴尔" ）。
    } 
} 

パブリック クラスレノボ実装コンピューター{
     パブリックレノボ（）{ 
        System.out.printlnは（ "联想" ）。
    } 
} 

パブリック クラスSimpleComputerFactory {
     静的コンピュータcreateComputer（文字列型）{ 
        コンピュータコンピューター = NULL ;
        もし（ "デル" .equalsIgnoreCase（タイプ））{ 
            コンピュータ = 新しいDellComputer（）。
        } そう であれば（ "レノボ" .equalsIgnoreCase（タイプ））{ 
            コンピュータ = 新しいレノボ（）。
        } 
        戻り  コンピュータ。
    } 
}

ラン

パブリック クラスSimpleFactoryTestDemo {
     公共 静的 ボイドメイン（文字列[]引数）{ 
        SimpleComputerFactory.createComputer（「デル」）。
        SimpleComputerFactory.createComputer（ "レノボ" ）。
    } 
}

結果

 

 

 

ファクトリパターン：オブジェクトのインタフェースの定義を作成するには、サブクラスをインスタンス化するクラスによって決定される、サブクラスが遅延にインスタンス化されます。

クラス図

例

public interface Computer {
}

public class Lenovo implements Computer {
   public Lenovo(){
       System.out.println("联想");
   }
}

public class ThinkPad implements Computer {
    public ThinkPad(){
        System.out.println("ThinkPad");
    }
}

public interface  ComputerFactory {
     Computer createCompute(String type) ;
}

public class LenovoComputerFactory implements ComputerFactory{
    @Override
    public Computer createCompute(String type) {
        Computer computer = null;
        if("lenovo".equalsIgnoreCase(type)){
            computer = new Lenovo();
        }else  if("thinkpad".equalsIgnoreCase(type)){
            computer = new ThinkPad();
        }
        return computer;
    }
}

运行

public class ComputerFactoryTestDemo {
    public static void main(String[] args){
        ComputerFactory lenovoComputerFactory = new LenovoComputerFactory();
        lenovoComputerFactory.createCompute("lenovo");
        lenovoComputerFactory.createCompute("thinkpad");
    }
}

结果

抽象工厂模式：提供了一个接口，用来创建相关或依赖或依赖对象的家族，而不需要明确指定具体类。（常包含多个工厂模式，可以看做创建工厂的工厂）

类图

示例

//键盘接口
public interface KeyBoard {
}
public class LogitechKeyBoardA implements KeyBoard {
    public LogitechKeyBoardA(){
        System.out.println("罗技键盘A");
    }
}

public class LogitechKeyBoardB implements KeyBoard {
    public LogitechKeyBoardB(){
        System.out.println("罗技键盘B");
    }
}

public class RazerKeyBoardA implements KeyBoard {
    public RazerKeyBoardA(){
        System.out.println("雷蛇键盘A");
    }
}

public class RazerKeyBoardB implements KeyBoard {
    public RazerKeyBoardB(){
        System.out.println("雷蛇键盘B");
    }
}

//鼠标接口
public interface Mouse {
}

public class LogitechMouseA implements Mouse{
    public LogitechMouseA(){
        System.out.println("罗技鼠标A");
    }
}

public class LogitechMouseB implements Mouse{
    public LogitechMouseB(){
        System.out.println("罗技鼠标B");
    }
}

public class RazerMouseA implements Mouse{
    public RazerMouseA(){
        System.out.println("雷蛇鼠标A");
    }
}

public class RazerMouseB implements Mouse{
    public RazerMouseB(){
        System.out.println("雷蛇鼠标B");
    }
}

//外设工厂接口，负责生产键盘和鼠标
public interface PeripheralsFactory {
     Mouse createMouse(String type);
     KeyBoard createKeyBord(String type);
}

public class LogitechPeripheralsFactory implements PeripheralsFactory {
    @Override
    public Mouse createMouse(String type) {
        Mouse mouse = null;
        if ("A".equalsIgnoreCase(type)) {
            mouse = new LogitechMouseA();
        } else if ("B".equalsIgnoreCase(type)) {
            mouse = new LogitechMouseB();
        }
        return mouse;
    }

    @Override
    public KeyBoard createKeyBord(String type) {
        KeyBoard keyBoard = null;
        if ("A".equalsIgnoreCase(type)) {
            keyBoard = new LogitechKeyBoardA();
        } else if ("B".equalsIgnoreCase(type)) {
            keyBoard = new LogitechKeyBoardB();
        }
        return keyBoard;
    }
}

public class RazerPeripheralsFactory implements PeripheralsFactory {
    @Override
    public Mouse createMouse(String type) {
        Mouse mouse = null;
        if ("A".equalsIgnoreCase(type)) {
            mouse = new RazerMouseA();
        } else if ("B".equalsIgnoreCase(type)) {
            mouse = new RazerMouseB();
        }
        return mouse;
    }

    @Override
    public KeyBoard createKeyBord(String type) {
        KeyBoard keyBoard = null;
        if ("A".equalsIgnoreCase(type)) {
            keyBoard = new RazerKeyBoardA();
        } else if ("B".equalsIgnoreCase(type)) {
            keyBoard = new RazerKeyBoardB();
        }
        return keyBoard;
    }
}

 

运行

public class PeripheralsAbstractFactoryTestDemo {
    public static void main(String[] args){
        PeripheralsFactory razerFactory = new RazerPeripheralsFactory();
        razerFactory.createKeyBord("A");
        razerFactory.createKeyBord("B");
        razerFactory.createMouse("A");
        razerFactory.createMouse("B");
        PeripheralsFactory logitechFactory = new LogitechPeripheralsFactory();
        logitechFactory.createKeyBord("A");
        logitechFactory.createKeyBord("B");
        logitechFactory.createMouse("A");
        logitechFactory.createMouse("B");
    }
}

结果