java设计模式面试考点

分类（常见的设计模式）

1．建立型模式

　　a) 工厂模式

　　b) 抽象工厂模式

　　c) 单例模式

　　d) 建造者模式

2．结构型模式

　　a) 适配器模式

　　b) 装饰器模式

　　c) 桥接模式

　　d) 代理模式

3．行为型模式

　　a) 命令模式

　　b) 迭代器模式

　　c) 策略模式

　　d) 观察者模式

六大原则

一、开闭原则

　　对扩展开放，对修改关闭。

二、里氏代换原则

　　任何基类能够出现的地方，子类必定能够出现。

三、依赖倒转原则

　　依赖于抽象而不依赖于具体。

四、接口隔离原则

　　使用多个隔离的接口，比使用单个接口要好。

五、迪米特法则，又称最少知道原则

　　一个实体应当尽可能少地与其余实体之间发生相互做用，使得系统功能模块相对独立。

六、合成复用原则

　　尽可能使用合成/聚合的方式，而不是使用继承。

1、工厂模式 

做用

一个抽象的接口，多个抽象接口的实现类，一个工厂，用来实例化抽象的接口。

优势

一个调用者想建立一个对象，直接向工厂请求便可，不须要知道具体实现，以提升系统的可维护性、可扩展性。

缺点

产品修改时，工厂也要进行修改。

代码

2、抽象工厂模式

做用

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂建立其余工厂。

优势

当一个产品类型（每一类中有多个产品）被设计成一块儿工做时，有良好的维护性。

缺点

产品类扩展困难。

例

 

3、单例模式

做用

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

特色

1、单例类只能有一个实例。

2、单例类必须本身建立本身的惟一实例。

3、单例类必须给全部其余对象提供这一实例。

懒汉式

线程不安全

public class Singleton {  

    private static Singleton instance;  

    private Singleton (){}   

    public static Singleton getInstance() {  

     if (instance == null) {  

         instance = new Singleton();  

    }  

    return instance;  

    }  

}  

线程安全

public class Singleton {  

    private static Singleton instance;  

    private Singleton (){}  

    public static synchronized Singleton getInstance() {  

    if (instance == null) {  

         instance = new Singleton();  

     }  

     return instance;  

    }  

}

双检锁

public class Singleton {  

    private static Singleton singleton;  

    private Singleton (){}  

    public static Singleton getSingleton() {  

     if (singleton == null) {  

         synchronized (Singleton.class) {  

         if (singleton == null) {  

             singleton = new Singleton();

         }  

          }  

   }  

     return singleton;  

    }  

}  

静态内部类

public class Singleton {  

    private static class SingletonHolder {  

     private static final Singleton INSTANCE = new Singleton();  

    }  

    private Singleton (){}  

    public static final Singleton getInstance() {  

     return SingletonHolder.INSTANCE;  

    }  

}   

饿汉式

public class Singleton {  

    private static final Singleton instance = new Singleton();  

    private Singleton (){}  

    public static Singleton getInstance() {  

     return instance;  

    }  

}

4、建造者模式

做用

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。

应用实例

肯德基里，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是常常变化的，生成出所谓的"套餐"。

角色

　　抽象建造者角色：一个抽象接口，以规范产品对象的各个组成成分的建造。

　　具体建造者角色：实现抽象建造者Builder所声明的接口，给出一步一步地完成建立产品实例的操做。

　　导演者角色：担任这个角色的类调用具体建造者角色以建立产品对象。应当指出的是，导演者角色并无产品类的具体知识，真正拥有产品类的具体知识的是具体建造者角色。

　　产品角色：产品即是建造中的复杂对象。通常来讲，一个系统中会有多于一个的产品类，并且这些产品类并不必定有共同的接口，而彻底能够是不相关联的。

例子

5、适配器模式

做用

将一个类的接口转换成客户但愿的另一个接口。Adapter模式使得本来因为接口不兼容而不能一块儿工做的那些类能够在一块儿工做。

模式中的角色

1．目标接口（Target）：客户所期待的接口。目标能够是具体的或抽象的类，也能够是接口。

2．须要适配的类（Adaptee）：须要适配的类或适配者类。

3．适配器（Adapter）：实现了目标接口，经过包装一个须要适配的对象，把原接口转换成目标接口。　

经过适配器把须要适配的类转成目标类

优势

1. 接口能够转成本身但愿的另外一个接口
2. 提升了类的复用。

