ファクトリメソッドファクトリメソッド
スキーマ定義：
オブジェクトを作成するためのインタフェースを定義しますが、サブクラスが技術をインスタンス化するクラスを決めましょう。サブクラスへのそのようなクラスのインスタンスそのファクトリメソッドリターダ（仮想関数オブジェクト：手段デカップリング）。
成分：
抽象ファクトリー（AbstractFactoryは）：プロダクトを作成するための製品、その具体的な方法newProduct工場による植物への発呼者アクセス（）を作成するためのインタフェースを提供します。
コンクリート工場（ConcreteFactory） ：抽象工場の抽象メソッドの実装主に、特定の製品の作成を完了します。
抽象生成物（製品）：、製品仕様を定義する主な機能や製品の機能を説明しています。
特定の製品（ConcreteProduct） ：コンクリート工場の間に対応するコンクリート工場、によって作成され、インターフェイス定義された役割を抽象製品を実装します。
package com.lillcol.designmodel;
/**
* @author lillcol
* 2019/6/16-21:36
*/
public class FactoryMethod {
public static void main(String[] args) {
ConcreteFactory1 concreteFactory1 = new ConcreteFactory1();
Product product = concreteFactory1.newProduct();
product.show();
System.out.println("-------------------------------------------");
ConcreteFactory2 concreteFactory2 = new ConcreteFactory2();
Product product2 = concreteFactory2.newProduct();
product2.show();
}
}
abstract class Product {//定义了产品的规范，描述了产品的主要特性和功能
abstract void show();
}
class ConcreteProductA extends Product { //具体产品ProductA
@Override
void show() {
System.out.println("ConcreteProductA");
}
}
class ConcreteProductB extends Product { //具体产品ProductB
@Override
void show() {
System.out.println("ConcreteProductB");
}
}
abstract class AbstractFactory{ //提供了创建产品的抽象
abstract Product newProduct();
}
class ConcreteFactory1 extends AbstractFactory{ //实现抽象工厂中的抽象方法，完成具体产品的创建。
@Override
Product newProduct() {
return new ConcreteProductA();
}
}
class ConcreteFactory2 extends AbstractFactory{//实现抽象工厂中的抽象方法，完成具体产品的创建。
@Override
Product newProduct() {
return new ConcreteProductB();
}
}
//输出结果：
ConcreteProductA
-------------------------------------------
ConcreteProductBFactory Methodパターンの利点は：
;ユーザーは、特定の製品の作成プロセスを知らなくても、あなたが欲しい物を得ることができ、特定の植物の名前を知っている必要がある
だけでなく、新しい製品を追加するには、システム内の特定の製品カテゴリと対応する具体的なファクトリクラスを追加します開閉の原則を満たすために、工場出荷時にすべての修正。ファクトリメソッドの欠点：
各追加の製品のを大きくすると、特定の製品クラスは、システムの複雑さを増加させるクラスコンクリート工場、に対応します。
AbstractFactory抽象ファクトリー
スキーマ定義：
言い訳は自分の具象クラスを指定せずに、「関連または相互に依存するオブジェクト」のシリーズを作成するための責任があるように、インターフェイスを定義します。
Abstract Factoryパターンは、ファクトリメソッドパターン、製品の唯一のレベルを生成ファクトリメソッドパターンのアップグレードバージョンであり、Abstract Factoryパターンは、製品のより多くのグレードを生成することができます。
抽象工場条件：
各家庭で複数の製品ファミリがあるが、しかし、異なる階層構造の具体的な工場の製品を作成します。
製品の同じ家族を一緒に使用する消費者製品のファミリのみ可能なシステム。
コンポーネント：
抽象ファクトリー（AbstractFactory）：複数の方法がnewProduct（製品を作る含まれている製品を作成するためのインタフェースを提供します）、あなたは、製品のいくつかの異なるグレードを作成することができます。
コンクリート工場（ConcreteFactory） ：メインは抽象的な工場でより多くの抽象メソッドを達成することである、特定の製品の作成を完了します。
抽象製品（商品）：製品仕様が定義するが、主な特徴と機能を説明し、抽象的な工場モデル抽象製品が複数存在します。
特定の製品（ConcreteProduct） ：特定の植物によって作成されたインタフェース定義された役割抽象的製品を実装し、それは多くのツーのコンクリート工場間の同じ関係です。
package com.lillcol.designmodel;
/**
* @author lillcol
* 2019/6/16-22:38
*/
public class AbstractFactory {
public static void main(String[] args) {
ConcreteFactory1 concreteFactory1 = new ConcreteFactory1();
concreteFactory1.newProduct1().show();
concreteFactory1.newProduct2().show();
System.out.println("-----------------------------------------");
ConcreteFactory2 concreteFactory2 = new ConcreteFactory2();
concreteFactory2.newProduct1().show();
concreteFactory2.newProduct2().show();
}
}
//中国 飞机:J20 航母:辽宁舰
//美国 飞机:F22 航母:福特级航母
abstract class Product1 { //飞机
abstract void show();
}
class ConcreteProduct11 extends Product1 {//中国飞机
@Override
void show() {
System.out.println("中国 飞机:J20");
}
}
class ConcreteProduct12 extends Product1 {//美国飞机:F22
@Override
void show() {
System.out.println("美国 飞机:F22 ");
}
}
abstract class Product2 { //航母
abstract void show();
}
class ConcreteProduct21 extends Product2 {//中国 航母:辽宁舰
@Override
void show() {
System.out.println("中国 航母:辽宁舰");
}
}
class ConcreteProduct22 extends Product2 {//美国 航母:福特级航母
@Override
void show() {
System.out.println("美国 航母:福特级航母 ");
}
}
abstract class Factory {
abstract Product1 newProduct1();
abstract Product2 newProduct2();
}
class ConcreteFactory1 extends Factory {//中国
@Override
Product1 newProduct1() {
return new ConcreteProduct11();
}
@Override
Product2 newProduct2() {
return new ConcreteProduct21();
}
}
class ConcreteFactory2 extends Factory {//美国
@Override
Product1 newProduct1() {
return new ConcreteProduct12();
}
@Override
Product2 newProduct2() {
return new ConcreteProduct22();
}
}
//输出结果：
中国 飞机:J20
中国 航母:辽宁舰
-----------------------------------------
美国 飞机:F22
美国 航母:福特级航母 ファクトリメソッドモデルを有することの利点に抽象工場パターンさらに次のように、他の主要な利点は、次のとおり
具体的に管理するために、複数の新たなクラスを導入せず、クラス管理内に一緒に関連付けられた製品ファミリをマルチレベルことができます。
元のコードを変更することなく、新しい製品ファミリを追加するときに、開閉の原則を満たします。Abstract Factoryパターンの欠点：
製品は製品の新ファミリを追加する必要がある場合、ファクトリクラスのすべてを変更する必要があります。
- プロトタイププロトタイプモデルの
スキーマ定義：
指定された型のオブジェクトのインスタンスを作成し、プロトタイプをコピーして新しいオブジェクトを作成するためのプロトタイプ
プロトタイプモデルコンポーネント：
抽象プロトタイプクラス：インタフェースは、特定のプロトタイプオブジェクトを実装する必要があります指定します。
詳細クラスプロトタイプ：プロトタイプ抽象クラスのオブジェクトをコピーするclone（）メソッドを実装します。
アクセスクラス：新しいオブジェクトをコピーするには、クラスの特定のプロトタイプのクローン（）メソッドを使用して。
package com.lillcol.designmodel;
/**
* @author lillcol
* 2019/6/17-21:48
*/
public class Prototype {
public static void main(String[] args) throws CloneNotSupportedException {
Realizetype realizetype = new Realizetype();
Realizetype clone = (Realizetype)realizetype.clonePrototype();
System.out.println("realizetype==clone? "+ (realizetype==clone));
}
}
abstract class AbstractPrototype implements Cloneable{
abstract Object clonePrototype() throws CloneNotSupportedException;
}
class Realizetype extends AbstractPrototype{
Realizetype(){
System.out.println("Real King of Monkey");
}
Object clonePrototype() throws CloneNotSupportedException {
System.out.println("fake King of Monkey");
return (Realizetype)super.clone();
}
}
//输出结果：
Real King of Monkey
fake King of Monkey
realizetype==clone? falseすでにこのプロトタイプオブジェクトをコピーすることで、同一または類似の新しいオブジェクトのプロトタイプを作成するためのプロトタイプとしてのインスタンスを作成したと。
ここでは、プロトタイプのインスタンスが作成されるオブジェクトの種類を指定します。このように作成されたオブジェクトは、オブジェクトの作成の詳細を知る必要がないので、非常に効率的です。
- ビルダービルダー
スキーマ定義：
同じ構成プロセス（安定剤）が異なる表現（変化）を作成できるように、複雑なオブジェクトの表現、その相分離を構築します。
ビルダー（ビルダー）モード成分：
製品の役割（製品）：これは、特定のビルダーによって、そのさまざまなコンポーネントを作成するためにオフに複数のコンポーネントが含まれており、複雑なオブジェクトです。
抽象ビルダー（ビルダー）：これは抽象メソッドである）、製品インタフェースの様々なサブコンポーネントを作成典型的には、（複雑な製品の処理はのgetResultを返し含有含みます。
特定ビルダー（ConcreteBuilder）：インタフェースビルダーは、実現複雑な製品の様々な構成要素を作成する具体的な方法を達成します。
ディレクター（監督）：それは、複雑なオブジェクトを作成するの一部の建設及び組立方法ビルダーオブジェクトを呼び出し、誰がコマンドで特定の製品を伴わなかったこと。
package com.lillcol.designmodel;
/**
* @author lillcol
* 2019/6/17-22:32
*/
//组装电脑
public abstract class Builder {
Product product = new Product();
abstract void buyKey();
abstract void buyMouse();
abstract Product returnComputer();
}
class ConcreteBuilder1 extends Builder {
@Override
void buyKey() {
product.setKey("ConcreteBuilder1 key :双飞燕无线鼠标");
}
@Override
void buyMouse() {
product.setMouse("ConcreteBuilder1 mouse :双飞燕机械键盘");
}
@Override
Product returnComputer() {
return product;
}
}
class ConcreteBuilder2 extends Builder {
@Override
void buyKey() {
product.setKey("ConcreteBuilder1 key :无线鼠标");
}
@Override
void buyMouse() {
product.setMouse("ConcreteBuilder1 mouse :雷柏机械键盘");
}
@Override
Product returnComputer() {
return product;
}
}
class Product {
String key;
String mouse;
public void setKey(String key) {
this.key = key;
}
public void setMouse(String mouse) {
this.mouse = mouse;
}
public void show() {
System.out.println(key + " " + mouse);
}
}
class Director {
Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public Product construct() {
builder.buyKey();
builder.buyMouse();
return builder.returnComputer();
}
}
class BuilderTest {
public static void main(String[] args) {
ConcreteBuilder1 concreteBuilder1 = new ConcreteBuilder1();
Director dirctor = new Director(concreteBuilder1);
Product product = dirctor.construct();
product.show();
System.out.println("-----------------");
ConcreteBuilder2 concreteBuilder2 = new ConcreteBuilder2();
Director dirctor2 = new Director(concreteBuilder2);
Product product2 = dirctor2.construct();
product2.show();
}
}
//输出结果：
ConcreteBuilder1 key :双飞燕无线鼠标 ConcreteBuilder1 mouse :双飞燕机械键盘
-----------------
ConcreteBuilder1 key :无线鼠标 ConcreteBuilder1 mouse :雷柏机械键盘利点：
- それぞれの具体的なビルダーが独立している、それはシステムの拡張を助長しています。
- クライアントは、リスクの詳細を制御しやすく、製品の内部構成の詳細を知る必要はありません。
短所：
- 製品の一部は、その使用が制限され、同じでなければなりません。
- 製品の複雑における内部変化した場合、モデルがたくさんにビルダーのカテゴリが増加します。
参考資料：
http://c.biancheng.net/view/1364.html
李Jianzhong 23のデザインパターン