设计模式常见面试题

发表于 | 分类于 | |

本文介绍了一些软件设计和设计模式的相关的问题，这些问题大多会出现在初学者面试情景。什么是设计模式？特定的设计模式又是什么？等等这些概念，也许你很轻易回答这些概念，但文内提供的这些问题也许能给你带来更多价值。

入门级程序员的面试题

什么是设计模式？在你编码过程中使用了哪些设计模式？

在软件工程中，设计模式（design pattern）是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。

平时用的比较多有单例模式（在内存中仅实例化一个对象时使用），适配器模式（典型的就是ListView和GridView的适配器），建造者模式（AlertDialog.Builder）,观察者模式可能比较隐蔽，在Android源码中BaseAdapater的NotifyDataSetChanged的实现。

你能说出在标准的JDK库中使用的一些设计模式吗？**

Birdge 桥接模式

这个模式将抽象和抽象操作的实现进行了解耦，这样使得抽象和实现可以独立地变化。
GOF在提出桥梁模式的时候指出，桥梁模式的用意是”将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化”。这句话有三个关键词，也就是抽象化、实现化和脱耦。
在Java应用中，对于桥接模式有一个非常典型的例子，就是应用程序使用JDBC驱动程序进行开发的方式。所谓驱动程序，指的是按照预先约定好的接口来操作计算机系统或者是外围设备的程序。

Adapter 适配器模式

用来把一个接口转化成另一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。

1
2
3
java.util.Arrays#asList()
java.io.InputStreamReader(InputStream)
java.io.OutputStreamWriter(OutputStream)

Composite 组合模式

又叫做部分-整体模式，使得客户端看来单个对象和对象的组合是同等的。换句话说，某个类型的方法同时也接受自身类型作为参数。

1
2
3
4
javax.swing.JComponent#add(Component)
java.util.Map#putAll(Map)
java.util.List#addAll(Collection)
java.util.Set#addAll(Collection)

装饰者模式

动态的给一个对象附加额外的功能，这也是子类的一种替代方式。可以看到，在创建一个类型的时候，同时也传入同一类型的对象。这在JDK里随处可见，你会发现它无处不在，所以下面这个列表只是一小部分。

1
2
3
4
5
java.io.BufferedInputStream(InputStream)
java.io.DataInputStream(InputStream)
java.io.BufferedOutputStream(OutputStream)
java.util.zip.ZipOutputStream(OutputStream)
java.util.Collections#checkedList|Map|Set|SortedSet|SortedMap

Facade 门面模式，即外观模式

给一组组件，接口，抽象，或者子系统提供一个简单的接口。

1
2
java.lang.Class
javax.faces.webapp.FacesServlet

Flyweight 享元模式

使用缓存来加速大量小对象的访问时间。

1
2
3
4
java.lang.Integer#valueOf(int)
java.lang.Boolean#valueOf(boolean)
java.lang.Byte#valueOf(byte)
java.lang.Character#valueOf(char)

Proxy 代理模式

代理模式是用一个简单的对象来代替一个复杂的或者创建耗时的对象。

1
2
java.lang.reflect.Proxy
RMI

Abstract Factory 抽象工厂模式

抽象工厂模式提供了一个协议来生成一系列的相关或者独立的对象，而不用指定具体对象的类型。它使得应用程序能够和使用的框架的具体实现进行解耦。这在JDK或者许多框架比如Spring中都随处可见。它们也很容易识别，一个创建新对象的方法，返回的却是接口或者抽象类的，就是抽象工厂模式了。

1
2
3
4
5
6
7
8
java.util.Calendar#getInstance()
java.util.Arrays#asList()
java.util.ResourceBundle#getBundle()
java.sql.DriverManager#getConnection()
java.sql.Connection#createStatement()
java.sql.Statement#executeQuery()
java.text.NumberFormat#getInstance()
javax.xml.transform.TransformerFactory#newInstance()

抽象工厂模式