缺点

过多地使用适配器，会让系统很是零乱，不易总体进行把握。

例子

 

6、装饰者模式

做用

对已有的业务逻辑进一步的封装，使其增长额外的功能。即向一个现有的对象添加新的功能，同时又不改变其结构。

优势

能够提供比继承更多的灵活性。

缺点

多层装饰比较复杂。

例子

实物基类

鸡肉

鸭肉

装饰者基类

蒸-装饰者

烤-装饰者

7、桥接模式

做用

将抽象部分与实现部分分离，使它们均可以独立的变化。把两个角色之间的继承关系改成了耦合的关系。 

例子

8、代理模式

做用

一个类代理另外一个类的功能。

模式中的角色

1. 抽象角色：声明真实对象和代理对象的共同接口。 
   2. 代理角色：代理对象角色内部含有对真实对象的引用，继承了抽象对象。 
   3. 真实角色：代理角色所表明的真实对象，是咱们最终要引用的对象。

缺点

因为在客户端和真实主题之间增长了代理对象，所以有些类型的代理模式可能会形成请求的处理速度变慢。

例子

9、命令模式

做用

将一个命令封装成一个对象，能够对命令接受者进行不一样的命令处理。

组成

命令接受者：执行命令的对象。

命令：操做命令接受者执行命令。

命令对象入口：要求命令对象执行请求，一般会持有命令对象，能够持有不少的命令对象。

例子

10、迭代器模式

做用

这种模式用于顺序访问集合对象的元素，不须要知道集合对象的底层表示。

经过容器获取迭代器，经过迭代器遍历元素。

角色

1．迭代器接口

2．迭代器具体实现

3．抽象容器

4．具体容器

例子

迭代器接口

public interface Iterator {

    public Object first();

    public Object previous();

    public Object next();

    public boolean hasNext();

}

具体迭代器

public class MyIterator implements Iterator{

    private List<Object> list;

    private int index = 0;

    public MyIterator(List<Object> list) {

        this.list = list;

    }

    @Override

    public Object previous() {

        if((this.index - 1) < 0){

            return null;

        }else{

            return this.list.get(--index);

        }

    }

    @Override

    public Object next() {

        if((this.index + 1) >= this.list.size()){

            return null;

        }else{

            return this.list.get(++index);

        }

    }

    @Override

    public boolean hasNext() {

        if(this.index < (this.list.size() - 1)){

            return true;

        }

        return false;

    }

    @Override

    public Object first() {

        if(this.list.size() <= 0){

            return null;

        }else{

            return this.list.get(0);

        }

    }

}

容器接口

package com.pichen.dp.behavioralpattern.iterator;

public abstract class Container {

    public abstract Iterator iterator();

    public abstract void put(Object obj);

}

具体容器  

public class MyContainer extends Container{

    private List<Object> list;

    public MyContainer() {

        this.list = new ArrayList<Object>();

    }

    @Override

    public void put(Object obj){

        this.list.add(obj);

    }

    @Override

    public Iterator iterator() {

        return new MyIterator(list);

    }

}

11、策略模式

做用

　　将多个算法封装到具备共同接口的独立的类中，从而使得它们能够相互替换。

组成

　　1．抽象策略角色：一般由一个接口或者抽象类实现。

　　2．具体策略角色: 包装了相关的算法和行为。

　　3．环境角色: 持有一个策略类的引用，最终给客户端调用。

实际举例

　　旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。

例子

12、观察者模式

做用

它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知全部的观察者对象，使他们可以自动更新本身。

优势

1．观察者模式在被观察者和观察者之间创建一个抽象的耦合。

2．观察者模式支持广播通信。被观察者会向全部的登记过的观察者发出通知。

缺点

1．若是一个被观察者对象有不少的直接和间接的观察者的话，将全部的观察者都通知到会花费不少时间。

2．若是在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能致使系统崩溃。

3．观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

结构图

1. Subject：抽象主题（抽象被观察者），每一个主题均可以有任意数量的观察者，抽象主题提供一个接口，能够增长和删除观察者对象。
2. ConcreteSubject：具体主题（具体被观察者），把全部观察者对象保存在一个集合里，在具体主题的内部状态发生改变时，给全部注册过的观察者发送通知。
3. Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在获得主题更改通知时更新本身。
4. ConcrereObserver：具体观察者，是实现抽象观察者定义的更新接口，以便在获得主题更改通知时更新自身的状态。

例子