设计模式相关面试题目

时间 2019-11-09

原文原文链接

设计模式理论

1.什么是设计模式？你是否在你的代码里面使用过任何设计模式？
在软件工程中，设计模式（design pattern）是对软件设计中广泛存在（反复出现）的各类问题，所提出的解决方案。
平时用的比较多有单例模式（在内存中仅实例化一个对象时使用），适配器模式（典型的就是ListView和GridView的适配器），建造者模式（AlertDialog.Builder）,观察者模式可能比较隐蔽，在Android源码中BaseAdapater的NotifyDataSetChanged的实现（？）。java

2.你能够说出几个在JDK库中使用的设计模式吗？web

 
         Birdge 桥接模式： 
        
         这个模式将抽象和抽象操做的实现进行了解耦，这样使得抽象和实现能够独立地变化。 
        
         GOF在提出桥梁模式的时候指出，桥梁模式的用意是 
         "将抽象化(Abstraction)与实现化(Implementation)脱耦，使得两者能够独立地变化" 
         。这句话有三个关键词，也就是抽象化、实现化和脱耦。 
        
         在Java应用中，对于桥接模式有一个很是典型的例子，就是应用程序使用JDBC驱动程序进行开发的方式。所谓驱动程序，指的是按照预先约定好的接口来操做计算机系统或者是外围设备的程序。 
        
         Adapter 适配器模式： 
        
         用来把一个接口转化成另外一个接口。使得本来因为接口不兼容而不能一块儿工做的那些类能够在一块儿工做。 
        
         java.util.Arrays#asList() 
        
         java.io.InputStreamReader(InputStream) 
        
         java.io.OutputStreamWriter(OutputStream) 
        
         Composite 组合模式： 
        
         又叫作部分-总体模式，使得客户端看来单个对象和对象的组合是同等的。换句话说，某个类型的方法同时也接受自身类型做为参数。 
        
         avax.swing.JComponent#add(Component) 
        
         java.util.Map#putAll(Map) 
        
         java.util.List#addAll(Collection) 
        
         java.util.Set#addAll(Collection) 
        
         装饰者模式： 
        
         动态的给一个对象附加额外的功能，这也是子类的一种替代方式。能够看到，在建立一个类型的时候，同时也传入同一类型的对象。这在JDK里随处可见，你会发现它无处不在，因此下面这个列表只是一小部分。 
        
         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 门面模式，即外观模式： 
        
         给一组组件，接口，抽象，或者子系统提供一个简单的接口。 
        
         java.lang.Class 
        
         javax.faces.webapp.FacesServlet 
        
         Flyweight 享元模式： 
        
         使用缓存来加速大量小对象的访问时间。 
        
         java.lang.Integer#valueOf( 
         int 
         ) 
        
         java.lang.Boolean#valueOf( 
         boolean 
         ) 
        
         java.lang.Byte#valueOf( 
         byte 
         ) 
        
         java.lang.Character#valueOf( 
         char 
         ) 
        
         Proxy 代理模式： 
        
         代理模式是用一个简单的对象来代替一个复杂的或者建立耗时的对象。 
        
         java.lang.reflect.Proxy 
        
         RMI 
        
         Abstract Factory 抽象工厂模式: 
        
         抽象工厂模式提供了一个协议来生成一系列的相关或者独立的对象，而不用指定具体对象的类型。它使得应用程序可以和使用的框架的具体实现进行解耦。这在JDK或者许多框架好比Spring中都随处可见。它们也很容易识别，一个建立新对象的方法，返回的倒是接口或者抽象类的，就是抽象工厂模式了。 
        
         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中都随处可见。它们也很容易识别，一个建立新对象的方法，返回的倒是接口或者抽象类的，就是抽象工厂模式了。 
        
         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 建造者模式: 
        
         定义了一个新的类来构建另外一个类的实例，以简化复杂对象的建立。建造模式一般也使用方法连接来实现。 
        
         java.lang.StringBuilder#append() 
        
         java.lang.StringBuffer#append() 
        
         java.sql.PreparedStatement 
        
         javax.swing.GroupLayout.Group#addComponent() 
        
         工厂方法： 
        
         就是一个返回具体对象的方法。 
        
         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() 
        
         原型模式 
        
         使得类的实例可以生成自身的拷贝。若是建立一个对象的实例很是复杂且耗时时，就可使用这种模式，而不从新建立一个新的实例，你能够拷贝一个对象并直接修改它。 
        
         java.lang.Object#clone() 
        
         java.lang.Cloneable 
        
         单例模式 
        
         用来确保类只有一个实例。Joshua Bloch在Effetive Java中建议到，还有一种方法就是使用枚举。 
        
         java.lang.Runtime#getRuntime() 
        
         java.awt.Toolkit#getDefaultToolkit() 
        
         java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment() 
        
         java.awt.Desktop#getDesktop() 
        
         责任链模式 
        
         经过把请求从一个对象传递到链条中下一个对象的方式，直到请求被处理完毕，以实现对象间的解耦。 
        
         java.util.logging.Logger#log() 
        
         javax.servlet.Filter#doFilter() 
        
         命令模式 
        
         将操做封装到对象内，以便存储，传递和返回。 
        
         java.lang.Runnable 
        
         javax.swing.Action 
        
         解释器模式 
        
         这个模式一般定义了一个语言的语法，而后解析相应语法的语句。 
        
         java.util.Pattern 
        
         java.text.Normalizer 
        
         java.text.Format 
        
         迭代器模式 
        
         提供一个一致的方法来顺序访问集合中的对象，这个方法与底层的集合的具体实现无关。 
        
         java.util.Iterator 
        
         java.util.Enumeration 
        
         中介者模式 
        
         经过使用一个中间对象来进行消息分发以及减小类之间的直接依赖。 
        
         java.util.Timer 
        
         java.util.concurrent.Executor#execute() 
        
         java.util.concurrent.ExecutorService#submit() 
        
         java.lang.reflect.Method#invoke() 
        
         备忘录模式 
        
         生成对象状态的一个快照，以便对象能够恢复原始状态而不用暴露自身的内容。Date对象经过自身内部的一个 
         long 
         值来实现备忘录模式。 
        
         java.util.Date 
        
         java.io.Serializable 
        
         空对象模式 
        
         这个模式经过一个无心义的对象来代替没有对象这个状态。它使得你不用额外对空对象进行处理。 
        
         java.util.Collections#emptyList() 
        
         java.util.Collections#emptyMap() 
        
         java.util.Collections#emptySet() 
        
         观察者模式 
        
         它使得一个对象能够灵活的将消息发送给感兴趣的对象。 
        
         java.util.EventListener 
        
         javax.servlet.http.HttpSessionBindingListener 
        
         javax.servlet.http.HttpSessionAttributeListener 
        
         javax.faces.event.PhaseListener 
        
         状态模式 
        
         经过改变对象内部的状态，使得你能够在运行时动态改变一个对象的行为。 
        
         java.util.Iterator 
        
         javax.faces.lifecycle.LifeCycle#execute() 
        
         策略模式 
        
         使用这个模式来将一组算法封装成一系列对象。经过传递这些对象能够灵活的改变程序的功能。 
        
         java.util.Comparator#compare() 
        
         javax.servlet.http.HttpServlet 
        
         javax.servlet.Filter#doFilter() 
        
         模板方法模式 
        
         让子类能够重写方法的一部分，而不是整个重写，你能够控制子类须要重写那些操做。 
        
         java.util.Collections#sort() 
        
         java.io.InputStream#skip() 
        
         java.io.InputStream#read() 
        
         java.util.AbstractList#indexOf() 
        
         访问者模式 
        
         提供一个方便的可维护的方式来操做一组对象。它使得你在不改变操做的对象前提下，能够修改或者扩展对象的行为。 
        
         javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor 
        
         javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor

