Javaの抽象ファクトリの詳細説明

この記事は主に Java デザイン パターン Abstract Factory の関連情報を詳しく紹介します。興味のある方は参考にしてください

1. コンセプト

関連する一連のインターフェイスを作成する方法を提供します。または、具体的なクラスを指定せずに相互依存するオブジェクト。

2. パターンの動機

この一連のオブジェクトは相互に依存しており、製品ファミリーに相当します

3. パターンの構造

上の図を通して明確に見ることができます。抽象的なファクトリー パターンには、以下の 4 つの役割:

1. 抽象ファクトリの役割 (AbstractFactory): 抽象ファクトリ パターンのコアは特定のビジネス ロジックとは何の関係もなく、通常は JAVA インターフェイスまたは抽象クラスです。

2. 具体的なファクトリ ロール: このロールは通常、特定のビジネス ロジックと密接に関連しており、このロールのファクトリ メソッドは特定のビジネス ロジックに基づいて特定の製品をインスタンス化し、それらを呼び出します。特定の製品オブジェクト。通常、この役割は特定の JAVA クラスによって引き受けられます。

3. 抽象プロダクトの役割: この役割を果たすクラスは、ファクトリ メソッド パターンによって作成されたプロダクトの親クラス、またはそれらが共有するインターフェイス、通常はインターフェイスまたは抽象クラスです。

4. 特定の製品の役割: 抽象ファクトリー パターンによって作成された製品はすべて、この役割のインスタンスであり、それを引き受ける特定の JAVA クラスを持ちます。

サンプルコードは以下の通りです:

public class AbstractProductA 
{
  
  /**
  * @roseuid 59AC05990327
  */
  public AbstractProductA() 
  {
  
  }
}


public class ProductA1 extends AbstractProductA 
{
  
  /**
  * @roseuid 59AC05990359
  */
  public ProductA1() 
  {
  
  }
}


public class ProductA2 extends AbstractProductA 
{
  
  /**
  * @roseuid 59AC05990381
  */
  public ProductA2() 
  {
  
  }
}

public class AbstractProductB 
{
  
  /**
  * @roseuid 59AC059903BA
  */
  public AbstractProductB() 
  {
  
  }
}

public class ProductB1 extends AbstractProductB 
{
  
  /**
  * @roseuid 59AC059A001F
  */
  public ProductB1() 
  {
  
  }
}

public class ProductB2 extends AbstractProductB 
{
  
  /**
  * @roseuid 59AC059A0049
  */
  public ProductB2() 
  {
  
  }
}


public abstract class AbstractFactory 
{
  
  /**
  * @roseuid 59AC05690005
  */
  public AbstractFactory() 
  {
  
  }
  
  /**
  * @return AbstractProductA
  * @roseuid 59ABFB0103BE
  */
  public Abstract AbstractProductA createProductA() ;
  
  
  /**
  * @return AbstractProductB
  * @roseuid 59ABFB3B029D
  */
  public Abstract AbstractProductB createProductB() ;
}


public class ConcreteFactory1 extends AbstractFactory 
{
  
  /**
  * @roseuid 59AC057A02FC
  */
  public ConcreteFactory1() 
  {
  
  }
  
  /**
  * @return AbstractProductA
  * @roseuid 59ABFB9C00C9
  */
  public AbstractProductA createProductA() 
  {
    return new ProductA1();
  }
  
  /**
  * @return AbstractProductB
  * @roseuid 59ABFBA30011
  */
  public AbstractProductB createProductB() 
  {
    return new ProductB1();
  }
}



public class ConcreteFactory2 extends AbstractFactory 
{
  
  /**
  * @roseuid 59AC057A02C0
  */
  public ConcreteFactory2() 
  {
  
  }
  
  /**
  * @return AbstractProductA
  * @roseuid 59ABFCC701B9
  */
  public AbstractProductA createProductA() 
  {
    return new ProductA2();
  }
  
