一、设计模式

现在社会分工越来越细节,比如程序设计,将现实生活中的事情放在计算机中去实现的方法,不是很好掌握,有些人在解决一些问题的过程中积累的一些经验性的总结.帮助他人掌握从抽象到具体的方法,这就是设计模式。

设计模式的分类（共24种）

一、创建型模式

1、抽象工厂模式(Abstract factory pattern): 提供一个接口, 用于创建相关或依赖对象的家族, 而不需要指定具体类.
2、生成器模式(Builder pattern): 使用生成器模式封装一个产品的构造过程, 并允许按步骤构造. 将一个复杂对象的构建与它的表示分离, 使得同样的构建过程可以创建不同的表示.
3、工厂模式(factory method pattern): 定义了一个创建对象的接口, 但由子类决定要实例化的类是哪一个. 工厂方法让类把实例化推迟到子类.
4、原型模式(prototype pattern): 当创建给定类的实例过程很昂贵或很复杂时, 就使用原形模式.
5、单例了模式(Singleton pattern): 确保一个类只有一个实例, 并提供全局访问点.
6、多例模式(Multition pattern): 在一个解决方案中结合两个或多个模式, 以解决一般或重复发生的问题.

二、结构型模式

1、适配器模式(Adapter pattern): 将一个类的接口, 转换成客户期望的另一个接口. 适配器让原本接口不兼容的类可以合作无间. 对象适配器使用组合, 类适配器使用多重继承.
2、桥接模式(Bridge pattern): 使用桥接模式通过将实现和抽象放在两个不同的类层次中而使它们可以独立改变.
3、组合模式(composite pattern): 允许你将对象组合成树形结构来表现"整体/部分"层次结构. 组合能让客户以一致的方式处理个别对象以及对象组合.
4、装饰者模式(decorator pattern): 动态地将责任附加到对象上, 若要扩展功能, 装饰者提供了比继承更有弹性的替代方案.
5、外观模式(facade pattern): 提供了一个统一的接口, 用来访问子系统中的一群接口. 外观定义了一个高层接口, 让子系统更容易使用.
6、亨元模式(Flyweight Pattern): 如想让某个类的一个实例能用来提供许多"虚拟实例", 就使用蝇量模式.
7、代理模式(Proxy pattern): 为另一个对象提供一个替身或占位符以控制对这个对象的访问.

三、行为型模式

1、责任链模式(Chain of responsibility pattern): 通过责任链模式, 你可以为某个请求创建一个对象链. 每个对象依序检查此请求并对其进行处理或者将它传给链中的下一个对象.
2、命令模式(Command pattern): 将"请求"封闭成对象, 以便使用不同的请求,队列或者日志来参数化其他对象. 命令模式也支持可撤销的操作.
3、解释器模式(Interpreter pattern): 使用解释器模式为语言创建解释器.
4、迭代器模式(iterator pattern): 提供一种方法顺序访问一个聚合对象中的各个元素, 而又不暴露其内部的表示.
5、中介者模式(Mediator pattern) : 使用中介者模式来集中相关对象之间复杂的沟通和控制方式.
6、备忘录模式(Memento pattern): 当你需要让对象返回之前的状态时(例如, 你的用户请求"撤销"), 你使用备忘录模式.
7、观察者模式(observer pattern): 在对象之间定义一对多的依赖, 这样一来, 当一个对象改变状态, 依赖它的对象都会收到通知, 并自动更新.
8、状态模式(State pattern): 允许对象在内部状态改变时改变它的行为, 对象看起来好象改了它的类.
9、策略模式(strategy pattern): 定义了算法族, 分别封闭起来, 让它们之间可以互相替换, 此模式让算法的变化独立于使用算法的客户.
10、模板方法模式(Template pattern): 在一个方法中定义一个算法的骨架, 而将一些步骤延迟到子类中. 模板方法使得子类可以在不改变算法结构的情况下, 重新定义算法中的某些步骤.
11、访问者模式(visitor pattern): 当你想要为一个对象的组合增加新的能力, 且封装并不重要时, 就使用访问者模式.

七大设计原则：

1、单一职责原则【SINGLE RESPONSIBILITY PRINCIPLE】：一个类负责一项职责.

