浅谈设计模式

针对某一问题的最佳解决方案，我们在程序中称之为设计模式。

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免得我们自己再去思考和摸索。

设计模式很好学，但是碰到问题要想到用什么设计模式解决才是真正的目的。

java一共有32种设计模式。

1. 单态设计模式

定义：所谓类的单态设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

 

单态设计模式3大特征：

    1.构造方法私有化。

    2.对外提供一个公有的get方法，让别人通过此方法来获得实例。由于不能创建对象，所以get方法必须静态，这样别人才能使用类名.方法名的方式访问。

    3.需要保证单例，所以要提供一个静态变量记住一个实例，用于返回。该实例应该私有，禁止外界通过直接访问进行改动。

例子：

class Person7
{
     //3.提供一个私有静态变量记住一个实例，用于返回。类是在第一次被使用的时候才进行加载，而且只加载一次，所以，这个静态变量只被初始化一次。

     private static Person7 p = new Person7();
     //1.构造方法私有化
     private Person7(){}
     //2.提供此方法来给外界获得实例
     public static Person7 getInstance()
     {
          return p;
      }
}

 

class Demo7
{
     public static void main(String args[])
     {
          Person7 p1 = Person7.getInstance();
          Person7 p2 = Person7.getInstance();
          Person7 p3 = Person7.getInstance();
          //p3.p = null;
          Person7 p4 = Person7.getInstance();
  
          System.out.println(p1);
          System.out.println(p2);
          System.out.println(p3);
          System.out.println(p4);
     }
}

 

输出结果全部为同一个地址。

 

2. 组合模式

    什么是组合

        组合是一种实现代码复用的方式

        当我们在定义一个类的时候需要用到另外一个类的方法时，就可以用组合，将用到的类定义为当前类的一个属性，通过构造函数进行装配。

    为什么要用组合

        组合可以实现代码的复用性

        由于Java只支持单继承，用组合就不占用继承的那个名额了

        有的时候我们需要用到另外一个类的方法，由于没有父子关系，不方便用继承，这时就用组合

        我们在编程过程中要尽量多使用组合，少使用继承

        构造方法声明需要一个父类，这时也可以将子类组合进去

/*组合设计模式
1.当我们在实现一个类的方法时，需要用到其他的类，用到的类和当前类又不构成继承关系，此时，就需要用组合
2.如果一个类能正常工作的前提就是必须用到另一个类的方法，这时首先需要将用到的类组合进来
3.组合： 将需要的对象定义为当前对象的属性，让别人通过构造函数装配进来
4.通常我们在定义类的时候组合进来的对象不是为了给自己用，而是给父类去用
*/

class Card{
    public void spend(){
        System.out.println("一不小心花了400个大洋");
    }
}

class Person8{
    private Card card;
    public Person8(Card card){
         this.card = card;
    }
    public void shopping(){
         card.spend();
    }
}

class Chinese extends Person8{
     public Chinese(Card card){
        super(card);
     }
      public void shopping(){
          System.out.println("讨价还价！！");
          super.shopping();
      }
}

class Demo8{
      public static void main(String args[]){
      Card card = new Card();
      Person8 p = new Person8(card);
      p.shopping(); //此方法调用成功的前提是它的内部去调用了Card类的spend方法
  
      Card card1 = new Card();
      Chinese ch = new Chinese(card1);
      ch.shopping();
  
      new Chinese(new Card(){
           public void spend(){
                System.out.println("使用饭卡成功消费！！！"); 
            }
       }).shopping();
 }
}

个人觉得：spring的service层用到的就是组合模式，如下：

public class AccitemBOImpl extends BaseBO implements AccitemBO {
   
    private AccitemDAO accitemDAO;

    public AccitemDAO getAccitemDAO() {
        return accitemDAO;
    }

    public void setAccitemDAO(AccitemDAO accitemDAO) {
        this.accitemDAO = accitemDAO;
    }
}

 

3. 模板方法设计模式

    为什么要使用模板方法设计模式

        在解决一些问题或者设计一个软件的时候，需要先定义一个模板，就相当于一种事先定义好的协议。以后要做这系列的事情都按照这个模板来做。这样就实现统一化管理。

    如何实现模板方法设计模式

        定义一个抽象的父类做为模板，定义所有需要的方法

        在父类中实现供外界调用的主方法，将方法声明为final

        根据不同业务需求定义子类实现父类的抽象方法

/*
模板方法设计模式：
定义一个抽象的父类作为模板，在模板中规定做事情的先后顺序，
具体每个步骤怎么做交给具体的子类去实现
*/
abstract class AbstractPrint
{
     abstract void open();
     abstract void print();
     abstract void close();
     public final void run()
     {
          //规定做事情的顺序
          open();
          print();
          close();
     }
}

class StringPrint extends AbstractPrint
{
     private String data;
     public StringPrint(String data)
     {
          this.data = data;
     }
     public void open()
     {
          System.out.print("<<");
     }
     public void close()
     {
          System.out.println(">>"); 
     }
     public void print()
     {
          System.out.print(data);
     }
     /*因为父类的run()被final了，所以模板就不能随便改了
     public void run()
     {
          print();
          close();
          open();
      }*/
}

class Demo12
{
     public static void main(String args[])
     {
          StringPrint sp = new StringPrint("hello");
          sp.run();
          //为什么可以new?
          new AbstractPrint(){
              public void open()
              {
                    System.out.print("[[");
               }
              public void print()
             {
                   System.out.print('a');
              }
              public void close()
              {
                    System.out.println("]]");
              } 
         }.run();
     }
}