浅谈Java设计模式第一篇

java创建型设计模式

一、单例模式:一个类只有一个实例，并提供一个访问的全局访问点

public   class   Singleton{

      private Static Singleton singleton = null;

      private Singleton(){}

     public Static Singleton getInstance(){

                 if(singleton==null){

                         singleton = new Singleton();

                 }

                   return singleton;

       }

}

二：工厂模式

分为工厂方法模式（普通工厂方法模式，多个工厂方法模式，静态工厂方法模式），抽象工厂方法模式两大类，两者区别在于前者工厂类会随着其它类功能增加而要不断修改，不易于扩展，而后者直接增加工厂类不用修改其它类。

普通工厂方法模式：

public Interface Animal(){

       public void eat();

}

public Class Cattle implements Animal{

     public void eat(){

         system.out.println("牛吃草");   

  }

}

public Class cat implements Animal{

     public void eat(){

         system.out.println("猫吃鱼");   

  }

}

public Class AnimalFactory{

     public  Animal   getAni(String str){

         if("牛".equals(str)){

              return new Cattle();

         }else if("猫".equals(str)){

            return new Cat(); 

         }else{

             throw Excepion("无该动物");

         }

   }

}

public Class FactoryTest(){

      public static void main(str[] args){

          AnimalFactory  facTest = new AnimalFactory();

          Animal animal = facTest.getAni("牛");

         animal.eat();

      }

}

多个工厂方法模式:

把工厂类做如下修改

public Class AnimalFactory{

     public Animal getCattle(){ 

          return new Cattle();

}

   public Animal getCat(){

          return new Cat();

    }

}

静态工厂方法模式：

把上面工厂类里的方法变为静态方法，加上static关键字

抽象工厂方法模式：增加一个接口，所有工厂类实现该接口，不用改变以前工厂类，若功能改变，只增加相应的工厂类即可

public Interface Animal{

    public void eat();

}

public Class Cattle  implements  Animal{

      public void eat(){

          system.out.println("牛吃草");

     }           

}

public Class Cat implements Animal{

   public  void eat(){

       system.out.println("猫吃鱼");

 }

}

public Interface Provider{

     public Animal  providerAnimal();

}

public Class CattleFactory implements Provider{

           public Animal providerAnimal(){

               return new Cattle();  

  }

}

public Class CatFactory implements Provider{

   

         public Animal providerAnimal(){

              return new Cat();

    }

}

public Class FactoryTest{

    public static void main(String[] args){

         Provider provider = new CatFactory();

       Animal animal = provider.providerAnimal();

       animal.eat();

}

}

三、建造模式

与工厂模式的区别在于：工厂模式只是针对单个类的产品，而建造模式是符合要求对象的集合

public Class Builder{

   public List<Animal> list = new ArrayList<Animal>();

  public  List<Animal> buildCattle(int count){

       for(int i=0;i<count;i++){

            list.add(new Cattle());   

}

   return list;

}

    public List<Animal>  buildCat(int count){

        for(int i=0;i<count;i++){

         list.add(new Cat());

}

     return list;

}    

}

public Class  BuildTest{

    public static void main(String[] args){

        Builder build = new Builder();

        List<Animal> list = build.buildCattle(10);

}

}

四 、原型模式

原型模式分为浅复制模式、深复制模式

浅复制模式：基本数据类型的复制，引用类型仍是原对象所指向的

深复制模式：基本数据类型和引用类型都进行复制，是完全彻底的复制

public Class  Prototype  implements Clonnable,Serializeable{

       private static final String SerializeId = 1L;

        private  SerializeableObj  serializeableObj;

       private String str;

        public void setSerializeableObj(SerializeableObj serializeableObj){

                 serializeableObj = this.serializeableObj;

}

     public SerializeableObj  getSerializeableObj(){ 

         return serializeableObj; 

}

   public void setStr(String string){

          str= this.string;

}

public String getStr(){

       return str;

}

//浅复制

public Object clone() throws CloneNotSupportedException {

      Prototype prototype = (Prototype)Super.clone();

      return prototype;

}

//深复制

public Object  deepClone() IOException, ClassNotFoundException{

     ByteArrayOutputStream  bos = new ByteArrayOutputStream();

     ObjectOutputStream   os  = new ObjectOutputStream(bos);

    os.writeObject(this);

   ByteArrayInputStream bis = new  ByteArrayInputStream(bos.toByteArray());

  ObjectInputStream ois = new ObjectInputStream(bis);

 return ois.readObject();

}

Class   SerializeableObj   implements Serializeable{

       public static final String    SerializeId = 2L;

        

} 

    

}