Java面试题--设计模式

一、Java 中有几种设计模式？

Java 中一般认为有 23 种设计模式

分为三大类：

1. 创建型模式 5 种

① 工厂方法模式

② 抽象工厂模式

③ 单例模式

④ 建造者模式

⑤ 原型模式

2. 结构型模式 7 种

① 适配器模式

② 装饰器模式

③ 代理模式

④ 外观模式

⑤ 桥接模式

⑥ 组合模式

⑦ 享元模式

3. 行为型模式 11 种

① 策略模式

② 模板方法模式

③ 观察者模式

④ 迭代子模式

⑤ 责任链模式

⑥ 命令模式

⑦ 备忘录模式

⑧ 状态模式

⑨ 访问者模式

⑩ 中介者模式

⑪ 解释器模式

 二、什么是单例设计模式？

1. 单例模式定义

单例模式确保某个类只有一个实例，而

且自行实例化并向整个系统提供这个实

例

在计算机系统中，线程池、缓存、日志

对象、对话框、打印机、显卡的驱动程

序对象常被设计成单例，选择单例模式

就是为了避免不一致状态

2. 单例模式的特点

① 单例类只能有一个实例

② 单例类必须自己创建自己的唯一实例

③ 单例类必须给所有其他对象提供这一

    实例

④ 单例模式保证了全局对象的唯一性，

    比如系统启动读取配置文件就需要单

    例保证配置的一致性

3. 单例的四大原则

① 构造器私有化

② 以静态方法或者枚举返回实例

③ 确保实例只有一个，尤其是多线程

    环境

④ 确保反序列化时不会重新构建对象

4.  实现单例模式的方式

(1) 饿汉式 (立即加载)：

饿汉式单例在类加载初始化时就创建好

一个静态的对象供外部使用，除非系统

重启，这个对象不会改变，所以本身就

是线程安全的

Singleton 通过将构造方法限定为 private

避免了类在外部被实例化，在同一个虚拟

机范围内，Singleton 的唯一实例只能通

