デザインパターンの[インタビュープログラム]シリーズ用

シングルトン

簡単に言えば、あること、アプリケーション、クラスのオブジェクトインスタンスは、コンストラクタをプライベートに変更されているので、あなたが通常のgetInstance（）メソッドによって、その一例を得るために、新に方法はありません、一つだけを持っています。

getInstance（）の戻り値は、そうではない誤解複数のオブジェクトに、オブジェクトではなく、新しいインスタンスへの参照です。シングルトンパターンは、実装デモを見るためにそれを指示することは非常に簡単でもあります

public class Singleton {

private static Singleton singleton;

private Singleton() {
}

public static Singleton getInstance() {
 if (singleton == null) {
  singleton = new Singleton();
 }
 return singleton;
}
}
复制代码

私の習慣によると、私は、コメントをあなたが理解していない恐れて埋め待つことができないが、このコードは単純すぎる、コードのこれらのいくつかの行は、あなたが理解していない場合、私は、メモを書いていないので、あなたは睡眠を洗うことができますあなたが私のブログを見て目を覚ますとなるように理解することができるかもしれません。

上記の私はいくつかのシングルトンパターンの文言を公表下記（スレッドセーフではありません）も怠惰な書き込みとして知られている最も基本的な書き込み、次のとおりです。

怠惰な人間の書き込み（スレッドセーフ）

public class Singleton {  
   private static Singleton instance;  
   private Singleton (){}  
   public static synchronized Singleton getInstance() {  
   if (instance == null) {  
       instance = new Singleton();  
   }  
   return instance;  
   }  
}
复制代码

空腹中国風の書き込み

public class Singleton {  
   private static Singleton instance = new Singleton();  
   private Singleton (){}  
   public static Singleton getInstance() {  
   return instance;  
   }  
}
复制代码

静的な内部クラス

public class Singleton {  
   private static class SingletonHolder {  
   private static final Singleton INSTANCE = new Singleton();  
   }  
   private Singleton (){}  
   public static final Singleton getInstance() {  
   return SingletonHolder.INSTANCE;  
   }  
}
复制代码

列挙

public enum Singleton {  
   INSTANCE;  
   public void whateverMethod() {  
   }  
}
复制代码

このアプローチは、それが唯一のマルチスレッド同期の問題を避けることはできませんが、また、ああ、非常に強力な障壁として記述することができ、デシリアライゼーションは、新しいオブジェクトを再作成を防止するために、しかし、個人的に1.5にその原因を考えて、効果的なJavaの著者ジョシュブロッホの方法を提唱しています列挙型プロパティを追加する前に、このように書き込みが助けることが奇妙に感じることができません。

ダブルチェックロック

public class Singleton {  
   private volatile static Singleton singleton;  
   private Singleton (){}  
   public static Singleton getSingleton() {  
   if (singleton == null) {  
       synchronized (Singleton.class) {  
       if (singleton == null) {  
           singleton = new Singleton();  
       }  
       }  
   }  
   return singleton;  
   }  
}
复制代码

概要：私は個人的に静的な内部クラスを好むし、実際には、書き込みの飢えた男のスタイルを書いて、例大半の文言の両方に対処することができます。また、主にビジネスがそれを必要と見て、他の文言を選択することができます。

Observerパターン

オブジェクトの状態が変化するが、それに依存するすべてのオブジェクトが通知され、自動的に更新されたオブジェクト間の多くの依存関係、。

画像

ObserverパターンUMLダイアグラム

読むにはここに小さなベンチを運ぶ人々をグラフに、あなたに栗を与える：3人、メル（22、女性）、王とLiがあるとします。リトル・アメリカは非常に美しいです、王とLiは常にメルのすべての動きを懸念し、二つのプログラムの猿です。ある日、メルが何かを言った：「誰がああゲームをプレイするために私に同行します」これらの言葉は、Cengceng摩擦ではなく、しばらくの間、王とLi、悪い音楽の結果を聞いてきた、王はリトルアメリカに駆けつけ王とLiが観測されている米国が小さい観測者である家のドアは、メッセージがオブザーバー、適切な治療を行い、その後、観察、コードを見て送信されます。

public interface Person {
   //小王和小李通过这个接口可以接收到小美发过来的消息
   void getMessage(String s);
}
复制代码

