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,quacker接口会飞会叫的
行为类，赋于鸭子类的成员变量。

这样鸭子类 的不变的部分写在主抽象类中，变化的部分写在其成员变量中，

好处：若都是继承得来，主类实现飞和叫，若子类不会飞和叫，那每继承一个就要修改飞和叫。

         若把会叫和飞写成接口，主类实现接口，这样若子类中有一样的会飞和会叫这样更新和新加都要重复写，这样代码不能复用。

所以把变化的部分写成实现接口的行为类，组合在主类中，这样避免了上面的情况的发生。

 

三：观察者：

      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   是类，不是接口，有好有坏。

 

三装饰者模式：

一个抽象的主件：可为抽象类或接口

    下面分为：两种

    一主类 二位装饰者

  注意这三个必须是同一种类型。

装饰者模式：实现3个组件
一个抽象的组件，一个抽象的装饰者的组件， 一个具体的组件，一个具体的装饰者组件
装饰者模式：所有的组件必须都是实现统一的接口.
其中实现的继承是为了使所有的组件都属于统一的类型，而不是继承主件的行为。而是通过组合来实现行为的改变。
javaIO模型就是实现了装饰者模式。
   inputStream 为抽象的组件，FileInputStream 为抽象的组件。LineNumberInputStream ，BufferedInputStream为装饰者的具体类。
   那抽象的装饰者组件是哪个类呢。

OK

     

四:工厂模式:

   1.简单工厂:

          如果在客户端得到一个实例,都要NEW一个对象的话,这样就是针对具体的实现类来编成,这样以后要是改变的话,就要修改客户端的代码.这样把对象的创建放到另外一个类中去创建.就构成了简单工厂,

 

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";
     }
}

 

也个同步获得实例的静态方法,但是性能不好，不如同步块，只是在第一次创建的时候同步块才运行一次。