随笔 - 1690  文章 - 666 评论 - 463 trackbacks - 0

1.设计模式分类

 

 

2.设计模式的优点

  设计模式可在多个项目中重用。

  设计模式提供了一个帮助定义系统架构的解决方案。

  设计模式吸收了软件工程的经验。

  设计模式为应用程序的设计提供了透明性。

  设计模式是被实践证明切实有效的,由于它们是建立在专家软件开发人员的知识和经验之上的。

 

3.单例模式的创建方式

 Early Instantiation 示例代码如下:

public class Singleton {
    private final static Singleton INSTANCE = new Singleton();  
 
    // Private constructor suppresses   
    private Singleton() {}
 
    // default public constructor
    public static Singleton getInstance() {  
        return INSTANCE;
    }
  } 

Lazy Instantiation

public class SingletonDemo {
    private static SingletonDemo instance = null;  
    private SingletonDemo() {    }
 
    public static  SingletonDemo getInstance() {
        if (instance == null) {
                    instance = new SingletonDemo (); 
        }
        return instance;
    }
}

4.jdk中使用了哪些设计模式?

Structural(结构模式)

Adapter:
把一个接口或是类变成另外一种。

 

  • java.util.Arrays#asList()
  • javax.swing.JTable(TableModel)
  • java.io.InputStreamReader(InputStream)
  • java.io.OutputStreamWriter(OutputStream)
  • javax.xml.bind.annotation.adapters.XmlAdapter#marshal()
  • javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()

Bridge:
把抽象和实现解藕,于是接口和实现可在完全独立开来。

  • AWT (提供了抽象层映射于实际的操作系统)
  • JDBC

Composite:
让使用者把单独的对象和组合对象混用。

  • javax.swing.JComponent#add(Component)
  • java.awt.Container#add(Component)
  • java.util.Map#putAll(Map)
  • java.util.List#addAll(Collection)
  • java.util.Set#addAll(Collection)

 

Decorator:
为一个对象动态的加上一系列的动作,而不需要因为这些动作的不同而产生大量的继承类。这个模式在JDK中几乎无处不在,所以,下面的列表只是一些典型的。

  • java.io.BufferedInputStream(InputStream)
  • java.io.DataInputStream(InputStream)
  • java.io.BufferedOutputStream(OutputStream)
  • java.util.zip.ZipOutputStream(OutputStream)
  • java.util.Collections#checked[List|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

Creational(创建模式)

Abstract factory:
创建一组有关联的对象实例。这个模式在JDK中也是相当的常见,还有很多的framework例如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:
主要用来简化一个复杂的对象的创建。这个模式也可以用来实现一个 Fluent Interface

  • java.lang.StringBuilder#append()
  • java.lang.StringBuffer#append()
  • java.sql.PreparedStatement
  • javax.swing.GroupLayout.Group#addComponent()

Factory:
简单来说,按照需求返回一个类型的实例。

  • 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()

Prototype:
使用自己的实例创建另一个实例。有时候,创建一个实例然后再把已有实例的值拷贝过去,是一个很复杂的动作。所以,使用这个模式可以避免这样的复杂性。

  • java.lang.Object#clone()
  • java.lang.Cloneable

Singleton:
只允许一个实例。在 Effective Java中建议使用Emun.

  • java.lang.Runtime#getRuntime()
  • java.awt.Toolkit#getDefaultToolkit()
  • java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()
  • java.awt.Desktop#getDesktop()

Behavioral(行为模式)

Chain of responsibility:
把一个对象在一个链接传递直到被处理。在这个链上的所有的对象有相同的接口(抽象类)但却有不同的实现。

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

Command:
把一个或一些命令封装到一个对象中。

  • java.lang.Runnable
  • javax.swing.Action

Interpreter:
一个语法解释器的模式。

  • java.util.Pattern
  • java.text.Normalizer
  • java.text.Format

Iterator:
提供一种一致的方法来顺序遍历一个容器中的所有元素。

  • java.util.Iterator
  • java.util.Enumeration

Mediator:
用来减少对象单的直接通讯的依赖关系。使用一个中间类来管理消息的方向。

  • java.util.Timer
  • java.util.concurrent.Executor#execute()
  • java.util.concurrent.ExecutorService#submit()
  • java.lang.reflect.Method#invoke()

Memento:
给一个对象的状态做一个快照。Date类在内部使用了一个long型来做这个快照。

  • java.util.Date
  • java.io.Serializable

Null Object:
这个模式用来解决如果一个Collection中没有元素的情况。

  • java.util.Collections#emptyList()
  • java.util.Collections#emptyMap()
  • java.util.Collections#emptySet()