このインタフェースは、王とマイクの電話番号に相当し、小さな米国は、この電話のgetMessageを呼ぶときに通知を送信するコール・インタフェースであり、それは問題ではない理解していない、最初のルックダウン

public class LaoWang implements Person {

   private String name = "小王";

   public LaoWang() {
   }

   @Override
   public void getMessage(String s) {
       System.out.println(name + "接到了小美打过来的电话，电话内容是：" + s);
   }

}

public class LaoLi implements Person {

   private String name = "小李";

   public LaoLi() {
   }

   @Override
   public void getMessage(String s) {
       System.out.println(name + "接到了小美打过来的电话，电话内容是：->" + s);
   }

}
复制代码

コードは、私たちは小さな米国のコードを見て、簡単です：

public class XiaoMei {
   List<Person> list = new ArrayList<Person>();
    public XiaoMei(){
    }

    public void addPerson(Person person){
        list.add(person);
    }

    //遍历list，把自己的通知发送给所有暗恋自己的人
    public void notifyPerson() {
        for(Person person:list){
            person.getMessage("你们过来吧，谁先过来谁就能陪我一起玩儿游戏!");
        }
    }
}
复制代码

我々は右の結果でテストクラスの外観を書きます

public class Test {
   public static void main(String[] args) {

       XiaoMei xiao_mei = new XiaoMei();
       LaoWang lao_wang = new LaoWang();
       LaoLi lao_li = new LaoLi();

       //小王和小李在小美那里都注册了一下
       xiao_mei.addPerson(lao_wang);
       xiao_mei.addPerson(lao_li);

       //小美向小王和小李发送通知
       xiao_mei.notifyPerson();
   }
}复制代码

Decoratorパターン

既存のビジネス・ロジックのさらにパッケージ、例えばJavaのIOなどの追加機能は、その所望の効果を達成するために組み立てることができDecoratorパターン、ユーザの使用での使用ににストリームよう。栗のために、私は大きなソーセージを必要とするすべての最初の、サンドイッチを食べたい、私は、バターを食べるソーセージの上に少しクリームを追加し、いくつかの野菜を追加したい、そして最終的にパンの2つのスライスで、それは非常に心のこもった食事昼食です、栄養と健康。（詩：私は〜の勧告を求めて、どこ上海おいしいサンドイッチを販売することを知らない）私たちがなければならないことをどのようにコードを記述しますか？まず、我々は、他のすべての食品は、コードを見て、このクラスを継承しているので、こと、食べ物のクラスを記述する必要があります。

public class Food {

   private String food_name;

   public Food() {
   }

   public Food(String food_name) {
       this.food_name = food_name;
   }

   public String make() {
       return food_name;
   };
}
复制代码

コードは、私が説明できないだろう、そして我々はそれがいくつかのサブクラスの継承を書き、簡単です：

//面包类
public class Bread extends Food {

   private Food basic_food;

   public Bread(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+面包";
   }
}

//奶油类
public class Cream extends Food {

   private Food basic_food;

   public Cream(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+奶油";
   }
}

//蔬菜类
public class Vegetable extends Food {

   private Food basic_food;

   public Vegetable(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+蔬菜";
   }

}
复制代码

これらのクラスはコンストラクタがない心配を行い、なぜ書き込みので、あなたはまだ理解していない場合は、自分自身の方法を作るためにいくつかのロジックを追加し、食品の型パラメータを渡し、似ている、あなたは私のテストクラスを見て書く方法、外観はあなたが理解します

public class Test {
   public static void main(String[] args) {
       Food food = new Bread(new Vegetable(new Cream(new Food("香肠"))));
       System.out.println(food.make());
   }
}
复制代码

私が最も外側、私は野菜の層を追加して、最も内側の私の新しいソーセージ、ソーセージの外側を、私はクリームの層を包み、バター外：レイヤパッケージによって全く、レイヤーを参照してくださいしない、我々は内から外を見ましたパンは非常にイメージではありません入れ、ハハ〜実際の生活の中で、ほぼ正確に同じで、このデザインパターンは、それを読みますか？我々は結果を見て、それ

画像

業績

ほかのサンドイッチ〜

アダプタモード