2、里氏替换原则【LISKOV SUBSTITUTION PRINCIPLE】：继承与派生的规则.

• 1.子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
• 2.子类中可以增加自己特有的方法。
• 3.当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。
• 4.当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。
  一句话总结：尽量不要重写父类的已经实现了的方法，可以用接口等其他方法绕过

3、依赖倒置原则【DEPENDENCE INVERSION PRINCIPLE】：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。即针对接口编程，不要针对实现编程.

4、接口隔离原则【INTERFACE SEGREGATION PRINCIPLE】：建立单一接口，不要建立庞大臃肿的接口，尽量细化接口，接口中的方法尽量少.

5、迪米特法则【LOW OF DEMETER】：低耦合，高内聚.
通俗的来讲，就是一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类来说，无论逻辑多么复杂，都尽量地的将逻辑封装在类的内部，对外除了提供的public方法，不对外泄漏任何信息。

6、开闭原则【OPEN CLOSE PRINCIPLE】：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭.

7、组合/聚合复用原则【Composition/Aggregation Reuse Principle(CARP) 】：尽量使用组合和聚合少使用继承的关系来达到复用的原则.

一、单例设计模式

单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点，需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。这个方法应该是静态方法（类方法），因为让类的实例去生成另一个唯一实例毫无意义。
如何实现类在内存中只有一个对象呢?
1. 构造方法私有
2. 在类中提供一个本类对象
3. 提供一个公共的方法让外界访问，获取到已创建的本类对象

实现方式：

• 饿汉式 : 直接创建对象
  线程安全的

• 懒汉式 : 当需要用到对象的时候，再创建对象(延迟加载方式)
  一个线程对象的时候，这种方式线程是安全的
  多个线程对象的时候，这种方式线程是不安全, 可以同步机制处理

1. 饿汉式

保证类在内存中只有一个对象[饿汉式 : 直接创建对象]

public class Son {
    /在类中提供一个本类对象
    private static Son s = new Son();
    //构造方法私有化
    private Son(){
    }
    //提供一个公共的方法让外界访问，获取到已创建的本类对象
    public static Son getInstance(){
        return s;
    }
}   

测试类

public class SinglePatternDemo {
    public static void main(String[] args) throws IOException {
        Son s1 = Son.getInstance();
        Son s2 = Son.getInstance();
        System.out.println(s1);
        System.out.println(s2);
    }
}

2.懒汉式

保证类在内存中只有一个对象[懒汉式 : 当要用到对象的时候，再创建对象(延迟加载方式)]

public class Girl {
    //创建本类对象的引用
    private static Girl g = null;
    //构造方法私有
    private Girl(){
    }
    //提供一个公共的方法让外界访问，获取到已创建的本类对象
    //第一次访问该方法，创建对象
    //之后再访问该方法，返回以前创建好的对象
    public static Girl getInstance(){
        //第一次访问该方法，创建对象
        if (g == null) {
            g = new Girl();
        }
        //之后再访问该方法，返回以前创建好的对象
        return g;
    }
}

测试类

public class SinglePatternDemo {
    public static void main(String[] args) throws IOException {
        //一个线程对象的时候，线程安全的
        Girl g1 = Girl.getInstance();
        Girl g2 = Girl.getInstance();
        System.out.println(g1);
        System.out.println(g2);
        
        //---------------------------------
        //多个线程对象的时候，线程不安全
        new Thread(){
            @Override
            public void run() {
                Girl g = Girl.getInstance();
                System.out.println(g);
            }
        }.start();
        
        new Thread(){
            @Override
            public void run() {
                Girl g = Girl.getInstance();
                System.out.println(g);
            }
        }.start();
    }
}

3. 双重锁的形式

保证类在内存中只有一个对象[懒汉式 : 当要用到对象的时候，再创建对象(延迟加载方式)]

public class Girl {

 //创建本类对象的引用

 private static Girl g = null;

 //构造方法私有

 private Girl(){

 }

 //提供一个公共的方法让外界访问，获取到已创建的本类对象

 //第一次访问该方法，创建对象

 //之后再访问该方法，返回以前创建好的对象

 public static Girl getInstance(){

 //第一次访问该方法，创建对象

 if (g == null) {

 synchronized(Girl.class){

  if (g == null) {

  g = new Girl();

 }

}

 }

 //之后再访问该方法，返回以前创建好的对象

 return g;

 }

}

