1。概要
全体として、設計パターンは3つのカテゴリに分かれています。
（1）クリエイティブモード、合計5つのタイプのファクトリーメソッドモード、抽象的な工場モード、シングルトンモード、ビルダーモード、およびプロトタイプモード。
（2）構造モード、合計7つのタイプ：アダプターモード、デコレーターモード、プロキシモード、外観モード、ブリッジモード、コンビネーションモード、および楽しみモード。
（3）動作モード、合計11：ポリシーモード、テンプレートメソッドモード、オブザーバーモード、反復サブモード、責任チェーンモード、メモモード、ステータスモード、ビジターモード、中間モード、およびインタープリターモード。
2。設計モデルの6つの原則
1。密接な原則を開きます
開閉の原則は、拡張機能を開放し、修正に近づけることです。プログラムを拡張する必要がある場合、ホットプラグ効果を達成するために元のコードを変更することはできません。
2。リスコフ置換原理
その公式の説明は比較的抽象的であり、Baiduに使用できます。実際、次のように理解できます。（1）サブクラスの能力は、親クラスよりも大きい、つまり、親クラスが使用できる方法であり、サブクラスが使用できる方法です。 （2）返品値にも同じことが言えます。親クラスのメソッドがリストを返し、サブクラスがアレイリストを返すとします。もちろん、これを実行できます。親クラスのメソッドが配列リストを返し、子クラスがリストを返す場合、意味がありません。ここで、サブクラスの値を返す能力は、親クラスの能力よりも小さくなります。 （3）例外がスローされる場合もあります。サブクラス方式は、親クラスの方法をスローするサブクラスを宣言して例外を宣言できます。
親クラスが宣言していない例外がスローされていることを宣言することはできません。
3。依存関係の反転原理
これは、開閉の原則と、コンクリートではなく抽象化に依存するインターフェイス指向プログラミングの特定のコンテンツの基礎です。
4。インターフェイス分離原理
この原則は、次のことを意味します。複数の分離インターフェイスを使用すると、単一のインターフェイスを使用するよりも優れています。また、クラス間の結合度を減らすことも意味します。ここから、デザインパターンは、アップグレードとメンテナンスの利便性のために、実際には大規模なソフトウェアアーキテクチャから始まるソフトウェアの設計アイデアであることがわかります。したがって、上記の記事は何度も登場しました。依存を減らし、結合を減らすことです。
5。デメテル原理
なぜ知識のない原則があるのですか？つまり、1つのエンティティは、システム機能モジュールが比較的独立しているように、できる限り他のエンティティと対話する必要があります。
6。複合再利用原理
原則は、継承ではなく合成/集約方法を使用しようとすることです。
3。作成モード
作成モードには、ファクトリーメソッドモード、抽象的な工場モード、シングルトンモード、ビルダーモード、プロトタイプモードの5つのタイプがあります。
3.1。工場メソッドモデル
ファクトリーメソッドモードは、通常の工場モード、複数の工場メソッドモード、静的ファクトリーメソッドモードの3つのタイプに分割されます。
3.1.1。通常の工場モデル
通常の工場モデルは、工場クラスを確立し、同じインターフェイスを実装するいくつかのクラスのインスタンスを作成することです。
パッケージcom.mode.create;パブリックインターフェイスmyinterface {public void print（）;}パッケージcom.mode.create;パブリッククラスMyClassoneはmyInterfaceを実装します{@Override public void print（）{system.out.println（ "myclassone"）; }}パッケージcom.mode.create;パブリッククラスmyclasstwoはmyinterfaceを実装します{@override public void print（）{system.out.println（ "myclasstwo"）; }}パッケージcom.mode.create; public class myFactory {public myinterface produce（string type）{if（ "one" .equals（type））{return new myclassone（）; } else if（ "two" .equals（type））{return new myclasstwo（）; } else {system.out.println（ "型型は見つかりません"）; nullを返します。 }}}パッケージcom.mode.create; public class factorytest {public static void main（string [] args）{myFactory Factory = new MyFactory（）; myinterface myi = factory.produce（ "one"）; myi.print（）; }}FactoryTestの結果は明らかだと思います。
この文をもう一度理解しましょう。通常の工場モデルは、工場クラスを確立し、同じインターフェイスを実装するいくつかのクラスのインスタンスを作成することです。
3.1.2。複数の工場メソッドモード
複数の工場メソッドモードは、通常の工場メソッドモードの改善です。複数の工場メソッドモードは、オブジェクトを個別に作成するための複数の工場メソッドを提供することです。
コードを直接見てみましょう。次のように、私の要因とFactoryTestを変更します。
パッケージcom.mode.create; public class myFactory {public myinterface procuseone（）{return new myclassone（）; } public MyInterface productwo（）{return new myclasstwo（）; }}パッケージcom.mode.create; public class factorytest {public static void main（string [] args）{myFactory Factory = new MyFactory（）; myinterface myi = factory.produceone（）; myi.print（）; }}操作結果も非常に明白です。
この文をもう一度理解しましょう。複数の工場メソッドモードは、通常の工場メソッドモードの改善です。複数の工場メソッドモードは、オブジェクトを個別に作成するための複数の工場メソッドを提供することです。
3.1.3。静的ファクトリーメソッドモード
静的ファクトリーメソッドモードは、上記の複数の工場メソッドモードのメソッドを静的に設定し、インスタンスを作成する必要はありません。直接呼び出すだけです。
コードを直接見てみましょう。次のように、私の要因とFactoryTestを変更します。
パッケージcom.mode.create; public class myFactory {public static myinterface procuseone（）{return new myclassone（）; } public static myinterface productwo（）{return new myclasstwo（）; }}パッケージcom.mode.create; Public Class FactoryTest {public static void main（string [] args）{myinterface myi = myfactory.produceone（）; myi.print（）; }}操作の結果はまだ非常に明白です。
もう一度確認してください：静的工場メソッドモード、上記の複数の工場メソッドモードのメソッドを静的に設定します。インスタンスを作成する必要はありません。直接呼び出すだけです。
3.2。抽象的な工場パターン
ファクトリーメソッドモデルには、クラスの作成が工場クラスに依存すること、つまりプログラムを拡張したい場合は、閉鎖原則に違反する工場クラスを変更する必要があります。
この問題を解決するために、抽象的な工場パターンを見てみましょう。複数の工場クラスを作成して、新しい機能が必要になったら、前のコードを変更せずに新しい工場クラスを直接追加できるようにします。
これは閉鎖原則に準拠しています。
以下のコードを見てみましょう。
myinterface、myclassone、myclasstwoは変わらない。
次のインターフェイスとクラスが追加されています。
パッケージcom.mode.create;パブリックインターフェイスプロバイダー{public myinterface produce（）; }パッケージcom.mode.create;パブリッククラスMyFactoryOneはプロバイダー{@Override public myinterface produce（）{return new myclassone（）; }}パッケージcom.mode.create;パブリッククラスMyFactoryTWO実装プロバイダー{@Override public MyInterface produce（）{return new myclasstwo（）; }}テストクラスのファクトリテストを次のように変更します。
パッケージcom.mode.create; public class factorytest {public static void main（string [] args）{provider provider = new myfactoryone（）; myinterface myi = probider.produce（）; myi.print（）; }}操作の結果はまだ明らかです。
もう一度レビュー：抽象的な工場パターンは、複数の工場クラスを作成することです。これにより、新しい機能が必要になると、以前のコードを変更せずに新しい工場クラスを直接追加できます。
3.3。シングルトンモード
シングルトンのパターン、あまり多くの説明が必要ありません。
コードを見てください：
パッケージテスト; public class myobject {private static myobject myobject; private myobject（）{} public static myobject getInstance（）{if（myobject！= null）{} else {myobject = new Myobject（）; } myobjectを返します。 }}ただし、これによりマルチスレッドの問題が発生します。詳細な説明については、「Java Multi-Threadingプログラミングのコアテクノロジー」という本の第6章を見ることができます。
3.4。ビルダーモード
ビルダーパターン：複雑なオブジェクトの構造を表現から分離して、同じ構造プロセスが異なる表現を作成できるようにすることです。
それは文字通り非常に抽象的に見えますが、実際には非常に抽象的です！ ！ ！ ！
ビルダーモードには通常、次の文字が含まれます。
（1）ビルダー：製品オブジェクトのさまざまなコンポーネントの構築を標準化するための抽象インターフェイスを指定します。このインターフェイスは、複雑なオブジェクトのどの部分が作成されているかを指定し、特定のオブジェクトコンポーネントの作成を伴いません。
（2）ConcreteBuilder：ビルダーインターフェイスを実装し、異なるビジネスロジックの複雑なオブジェクトのさまざまな部分の作成を定義します。建設プロセスが完了した後、製品の例が提供されます。
（3）ディレクター：特定のビルダーに電話して、複雑なオブジェクトのさまざまな部分を作成します。インストラクターは特定の製品情報を伴うものではありませんが、オブジェクトのすべての部分がそのまままたは特定の順序で作成されることを保証する責任のみを担当します。
（4）製品：作成される複雑なオブジェクト。
ゲーム開発に悪役を築くことが一般的であり、要件は次のとおりです。悪役は頭、体、足を含める必要があります。
次のコードを見てみましょう。
製品（作成される複雑なオブジェクト）：
パッケージcom.mode.create;パブリッククラスの人{プライベートストリングヘッド。プライベートストリングボディ;プライベートストリングフット; public string gethead（）{return head; } public void sethead（string head）{this.head = head; } public string getBody（）{return body; } public void setbody（string body）{this.body = body; } public string getFoot（）{return foot; } public void setfoot（string foot）{this.foot = foot; }}ビルダー（製品オブジェクトのさまざまなコンポーネントの構築を標準化するための抽象インターフェイスを提供します。このインターフェイスは、複雑なオブジェクトのどの部分が実装されるように作成され、特定のオブジェクトコンポーネントの作成を含むものではないことを指定します。）：
パッケージcom.mode.create; public Interface PersonBuilder {void buildhead（）; void buildbody（）; void buildfoot（）;人BuildPerson（）;} ConcreteBuilder（さまざまなビジネスロジックの複雑なオブジェクトのさまざまな部分の作成を具体化するビルダーインターフェイスを実装します。建設プロセスが完了したら、製品の例を提供します。）
パッケージcom.mode.create;パブリッククラスのマンバイルダーは、PersonBuilderを実装しています{人の人。 public manbuilder（）{person = new person（）; } public void buildbody（）{person.setbody（ "男の体を構築する"）; } public void buildfoot（）{person.setfoot（ "男の足を構築する"）; } public void buildhead（）{person.sethead（ "男の頭を構築する"）; } public Person buildPerson（）{return person; }}ディレクター（特定のビルダーに電話して複雑なオブジェクトのさまざまな部分を作成します。インストラクターは特定の製品情報を伴うものではありません。オブジェクトの部分が無傷または特定の順序で作成されるようにすることのみを担当します。）
パッケージcom.mode.create; Public Class PersonDirector {public Person constructsperson（personbuilder pb）{pb.buildhead（）; pb.buildbody（）; pb.buildfoot（）; return pb.buildperson（）; }}テストクラス：
パッケージcom.mode.create; public class test {public static void main（string [] args）{persondirector pd = new PersonDirector（）; Person person = pd.constructserson（new manbuilder（））; System.out.println（person.getBody（））; System.out.println（person.getFoot（））; System.out.println（person.gethead（））; }}実行結果：
レビュー：ビルダーパターン：複雑なオブジェクトの構築を表現から分離して、同じ構造プロセスが異なる表現を作成できるようにすることです。
3.5。プロトタイプモード
このパターンのアイデアは、オブジェクトをプロトタイプとして使用し、コピーしてクローン化し、元のオブジェクトに似た新しいオブジェクトを作成することです。
オブジェクトのコピーといえば、オブジェクトの浅いコピーとディープコピーと組み合わせて話をします。まず、オブジェクトの深く浅いコピーの概念を理解する必要があります。
浅いコピー：オブジェクトをコピーした後、基本データ型の変数が再作成され、参照型は元のオブジェクトを指します。
ディープコピー：オブジェクトをコピーした後、基本的なデータ型と参照型の両方が再作成されます。簡単に言えば、深いコピーは完全にコピーされますが、浅いコピーは徹底的ではありません。
深さのコピーの例を書く：
パッケージcom.mode.create; java.io.io.bytearrayinputStream; Import java.io.io.bytearrayoutputStream; Import java.io.ioexception; Import java.io.objectinputStream; Import java.io.objectOutputStream; Import java.io.Serializable;パブリッククラスのプロトタイプは、クローン可能、シリアル化可能{プライベート静的最終long serialversionuid = 1l;プライベートINTベース。プライベート整数OBJ; /*浅いコピー*/ public Object clone（）はcloneNotsupportedexception {//クローン可能なインターフェイスが空のインターフェイスであるため、クロネアやクロネなどの実装クラスのメソッド名を定義できます。 proto =（prototype）super.clone（）; protoを返します。 } /*ディープコピー* / public Object deepclone（）throws ioException、classNotFoundException { /*バイナリストリームを現在のオブジェクトに書き込みます* / bytearrayoutputStream bos = new bytearrayoutputStream（）; ObjectOutputStream OOS = new ObjectOutputStream（BOS）; oos.writeobject（this）; /*バイナリストリームによって生成された新しいオブジェクトを読み取ります*/ bytearrayinputStream bis = new bytearrayinputStream（bos.tobytearray（））; ObjectInputStream ois = new ObjectInputStream（bis）; ois.readObject（）を返します。 } public int getBase（）{return base; } public void setBase（int base）{this.base = base; } public Integer getobj（）{return obj; } public void setobj（integer obj）{this.obj = obj; }}テストクラス：
パッケージcom.mode.create; java.io.ioexceptionをインポートします。 public class test {public static void main（string [] args）throws clonenotsuptedexception、classnotfoundexception、ioexception {prototype prototype = new Prototype（）; prototype.setbase（1）; prototype.setobj（new Integer（2））; /* shallow copy*/ prototype prototype1 =（prototype）prototype.clone（）; /*ディープコピー*/プロトタイプPrototype2 =（prototype）prototype.deepclone（）; System.out.println（prototype1.getobj（）== prototype1.getobj（））; system.out.println（prototype1.getobj（）== prototype2.getobj（））; }}実行結果：
上記はこの記事に関するものです。すべての人の学習に役立つことを願っています。