2つの完全に異なるものは、ちょうど変圧器の実際の生活の中でのように、一緒にリンク。電圧が必要と仮定すると、携帯電話の充電器20Vですが、通常の電圧は220V、あなたは20Vの電圧変圧器と携帯電話がアップリンクされますので、20Vの電圧を220Vの電圧を変換する変圧器を必要とし、この時間です。

public class Test {
   public static void main(String[] args) {
       Phone phone = new Phone();
       VoltageAdapter adapter = new VoltageAdapter();
       phone.setAdapter(adapter);
       phone.charge();
   }
}

// 手机类
class Phone {

   public static final int V = 220;// 正常电压220v，是一个常量

   private VoltageAdapter adapter;

   // 充电
   public void charge() {
       adapter.changeVoltage();
   }

   public void setAdapter(VoltageAdapter adapter) {
       this.adapter = adapter;
   }
}

// 变压器
class VoltageAdapter {
   // 改变电压的功能
   public void changeVoltage() {
       System.out.println("正在充电...");
       System.out.println("原始电压：" + Phone.V + "V");
       System.out.println("经过变压器转换之后的电压:" + (Phone.V - 200) + "V");
   }
}
复制代码

ファクトリパターン

単純なファクトリパターン：抽象クラスの複数の抽象インターフェースのインターフェースを実装し、ファクトリクラスが抽象インタフェースをインスタンス化するために使用され

// 抽象产品类
abstract class Car {
   public void run();

   public void stop();
}

// 具体实现类
class Benz implements Car {
   public void run() {
       System.out.println("Benz开始启动了。。。。。");
   }

   public void stop() {
       System.out.println("Benz停车了。。。。。");
   }
}

class Ford implements Car {
   public void run() {
       System.out.println("Ford开始启动了。。。");
   }

   public void stop() {
       System.out.println("Ford停车了。。。。");
   }
}

// 工厂类
class Factory {
   public static Car getCarInstance(String type) {
       Car c = null;
       if ("Benz".equals(type)) {
           c = new Benz();
       }
       if ("Ford".equals(type)) {
           c = new Ford();
       }
       return c;
   }
}

public class Test {

   public static void main(String[] args) {
       Car c = Factory.getCarInstance("Benz");
       if (c != null) {
           c.run();
           c.stop();
       } else {
           System.out.println("造不了这种汽车。。。");
       }

   }

}
复制代码

ファクトリメソッドパターン：4つの役割、Abstract Factoryパターン、具体的なファクトリパターン、抽象製品モデル、製品固有のモードがあります。もはや、特定の製品をインスタンス化するクラスファクトリではありませんが、製品は抽象工場のサブクラスをインスタンス化します

// 抽象产品角色
public interface Moveable {
   void run();
}

// 具体产品角色
public class Plane implements Moveable {
   @Override
   public void run() {
       System.out.println("plane....");
   }
}

public class Broom implements Moveable {
   @Override
   public void run() {
       System.out.println("broom.....");
   }
}

// 抽象工厂
public abstract class VehicleFactory {
   abstract Moveable create();
}

// 具体工厂
public class PlaneFactory extends VehicleFactory {
   public Moveable create() {
       return new Plane();
   }
}

public class BroomFactory extends VehicleFactory {
   public Moveable create() {
       return new Broom();
   }
}

// 测试类
public class Test {
   public static void main(String[] args) {
       VehicleFactory factory = new BroomFactory();
       Moveable m = factory.create();
       m.run();
   }
}
复制代码

抽象ファクトリーモード：ファクトリメソッドとモードは、単一の製品を製造する工場の工場法モデル異なる、工場の複数の製品の抽象工場モデル

/抽象工厂类
public abstract class AbstractFactory {
   public abstract Vehicle createVehicle();
   public abstract Weapon createWeapon();
   public abstract Food createFood();
}
//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory extends AbstractFactory{
   @Override
   public Food createFood() {
       return new Apple();
   }
   @Override
   public Vehicle createVehicle() {
       return new Car();
   }
   @Override
   public Weapon createWeapon() {
       return new AK47();
   }
}
//测试类
public class Test {
   public static void main(String[] args) {
       AbstractFactory f = new DefaultFactory();
       Vehicle v = f.createVehicle();
       v.run();
       Weapon w = f.createWeapon();
       w.shoot();
       Food a = f.createFood();
       a.printName();
   }
}
复制代码

