Java中设计模式的高频面试考点

最新推荐文章于 2026-06-14 00:27:39 发布

原创最新推荐文章于 2026-06-14 00:27:39 发布 · 360 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

java 专栏收录该内容

4 篇文章

订阅专栏

本文介绍了Java中常见的六种设计模式：单例模式、观察者模式、装饰者模式、适配器模式、工厂模式和代理模式。通过实例代码详细解释了每种模式的概念和使用场景，帮助读者理解和掌握这些设计模式。

设计模式分类曲线图
在这里插入图片描述

接下来介绍图中常用的几种设计模式：

1单例模式
在一个应用程序中，某个类的实例对象只有一个，因为构造器是被private修饰的，所以无法直接去new对象，一般通过getInstance()的方法来获取它们的实例。getInstance()的返回值是一个对象的引用。对应的demo如下：

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

常见的单例模式有懒汉式写法和饿汉式写法
懒汉式写法(对应的代码如下)

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

饿汉式写法(对应的代码如下)

public class Singleton {     
private static Singleton instance = new Singleton();     
private Singleton (){}     
public static  Singleton getInstance() {    
    return instance;     
}  
}

2 观察者模式

指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。对应的demo如下：

//被观察者接口
public interface Observable {
//添加一个观察者
public void addObserver(Observer observer);
//删除一个观察者
public void deleteObserver(Observer observer);
//当被观察者有所行动的是，通知观察者
public void notifyObserver(String context);
}
public interface IStar {
//明星也要吃饭啊
public void eat();
//明星的行动
public void action();
}
public class ZhaoLiYing implements IStar,Observable{
private ArrayList<Observer> observerList=new ArrayList<>();
@Override
public void eat() {
System.out.println("颖宝吃饭ing......");
this.notifyObserver("颖宝开始吃饭了！！！");
}
@Override
public void action() {
System.out.println("颖宝电视剧宣传中......");
this.notifyObserver("赵丽颖宣传电视剧！！！");
}
@Override
public void addObserver(Observer observer) {
this.observerList.add(observer);
}
@Override
public void deleteObserver(Observer observer) {
this.observerList.remove(observer);
 }
@Override
public void notifyObserver(String context) {
for (Observer observer : observerList) {
observer.update(context);
}
}
}
//观察者接口
public interface Observer {
//一旦发现别人有动静，自己就行动
void update(String context);
}
//具体观察者：粉丝
public class Fans implements Observer{
@Override
public void update(String context) {
System.out.println("粉丝：观察到明星活动");
this.action(context);
}
private void action(String context){
System.out.println(context+"----> 好可爱啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊......");
}
}
//具体的观察者：记者
public class Reportor implements Observer{
@Override
public void update(String context) {
System.out.println("记者：观察到明星活动");
this.action(context);
}
private void action(String context){
System.out.println(context+"----> 演技高，敬业......");
}
}
//具体观察者：淘宝店主
public class TaobaoShop implements Observer {
@Override
public void update(String context) {
System.out.println("淘宝店主：观察到明星活动");
this.action(context);
}
private void action(String context){
System.out.println(context+"----> 同款商品准备上架......");
}
}
public class Client {
public static void main(String[] args) {
Observer fan=new Fans();
Observer reportor=new Reportor();
Observer shop=new TaobaoShop();
//定义被观察者
  ZhaoLiYing zhao=new ZhaoLiYing();
//三个观察者都在观察着赵丽颖
  zhao.addObserver(fan);
  zhao.addObserver(reportor);
  zhao.addObserver(shop);
//赵丽颖行动
  zhao.eat();
  zhao.action();
}
}

3 装饰者模式
顾名思义，该模式指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。接下来以一个具体的demo进行讲解。汉堡就是由面包+沙拉酱+生菜+鸡排组成，具体的代码如下：

 class Food {

    private String food_name;

    public Food() {
    }

    public Food(String food_name) {
        this.food_name = food_name;
    }

    public String make() {
        return food_name;
    }
}

//面包类
 class Bread extends Food {

    private Food basic_food;

    public Bread(Food basic_food) {
        this.basic_food = basic_food;
    }

    public String make() {
        return basic_food.make()+"+面包";
    }
}

//奶油类
 class Cream extends Food {

    private Food basic_food;

    public Cream(Food basic_food) {
        this.basic_food = basic_food;
    }

    public String make() {
        return basic_food.make()+"+沙拉";
    }
}

//蔬菜类
class Vegetable extends Food {

    private Food basic_food;

    public Vegetable(Food basic_food) {
        this.basic_food = basic_food;
    }

    public String make() {
        return basic_food.make()+"+生菜";
    }

}
//应用场景测试类
public class Test {
    public static void main(String[] args) {
        Food food = new Bread(new Vegetable(new Cream(new Food("鸡排"))));
        System.out.println(food.make());
    }
}