Observer:
允许一个对象向所有的侦听的对象广播自己的消息或事件。

  • java.util.EventListener
  • javax.servlet.http.HttpSessionBindingListener
  • javax.servlet.http.HttpSessionAttributeListener
  • javax.faces.event.PhaseListener

State:
这个模式允许你可以在运行时很容易地根据自身内部的状态改变对象的行为。

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

Strategy:
定义一组算法,并把其封装到一个对象中。然后在运行时,可以灵活的使用其中的一个算法。

  • java.util.Comparator#compare()
  • javax.servlet.http.HttpServlet
  • javax.servlet.Filter#doFilter()

Template method:
允许子类重载部分父类而不需要完全重写。

  • java.util.Collections#sort()
  • java.io.InputStream#skip()
  • java.io.InputStream#read()
  • java.util.AbstractList#indexOf()

Visitor:

作用于某个对象群中各个对象的操作. 它可以使你在不改变这些对象本身的情况下,定义作用于这些对象的新操作.

  • javax.lang.model.element.Element 和javax.lang.model.element.ElementVisitor
  • javax.lang.model.type.TypeMirror 和javax.lang.model.type.TypeVisitor

5.  如何编写线程安全的单例

双重检查锁(Double-checked locking)

public static synchronized Singleton getInstance() {
  if(singleton == null) {
     synchronized(Singleton.class) {
       if(singleton == null) {
         singleton = new Singleton();
       }
    }
  }
  return singleton;
}

6.  代理模式有哪些类型?

保护代理

  它根据某些条件控制对真实主题的访问。

虚拟代理

  虚拟代理用于实例化昂贵的对象。代理管理实现中真实主体的生命周期。

  它决定创建实例的需要以及何时重用实例。虚拟代理优化性能。

缓存代理

  缓存代理用于缓存对真实主题的昂贵调用。代理可以使用许多缓存策略。

  其中一些是通读、写、缓存和基于时间的。缓存代理用于提高性能。

远程代理

  远程代理用于分布式对象通信。远程代理通过调用本地对象方法在远程对象上执行。

智能代理

  智能代理用于实现对对象的日志调用和引用计数

7. mvc模式

MVC 模式代表 Model-View-Controller(模型-视图-控制器) 模式。这种模式用于应用程序的分层开发。

  • Model(模型) - 模型代表一个存取数据的对象或 JAVA POJO。它也可以带有逻辑,在数据变化时更新控制器。
  • View(视图) - 视图代表模型包含的数据的可视化。
  • Controller(控制器) - 控制器作用于模型和视图上。它控制数据流向模型对象,并在数据变化时更新视图。它使视图与模型分离开。

 

8. 拦截过滤器模式及其有点

拦截过滤器设计模式用于在请求处理之前和之后拦截和操作请求和响应。过滤器执行请求的身份验证/授权/日志记录或跟踪,然后将请求转发给相应的处理程序。让我们看一下拦截设计模式的一些基本实体。

过滤器

  它在请求处理程序执行请求之前或之后执行特定的任务。

过滤器链

  它包含多个过滤器,有助于在目标上按定义的顺序执行它们。

目标

  目标对象是请求处理程序

过滤器管理器

  它管理过滤器和过滤器链。 

客户端

  客户机对象是向目标对象发送请求的对象。

拦截过滤器设计模式的好处

  过滤器模式使用松散耦合的处理程序提供中央控制。

  它扩展了可重用性。

  可以随时添加新的过滤器,而不影响客户机的代码。

  过滤器可以在程序执行期间动态选择。

 9. dao设计模式

数据访问对象模式用于将低级数据访问API或操作与高级业务服务隔离开来。下面是DAO模式中的组件。

数据存取对象接口

  DAO接口描述要在模型对象上执行的标准操作。

数据访问对象的具体类

  该类实现一个DAO接口。该类负责从数据源(可以是Xml/数据库或任何其他存储机制)获取数据。

模型对象或值对象

  这个对象是一个普通的旧java对象,包含用于存储使用DAO类检索的数据的get/set方法。

 

参考资料

【1】https://www.javatpoint.com/java-design-pattern-interview-questions

 【2】https://coolshell.cn/articles/3320.html

【3】https://www.cnblogs.com/davidwang456/p/3642696.html

【4】 https://www.runoob.com/design-pattern/mvc-pattern.html

posted on 2019-08-13 14:54  一天不进步,就是退步  阅读(16283)  评论(2编辑  收藏