抽象工厂模式提供了一个协议来生成一系列的相关或者独立的对象，而不用指定具体对象的类型。它使得应用程序能够和使用的框架的具体实现进行解耦。这在JDK或者许多框架比如Spring中都随处可见。它们也很容易识别，一个创建新对象的方法，返回的却是接口或者抽象类的，就是抽象工厂模式了。

1
2
3
4
5
6
7
8
java.util.Calendar#getInstance()
java.util.Arrays#asList()
java.util.ResourceBundle#getBundle()
java.sql.DriverManager#getConnection()
java.sql.Connection#createStatement()
java.sql.Statement#executeQuery()
java.text.NumberFormat#getInstance()
javax.xml.transform.TransformerFactory#newInstance()

Builder 建造者模式:

定义了一个新的类来构建另一个类的实例，以简化复杂对象的创建。建造模式通常也使用方法链接来实现。

1
2
3
4
java.lang.StringBuilder#append()
java.lang.StringBuffer#append()
java.sql.PreparedStatement
javax.swing.GroupLayout.Group#addComponent()

工厂方法

就是一个返回具体对象的方法。

1
2
3
4
5
6
7
java.lang.Proxy#newProxyInstance()
java.lang.Object#toString()
java.lang.Class#newInstance()
java.lang.reflect.Array#newInstance()
java.lang.reflect.Constructor#newInstance()
java.lang.Boolean#valueOf(String)
java.lang.Class#forName()

原型模式

使得类的实例能够生成自身的拷贝。如果创建一个对象的实例非常复杂且耗时时，就可以使用这种模式，而不重新创建一个新的实例，你可以拷贝一个对象并直接修改它。

1
2
java.lang.Object#clone()
java.lang.Cloneable

单例模式

用来确保类只有一个实例。Joshua Bloch在Effetive Java中建议到，还有一种方法就是使用枚举。

1
2
3
4
java.lang.Runtime#getRuntime()
java.awt.Toolkit#getDefaultToolkit()
java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()
java.awt.Desktop#getDesktop()

责任链模式

通过把请求从一个对象传递到链条中下一个对象的方式，直到请求被处理完毕，以实现对象间的解耦。

1
2
java.util.logging.Logger#log()
javax.servlet.Filter#doFilter()

命令模式

将操作封装到对象内，以便存储，传递和返回。

1
2
java.lang.Runnable
javax.swing.Action

解释器模式

这个模式通常定义了一个语言的语法，然后解析相应语法的语句。

1
2
3
java.util.Pattern
java.text.Normalizer
java.text.Format

迭代器模式

提供一个一致的方法来顺序访问集合中的对象，这个方法与底层的集合的具体实现无关。

1
2
java.util.Iterator
java.util.Enumeration

中介者模式

通过使用一个中间对象来进行消息分发以及减少类之间的直接依赖。

1
2
3
4
java.util.Timer
java.util.concurrent.Executor#execute()
java.util.concurrent.ExecutorService#submit()
java.lang.reflect.Method#invoke()

备忘录模式

生成对象状态的一个快照，以便对象可以恢复原始状态而不用暴露自身的内容。Date对象通过自身内部的一个long值来实现备忘录模式。

1
2
java.util.Date
java.io.Serializable

空对象模式

这个模式通过一个无意义的对象来代替没有对象这个状态。它使得你不用额外对空对象进行处理。

1
2
3
java.util.Collections#emptyList()
java.util.Collections#emptyMap()
java.util.Collections#emptySet()

观察者模式

它使得一个对象可以灵活的将消息发送给感兴趣的对象。

1
2
3
4
java.util.EventListener
javax.servlet.http.HttpSessionBindingListener
javax.servlet.http.HttpSessionAttributeListener
javax.faces.event.PhaseListener

状态模式

通过改变对象内部的状态，使得你可以在运行时动态改变一个对象的行为。

1
2
java.util.Iterator
javax.faces.lifecycle.LifeCycle#execute()

策略模式

使用这个模式来将一组算法封装成一系列对象。通过传递这些对象可以灵活的改变程序的功能。