4 适配器模式

该模式就是将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。接下来以生活中常见的手机充电器为例，手机充电的电压为5V，但是正常的供电电压为220V。这时候需要一个变压器将220V的电压转化为5V的电压。变压器的角色相当于一个适配器。具体的demo如下：

class   Phone{
    public static final int V=220;
    private VoltageAdapter adapter;
    public void charge(){
        adapter.changeVoltage();
    }
    public void setAdapter(VoltageAdapter adapter){
        this.adapter =adapter;
    }
}

class VoltageAdapter{
    public void changeVoltage(){
        System.out.println("正在充电...");
        System.out.println("原始电压"+Phone.V+"V");
        System.out.println("经过变压器转换之后的电压为"+(Phone.V-215)+"V");
    }
}

public class Test{
    public static void main(String[] args) {
        Phone phone = new Phone();
        VoltageAdapter adapter = new VoltageAdapter();
        phone.setAdapter(adapter);
        phone.charge();
    }
}

5 工厂模式

该模式定义一个用户创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。工厂方法模式的主要角色如下：

1）. 抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
2）具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
3）. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
4）. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
接下来通过一个具体的demo来深刻理解该模式，疫情期间大家不能出门，于是乎很多人在家学习制作面包。由于是新手的原因，不能很好掌握烘焙的时间，可能烤出来的面包会不同。根据时间长短分为北极熊面包，布朗熊面包，黑熊面包。创建一个面包接口和抽象面包工厂接口，之后建立黑熊面包，布朗熊面包以及北极熊面包，面包工厂的实现类，最后创建应用场景测试类。具体代码如下：

面包接口和抽象面包工厂接口

package com.factory;

public interface Bread{
    void getColor();

}

package com.factory;

public interface AbstractBreadFactory {
    public abstract Bread createBread(Class cls);
}

黑熊面包，布朗熊面包以及北极熊面包，面包工厂的实现类

package com.factory;

public class BlackBearBread implements Bread{
    @Override
    public void getColor() {
        System.out.println("烤的时间有点长------黑熊面包");
    }
}

package com.factory;

public class BrownBearBread implements Bread{
    @Override
    public void getColor() {
        System.out.println("烤的时间刚刚好------布朗熊面包");
    }
}

package com.factory;

public class PolorBearBread implements Bread{
    @Override
    public void getColor() {
        System.out.println("烤的时间有点短-------北极熊面包");
    }
}

package com.factory;

public class BreadFactory implements AbstractBreadFactory {
    @Override
    public Bread createBread(Class cls) {
        Bread bread = null;
        try {
            bread = (Bread)Class.forName(cls.getName()).newInstance();

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("出错啦");
        }
        return bread;
    }
}

创建应用场景测试类

package com.factory;

public class Chef {
    public static void main(String[] args) {
        AbstractBreadFactory kitty = new  BreadFactory();
        System.out.println("----------大厨第一次烤面包--------");
        Bread polorBearBread = kitty.createBread(PolorBearBread.class);
        polorBearBread.getColor();


        System.out.println("---------大厨第二次烤面包--------");
        Bread blackBearBread = kitty.createBread(BlackBearBread.class);
        blackBearBread.getColor();

        System.out.println("--------大厨第三次烤面包--------");
        Bread brownBearBread = kitty.createBread(BrownBearBread.class);
        brownBearBread.getColor();
    }
}

抽象工厂（AbstractFactory）模式的定义：为创建一组相关或者相互依赖的对象提供一个接口，而且无须指定他们的具体类。

6 代理模式
定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

public interface MakeUp {   
 int getPrice();    
 String getDescription();
 }
 public class WangJie implements MakeUp{    
 @Override   
  public int getPrice() {        
  //化妆品100块一个        
  return 100;    
  }
    @Override   
   public String getDescription() {       
      return "化妆品很好用";    
   }
}
public class XiaoMeiProxy implements MakeUp{    
private WangJie wangjie = new WangJie();
    @Override    
    public int getPrice() {        //每个化妆品多赚100块              
    return wangjie.getPrice()+100;    
    }
    @Override    
    public String getDescription() {        
    StringBuilder d = new StringBuilder();        
    d.append("我最近发现了一款新的化妆品\n");            
    d.append(wangjie.getDescription());        
    d.append("\n用了感觉美美哒\n");        
    return d.toString();    
    }
}
public class Test {   
 public static void main(String[] args) {        
  XiaoMeiProxy x = new XiaoMeiProxy();       
  int price = x.getPrice();        
  String d = x.getDescription();          
  System.out.println(price);        
  System.out.println(d);    
 }
}