プロキシモード（プロキシ）

静的および動的プロキシエージェントの2種類があります。私は、静的なエージェントについてお話しましょう、私は話すことはありません、理論的なものの多くは、私が言う場合でも、あなたは読むことができません。本当の役割、抽象的役割、エージェント委託役割の役割はどのようなものです。。。混乱、私は理解していません。代理店モデル校までの時間は、私はあなたがに行くことができるとは思わない、それは非常に難しいと思われる、基本的にはどのような役割、理論の多くを分析し、リンクの外観を開いて、簡単な外観、多くの情報をオンラインに外観は、私は彼らが言うことを理解していません。彼らは生活の例と直接話すように、空の来ていません。（注：私は知識の理論を否定するためにここにいないよ、私は時々不明瞭だと思うの理論的な知識、片側に人の刺すように、あなたが刺すために、学ぶことではない来ている）
一定の年齢に、私たちは結婚しています結婚は（両親の結婚をしている者を含む）、非常に面倒なことです。裕福な家族が司会を探している可能性があり結婚式に、活気のある、西洋スタイル〜まあを見て、今の会社の事業の結婚式を主宰、私達はちょうどそれが私たちが結婚式のセットの結婚式のプロセスを整理するのに役立ちます、お金を与える必要があります。全体のプロセスは、おそらくこれです：家族が結婚する-結婚式の企業フライを検索する> - -両方の家族の男性と女性は黄道今日と結婚することに同意した>>指定された時間での結婚式- >結婚式の仕上げ
どのように結婚式を配置する結婚式の計画このプログラムは、会社がどうなるの結婚式の結婚式が終了した後、我々は何も知りませんでした。。。ない心配ではなく、黒の仲介を行い、私たちは人々にお金を与える、人々は私たちに物事を行います。だから、ここの結婚式のエージェントの役割と同等のものをだ、エージェントの役割は、今あるものを理解しています。

達成するためのコードを見てください：

//代理接口
public interface ProxyInterface {
//需要代理的是结婚这件事，如果还有其他事情需要代理，比如吃饭睡觉上厕所，也可以写
void marry();
//代理吃饭(自己的饭，让别人吃去吧)
//void eat();
//代理拉屎，自己的屎，让别人拉去吧
//void shit();
}
复制代码

文明社会、エージェントが食べる、私は書いていないどのようなプロキシのたわごとは、傷公序良俗は~~~うまく理解できています

さて、私たちは結婚式の会社コードを見て：

public class WeddingCompany implements ProxyInterface {

private ProxyInterface proxyInterface;

public WeddingCompany(ProxyInterface proxyInterface) {
 this.proxyInterface = proxyInterface;
}

@Override
public void marry() {
 System.out.println("我们是婚庆公司的");
 System.out.println("我们在做结婚前的准备工作");
 System.out.println("节目彩排...");
 System.out.println("礼物购买...");
 System.out.println("工作人员分工...");
 System.out.println("可以开始结婚了");
 proxyInterface.marry();
 System.out.println("结婚完毕，我们需要做后续处理，你们可以回家了，其余的事情我们公司来做");
}

}
复制代码

いいえ、結婚式の会社は、私たちが結婚ファミリーのコードを見て多くのことを行う必要があります参照してください。

public class NormalHome implements ProxyInterface{

@Override
public void marry() {
 System.out.println("我们结婚啦～");
}

}
复制代码

このすでに明らかなように、結婚し家族が唯一の結婚ですが、結婚式を行うには、物事のすべてのもの、すべてのインとアウトを行うために結婚式の会社、結婚式の企業は今、たくさんのお金を聞き、これが理由で、ライブなどを行い、缶お金を稼ぎますか？

テストクラスのコードを見てみましょう：

public class Test {
public static void main(String[] args) {
 ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());
 proxyInterface.marry();
}
}
复制代码

結果は以下の通りであります：

画像

私たちは、これは私がそれを更新する時間があるでしょう、オンライン関係、多くの情報のJavaのリフレクションと、私は言いたくない帯電防止剤、ダイナミック剤であり、結果が正しい、期待しています。