过 getInstance() 方法访问 (事实上，通过

Java 反射机制是能够实例化构造方法为

private 的类的，会使 Java 单例实现失效）

/*** 饿汉式（立即加载）*/
public class Singleton1 {/*** 私有构造*/private Singleton1() {System.out.println("构造函数Singleton1");}/*** 初始值为实例对象*/private static Singleton1 single = new Singleton1();/*** 静态工厂方法* @return 单例对象*/public static Singleton1 getInstance() {System.out.println("getInstance");return single;}public static void main(String[] args){System.out.println("初始化");Singleton1 instance = Singleton1.getInstance();}
}

(2) 懒汉式 (延迟加载)：

该示例虽然用延迟加载方式实现了懒汉

式单例，但在多线程环境下会产生多个

Singleton 对象

/*** 懒汉式（延迟加载）*/
public class Singleton2 {/*** 私有构造*/private Singleton2() {System.out.println("构造函数Singleton2");}/*** 初始值为null*/private static Singleton2 single = null;/*** 静态工厂方法* @return 单例对象*/public static Singleton2 getInstance() {if(single == null){System.out.println("getInstance");single = new Singleton2();}return single;}public static void main(String[] args){System.out.println("初始化");Singleton2 instance = Singleton2.getInstance();}
}

(3) 同步锁 (解决线程安全问题)：

在方法上加 synchronized 同步锁或是

用同步代码块对类加同步锁，此种方

式虽然解决了多个实例对象问题，但

是该方式运行效率却很低下，下一个

线程想要获取对象，就必须等待上一

个线程释放锁之后，才可以继续运行

/**** 同步锁（解决线程安全问题）*/
public class Singleton3 {/*** 私有构造*/private Singleton3() {}/*** 初始值为null*/private static Singleton3 single = null;public static Singleton3 getInstance() {// 等同于 synchronized public static Singleton3 getInstance()synchronized(Singleton3.class){// 注意：里面的判断是一定要加的，否则出现线程安全问题if(single == null){single = new Singleton3();}}return single;}
}

(4) 双重检查锁 (提高同步锁的效率)：

使用双重检查锁进一步做了优化，可

以避免整个方法被锁，只对需要锁的

代码部分加锁，可以提高执行效率

/*** 双重检查锁（提高同步锁的效率）*/
public class Singleton4 {/*** 私有构造*/private Singleton4() {}/*** 初始值为null*/private static Singleton4 single = null;/*** 双重检查锁* @return 单例对象*/public static Singleton4 getInstance() {if (single == null) {synchronized (Singleton4.class) {if (single == null) {single = new Singleton4();}}}return single;}
}

(5) 静态内部类：

引入了一个内部静态类 (static class)，静

态内部类只有在调用时才会加载，它保证

了 Singleton 实例的延迟初始化，又保证

了实例的唯一性

它把 singleton 的实例化操作放到一个静

态内部类中，在第一次调用 getInstance()

方法时，JVM 才会去加载 InnerObject 类，

同时初始化 singleton 实例，所以能让

getInstance() 方法线程安全

   特点：即能延迟加载，也能保证线程安全

静态内部类虽然保证了单例在多线程并发

下的线程安全性，但是在遇到序列化对象

时，默认的方式运行得到的结果就是多例

的

/**** 静态内部类（延迟加载，线程安全）*/
public class Singleton5 {/*** 私有构造*/private Singleton5() {}/*** 静态内部类*/private static class InnerObject{private static Singleton5 single = new Singleton5();}public static Singleton5 getInstance() {return InnerObject.single;}
}

(6) 内部枚举类实现 (防止反射攻击)：

事实上，通过 Java 反射机制是能够实例

化构造方法为 private 的类的，这也就是

我们现在需要引入的枚举单例模式

public class SingletonFactory {/*** 内部枚举类*/private enum EnumSingleton{Singleton;private Singleton6 singleton;//枚举类的构造方法在类加载是被实例化private EnumSingleton(){singleton = new Singleton6();}public Singleton6 getInstance(){return singleton;}}public static Singleton6 getInstance() {return EnumSingleton.Singleton.getInstance();}
}class Singleton6 {public Singleton6(){}
}

三、什么是工厂设计模式？

工厂设计模式就是用来生产对象的，在

java 中，万物皆对象，这些对象都需要

创建，如果创建的时候直接 new 该对象，

就会对该对象耦合严重，假如我们要更

换对象，所有 new 对象的地方都需要修

改一遍，这显然违背了软件设计的开闭

原则，如果我们使用工厂来生产对象，

我们就只和工厂打交道就可以了，彻底

和对象解耦，如果要更换对象，直接在

工厂里更换该对象即可，达到了与对象

解耦的目的；所以说，工厂模式最大的

优点就是：解耦

1. 简单工厂 (Simple Factory)

定义：

一个工厂方法，依据传入的参数，生成对

应的产品对象；

角色：

① 抽象产品
② 具体产品
③ 具体工厂
④ 产品使用者

使用说明：

先将产品类抽象出来，比如，苹果和梨都属

于水果，抽象出来一个水果类 Fruit，苹果和

梨就是具体的产品类，然后创建一个水果工

厂，分别用来创建苹果和梨

代码如下：

// 水果接口：
public interface Fruit {void whatIm();
}// 苹果类：
public class Apple implements Fruit {@Overridepublic void whatIm() {System.out.println("苹果");}
}// 梨类：
public class Pear implements Fruit {@Overridepublic void whatIm() {System.out.println("梨");}
}//水果工厂：public class FruitFactory {public Fruit createFruit(String type) {if (type.equals("apple")) {//生产苹果return new Apple();} else if (type.equals("pear")) {//生产梨return new Pear();}return null;}
}// 使用工厂生产产品：
public class FruitApp {public static void main(String[] args) {FruitFactory mFactory = new FruitFactory();Apple apple = (Apple) mFactory.createFruit("apple");//获得苹果Pear pear = (Pear) mFactory.createFruit("pear");//获得梨apple.whatIm();pear.whatIm();}
}

以上的这种方式，每当添加一种水果，就必

然要修改工厂类，违反了开闭原则；

所以简单工厂只适合于产品对象较少，且产

品固定的需求，对于产品变化无常的需求来

说显然不合适

2. 工厂方法 (Factory Method)

定义：

将工厂提取成一个接口或抽象类，具体生

产什么产品由子类决定；

角色：

① 抽象产品
② 具体产品
③ 抽象工厂
④ 具体工厂

使用说明：

和上例中一样，产品类抽象出来，这次我们

把工厂类也抽象出来，生产什么样的产品由

子类来决定

代码如下：

// 水果接口、苹果类和梨类：代码和上例一样// 抽象工厂接口：
public interface FruitFactory {Fruit createFruit();//生产水果
}// 苹果工厂：
public class AppleFactory implements FruitFactory {@Overridepublic Apple createFruit() {return new Apple();}
}// 梨工厂：
public class PearFactory implements FruitFactory {@Overridepublic Pear createFruit() {return new Pear();}
}// 使用工厂生产产品：
public class FruitApp {public static void main(String[] args){AppleFactory appleFactory = new AppleFactory();PearFactory pearFactory = new PearFactory();Apple apple = appleFactory.createFruit();//获得苹果Pear pear = pearFactory.createFruit();//获得梨apple.whatIm();pear.whatIm();}
}

以上这种方式，虽然解耦了，也遵循了开闭

原则，但是如果我需要的产品很多的话，需

要创建非常多的工厂，所以这种方式的缺点

也很明显

3. 抽象工厂 (Abstract Factory)

定义：

为创建一组相关或者是相互依赖的对象提供

的一个接口，而不需要指定它们的具体类

角色：

① 抽象产品
② 具体产品

③ 抽象工厂

④ 具体工厂

使用说明：

抽象工厂和工厂方法的模式基本一样，区别

在于，工厂方法是生产一个具体的产品，而

抽象工厂可以用来生产一组相同，有相对关

系的产品

用抽象工厂来实现：

// cpu接口和实现类：
public interface Cpu {void run();class Cpu650 implements Cpu {@Overridepublic void run() {System.out.println("650 也厉害");}}class Cpu825 implements Cpu {@Overridepublic void run() {System.out.println("825 更强劲");}}
}// 屏幕接口和实现类：
public interface Screen {void size();class Screen5 implements Screen {@Overridepublic void size() {System.out.println("" + "5寸");}}class Screen6 implements Screen {@Overridepublic void size() {System.out.println("6寸");}}
}// 抽象工厂接口：
public interface PhoneFactory {Cpu getCpu();//使用的cpuScreen getScreen();//使用的屏幕
}// 小米手机工厂：
public class XiaoMiFactory implements PhoneFactory {@Overridepublic Cpu.Cpu825 getCpu() {return new Cpu.Cpu825();//高性能处理器}@Overridepublic Screen.Screen6 getScreen() {return new Screen.Screen6();//6寸大屏}
}//红米手机工厂：
public class HongMiFactory implements PhoneFactory {@Overridepublic Cpu.Cpu650 getCpu() {return new Cpu.Cpu650();//高效处理器}@Overridepublic Screen.Screen5 getScreen() {return new Screen.Screen5();//小屏手机}
}// 使用工厂生产产品：
public class PhoneApp {public static void main(String[] args){HongMiFactory hongMiFactory = new HongMiFactory();XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();Cpu.Cpu650 cpu650 = hongMiFactory.getCpu();Cpu.Cpu825 cpu825 = xiaoMiFactory.getCpu();cpu650.run();cpu825.run();Screen.Screen5 screen5 = hongMiFactory.getScreen();Screen.Screen6 screen6 = xiaoMiFactory.getScreen();screen5.size();screen6.size();}
}

以上例子可以看出，抽象工厂可以解决一

系列的产品生产的需求，对于大批量，多

系列的产品，用抽象工厂可以更好地管理

和扩展

4. 三种工厂方式总结

① 对于简单工厂和工厂方法来说，两者的

    使用方式实际上是一样的，如果对于产

    品的分类和名称是确定的，数量是相对

    固定的，推荐使用简单工厂模式；

② 抽象工厂用来解决相对复杂的问题，适用于

    一系列、大批量的对象生产