seモード

一.基本的なオブジェクト向けの原則:パッケージ、マルチステート、インタフェース向け.
二.ポリシー・モード:
           

abstact class duck{
       private Flyber flyber;
       private Quacker quacker;
       
       private Higter highter;  
        public void display()
       {
          System.out.println(" ："+heiht);
        } 
        public void fly()
       {
            flyber.fly();
      }
       pulibc void quaker()
       {
            quacker.quacker();
       }
   .....get set  。
}

public interface Flyber{
   public  quacker();

}

そしてこのインタフェースを実現する飛翔クラスがあり、
アヒルのクラスはduckクラスを継承し、それは飛ぶことができて、叫ぶことができて、それではflyberを実現して、quakerインタフェースは飛ぶことができる行為クラスを飛んで、アヒルのクラスのメンバーの変数に与えます.
このようにアヒル類の不変の部分は主抽象類に書き,変化の部分はそのメンバー変数に書き,
メリット:継承されている場合、主クラスは飛和呼を実現し、子クラスが飛和呼をしない場合は、継承するたびに飛和呼を修正します.
会呼と飛をインタフェースとして書くと、主クラスはインタフェースを実現し、サブクラスに同じ会飛和がある場合は、このように更新と新加を繰り返し書くようにし、コードを多重化できません.
したがって,変化した部分をインタフェースを実現する行動クラスとして作成し,主クラスに組み合わせることで,上記のような状況の発生を回避する.
 
三:観察者:
      interface subject
{
        regiterObercts();
        removeObercts();
        notesObercts();
} 
 
interface Oberct
{
public update(転送オブジェクト);
}
 
このように実現する
   Oberct1 implements Oberct
{
        Oberct1( subject)
        {
                subject.regiterObercts(this);       
        }
public update(トランスポートオブジェクト)
        {
転送するオブジェクトを取得し、表示します.
        }
}
 