1
2
3
java.util.Comparator#compare()
javax.servlet.http.HttpServlet
javax.servlet.Filter#doFilter()

模板方法模式

让子类可以重写方法的一部分，而不是整个重写，你可以控制子类需要重写那些操作。

1
2
3
4
java.util.Collections#sort()
java.io.InputStream#skip()
java.io.InputStream#read()
java.util.AbstractList#indexOf()

访问者模式

提供一个方便的可维护的方式来操作一组对象。它使得你在不改变操作的对象前提下，可以修改或者扩展对象的行为。

1
2
javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor

Java中什么是单例设计模式？用Java写出线程安全的单例

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

使用单例模式最核心的一点是体现了面向对象封装特性中的“单一职责”和“对象自治”原则;

并且可以节省系统开销。

单例模式的若干种写法

使用工厂模式最主要的好处是什么？你在哪里使用？

使用工厂的理由：
Factory模式最主要的优势在于当创建对象时可提高封装水平。如果你使用Factory模式来创建对象，你可以在后期重置最初产品的装置或者无须任何客户层就可实现更先进更高性能的类。你所关心的仅仅是工厂方法返回的接口方法,不必关心实现细节。

各模式的理解：

  • 简单工厂：把对象的创建放到一个工厂类中，通过参数来创建不同的对象。
  • 工厂方法：每种产品由一种工厂来创建。（不这样会有什么问题？）
  • 抽象工厂：感觉只是工厂方法的复杂化，产品系列复杂化的工厂方法。

面向接口编程：设计模式的一个重要原则是 针对接口编程，不要依赖实现类。工厂模式遵循了这一个原则。

开闭原则（Open-Closed Principle,OCP） “Software entities should be open for extension,but closed for modification”。翻译过来就是：“软件实体应当对扩展开放，对修改关闭”。这句话说得略微有点专业，我们把它讲得更通俗一点，也就是：软件系统中包含的各种组件，例如模块（Modules）、类（Classes）以及功能（Functions）等等，应该在不修改现有代码的基础上，引入新功能。开闭原则中“开”，是指对于组件功能的扩展是开放的，是允许对其进行功能扩展的；开闭原则中“闭”，是指对于原有代码的修改是封闭的，即不应该修改原有的代码。

在Java中，什么叫观察者设计模式?

观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其它的对象做出相应的改变。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致，保证高度的协作。

举一个用Java实现的装饰模式？它是作用于对象层次还是类层次？

动态地给一个对象增加一些额外的职责，就增加对象功能来说，装饰模式比生成子类实现更为灵活。装饰模式是一种对象结构型模式。装饰模式是一种用于替代继承的技术,使用对象之间的关联关系取代类之间的继承关系。在装饰模式中引入了装饰类，在装饰类中既可以调用待装饰的原有类的方法，还可以增加新的方法，以扩充原有类的功能。

装饰原有对象、在不改变原有对象的情况下扩展增强新功能/新特征。当不能采用继承的方式对系统进行扩展或者采用继承不利于系统扩展和维护时可以使用装饰模式。

什么是MVC设计模式？举一个MVC设计模式的例子？

MVC是一个设计模式，它强制性的使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件：模型、视图、控制器。它们各自处理自己的任务。

什么是责任链模式

一个请求沿着一条“链”传递，直到该“链”上的某个处理者处理它为止。

一个请求可以被多个处理者处理或处理者未明确指定时。
责任链模式非常简单异常好理解，相信我它比单例模式还简单易懂，其应用也几乎无所不在，甚至可以这么说,从你敲代码的第一天起你就不知不觉用过了它最原始的裸体结构：switch-case语句。

什么是适配器模式？举用Java实现适配器模式的例子？

适配器必须实现原有的旧的接口

适配器对象中持有对新接口的引用，当调用旧接口时，将这个调用委托给实现新接口的对象来处理，也就是在适配器对象中组合一个新接口。

什么是代理模式？

代理（proxy）模式：指目标对象给定代理对象，并由代理对象代替真实对象控制客户端对真实对象的访问。