  /**
  * @return AbstractProductB
  * @roseuid 59ABFCC9001F
  */
  public AbstractProductB createProductB() 
  {
    return new ProductB2();
  }
}

public class Client 
{
  
  
  /**
  * @roseuid 59AC055700AB
  */
  public Client() 
  {
  
  }

  public static void main(String[] args){
      AbstractFactory theAbstractFactory;
    AbstractProductA theAbstractProductA;
    AbstractProductB theAbstractProductB;

    theAbstractFactory=new ConcreteFactory1();

    theAbstractProductA=theAbstractFactory.createProductA();
    theAbstractProductB=theAbstractFactory.createProductB();
 
  }
}

上記のパターン構造図に基づいて、「特定のクラスを指定せずに、一連の関連または相互依存するオブジェクトを作成するためのインターフェイスを提供する」ことに進みます。簡単な分析:

1. 関連オブジェクトまたは相互依存オブジェクト。ProductA1 のインスタンスと ProductB1 のインスタンスは、ビジネス ロジック、ProductA1 に基づいた一連の相互関連 (内部相関など) または相互依存 (全体と部分など) の関係です。

は、同じ製品レベル構造 AbstractProductB の下の ProductB1 にのみ関連付けることができますが、ProductB2 に関連付けることはできません。

2. 特定のクラスを指定せずに、一連の関連または相互依存するオブジェクトを作成するためのインターフェイスを提供します。ここでのインターフェイスは、構造図の AbstractProductA と AbstractProductB です。クライアントは、これらの製品のインターフェイスにのみ依存します。特定の実装は依存関係逆転の原則に準拠しています。 「特定のクラスを指定する必要はありません。」 つまり、クライアントは ProductA1、ProductA2、ProductB1、および ProductB2 の存在を知りません。クライアントは、特定のファクトリのファクトリ メソッドを呼び出して、特定の製品インスタンスを返すだけで済みます。

4. パターンの例

さらに詳しく分析するために、このタイヤ工場は、エンジン生産ライン (EngineLine) を導入しました。 DoorLine をはじめ、自動車全体のさまざまな部品の生産ラインが完成しました。ただし、すべての自動車が製造できるわけではありません。たとえば、ベンツと BMW の 2 種類しか製造できません。 NX にはこのような工場で十分です) たとえば、現在、自動車にはタイヤ、ドア、エンジンのみが含まれています (もちろん、それ以外にもあるはずです)。この工場では、以下に示すように、顧客の要求に応じて BMW やベンツの自動車を生産できます。 :

コードは次のとおりです:

public interface Door {
  public void open();
  public void close();
}
public class BenzDoor implements Door {

  @Override
  public void open() {
    System.out.println("奔驰车门开");
  }

  @Override
  public void close() {
    System.out.println("奔驰车门关");
  }
}
public class BmwDoor implements Door {

  @Override
  public void open() {
    System.out.println("宝马车门开");
  }

  @Override
  public void close() {
    System.out.println("宝马车门关");
  }

}
public interface Tire {
  public void getColor();
  public void getLife();
  public void getWidth();
}
public class BenzTire implements Tire {

  @Override
  public void getColor() {
    System.out.println("benz车color");
  }

  @Override
  public void getLife() {
    System.out.println("benz车life");
  }

  @Override
  public void getWidth() {
    System.out.println("benz车width");
  }
}
public class BmwTire implements Tire {

  @Override
  public void getColor() {
    System.out.println("bmw车color");
  }

  @Override
  public void getLife() {
    System.out.println("bmw车life");
  }

  @Override
  public void getWidth() {
    System.out.println("bmw车width");
  }

}
public interface Engine {
  public void start();

  public void stop();

}
public class BenzEngine implements Engine {

  @Override
  public void start() {
    System.out.println("benz车start");

  }

  @Override
  public void stop() {
    System.out.println("benz车stop");

  }

}
public class BmwEngine implements Engine {