subject implements subject
{
    private List list;
    regiterObercts(object){
      list.add(object);
      }
    removeObercts()
{
list.remove(object);
}
    notesObercts(
    for()
   {
       list.get(i).update(転送オブジェクト);
    }
 
);
JAva内蔵観察者:java.until.Observable   Observer
しかしObservableはクラスであり,インタフェースではなく,良し悪しがある.
 
三装飾者モード:
抽象的なプライマリ:抽象クラスまたはインタフェース
次の2つに分けます.
一主類二位装飾者
この3つは同じタイプでなければならないことに注意してください.
装飾者モード:3つのコンポーネントを実現する1つの抽象的なコンポーネント、1つの抽象的な装飾者のコンポーネント、1つの具体的なコンポーネント、1つの具体的な装飾者コンポーネント装飾者モード:すべてのコンポーネントは統一的なインタフェースを実現しなければならない.実装される継承は、すべてのコンポーネントがプライマリの動作を継承するのではなく、統一されたタイプに属するようにするためです.組み合わせによって行動の変化を実現するのですJAvaIOモデルは装飾者モードを実現したものです.InputStreamは抽象的なコンポーネントであり、FileInputStreamは抽象的なコンポーネントである.LineNumberInputStream,BufferedInputStreamは装飾者の具体的なクラスである.では抽象的な装飾者コンポーネントはどのクラスですか.
OK
     
四:工場モード:
   1.単純な工場:
クライアントでインスタンスを得る、いずれもNEWの1つのオブジェクトを必要とする場合、これは具体的な実装クラスに対して編成され、このように後で変更すると、クライアントのコードを修正する.このようにオブジェクトの作成を別のクラスに配置する作成する.単純な工場を構成し、
 

public class PizzsStore{
       Pizza OrderPizza(String type)
          {
            pizza= simplePizzaFactory.createPizza(type);

              pizza.prepare();
              pizza.bake();
              pizza.cut();
             pizza.box();
              return pizza;
            }

}

 
  2.工場方法:
しかし、ベースクラスを抽象クラスに作成すると、オブジェクトを作成するのはクラスの中で抽象的な方法にすぎず、具体的なサブクラスでオブジェクトの作成を実現しなければならない.このようにして工場の方法を構成する.
3.オブジェクトを作成するために使用する原料を、原料工場で完成させる場合は、異なる店舗で、異なるPIZZAオブジェクトを必要とします.このように、原料工場を作成し、異なるサブクラスで原料工場を実現することで、オブジェクトを作成する際に、具体的な工場を転送して、自分のpizzaオブジェクトを作成します.
このように抽象工場を構成し,抽象工場は工場法を用いて自分の具体的なクラスを作成する.
抽象的な物品及び具体的な物品:

public abstract class Pizza{
       String name;
       Dough dough;
      Sauce sauce;
      .....
     void baake(){System.out.println(" bake for 25 minutes at 350");}
     void cut(){}
     
}

public class CheesePizza extends Pizza{
      PizzaIngredientFactory ingredientFactory;

     public CheesePizza(PizzaIngredientFactory facotry)
   {
       this.factory=facotry;
   }

   void prepare()
  {
     this.dough=ingredientFactory.createDough();
     this.sauce=facotry.createSauce();
  }


}

 
具体的な店舗:
 

public class NyPizzaStore Extends PizzaStore{
     protected Pizza createPizza(String item)
   {
    Pizza pizza=null;
    PizzaIngredientFactory =new NyPizzaIngredIentFactory();  
    if(item.equasl("cheese"))
{
    pizza=new CheesePizza(factory);
}else if( ){

}else if( ){

}
      

   }


}

抽象的な店

public abstract class PizzaStore{
public Pizza orderPizza(String type){
     Pizza pizza;
pizza=createPizza(type);
pizza.prpare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}

protected abstract Pizza createPiizza(String type);
}

四:一例モード
クラスの構造方法がプライベートである場合、外部またはサブクラスからインスタンスを作成することはできないので、クラスの内部からインスタンスを作成するべきであるため、クラスには共通の静的方法が必要であり、インスタンスを提供する.
インスタンスは初期化時に作成されます.

/**
 * @author handw
 * @date 2009-12-12  01:46:52
 * @infomation: 
 */
public class Singtons {
	private static Singtons sington=new Singtons();
	/**
	 *  
	 */
	private Singtons() 
	{
	}

	/**
	 * 
	 * @author handw
	 * @date 2009-12-12  01:48:12
	 * @infomation: 
	 * @return
	 */
	public static Singtons getSingtonIntance()
	{
		return sington;
	}
	

}

 
インスタンスを取得するときにインスタンスを作成します.

package maintest;

/**
 * @author handw
 * @date 2009-12-12  03:07:06
 * @infomation: 
 */
public class Sington {
    private static Sington sington;
    private String QueryCarSQL="select * from mg_car";
    private String QueryStationSQL="select * from mg_car";
        /**
	 *  
	 */
	private Sington() 
	{
	}
	/**
	 *  
	 * @author handw
	 * @date 2009-12-12  03:08:11
	 * @infomation:
	 * @return
	 */
	public static Sington getSingtonIntance()
	{
		if(sington==null)
		{
		    synchronized (Sington.class) {//--- ， 
			if(sington==null)
			{
			    sington=new Sington();
			}			    		    }
		}
                     return sington;
	}
     public String getPublicQueryCar()
     {
	 return "select * from mg_car";
     }
     /**
      *  
      * @author handw
      * @date 2009-12-12  03:43:21
      * @infomation:
      * @return
      */
     private String getPrivateQueryCar()
     {
	 return "select * from mg_car";
     }
     /**
      * 
      * @author handw
      * @date 2009-12-12  03:43:42
      * @infomation: ， , 
      * @return
      */
     protected String getProtectedQueryCar()
     {
	 return "select * from mg_car";
     }
     /**
      * 
      * @author handw
      * @date 2009-12-12  03:46:08
      * @infomation: 
      * @return
      */
     String getFriendly()
     {
	 return "select * from mg_car";
     }
}

 
インスタンスを同期して取得する静的メソッドもありますが、同期ブロックよりもパフォーマンスが悪く、最初に作成したときに同期ブロックが1回しか実行されません.