zoukankan      html  css  js  c++  java
  • Java设计模式

       Java设计模式:

    (一)、工厂模式      

    问题:工厂模式
    分析:(一)、工厂模式是我们在java设计模式中是随处可见的模式,例如著名的Jive论坛就使用了大量的工厂模式
    为什么工厂模式会如此受到?因为工厂模式相当于创建实例对象的NEW,我们常常根据类Class生成实例对象,
    例如:A a=new A();因此,以后若创建多个实例对象,可以考虑使用工厂模式。
    (二)、在简单创建实例化对象(A a=new A())的情况下,我们考虑实例化参数之类,方便修改,就可以不再实例化对象
    再去做修改。
    (三)、在创建实例化对象时,是根据需求而创建,例如,一个妈妈她今年生了一个儿子,可以实例化一个对象,若明年她接着又
    生两个儿子,不可能又实例化,就可以把妈妈这个类抽象成一个接口对象类,不管她生多少个儿子,都可以实现这个接口对象类即可。
    如:Simpole son=new SonSimple(),Simpole son2=new Son2Simpole();
    以上的例子都是传统的程序,若是考虑到现在的工厂设计模式,就不会那么繁琐及死板。
    结果:代码示例

    public class Factory{
    
      public static Sample creator(int which){
    
      //getClass 产生Sample 一般可使用动态类装载装入类。
      if (which==1)
        return new SampleA();
      else if (which==2)
        return new SampleB();
    
      }
    
    }

    (二)、抽象工厂模式

    问题:抽象工厂
    分析:在刚刚操作完工厂模式实例之后,我们有时需要改变需求,就是不知只有一个妈妈这个抽象接口,还新增了一个妈妈抽象接口,则其需要用
    到抽象工厂模式来封装在一个接口类中。再去继承该接口实现其中的属性方法。
    结果:代码示例:

    public abstract class Factory{
    
      public abstract Sample creator();
    
      public abstract Sample2 creator(String name);
    
    }
    
    public class SimpleFactory extends Factory{
    
      public Sample creator(){
        .........
        return new SampleA
      }
    
      public Sample2 creator(String name){
        .........
        return new Sample2A
      }
    
    }
    
    public class BombFactory extends Factory{
    
      public Sample creator(){
        ......
        return new SampleB 
      }
    
      public Sample2 creator(String name){
        ......
        return new Sample2B
      }
    
    }

    (三)、单例模式

    问题:单例模式
    分析:单例模式在程序中的作用是保证在Java应用中,一个类只有一个实例存在,在以后项目的很多操作中,比如
    数据库的连接都需要这样单线程操作。还有,单例模式能够被状态化,这样,多个单态类在一起可以做一个状态仓库
    一样向外提供服务。比如,你在一个论坛游览器评论了一条信息,每次游览该论坛都会计数,单态类能保持这个状态
    计数,并且单线程能自动加1。你可以在不修改单态接口的情况下方便做到。

    结果:代码示例:

    public class Singleton {
    
      private Singleton(){}
      //在自己内部定义自己一个实例,是不是很奇怪?
      //注意这是private 只供内部调用
    
      private static Singleton instance = new Singleton();
    
      //这里提供了一个供外部访问本class的静态方法,可以直接访问  
      public static Singleton getInstance() {
        return instance;   
       } 
    }
    
    第二种形式:
    public class Singleton {
      private static Singleton instance = null;
    
      public static synchronized Singleton getInstance() {
    
      if (instance==null)
        instance=new Singleton();
      return instance;   }
    
    }

    (四)、建造者模式

      问题:建造者模式
      分析:建造者模式是一步一步创建的一个复杂对象,该模式类似于抽象工厂模式,是为了构建复杂的过程和部件
    ,是解耦过程和部件。因为一个复杂对象有很多复杂部分组成,例如:汽车是由方向盘、轮胎等部件组成完成的。

      结果:代码示例:

      

    public interface Builder {
      //创建部件A  比如创建汽车车轮
      void buildPartA(); 
      //创建部件B 比如创建汽车方向盘
      void buildPartB(); 
      //创建部件C 比如创建汽车发动机
      void buildPartC(); 
    
      //返回最后组装成品结果 (返回最后装配好的汽车)
      //成品的组装过程不在这里进行,而是转移到下面的Director类中进行.
      //从而实现了解耦过程和部件
      Product getResult();
    
    }
    ------
    public class Director {
    
      private Builder builder;
    
      public Director( Builder builder ) { 
        this.builder = builder; 
      } 
      // 将部件partA partB partC最后组成复杂对象
      //这里是将车轮 方向盘和发动机组装成汽车的过程
      public void construct() { 
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    
      }
    
    }
    ---
    public class ConcreteBuilder implements Builder {
    
      Part partA, partB, partC; 
      public void buildPartA() {
        //这里是具体如何构建partA的代码
    
      }; 
      public void buildPartB() { 
        //这里是具体如何构建partB的代码
      }; 
       public void buildPartC() { 
        //这里是具体如何构建partB的代码
      }; 
       public Product getResult() { 
        //返回最后组装成品结果
      }; 
    }
    ----

    public static void main(String[] args) {

    ConcreteBuilder builder = new ConcreteBuilder();
    Director director = new Director( builder );

    director.construct();
    Product product = builder.getResult();


    }

     

    (五)、原型模式

    问题:原型模式
    分析:定义:指定创建对象的种类,并且通过拷贝这些原型创建新对象,原型模式允许一个对象可以创建宁一个对象,根本无须知道它创建的过程,
    而工作原理是通过原型对象传给那个要创建对象的对象,这个要发动创建对象的对象通过请求原型对象拷贝它们来创建对象。

    结果:代码示例:

    public abstract class AbstractSpoon implements Cloneable
    { 
      String spoonName; 
    
      public void setSpoonName(String spoonName) {this.spoonName = spoonName;}
      public String getSpoonName() {return this.spoonName;}
    
      public Object clone() 
      {
        Object object = null;
        try {
          object = super.clone();
        } catch (CloneNotSupportedException exception) {
          System.err.println("AbstractSpoon is not Cloneable");
        }
        return object;
      }
    }
    ---- 具体实现类
    public class SoupSpoon extends AbstractSpoon
    { 
      public SoupSpoon()
      {
        setSpoonName("Soup Spoon"); 
      }
    }

     今晚,就暂时阐述这些设计模式,明天再继续。

  • 相关阅读:
    80年代的兄弟,你会什么?
    设计模式单件模式
    大冒险 这注定是部史诗级的探索。。。
    关于重构JS前端框架的失败经验(顺便怀念那些死去的代码)
    JDBC连接数据库类(主要用于存储过程)
    ActiveRecord学习(六):总结
    ASP.NET中常用的文件上传下载方法
    [整理]ASP.NET2.0新特性概述
    关于NHibernate中one to many 的问题
    关注06德国世界杯:比赛日程表
  • 原文地址:https://www.cnblogs.com/bwcx1375/p/7679033.html
Copyright © 2011-2022 走看看