代理模式模式有以下角色：

  • 抽象主题（subject）角色：声明真实主题和代理主题的共同接口。
  • 真实主题（real subject）角色：定义代理对象需要代理的真实对象。
  • 代理主题（proxy subject）角色：代替真实对象来控制对真实对象的访问，代理对象持有真实对象的应用，从而可以随时控制客户端对真实对象的访问。

策略模式有什么好处？

定义了一系列封装了算法、行为的对象，他们可以相互替换。

举例：Java.util.List就是定义了一个增（add）、删（remove）、改（set）、查（indexOf）策略，至于实现这个策略的ArrayList、LinkedList等类，只是在具体实现时采用了不同的算法。但因为它们策略一样，不考虑速度的情况下，使用时完全可以互相替换使用。

进阶级程序员的面试题

举例说明你什么时候会用抽象类，什么时候更愿意使用接口？

这是一个很常见的面试问题，并不算难。接口和抽象类都按照“不为实现写代码”的设计原则，这是为了增加代码的灵活性，以应付不断变化的要求。下面是一些帮助你回答这个问题的指南：

  • 在Java中，你只能继承一个类，但实现多个接口。所以你继承一个类的时候就无法再继承别的类了。
  • 接口是用来代表形容词或行为，例如Runnable、Clonable、Serializable等。因此，如果您使用一个抽象类来实现Runnable和Clonacle，你就不可以使你的类同时实现这两个功能，而如果接口的话就没问题。
  • 抽象类是比接口稍快，所以很在乎时间的应用尽量使用抽象类。
  • 如果多个继承层次的共同行为在在同一个地方编写更好，那么抽象类会是更好的选择。有时候可以在接口里定义函数但是在抽象类里默认功能就能实现接口和抽象类共同工作了。了解Java接口。

设计一个能接收不同硬币、出售不同货物的自动售货机。

在Java中，什么时候用重载，什么时候用重写？

重载和覆盖在Java里实现的都是同一个功能，但overload的输入变量不同，override则完全相同。

设计ATM机

我们所有人都使用ATM(自动柜员机)。想想你会怎么设计一个ATM？就设计金融系统来说，必须知道它们应该在任何情况下都能够如期工作。不管是断电还是其他情况，ATM应该保持 正确的状态（事务） , 想想 加锁（locking）、事务（transaction）、错误条件（error condition）、边界条件（boundary condition） 等等。尽管你不能想到具体的设计，但如果你可以指出非功能性需求，提出一些问题，想到关于边界条件，这些都会是很好的一步。

在Java中，为什么不允许从静态方法中访问非静态变量？

Java里不允许从静态方法中获取非静态变量仅仅是因为非静态变量会和特定的对象实例相关联，而静态变量不会。

有这样一段话，“由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。” 怎么深层次理解这句话呢？

深层次的解释是，“静态方法可以不通过对象进行调用”也就是说这个方法在对象尚未创建的时候就可以调用，而此时对象尚未创建，（非静态）成员变量根本都还不存在，何谈访问？

如果允许调用其他非静态变量，会引起什么后果么？

不是允许不允许的问题，是这个时候非静态成员变量都还不存在（他是伴随着对象的创建而创建的），根本无法访问。

在Java中设计一个并发规则的pipeline？

并发编程或并发设计这些天很火，它可以充分利用现在不断提升的高级处理器的处理能力，而Java成为一个多线程语言也从这种情况获益良多。设计一个并发系统需要记住的最关键的点是线程安全，不可变性，本地变量和避免使用static或者类变量（instance variables）。你只需要想着每一类都可以同时被多个线程同时执行，所以最好的做法就是每一个线程都处理自己的数据 ，不跟其他数据交互，并且运行时只需要最小的同步保证。这个问题可以涉及到从最初的讨论到完整的类和接口编码，但只要你记住并发中最重要的点和问题如，竞争条件（race condition）、死锁（deadlock）、内存交互问题（memory interference）、原子性、ThreadLocal变量等，你都可以回答它。