测试类

public class SinglePatternDemo {

 public static void main(String[] args) throws IOException {

 //一个线程对象的时候，线程安全的

 Girl g1 = Girl.getInstance();

 Girl g2 = Girl.getInstance();

 System.out.println(g1);

 System.out.println(g2);

 //---------------------------------

 //多个线程对象的时候，由于使用了线程同步处理，能够保证线程安全

 new Thread(){

 @Override

 public void run() {

 Girl g = Girl.getInstance();

 System.out.println(g);

 }

 }.start();

 new Thread(){

 @Override

 public void run() {

 Girl g = Girl.getInstance();

 System.out.println(g);

 }

 }.start();

 }

}

4. 单例设计模式案例

银行自动取款机,取款机同一时间只会为一个人服务，其他人必须等待,等待前面的人取款完毕后,后面的人才能取款.单例设计模式保证对象唯一性. 网站访问量的统计,无论多少人访问,只能有一个访问统计器,否则就会出现问题。

public class Singleton{
     private Singleton(){}
     public static final Singleton s = new Singleton();
     public static Singleton getInstance(){
          return s;
      }
}

public class Singleton{
      private Singleton(){}
      public static Singleton s = null;
      public static Singleton getInstance(){
          if( s == null )
              s = new Singleton();
          return s;
      }
}

二、简单工厂模式

定义具体的工厂类,来负责创建一些类的实例,这些被创建的类必须具有相同的父类,可以实现面向抽象不面向具体编程。

简单工厂模式方便创建对象,但是此模式具有弊端,传递的参数非法,将会导致对象建立的失败,一个简单工厂可以创建多个对象,分工不明确不够细致,有没有更好的方法解决这个问题呢,如果有专门创建Cat对象工厂,专门创建Dog对象的工厂,问题就可以解决了。

  public abstract class Animal{
     public abstract void eat();
  }

  public class Factory{
     public static Animal createAnimal(String animalName){
          if("Cat".equals(animalName)){
               return new Cat();
          }else if ("Dog".equals(animalName)){
               return new Dog();
          }
          return null;
     }
  }

   public class TestFactory{
      public static void main(String[] args){
          Animal a = Factory. createAnimal("Cat");
          a.eat();

          a = Factory.ceateAnimal("Dog");
          a.eat();
      }
   }

三、工厂方法模式

工厂方法模式中抽象工厂类负责创建对象的接口,具体对象的创建工作的工厂由实现工厂接口的具体类来完成。

public interface Factory {
        public abstract Animal createAnimal();
    }
    public abstract class Animal {
        public abstract void eat();
    }
    public class CatFactory implements Factory {
    public Animal createAnimal() {
        return new Cat();
        }
    }
    public class Dog extends Animal {
        public void eat() {
        }
    }
    public static void main(String[] args) {
        Factory f = new DogFactory();
        f.createAnimal().eat();
        f = new CatFactory();
        f.createAnimal().eat();
    }

四、装饰者模式

装修房子的时候,需要刷墙,铺地板,彩色墙壁木地板等等.但是这只是为了满足主人的喜好而已,但是墙壁和地板的本质功能并没有改变,这就是装饰模式的实际应用.
举例:设计一个手机业务,具有接电话的功能.一段时间后,用户想如果能在接听电话的同时响起彩铃更好,但是有些用户不想听彩铃,因此在接电话方法中加入彩铃,就会引起部分用户不满.开发人员有时候需要额外对对象添加一些功能.这时就需要一个装饰类出现,对原有的部分手机业务进行增强.
装饰设计在Java/IO中的实际应用 BufferedReader装饰流

public interface Phone {
    public abstract void call();
}
public class PhoneImpl implements Phone {
    public void call() {
        System.out.println("接电话");
    }

}
public class ColorPhoneDecorator {
    private Phone phone ;
    public ColorPhoneDecorator(Phone phone) {
        this.phone = phone;
    }
    public void call(){
        System.out.println("播放彩铃");
        phone.call();
    }
}
    public static void main(String[] args) {
        Phone p = new PhoneImpl();
        ColorPhoneDecorator color = new ColorPhoneDecorator(p);
        color.call();
    }
}