十、设计模式与重构
1.你能举例几个常见的设计模式
1)单例模式 (Spring Bean)
2)抽象工厂模式和工厂模式 (BeanFactory)
3)适配器模式 (Android 中的View Adapter)
4)装饰模式 (java io 中 InputStream/OutputStream/Reader/Writer)
5)观察者模式
6)外观模式
7)代理模式(java动态代理)
2.你在设计一个工厂的包的时候会遵循哪些原则？
3.你能列举一个使用了Visitor/Decorator模式的开源项目/库吗？
4.你在编码时最常用的设计模式有哪些？在什么场景下用？
5.如何实现一个单例？
//饿汉式单例(Eager initialization) 。缺点：没有真正的lazy loading.
public static class EagerInitializationSingleton {
//1.将构造方法私有化，不允许外部直接创建对象
private EagerInitializationSingleton() {
}
//2.创建类的唯一实例，使用private static修饰
private static EagerInitializationSingleton instance = new EagerInitializationSingleton();
//3.提供一个用于获取实例的方法，使用public static修饰
public static EagerInitializationSingleton getInstance() {
return instance;
}
}
/*
* 懒汉模式
* 区别：饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快，线程安全
* 懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全
*/
public static class LazyInitializationSingleton {
//1.将构造方式私有化，不允许外边直接创建对象
private LazyInitializationSingleton() {
}
//2.声明类的唯一实例，使用private static修饰
private static LazyInitializationSingleton instance;
//3.提供一个用于获取实例的方法，使用public static修饰
public static LazyInitializationSingleton getInstance() {
if (instance == null) {
instance = new LazyInitializationSingleton();
}
return instance;
}
}
/*
* 懒汉模式 线程安全写法
* 99%的时间需要同步，效率非常低下
*/
public static class LazyInitialization2Singleton {
private static volatile LazyInitialization2Singleton instance;
private LazyInitialization2Singleton() {
}
public static synchronized LazyInitialization2Singleton getInstance() {
if (instance == null) {
instance = new LazyInitialization2Singleton();
}
return instance;
}
}
/*
* 懒汉模式 双重检查（Double-Check）版本
* volatile为了解决 原子操作 指令重排 会出问题的。
*/
public static class LazyInitialization3Singleton {
private static volatile LazyInitialization3Singleton instance;
private LazyInitialization3Singleton() {
}
public static LazyInitialization3Singleton getInstance() {
if (instance == null) {
synchronized (LazyInitialization3Singleton.class) {
if (instance == null) {
instance = new LazyInitialization3Singleton();
}
}
}
return instance;
}
}
// Effective Java 第一版推荐写法
public static class EffectiveJava1Singleton {
private static class SingletonHolder {
private static final EffectiveJava1Singleton INSTANCE = new EffectiveJava1Singleton();
}
private EffectiveJava1Singleton() {
}
public static final EffectiveJava1Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
// Effective Java 第二版推荐写法
// 使用
//EffectiveJava2Singleton.INSTANCE.fun1();
public enum EffectiveJava2Singleton {
INSTANCE;
public void fun1() {
// do something
}
}
6.代理模式（动态代理）
public interface UserService {
public String getName(int id);
public Integer getAge(int id);
}
public class UserServiceImpl implements UserService {
@Override
public String getName(int id) {
System.out.println("------getName------");
return "Tom";
}
@Override
public Integer getAge(int id) {
System.out.println("------getAge------");
return 10;
}
}
public class MyInvocationHandler implements InvocationHandler {
private Object target;
MyInvocationHandler() {
super();
}
MyInvocationHandler(Object target) {
super();
this.target = target;
}
@Override
public Object invoke(Object o, Method method, Object[] args) throws Throwable {
if("getName".equals(method.getName())){
System.out.println("++++++before " + method.getName() + "++++++");
Object result = method.invoke(target, args);
System.out.println("++++++after " + method.getName() + "++++++");
return result;
}else{
Object result = method.invoke(target, args);
return result;
}
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Main1 {
public static void main(String[] args) {
UserService userService = new UserServiceImpl();
InvocationHandler invocationHandler = new MyInvocationHandler(userService);
UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),
userService.getClass().getInterfaces(), invocationHandler);
System.out.println(userServiceProxy.getName(1));
System.out.println(userServiceProxy.getAge(1));
}
}
7.单例模式（懒汉模式，并发初始化如何解决，volatile与lock的使用）
8.JDK源码里面都有些什么让你印象深刻的设计模式使用，举例看看？
目录列表
一、数据结构与算法基础
二、Java基础
三、JVM
四、多线程/并发
五、Linux使用与问题分析排查
六、框架使用
七、数据库相关
八、网络协议和网络编程
九、Redis等缓存系统/中间件/NoSQL/一致性Hash等
十、设计模式与重构
本文是针对知乎文章《成为Java顶尖程序员，先过了下面问题》的解答