3.Java中什么是单例设计模式？用Java写出线程安全的单例。
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
使用单例模式最核心的一点是体现了面向对象封装特性中的“单一职责”和“对象自治”原则。
而且能够节省系统开销。算法

4.使用工厂模式最主要的好处是什么？你在哪里使用？
各模式的理解：
简单工厂：把对象的建立放到一个工厂类中，经过参数来建立不一样的对象。
工厂方法：每种产品由一种工厂来建立。（不这样会有什么问题？）
抽象工厂：子工厂有一些相同的功能，将这些功能抽象放在父工厂中，每一个子工厂有这些公共行为，还有本身的功能。sql

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

使用工厂的理由：使开发者和对象的建立隔离开来。同时不在关心对象建立的细节
A.把对象的建立集中在一个地方(工厂中),在增长新的对象类型的时候,只须要改变工厂方法;不然在应用中四处散布对象建立逻辑,若是建立方法改变时则须要四处修改，维护量增长.
B.应用的场合是新的对象类型极可能常常被添加进来.
C.你所关心的仅仅是工厂方法返回的接口方法,没必要关心实现细节设计模式

5.在Java中，什么叫观察者设计模式（observer design pattern）？
观察者模式又叫作发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。
一个软件系统经常要求在某一个对象的状态发生变化的时候，某些其它的对象作出相应的改变。作到这一点的设计方案有不少，可是为了使系统可以易于复用，应该选择低耦合度的设计方案。减小对象之间的耦合有利于系统的复用，可是同时设计师须要使这些低耦合度的对象之间可以维持行动的协调一致，保证高度的协做。缓存

6.举一个用Java实现的装饰模式(decorator design pattern)？它是做用于对象层次仍是类层次？
动态地给一个对象增长一些额外的职责，就增长对象功能来讲，装饰模式比生成子类实现更为灵活。装饰模式是一种对象结构型模式。装饰模式是一种用于替代继承的技术,使用对象之间的关联关系取代类之间的继承关系。在装饰模式中引入了装饰类，在装饰类中既能够调用待装饰的原有类的方法，还能够增长新的方法，以扩充原有类的功能。
装饰原有对象、在不改变原有对象的状况下扩展加强新功能/新特征.。当不能采用继承的方式对系统进行扩展或者采用继承不利于系统扩展和维护时可使用装饰模式。安全

7.什么是MVC设计模式？举一个MVC设计模式的例子？
MVC是一个设计模式，它强制性的使应用程序的输入、处理和输出分开。使用MVC应用程序被分红三个核心部件：模型、视图、控制器。它们各自处理本身的任务。app

参考：https://yq.aliyun.com/articles/38175框架