设计模式面试题 （史上最全、持续更新、吐血推荐）
- 疯狂创客圈 经典图书 ： 《Netty Zookeeper Redis 高并发实战》 面试必备 + 面试必备 + 面试必备
- 疯狂创客圈 经典图书 ： 《SpringCloud、Nginx高并发核心编程》 大厂必备 + 大厂必备 + 大厂必备
- 入大厂+涨工资 必备的 高并发社群： 【博客园总入口 】
国内著名电商面试题：你的项目中用到了哪些设计模式，如何使用?
读完本文，你会有一个最佳的答案。html
设计模式基础
什么是设计模式
- 设计模式，是一套被反复使用、多数人知晓的、通过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
为何要学习设计模式
- 看懂源代码：若是你不懂设计模式去看Jdk、Spring、SpringMVC、IO等等等等的源码，你会很迷茫，你会步履维艰
- 看看前辈的代码：你去个公司难道都是新项目让你接手？颇有多是接盘的，前辈的开发难道不用设计模式？
- 编写本身的理想中的好代码：我我的反正是这样的，对于我本身开发的项目我会很认真，我对他比对我女友还好，把项目当成本身的儿子同样
设计模式分类
- 建立型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
- 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
- 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
设计模式的六大原则
开放封闭原则（Open Close Principle）
- 原则思想：尽可能经过扩展软件实体来解决需求变化，而不是经过修改已有的代码来完成变化
- 描述：一个软件产品在生命周期内，都会发生变化，既然变化是一个既定的事实，咱们就应该在设计的时候尽可能适应这些变化，以提升项目的稳定性和灵活性。
- 优势：单一原则告诉咱们，每一个类都有本身负责的职责，里氏替换原则不能破坏继承关系的体系。
里氏代换原则（Liskov Substitution Principle）
- 原则思想：使用的基类能够在任何地方使用继承的子类，完美的替换基类。
- 大概意思是：子类能够扩展父类的功能，但不能改变父类原有的功能。子类能够实现父类的抽象方法，但不能覆盖父类的非抽象方法，子类中能够增长本身特有的方法。
- 优势：增长程序的健壮性，即便增长了子类，原有的子类还能够继续运行，互不影响。
依赖倒转原则（Dependence Inversion Principle）
- 依赖倒置原则的核心思想是面向接口编程.
- 依赖倒转原则要求咱们在程序代码中传递参数时或在关联关系中，尽可能引用层次高的抽象层类，
- 这个是开放封闭原则的基础，具体内容是：对接口编程，依赖于抽象而不依赖于具体。
接口隔离原则（Interface Segregation Principle）
- 这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。仍是一个下降类之间的耦合度的意思，从这儿咱们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。因此上文中屡次出现：下降依赖，下降耦合。
- 例如：支付类的接口和订单类的接口，须要把这俩个类别的接口变成俩个隔离的接口
迪米特法则（最少知道原则）（Demeter Principle）
- 原则思想：一个对象应当对其余对象有尽量少地了解，简称类间解耦
- 大概意思就是一个类尽可能减小本身对其余对象的依赖，原则是低耦合，高内聚，只有使各个模块之间的耦合尽可能的低，才能提升代码的复用率。
- 优势：低耦合，高内聚。
单一职责原则（Principle of single responsibility）
- 原则思想：一个方法只负责一件事情。
- 描述：单一职责原则很简单，一个方法 一个类只负责一个职责，各个职责的程序改动，不影响其它程序。 这是常识，几乎全部程序员都会遵循这个原则。
- 优势：下降类和类的耦合，提升可读性，增长可维护性和可拓展性，下降可变性的风险。
J2EE中使用了哪些设计模式？
Structural（结构模式）
Adapter:java
- 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:
让使用者把单独的对象和组合对象混用。web
- 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#checkedList|Map|Set|SortedSet|SortedMap
Facade:
用一个简单的接口包状一组组件，接口，抽象或是子系统。算法
- java.lang.Class
- javax.faces.webapp.FacesServlet
Flyweight:
有效率地存储大量的小的对象。spring
- java.lang.Integer#valueOf(int)
- java.lang.Boolean#valueOf(boolean)
- java.lang.Byte#valueOf(byte)
- java.lang.Character#valueOf(char)
Proxy:
用一个简单的对象来代替一个复杂的对象。sql
- java.lang.reflect.Proxy
- RMI
Creational（建立模式）
Abstract factory:**数据库
- 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
mvc模式
MVC 模式表明 Model-View-Controller（模型-视图-控制器） 模式。这种模式用于应用程序的分层开发。
- Model（模型） - 模型表明一个存取数据的对象或 JAVA POJO。它也能够带有逻辑，在数据变化时更新控制器。
- View（视图） - 视图表明模型包含的数据的可视化。
- Controller（控制器） - 控制器做用于模型和视图上。它控制数据流向模型对象，并在数据变化时更新视图。它使视图与模型分离开。
拦截过滤器模式
拦截过滤器模式（Intercepting Filter Pattern）用于对应用程序的请求或响应作一些预处理/后处理。定义过滤器，并在把请求传给实际目标应用程序以前应用在请求上。过滤器能够作认证/受权/记录日志，或者跟踪请求，而后把请求传给相应的处理程序。如下是这种设计模式的实体。
- 过滤器（Filter） - 过滤器在请求处理程序执行请求以前或以后，执行某些任务。
- 过滤器链（Filter Chain） - 过滤器链带有多个过滤器，并在 Target 上按照定义的顺序执行这些过滤器。
- Target - Target 对象是请求处理程序。
- 过滤管理器（Filter Manager） - 过滤管理器管理过滤器和过滤器链。
- 客户端（Client） - Client 是向 Target 对象发送请求的对象。
实现
咱们将建立 FilterChain、FilterManager、Target、Client 做为表示实体的各类对象。AuthenticationFilter 和 DebugFilter 表示实体过滤器。
InterceptingFilterDemo，咱们的演示类使用 Client 来演示拦截过滤器设计模式。
步骤 1
建立过滤器接口 Filter。
Filter.java
public interface Filter {
void execute(String request);
}
12345
步骤 2
建立实体过滤器。
AuthenticationFilter.java
public class AuthenticationFilter implements Filter {
@Override
public void execute(String request){
System.out.println("Authenticating request: " + request);
}
}
DebugFilter.java
public class DebugFilter implements Filter {
@Override
public void execute(String request){
System.out.println("request log: " + request);
}
}
步骤 3
建立 Target。
Target.java
*/
public class Target {
public void execute(String request){
System.out.println("Executing request: " + request);
}
}
步骤 4
建立过滤器链。
FilterChain.java
public class FilterChain {
private List<Filter> filters = new ArrayList();
private Target target;
public void addFilter(Filter filter){
filters.add(filter);
}
public void execute(String request){
for (Filter filter : filters) {
filter.execute(request);
}
target.execute(request);
}
public void setTarget(Target target){
this.target = target;
}
}
步骤 5
建立过滤管理器。
FilterManager.java
public class FilterManager {
FilterChain filterChain;
public FilterManager(Target target){
filterChain = new FilterChain();
filterChain.setTarget(target);
}
public void setFilter(Filter filter){
filterChain.addFilter(filter);
}
public void filterRequest(String request){
filterChain.execute(request);
}
}
步骤 6
建立客户端 Client。
Client.java
public class Client {
FilterManager filterManager;
public void setFilterManager(FilterManager filterManager){
this.filterManager = filterManager;
}
public void sendRequest(String request){
filterManager.filterRequest(request);
}
}
步骤 7
使用 Client 来演示拦截过滤器设计模式。
InterceptingFilterDemo.java
public class InterceptingFilterPatternDemo {
public static void main(String[] args) {
FilterManager filterManager = new FilterManager(new Target());
filterManager.setFilter(new AuthenticationFilter());
filterManager.setFilter(new DebugFilter());
Client client = new Client();
client.setFilterManager(filterManager);
client.sendRequest("HOME");
}
}
步骤 8
验证输出。
Authenticating request: HOME request log: HOME Executing request: HOME
单例模式
1.什么是单例
- 保证一个类只有一个实例，而且提供一个访问该全局访问点
2.那些地方用到了单例模式
- 网站的计数器，通常也是采用单例模式实现，不然难以同步。
- 应用程序的日志应用，通常都是单例模式实现，只有一个实例去操做才好，不然内容很差追加显示。
- 多线程的线程池的设计通常也是采用单例模式，由于线程池要方便对池中的线程进行控制
- Windows的（任务管理器）就是很典型的单例模式，他不能打开俩个
- windows的（回收站）也是典型的单例应用。在整个系统运行过程当中，回收站只维护一个实例。
3.单例优缺点
优势：
- 在单例模式中，活动的单例只有一个实例，对单例类的全部实例化获得的都是相同的一个实例。这样就防止其它对象对本身的实例化，确保全部的对象都访问一个实例
- 单例模式具备必定的伸缩性，类本身来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
- 提供了对惟一实例的受控访问。
- 因为在系统内存中只存在一个对象，所以能够节约系统资源，当须要频繁建立和销毁的对象时单例模式无疑能够提升系统的性能。
- 容许可变数目的实例。
- 避免对共享资源的多重占用。
缺点：
- 不适用于变化的对象，若是同一类型的对象老是要在不一样的用例场景发生变化，单例就会引发数据的错误，不能保存彼此的状态。
- 因为单利模式中没有抽象层，所以单例类的扩展有很大的困难。
- 单例类的职责太重，在必定程度上违背了“单一职责原则”。
- 滥用单例将带来一些负面问题，如为了节省资源将数据库链接池对象设计为的单例类，可能会致使共享链接池对象的程序过多而出现链接池溢出；若是实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将致使对象状态的丢失。
4.单例模式使用注意事项：
- 使用时不能用反射模式建立单例，不然会实例化一个新的对象
- 使用懒单例模式时注意线程安全问题
- 饿单例模式和懒单例模式构造方法都是私有的，于是是不能被继承的，有些单例模式能够被继承（如登记式模式）
5.单例防止反射漏洞攻击
private static boolean flag = false;
private Singleton() {
if (flag == false) {
flag = !flag;
} else {
throw new RuntimeException("单例模式被侵犯！");
}
}
public static void main(String[] args) {
}
6.如何选择单例建立方式
- 若是不须要延迟加载单例，可使用枚举或者饿汉式，相对来讲枚举性好于饿汉式。
若是须要延迟加载，可使用静态内部类或者懒汉式，相对来讲静态内部类好于懒韩式。
最好使用饿汉式
7.单例建立方式
（主要使用懒汉和懒汉式）
- 饿汉式:类初始化时,会当即加载该对象，线程天生安全,调用效率高。
- 懒汉式: 类初始化时,不会初始化该对象,真正须要使用的时候才会建立该对象,具有懒加载功能。
- 静态内部方式:结合了懒汉式和饿汉式各自的优势，真正须要对象的时候才会加载，加载类是线程安全的。
- 枚举单例: 使用枚举实现单例模式 优势:实现简单、调用效率高，枚举自己就是单例，由jvm从根本上提供保障!避免经过反射和反序列化的漏洞， 缺点没有延迟加载。
- 双重检测锁方式 (由于JVM本质重排序的缘由，可能会初始化屡次，不推荐使用)
1.饿汉式
- 饿汉式:类初始化时,会当即加载该对象，线程天生安全,调用效率高。
package com.lijie;
//饿汉式
public class Demo1 {
// 类初始化时,会当即加载该对象，线程安全,调用效率高
private static Demo1 demo1 = new Demo1();
private Demo1() {
System.out.println("私有Demo1构造参数初始化");
}
public static Demo1 getInstance() {
return demo1;
}
public static void main(String[] args) {
Demo1 s1 = Demo1.getInstance();
Demo1 s2 = Demo1.getInstance();
System.out.println(s1 == s2);
}
}
2.懒汉式
- 懒汉式: 类初始化时,不会初始化该对象,真正须要使用的时候才会建立该对象,具有懒加载功能。
package com.lijie;
//懒汉式
public class Demo2 {
//类初始化时，不会初始化该对象，真正须要使用的时候才会建立该对象。
private static Demo2 demo2;
private Demo2() {
System.out.println("私有Demo2构造参数初始化");
}
public synchronized static Demo2 getInstance() {
if (demo2 == null) {
demo2 = new Demo2();
}
return demo2;
}
public static void main(String[] args) {
Demo2 s1 = Demo2.getInstance();
Demo2 s2 = Demo2.getInstance();
System.out.println(s1 == s2);
}
}
3.静态内部类
- 静态内部方式:结合了懒汉式和饿汉式各自的优势，真正须要对象的时候才会加载，加载类是线程安全的。
package com.lijie;
// 静态内部类方式
public class Demo3 {
private Demo3() {
System.out.println("私有Demo3构造参数初始化");
}
public static class SingletonClassInstance {
private static final Demo3 DEMO_3 = new Demo3();
}
// 方法没有同步
public static Demo3 getInstance() {
return SingletonClassInstance.DEMO_3;
}
public static void main(String[] args) {
Demo3 s1 = Demo3.getInstance();
Demo3 s2 = Demo3.getInstance();
System.out.println(s1 == s2);
}
}
4.枚举单例式
- 枚举单例: 使用枚举实现单例模式 优势:实现简单、调用效率高，枚举自己就是单例，由jvm从根本上提供保障!避免经过反射和反序列化的漏洞， 缺点没有延迟加载。
package com.lijie;
//使用枚举实现单例模式 优势:实现简单、枚举自己就是单例，由jvm从根本上提供保障!避免经过反射和反序列化的漏洞 缺点没有延迟加载
public class Demo4 {
public static Demo4 getInstance() {
return Demo.INSTANCE.getInstance();
}
public static void main(String[] args) {
Demo4 s1 = Demo4.getInstance();
Demo4 s2 = Demo4.getInstance();
System.out.println(s1 == s2);
}
//定义枚举
private static enum Demo {
INSTANCE;
// 枚举元素为单例
private Demo4 demo4;
private Demo() {
System.out.println("枚举Demo私有构造参数");
demo4 = new Demo4();
}
public Demo4 getInstance() {
return demo4;
}
}
}
5.双重检测锁方式
- 双重检测锁方式 (由于JVM本质重排序的缘由，可能会初始化屡次，不推荐使用)
package com.lijie;
//双重检测锁方式
public class Demo5 {
private static Demo5 demo5;
private Demo5() {
System.out.println("私有Demo4构造参数初始化");
}
public static Demo5 getInstance() {
if (demo5 == null) {
synchronized (Demo5.class) {
if (demo5 == null) {
demo5 = new Demo5();
}
}
}
return demo5;
}
public static void main(String[] args) {
Demo5 s1 = Demo5.getInstance();
Demo5 s2 = Demo5.getInstance();
System.out.println(s1 == s2);
}
}
8 单例模式懒汉式和饿汉式有哪些区别？(美团)
单例模式是 Java 中最简单的设计模式之一。这种类型的设计模式属于建立型模式，它提供了一种建立对象的最佳方式。
这种模式涉及到一个单一的类，该类负责建立本身的对象，同时确保只有单个对象被建立。这个类提供了一种访问其惟一的对象的方式，能够直接访问，不须要实例化该类的对象。
注意：
一、单例类只能有一个实例。
二、单例类必须本身建立本身的惟一实例。
三、单例类必须给全部其余对象提供这一实例。
明肯定义后，看一下代码：
饿汉式
public class SingletonEH {
/**
*是否 Lazy 初始化：否
*是否多线程安全：是
*实现难度：易
*描述：这种方式比较经常使用，但容易产生垃圾对象。
*优势：没有加锁，执行效率会提升。
*缺点：类加载时就初始化，浪费内存。
*它基于 classloder 机制避免了多线程的同步问题，
* 不过，instance 在类装载时就实例化，虽然致使类装载的缘由有不少种，
* 在单例模式中大多数都是调用 getInstance 方法，
* 可是也不能肯定有其余的方式（或者其余的静态方法）致使类装载，
* 这时候初始化 instance 显然没有达到 lazy loading 的效果。
*/
private static SingletonEH instance = new SingletonEH();
private SingletonEH (){}
public static SingletonEH getInstance() {
System.out.println("instance:"+instance);
System.out.println("加载饿汉式....");
return instance;
}
}
饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了。
懒汉式
public class SingletonLH {
/**
*是否 Lazy 初始化：是
*是否多线程安全：否
*实现难度：易
*描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。由于没有加锁 synchronized，因此严格意义上它并不算单例模式。
*这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工做。
*/
private static SingletonLH instance;
private SingletonLH (){}
public static SingletonLH getInstance() {
if (instance == null) {
instance = new SingletonLH();
}
return instance;
}
}
而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。
一、线程安全：
饿汉式天生就是线程安全的，能够直接用于多线程而不会出现问题，
懒汉式自己是非线程安全的，为了实现线程安全有几种写法。
例：
public class SingletonLHsyn {
/**
*是否 Lazy 初始化：是
*是否多线程安全：是
*实现难度：易
*描述：这种方式具有很好的 lazy loading，可以在多线程中很好的工做，可是，效率很低，99% 状况下不须要同步。
*优势：第一次调用才初始化，避免内存浪费。
*缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
*getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。
*/
private static SingletonLHsyn instance;
private SingletonLHsyn (){}
public static synchronized SingletonLHsyn getInstance() {
if (instance == null) {
instance = new SingletonLHsyn();
}
return instance;
}
}
二、资源加载和性能：
饿汉式在类建立的同时就实例化一个静态对象出来，无论以后会不会使用这个单例，都会占据必定的内存，可是相应的，在第一次调用时速度也会更快，由于其资源已经初始化完成。
而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要作初始化，若是要作的工做比较多，性能上会有些延迟，以后就和饿汉式同样了。
-
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
-
主要解决：一个全局使用的类频繁地建立与销毁。
-
什么时候使用：当您想控制实例数目，节省系统资源的时候。
-
如何解决：判断系统是否已经有这个单例，若是有则返回，若是没有则建立。
-
关键代码：构造函数是私有的。
-
应用实例：
一、一个党只能有一个主席。
二、Windows是多进程多线程的，在操做一个文件的时候，就不可避免地出现多个进程或线程同时操做一个文件的现象，因此全部文件的处理必须经过惟一的实例来进行。
三、一些设备管理器经常设计为单例模式，好比一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。 -
优势：
一、在内存里只有一个实例，减小了内存的开销，尤为是频繁的建立和销毁实例（好比管理学院首页页面缓存）。
二、避免对资源的多重占用（好比写文件操做）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。 -
使用场景：
一、要求生产惟一序列号。
二、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
三、建立的一个对象须要消耗的资源过多，好比 I/O 与数据库的链接等。 注意事项：getInstance() 方法中须要使用同步锁,synchronized (Singleton.class) 防止多线程同时进入形成instance 被屡次实例化。
工厂模式
1.什么是工厂模式
- 它提供了一种建立对象的最佳方式。在工厂模式中，咱们在建立对象时不会对客户端暴露建立逻辑，而且是经过使用一个共同的接口来指向新建立的对象。实现了建立者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式
2.工厂模式好处
- 工厂模式是咱们最经常使用的实例化对象模式了，是用工厂方法代替new操做的一种模式。
- 利用工厂模式能够下降程序的耦合性，为后期的维护修改提供了很大的便利。
- 将选择实现类、建立对象统一管理和控制。从而将调用者跟咱们的实现类解耦。
3.为何要学习工厂设计模式
- 不知道大家面试题问到过源码没有，你知道Spring的源码吗，MyBatis的源码吗，等等等
若是你想学习不少框架的源码，或者你想本身开发本身的框架，就必须先掌握设计模式（工厂设计模式用的是很是很是普遍的）
4.Spring开发中的工厂设计模式
1.Spring IOC
- 看过Spring源码就知道，在Spring IOC容器建立bean的过程是使用了工厂设计模式
- Spring中不管是经过xml配置仍是经过配置类仍是注解进行建立bean，大部分都是经过简单工厂来进行建立的。
- 当容器拿到了beanName和class类型后，动态的经过反射建立具体的某个对象，最后将建立的对象放到Map中。
2.为何Spring IOC要使用工厂设计模式建立Bean呢
- 在实际开发中，若是咱们A对象调用B，B调用C，C调用D的话咱们程序的耦合性就会变高。（耦合大体分为类与类之间的依赖，方法与方法之间的依赖。）
- 在好久之前的三层架构编程时，都是控制层调用业务层，业务层调用数据访问层时，都是是直接new对象，耦合性大大提高，代码重复量很高，对象满天飞
- 为了不这种状况，Spring使用工厂模式编程，写一个工厂，由工厂建立Bean，之后咱们若是要对象就直接管工厂要就能够，剩下的事情不归咱们管了。Spring IOC容器的工厂中有个静态的Map集合，是为了让工厂符合单例设计模式，即每一个对象只生产一次，生产出对象后就存入到Map集合中，保证了实例不会重复影响程序效率。
5.工厂模式分类
- 工厂模式分为简单工厂、工厂方法、抽象工厂模式
简单工厂 ：用来生产同一等级结构中的任意产品。（不支持拓展增长产品） 工厂方法 ：用来生产同一等级结构中的固定产品。（支持拓展增长产品） 抽象工厂 ：用来生产不一样产品族的所有产品。（不支持拓展增长产品；支持增长产品族） 123 我下面来使用代码演示一下：
5.1 简单工厂模式
什么是简单工厂模式
- 简单工厂模式至关因而一个工厂中有各类产品，建立在一个类中，客户无需知道具体产品的名称，只须要知道产品类所对应的参数便可。可是工厂的职责太重，并且当类型过多时不利于系统的扩展维护。
代码演示：
- 建立工厂
package com.lijie;
public interface Car {
public void run();
}
- 建立工厂的产品（宝马）
package com.lijie;
public class Bmw implements Car {
public void run() {
System.out.println("我是宝马汽车...");
}
}
- 建立工另一种产品（奥迪）
package com.lijie;
public class AoDi implements Car {
public void run() {
System.out.println("我是奥迪汽车..");
}
}
- 建立核心工厂类，由他决定具体调用哪产品
package com.lijie;
public class CarFactory {
public static Car createCar(String name) {
if ("".equals(name)) {
return null;
}
if(name.equals("奥迪")){
return new AoDi();
}
if(name.equals("宝马")){
return new Bmw();
}
return null;
}
}
- 演示建立工厂的具体实例
package com.lijie;
public class Client01 {
public static void main(String[] args) {
Car aodi =CarFactory.createCar("奥迪");
Car bmw =CarFactory.createCar("宝马");
aodi.run();
bmw.run();
}
}
单工厂的优势/缺点
- 优势：简单工厂模式可以根据外界给定的信息，决定究竟应该建立哪一个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
- 缺点：很明显工厂类集中了全部实例的建立逻辑，容易违反GRASPR的高内聚的责任分配原则
5.2 工厂方法模式
什么是工厂方法模式
- 工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类再也不负责全部的产品的建立，而是将具体建立的工做交给子类去作。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪个产品类应当被实例化这种细节
代码演示：
- 建立工厂
package com.lijie;
public interface Car {
public void run();
}
- 建立工厂方法调用接口（全部的产品须要new出来必须继承他来实现方法）
package com.lijie;
public interface CarFactory {
Car createCar();
}
- 建立工厂的产品（奥迪）
package com.lijie;
public class AoDi implements Car {
public void run() {
System.out.println("我是奥迪汽车..");
}
}
- 建立工厂另一种产品（宝马）
package com.lijie;
public class Bmw implements Car {
public void run() {
System.out.println("我是宝马汽车...");
}
}
- 建立工厂方法调用接口的实例（奥迪）
package com.lijie;
public class AoDiFactory implements CarFactory {
public Car createCar() {
return new AoDi();
}
}
- 建立工厂方法调用接口的实例（宝马）
package com.lijie;
public class BmwFactory implements CarFactory {
public Car createCar() {
return new Bmw();
}
}
- 演示建立工厂的具体实例
package com.lijie;
public class Client {
public static void main(String[] args) {
Car aodi = new AoDiFactory().createCar();
Car jili = new BmwFactory().createCar();
aodi.run();
jili.run();
}
}
5.3 抽象工厂模式
什么是抽象工厂模式
- 抽象工厂简单地说是工厂的工厂，抽象工厂能够建立具体工厂，由具体工厂来产生具体产品。
代码演示：
- 建立第一个子工厂，及实现类
package com.lijie;
//汽车
public interface Car {
void run();
}
class CarA implements Car{
public void run() {
System.out.println("宝马");
}
}
class CarB implements Car{
public void run() {
System.out.println("摩拜");
}
}
- 建立第二个子工厂，及实现类
package com.lijie;
//发动机
public interface Engine {
void run();
}
class EngineA implements Engine {
public void run() {
System.out.println("转的快!");
}
}
class EngineB implements Engine {
public void run() {
System.out.println("转的慢!");
}
}
- 建立一个总工厂，及实现类（由总工厂的实现类决定调用那个工厂的那个实例）
package com.lijie;
public interface TotalFactory {
// 建立汽车
Car createChair();
// 建立发动机
Engine createEngine();
}
//总工厂实现类，由他决定调用哪一个工厂的那个实例
class TotalFactoryReally implements TotalFactory {
public Engine createEngine() {
return new EngineA();
}
public Car createChair() {
return new CarA();
}
}
- 运行测试
package com.lijie;
public class Test {
public static void main(String[] args) {
TotalFactory totalFactory2 = new TotalFactoryReally();
Car car = totalFactory2.createChair();
car.run();
TotalFactory totalFactory = new TotalFactoryReally();
Engine engine = totalFactory.createEngine();
engine.run();
}
}
代理模式
1.什么是代理模式
- 经过代理控制对象的访问，能够在这个对象调用方法以前、调用方法以后去处理/添加新的功能。(也就是AO的P微实现)
- 代理在原有代码乃至原业务流程都不修改的状况下，直接在业务流程中切入新代码，增长新功能，这也和Spring的（面向切面编程）很类似
2.代理模式应用场景
- Spring AOP、日志打印、异常处理、事务控制、权限控制等
3.代理的分类
- 静态代理(静态定义代理类)
- 动态代理(动态生成代理类，也称为Jdk自带动态代理)
- Cglib 、javaassist（字节码操做库）
4.三种代理的区别
- 静态代理：简单代理模式，是动态代理的理论基础。常见使用在代理模式
- jdk动态代理：使用反射完成代理。须要有顶层接口才能使用，常见是mybatis的mapper文件是代理。
- cglib动态代理：也是使用反射完成代理，能够直接代理类（jdk动态代理不行），使用字节码技术，不能对 final类进行继承。（须要导入jar包）
5.用代码演示三种代理
5.1.静态代理
什么是静态代理
- 由程序员建立或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就肯定了。
代码演示：
- 有一段这样的代码：（如何能在不修改UserDao接口类的状况下开事务和关闭事务呢）
package com.lijie;
//接口类
public class UserDao{
public void save() {
System.out.println("保存数据方法");
}
}
12345678
package com.lijie;
//运行测试类
public class Test{
public static void main(String[] args) {
UserDao userDao = new UserDao();
userDao.save();
}
}
修改代码，添加代理类
package com.lijie;
//代理类
public class UserDaoProxy extends UserDao {
private UserDao userDao;
public UserDaoProxy(UserDao userDao) {
this.userDao = userDao;
}
public void save() {
System.out.println("开启事物...");
userDao.save();
System.out.println("关闭事物...");
}
}
1234567891011121314151617
//添加完静态代理的测试类
public class Test{
public static void main(String[] args) {
UserDao userDao = new UserDao();
UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
userDaoProxy.save();
}
}
- 缺点：每一个须要代理的对象都须要本身重复编写代理，很不舒服，
- 优势：可是能够面相实际对象或者是接口的方式实现代理
2.2.动态代理
什么是动态代理
- 动态代理也叫作，JDK代理、接口代理。
- 动态代理的对象，是利用JDK的API，动态的在内存中构建代理对象（是根据被代理的接口来动态生成代理类的class文件，并加载运行的过程），这就叫动态代理
package com.lijie;
//接口
public interface UserDao {
void save();
}
123456
package com.lijie;
//接口实现类
public class UserDaoImpl implements UserDao {
public void save() {
System.out.println("保存数据方法");
}
}
- //下面是代理类，可重复使用，不像静态代理那样要本身重复编写代理
package com.lijie;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
// 每次生成动态代理类对象时,实现了InvocationHandler接口的调用处理器对象
public class InvocationHandlerImpl implements InvocationHandler {
// 这其实业务实现类对象，用来调用具体的业务方法
private Object target;
// 经过构造函数传入目标对象
public InvocationHandlerImpl(Object target) {
this.target = target;
}
//动态代理实际运行的代理方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用开始处理");
//下面invoke()方法是以反射的方式来建立对象，第一个参数是要建立的对象，第二个是构成方法的参数，由第二个参数来决定建立对象使用哪一个构造方法
Object result = method.invoke(target, args);
System.out.println("调用结束处理");
return result;
}
}
- //利用动态代理使用代理方法
package com.lijie;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
// 被代理对象
UserDao userDaoImpl = new UserDaoImpl();
InvocationHandlerImpl invocationHandlerImpl = new InvocationHandlerImpl(userDaoImpl);
//类加载器
ClassLoader loader = userDaoImpl.getClass().getClassLoader();
Class<?>[] interfaces = userDaoImpl.getClass().getInterfaces();
// 主要装载器、一组接口及调用处理动态代理实例
UserDao newProxyInstance = (UserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
newProxyInstance.save();
}
}
- 缺点：必须是面向接口，目标业务类必须实现接口
- 优势：不用关心代理类，只须要在运行阶段才指定代理哪个对象
5.3.CGLIB动态代理
CGLIB动态代理原理：
- 利用asm开源包，对代理对象类的class文件加载进来，经过修改其字节码生成子类来处理。
什么是CGLIB动态代理
- CGLIB动态代理和jdk代理同样，使用反射完成代理，不一样的是他能够直接代理类（jdk动态代理不行，他必须目标业务类必须实现接口），CGLIB动态代理底层使用字节码技术，CGLIB动态代理不能对 final类进行继承。（CGLIB动态代理须要导入jar包）
代码演示：
package com.lijie;
//接口
public interface UserDao {
void save();
}
123456
package com.lijie;
//接口实现类
public class UserDaoImpl implements UserDao {
public void save() {
System.out.println("保存数据方法");
}
}
12345678
package com.lijie;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
//代理主要类
public class CglibProxy implements MethodInterceptor {
private Object targetObject;
// 这里的目标类型为Object，则能够接受任意一种参数做为被代理类，实现了动态代理
public Object getInstance(Object target) {
// 设置须要建立子类的类
this.targetObject = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(this);
return enhancer.create();
}
//代理实际方法
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("开启事物");
Object result = proxy.invoke(targetObject, args);
System.out.println("关闭事物");
// 返回代理对象
return result;
}
}
123456789101112131415161718192021222324252627282930
package com.lijie;
//测试CGLIB动态代理
public class Test {
public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy();
UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDaoImpl());
userDao.save();
}
}
建造者模式
1.什么是建造者模式
- 建造者模式：是将一个复杂的对象的构建与它的表示分离，使得一样的构建过程能够建立不一样的方式进行建立。
- 工厂类模式是提供的是建立单个类的产品
- 而建造者模式则是将各类产品集中起来进行管理，用来具备不一样的属性的产品
建造者模式一般包括下面几个角色：
- uilder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的建立，并不涉及具体的对象部件的建立。
- ConcreteBuilder：实现Builder接口，针对不一样的商业逻辑，具体化复杂对象的各部分的建立。 在建造过程完成后，提供产品的实例。
- Director：调用具体建造者来建立复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整建立或按某种顺序建立。
- Product：要建立的复杂对象。
2.建造者模式的使用场景
使用场景：
- 须要生成的对象具备复杂的内部结构。
- 须要生成的对象内部属性自己相互依赖。
- 与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。
- JAVA 中的 StringBuilder就是建造者模式建立的，他把一个单个字符的char数组组合起来
- Spring不是建造者模式，它提供的操做应该是对于字符串自己的一些操做，而不是建立或改变一个字符串。
3.代码案例
- 创建一个装备对象Arms
package com.lijie;
//装备类
public class Arms {
//头盔
private String helmet;
//铠甲
private String armor;
//武器
private String weapon;
//省略Git和Set方法...........
}
- 建立Builder接口（给出一个抽象接口，以规范产品对象的各个组成成分的建造，这个接口只是规范）
package com.lijie;
public interface PersonBuilder {
void builderHelmetMurder();
void builderArmorMurder();
void builderWeaponMurder();
void builderHelmetYanLong();
void builderArmorYanLong();
void builderWeaponYanLong();
Arms BuilderArms(); //组装
}
- 建立Builder实现类（这个类主要实现复杂对象建立的哪些部分须要什么属性）
package com.lijie;
public class ArmsBuilder implements PersonBuilder {
private Arms arms;
//建立一个Arms实例,用于调用set方法
public ArmsBuilder() {
arms = new Arms();
}
public void builderHelmetMurder() {
arms.setHelmet("夺命头盔");
}
public void builderArmorMurder() {
arms.setArmor("夺命铠甲");
}
public void builderWeaponMurder() {
arms.setWeapon("夺命宝刀");
}
public void builderHelmetYanLong() {
arms.setHelmet("炎龙头盔");
}
public void builderArmorYanLong() {
arms.setArmor("炎龙铠甲");
}
public void builderWeaponYanLong() {
arms.setWeapon("炎龙宝刀");
}
public Arms BuilderArms() {
return arms;
}
}
- Director（调用具体建造者来建立复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整建立或按某种顺序建立）
package com.lijie;
public class PersonDirector {
//组装
public Arms constructPerson(PersonBuilder pb) {
pb.builderHelmetYanLong();
pb.builderArmorMurder();
pb.builderWeaponMurder();
return pb.BuilderArms();
}
//这里进行测试
public static void main(String[] args) {
PersonDirector pb = new PersonDirector();
Arms arms = pb.constructPerson(new ArmsBuilder());
System.out.println(arms.getHelmet());
System.out.println(arms.getArmor());
System.out.println(arms.getWeapon());
}
}
模板方法模式
1.什么是模板方法
- 模板方法模式：定义一个操做中的算法骨架（父类），而将一些步骤延迟到子类中。
模板方法使得子类能够不改变一个算法的结构来重定义该算法的
2.何时使用模板方法
- 实现一些操做时，总体步骤很固定，可是呢。就是其中一小部分须要改变，这时候可使用模板方法模式，将容易变的部分抽象出来，供子类实现。
3.实际开发中应用场景哪里用到了模板方法
- 其实不少框架中都有用到了模板方法模式
- 例如：数据库访问的封装、Junit单元测试、servlet中关于doGet/doPost方法的调用等等
4.现实生活中的模板方法
例如：
- 去餐厅吃饭，餐厅给咱们提供了一个模板就是：看菜单，点菜，吃饭，付款，走人
（这里 “点菜和付款” 是不肯定的由子类来完成的，其余的则是一个模板。）
5.代码实现模板方法模式
- 先定义一个模板。把模板中的点菜和付款，让子类来实现。
package com.lijie;
//模板方法
public abstract class RestaurantTemplate {
// 1.看菜单
public void menu() {
System.out.println("看菜单");
}
// 2.点菜业务
abstract void spotMenu();
// 3.吃饭业务
public void havingDinner(){ System.out.println("吃饭"); }
// 3.付款业务
abstract void payment();
// 3.走人
public void GoR() { System.out.println("走人"); }
//模板通用结构
public void process(){
menu();
spotMenu();
havingDinner();
payment();
GoR();
}
}
- 具体的模板方法子类 1
package com.lijie;
public class RestaurantGinsengImpl extends RestaurantTemplate {
void spotMenu() {
System.out.println("人参");
}
void payment() {
System.out.println("5快");
}
}
- 具体的模板方法子类 2
package com.lijie;
public class RestaurantLobsterImpl extends RestaurantTemplate {
void spotMenu() {
System.out.println("龙虾");
}
void payment() {
System.out.println("50块");
}
}
- 客户端测试
package com.lijie;
public class Client {
public static void main(String[] args) {
//调用第一个模板实例
RestaurantTemplate restaurantTemplate = new RestaurantGinsengImpl();
restaurantTemplate.process();
}
}
外观模式
1.什么是外观模式
- 外观模式：也叫门面模式，隐藏系统的复杂性，并向客户端提供了一个客户端能够访问系统的接口。
- 它向现有的系统添加一个接口，用这一个接口来隐藏实际的系统的复杂性。
- 使用外观模式，他外部看起来就是一个接口，其实他的内部有不少复杂的接口已经被实现
2.外观模式例子
- 用户注册完以后，须要调用阿里短信接口、邮件接口、微信推送接口。
- 建立阿里短信接口
package com.lijie;
//阿里短信消息
public interface AliSmsService {
void sendSms();
}
123456
package com.lijie;
public class AliSmsServiceImpl implements AliSmsService {
public void sendSms() {
System.out.println("阿里短信消息");
}
}
- 建立邮件接口
package com.lijie;
//发送邮件消息
public interface EamilSmsService {
void sendSms();
}
123456
package com.lijie;
public class EamilSmsServiceImpl implements EamilSmsService{
public void sendSms() {
System.out.println("发送邮件消息");
}
}
- 建立微信推送接口
package com.lijie;
//微信消息推送
public interface WeiXinSmsService {
void sendSms();
}
123456
package com.lijie;
public class WeiXinSmsServiceImpl implements WeiXinSmsService {
public void sendSms() {
System.out.println("发送微信消息推送");
}
}
- 建立门面（门面看起来很简单使用，复杂的东西以及被门面给封装好了）
package com.lijie;
public class Computer {
AliSmsService aliSmsService;
EamilSmsService eamilSmsService;
WeiXinSmsService weiXinSmsService;
public Computer() {
aliSmsService = new AliSmsServiceImpl();
eamilSmsService = new EamilSmsServiceImpl();
weiXinSmsService = new WeiXinSmsServiceImpl();
}
//只须要调用它
public void sendMsg() {
aliSmsService.sendSms();
eamilSmsService.sendSms();
weiXinSmsService.sendSms();
}
}
- 启动测试
package com.lijie;
public class Client {
public static void main(String[] args) {
//普通模式须要这样
AliSmsService aliSmsService = new AliSmsServiceImpl();
EamilSmsService eamilSmsService = new EamilSmsServiceImpl();
WeiXinSmsService weiXinSmsService = new WeiXinSmsServiceImpl();
aliSmsService.sendSms();
eamilSmsService.sendSms();
weiXinSmsService.sendSms();
//利用外观模式简化方法
new Computer().sendMsg();
}
}
原型模式
1.什么是原型模式
- 原型设计模式简单来讲就是克隆
- 原型代表了有一个样板实例，这个原型是可定制的。原型模式多用于建立复杂的或者构造耗时的实例，由于这种状况下，复制一个已经存在的实例可以使程序运行更高效。
2.原型模式的应用场景
- 类初始化须要消化很是多的资源，这个资源包括数据、硬件资源等。这时咱们就能够经过原型拷贝避免这些消耗。
- 经过new产生的一个对象须要很是繁琐的数据准备或者权限，这时可使用原型模式。
- 一个对象须要提供给其余对象访问，并且各个调用者可能都须要修改其值时，能够考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。
咱们Spring框架中的多例就是使用原型。
3.原型模式的使用方式
- 实现Cloneable接口。在java语言有一个Cloneable接口，它的做用只有一个，就是在运行时通知虚拟机能够安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才能够被拷贝，不然在运行时会抛出CloneNotSupportedException异常。
- 重写Object类中的clone方法。Java中，全部类的父类都是Object类，Object类中有一个clone方法，做用是返回对象的一个拷贝，可是其做用域protected类型的，通常的类没法调用，所以Prototype类须要将clone方法的做用域修改成public类型。
3.1原型模式分为浅复制和深复制
- （浅复制）只是拷贝了基本类型的数据，而引用类型数据，只是拷贝了一份引用地址。
- （深复制）在计算机中开辟了一块新的内存地址用于存放复制的对象。
4.代码演示
- 建立User类
package com.lijie;
import java.util.ArrayList;
public class User implements Cloneable {
private String name;
private String password;
private ArrayList<String> phones;
protected User clone() {
try {
User user = (User) super.clone();
//重点，若是要连带引用类型一块儿复制，须要添加底下一条代码，若是不加就对因而复制了引用地址
user.phones = (ArrayList<String>) this.phones.clone();//设置深复制
return user;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
//省略全部属性Git Set方法......
}
- 测试复制
package com.lijie;
import java.util.ArrayList;
public class Client {
public static void main(String[] args) {
//建立User原型对象
User user = new User();
user.setName("李三");
user.setPassword("123456");
ArrayList<String> phones = new ArrayList<>();
phones.add("17674553302");
user.setPhones(phones);
//copy一个user对象,而且对象的属性
User user2 = user.clone();
user2.setPassword("654321");
//查看俩个对象是不是一个
System.out.println(user == user2);
//查看属性内容
System.out.println(user.getName() + " | " + user2.getName());
System.out.println(user.getPassword() + " | " + user2.getPassword());
//查看对于引用类型拷贝
System.out.println(user.getPhones() == user2.getPhones());
}
}
- 若是不须要深复制，须要删除User 中的
//默认引用类型为浅复制，这是设置了深复制 user.phones = (ArrayList<String>) this.phones.clone();
策略模式
1.什么是策略模式
- 定义了一系列的算法 或 逻辑 或 相赞成义的操做，并将每个算法、逻辑、操做封装起来，并且使它们还能够相互替换。（其实策略模式Java中用的很是很是普遍）
- 我以为主要是为了 简化 if…else 所带来的复杂和难以维护。
2.策略模式应用场景
- 策略模式的用意是针对一组算法或逻辑，将每个算法或逻辑封装到具备共同接口的独立的类中，从而使得它们之间能够相互替换。
- 例如：我要作一个不一样会员打折力度不一样的三种策略，初级会员，中级会员，高级会员（三种不一样的计算）。
- 例如：我要一个支付模块，我要有微信支付、支付宝支付、银联支付等
3.策略模式的优势和缺点
- 优势： 一、算法能够自由切换。 二、避免使用多重条件判断。 三、扩展性很是良好。
- 缺点： 一、策略类会增多。 二、全部策略类都须要对外暴露。
4.代码演示
- 模拟支付模块有微信支付、支付宝支付、银联支付
- 定义抽象的公共方法
package com.lijie;
//策略模式 定义抽象方法 全部支持公共接口
abstract class PayStrategy {
// 支付逻辑方法
abstract void algorithmInterface();
}
- 定义实现微信支付
package com.lijie;
class PayStrategyA extends PayStrategy {
void algorithmInterface() {
System.out.println("微信支付");
}
}
- 定义实现支付宝支付
package com.lijie;
class PayStrategyB extends PayStrategy {
void algorithmInterface() {
System.out.println("支付宝支付");
}
}
- 定义实现银联支付
package com.lijie;
class PayStrategyC extends PayStrategy {
void algorithmInterface() {
System.out.println("银联支付");
}
}
- 定义下文维护算法策略
package com.lijie;// 使用上下文维护算法策略
class Context {
PayStrategy strategy;
public Context(PayStrategy strategy) {
this.strategy = strategy;
}
public void algorithmInterface() {
strategy.algorithmInterface();
}
}
- 运行测试
package com.lijie;
class ClientTestStrategy {
public static void main(String[] args) {
Context context;
//使用支付逻辑A
context = new Context(new PayStrategyA());
context.algorithmInterface();
//使用支付逻辑B
context = new Context(new PayStrategyB());
context.algorithmInterface();
//使用支付逻辑C
context = new Context(new PayStrategyC());
context.algorithmInterface();
}
}
观察者模式
1.什么是观察者模式
- 先讲什么是行为性模型，行为型模式关注的是系统中对象之间的相互交互，解决系统在运行时对象之间的相互通讯和协做，进一步明确对象的职责。
- 观察者模式，是一种行为性模型，又叫发布-订阅模式，他定义对象之间一种一对多的依赖关系，使得当一个对象改变状态，则全部依赖于它的对象都会获得通知并自动更新。
2.模式的职责
- 观察者模式主要用于1对N的通知。当一个对象的状态变化时，他须要及时告知一系列对象，令他们作出相应。
实现有两种方式：
- 推：每次都会把通知以广播的方式发送给全部观察者，全部的观察者只能被动接收。
- 拉：观察者只要知道有状况便可，至于何时获取内容，获取什么内容，均可以自主决定。
3.观察者模式应用场景
- 关联行为场景，须要注意的是，关联行为是可拆分的，而不是“组合”关系。事件多级触发场景。
- 跨系统的消息交换场景，如消息队列、事件总线的处理机制。
4.代码实现观察者模式
- 定义抽象观察者，每个实现该接口的实现类都是具体观察者。
package com.lijie;
//观察者的接口，用来存放观察者共有方法
public interface Observer {
// 观察者方法
void update(int state);
}
- 定义具体观察者
package com.lijie;
// 具体观察者
public class ObserverImpl implements Observer {
// 具体观察者的属性
private int myState;
public void update(int state) {
myState=state;
System.out.println("收到消息,myState值改成："+state);
}
public int getMyState() {
return myState;
}
}
- 定义主题。主题定义观察者数组，并实现增、删及通知操做。
package com.lijie;
import java.util.Vector;
//定义主题，以及定义观察者数组，并实现增、删及通知操做。
public class Subjecct {
//观察者的存储集合，不推荐ArrayList，线程不安全，
private Vector<Observer> list = new Vector<>();
// 注册观察者方法
public void registerObserver(Observer obs) {
list.add(obs);
}
// 删除观察者方法
public void removeObserver(Observer obs) {
list.remove(obs);
}
// 通知全部的观察者更新
public void notifyAllObserver(int state) {
for (Observer observer : list) {
observer.update(state);
}
}
}
- 定义具体的，他继承继承Subject类，在这里实现具体业务，在具体项目中，该类会有不少。
package com.lijie;
//具体主题
public class RealObserver extends Subjecct {
//被观察对象的属性
private int state;
public int getState(){
return state;
}
public void setState(int state){
this.state=state;
//主题对象(目标对象)值发生改变
this.notifyAllObserver(state);
}
}
- 运行测试
package com.lijie;
public class Client {
public static void main(String[] args) {
// 目标对象
RealObserver subject = new RealObserver();
// 建立多个观察者
ObserverImpl obs1 = new ObserverImpl();
ObserverImpl obs2 = new ObserverImpl();
ObserverImpl obs3 = new ObserverImpl();
// 注册到观察队列中
subject.registerObserver(obs1);
subject.registerObserver(obs2);
subject.registerObserver(obs3);
// 改变State状态
subject.setState(300);
System.out.println("obs1观察者的MyState状态值为："+obs1.getMyState());
System.out.println("obs2观察者的MyState状态值为："+obs2.getMyState());
System.out.println("obs3观察者的MyState状态值为："+obs3.getMyState());
// 改变State状态
subject.setState(400);
System.out.println("obs1观察者的MyState状态值为："+obs1.getMyState());
System.out.println("obs2观察者的MyState状态值为："+obs2.getMyState());
System.out.println("obs3观察者的MyState状态值为："+obs3.getMyState());
}
}
相关文章
- 1. JVM面试题（史上最强、持续更新、吐血推荐）
- 2. 多线程面试题（史上最全、持续更新、吐血推荐）
- 3. 网络协议面试题（史上最全、持续更新、吐血推荐）
- 4. Java基础面试题（史上最全、持续更新、吐血推荐）
- 5. Java算法面试题（史上最强、持续更新、吐血推荐）
- 6. 消息队列面试题、RabbitMQ面试题、Kafka面试题、RocketMQ面试题 （史上最全、持续更新、吐血推荐）
- 7. 史上最全的Java面试题汇总，持续更新...
- 8. 2019 CSS经典面试题（史上最全，持续更新中...）
- 9. 史上最全的spark面试题——持续更新中
- 10. SpringBoot面试题 (史上最全，持续更新....)
- 更多相关文章...
- • ADO 更新记录 - ADO 教程
- • Web 创建设计 - 网站建设指南
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • 委托模式
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. JVM面试题（史上最强、持续更新、吐血推荐）
- 2. 多线程面试题（史上最全、持续更新、吐血推荐）
- 3. 网络协议面试题（史上最全、持续更新、吐血推荐）
- 4. Java基础面试题（史上最全、持续更新、吐血推荐）
- 5. Java算法面试题（史上最强、持续更新、吐血推荐）
- 6. 消息队列面试题、RabbitMQ面试题、Kafka面试题、RocketMQ面试题 （史上最全、持续更新、吐血推荐）
- 7. 史上最全的Java面试题汇总，持续更新...
- 8. 2019 CSS经典面试题（史上最全，持续更新中...）
- 9. 史上最全的spark面试题——持续更新中
- 10. SpringBoot面试题 (史上最全，持续更新....)