  @Override
  public void start() {
    System.out.println("bmw车start");

  }

  @Override
  public void stop() {
    System.out.println("bmw车stop");

  }

}
public interface PartFactory {
  public Door createDoor();

  public Tire createTire();

  public Engine createEngine();

}
public class BenzPartFactory implements PartFactory {

  @Override
  public Door createDoor() {
    return new BenzDoor();
  }

  @Override
  public Tire createTire() {
    return new BenzTire();
  }

  @Override
  public Engine createEngine() {
    return new BenzEngine();
  }

}
public class BmwPartFactory implements PartFactory {

  @Override
  public Door createDoor() {
    return new BmwDoor();
  }

  @Override
  public Tire createTire() {
    return new BmwTire();
  }

  @Override
  public Engine createEngine() {
    return new BmwEngine();
  }

}
public class Car {
  private Door door;
  private Engine engine;
  private Tire tire;

  public Car(PartFactory factory) {
    this.door = factory.createDoor();
    this.engine = factory.createEngine();
    this.tire = factory.createTire();
  }

  public Door getDoor() {
    return door;
  }

  public Engine getEngine() {
    return engine;
  }

  public Tire getTire() {
    return tire;
  }  
}
public class Client {
  
  public static void main(String[] args) {
    PartFactory partFactory=new BenzPartFactory();
    Car benzCar=new Car(partFactory);
    
    benzCar.getDoor().open();
    benzCar.getEngine().start();
    benzCar.getTire().getColor();
    
  }

}

実行結果は次のとおりです:

ベンツ車のドアが開く
ベンツ車のスタート
ベンツ車の色

上記のクラス図と実行結果によると、次の分析が可能です:

BenzDoor、Benztire、BenzEngine には強い関係があります。ベンツ車は Bmw ドア、つまり BmwDoor を使用できないと言えます。この強力な関係は、BenzPartFactory を通じて良好に維持されています。クライアントの場合、上記のクライアント クラスのように、顧客がベンツ車を望んでいる場合、必要なのはベンツ車を生産する工場だけです。この工場内のすべての製品インスタンスはベンツ車の部品です。走行結果からも分かります。

Revise を使用します。しかし、顧客は渋滞時に飛行できるように車に一対の翼を取り付けたいと言いました。このとき、翼を各工場に戻して修正できる工場方式を追加する必要があります。これはオープンアンドクローズの原則に反します。したがって、抽象ファクトリは、製品階層構造を追加するための開閉原則をサポートしませんが、製品ファミリ ディメンション (アウディ車など) については開閉原則をサポートします。

5. パターン制約

相互関連または依存する製品ファミリーの生成に適しており、製品ファミリー方向の拡張をサポートしますが、製品レベル方向の拡張には適していません。

6. パターンのバリエーションと拡張

1. 抽象ファクトリは静的ファクトリ メソッドを提供します: 抽象ファクトリは静的ファクトリ メソッドを提供し、パラメータを通じて特定のファクトリ インスタンスを返すことができます。

2. 抽象ファクトリーを特定ファクトリーとマージする: 製品ファミリーの方向に製品ファミリーが 1 つしかないと判断された場合、現時点では、抽象ファクトリーは 1 つだけ必要です。これをさらに拡張して、それ自体のインスタンスを返す静的メソッドをこの具体的なファクトリに提供できます。

7. 他のパターンとの関係

プロダクトレベル構造が 1 つだけある場合、それは以下に示すようにファクトリメソッドパターンになります:

複数のプロダクトレベル構造がある場合、それぞれのパターン抽象ファクトリ ファクトリ メソッドは、「ファクトリ メソッド」パターンです。

8. モデルの長所と短所

製品ファミリー方向の開閉原則をサポートしますが、製品階層方向の開閉原則はサポートしません。

以上がJavaの抽象ファクトリの詳細説明の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。