Java八股文(设计模式)

Java八股文の设计模式

  • 设计模式

设计模式

  1. 什么是设计模式?请列举一些常见的设计模式。

设计模式是软件设计中常用的一种思维模式,它描述了一类具有相似特征和解决思路的问题。
常见的设计模式包括单例模式、工厂模式、观察者模式、装饰器模式等。

  1. 请解释什么是单例模式,并提供一个线程安全的单例实现。

单例模式是一种常见的创建型模式,它确保一个类只有一个实例,并提供一个全局访问点。
以下是一个线程安全的懒汉式单例实现:

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
  1. 什么是工厂模式?请列举工厂模式的几种变体。

工厂模式是一种常见的创建型模式,它将对象的创建和使用分离。
常见的工厂模式包括简单工厂模式、工厂方法模式和抽象工厂模式。

  1. 请解释什么是装饰器模式,并提供一个示例。

装饰器模式是一种结构型模式,它允许用户在不修改原始对象的情况下,以动态方式扩展其功能。
以下是一个装饰器模式的示例:

interface Shape {
    void draw();
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing circle.");
    }
}

class ShapeDecorator implements Shape {
    protected Shape decoratedShape;

    public ShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }

    @Override
    public void draw() {
        decoratedShape.draw();
    }
}

class RedShapeDecorator extends ShapeDecorator {
    public RedShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }

    @Override
    public void draw() {
        decoratedShape.draw();
        setRedBorder();
    }

    private void setRedBorder() {
        System.out.println("Setting red border.");
    }
}

public class DecoratorPatternExample {
    public static void main(String[] args) {
        Shape circle = new Circle();
        Shape redCircle = new RedShapeDecorator(new Circle());

        circle.draw();
        System.out.println("---");
        redCircle.draw();
    }
}
  1. 请解释什么是观察者模式,并提供一个示例。

观察者模式是一种行为型模式,它定义了对象之间的一对多关系,当一个对象的状态发生变化时,其相关对象会自动收到通知并更新。
以下是一个观察者模式的示例:

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update();
}

class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update() {
        System.out.println(name + " received the update.");
    }
}

interface Subject {
    void attach(Observer observer);

    void detach(Observer observer);

    void notifyObservers();
}

class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();

    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

public class ObserverPatternExample {
    public static void main(String[] args) {
        Subject subject = new ConcreteSubject();

        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        subject.attach(observer1);
        subject.attach(observer2);

        subject.notifyObservers();
    }
}
  1. 请解释什么是策略模式,并提供一个示例。

策略模式是一种行为型模式,它允许在运行时根据需求切换算法或策略。
以下是一个策略模式的示例:

interface Strategy {
    int doOperation(int num1, int num2);
}

class AddStrategy implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

class SubtractStrategy implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

public class StrategyPatternExample {
    public static void main(String[] args) {
        Context context = new Context(new AddStrategy());
        System.out.println("5 + 2 = " + context.executeStrategy(5, 2));

        context = new Context(new SubtractStrategy());
        System.out.println("5 - 2 = " + context.executeStrategy(5, 2));
    }
}
  1. 你在实际开发的过程中用过哪些设计模式?

当面试官问到你在实际开发中接触过哪些设计模式时,你可以按照以下步骤来回答这个问题:

步骤一:回答问题前的准备

● 细心回忆:回忆你在实际项目中遇到的设计问题和解决方案,并思考你应用了哪些设计模式。
● 项目准备:选择一个或多个具体的项目例子,这些例子最好能展示你在实际开发中对设计模式的应用和理解。

步骤二:回答问题的结构
你可以按如下结构组织你的回答,确保你的回答清晰有条理:

● 简要介绍项目:首先,简要介绍你参与的项目的背景和规模,包括项目的类型(Web应用、移动应用等)、主要功能和技术栈等。
● 问题和挑战:描述在该项目中你面对的设计问题和挑战,阐明为什么需要使用设计模式来解决这些问题。
● 解决方案:详细解释你选择的设计模式及其原理,并展示如何应用到实际项目中。

○ 描述设计模式的名称和概念。
○ 解释设计模式的工作原理,包括它是如何解决特定问题的。
○ 提供在实际项目中如何应用设计模式的具体示例代码。

● 结果和效益:说明使用设计模式的结果及其在项目中的效益。

○ 描述设计模式的应用对项目的影响。
○ 强调设计模式所带来的优势,比如代码的可维护性、可扩展性、重用性等。

步骤三:具体例子与解释
在回答问题时,可以结合具体的例子和相关代码来解释你在实际开发中的应用。下面是一个例子:

● 介绍项目:我曾参与一个电商平台的开发项目,该项目采用Java技术栈,用于构建一个多平台的在线购物平台。该项目主要包括用户管理、商品管理、订单管理等功能模块。
● 问题和挑战:在该项目中,我们面临了一个问题,即如何实现订单模块中的支付系统。我们需要支持多种支付方式,并且需求可能随时发生变化。同时,我们还需要保持订单模块的稳定性和可扩展性。
● 解决方案:为了解决这个问题,我们采用了策略模式和工厂模式的组合应用。

○ 策略模式的应用:我们定义了一个支付策略接口,通过实现不同的支付策略类来支持不同的支付方式,如微信支付、支付宝支付等。这样,在订单模块中,我们只需关注接口方法的调用,具体的支付逻辑由支付策略类来实现。这样的设计使我们能够动态切换支付方式,并且简化了代码。
○ 工厂模式的应用:我们使用工厂模式来创建支付策略对象。通过一个支付策略工厂类,我们可以根据用户选择的支付方式创建相应的支付策略对象。这样的设计保持了代码的灵活性,如新增一种支付方式时只需扩展工厂类而不影响其他模块。

● 结果和效益:通过应用策略模式和工厂模式,我们在订单模块中实现了一个灵活、可扩展的支付系统。当需求变化时,我们只需添加新的支付策略类和工厂方法即可,并且这样的设计提高了代码的可维护性和可测试性。

重要的是,不仅仅列出设计模式的名称,还要详细说明你在项目中的具体应用,以及应用所带来的优势和效益。这样可以体现出你对设计模式的理解和在实际项目中的应用能力。

  1. 什么是设计模式?

设计模式是在软件设计中经过验证的解决方案,可用于解决常见问题或模式。
它们提供了重用可维护代码的指导原则。

  1. 列举几个常用的设计模式?

单例模式、工厂模式、观察者模式、适配器模式、命令模式等。

  1. 解释单例模式的概念。

单例模式确保一个类只有一个实例,并提供一个全局访问点。
它用于限制对某个类只能创建一个对象的情况。

  1. 请提供一个单例模式的示例和实现。

以下是一个线程安全的懒汉式单例模式实现的例子:

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
  1. 解释工厂模式的概念。

工厂模式是用于创建对象的创建模式,通过一个共同接口或基类创建具体类的实例。

  1. 请提供一个工厂模式的示例和实现。

以下是一个简单的工厂模式实现的例子:

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}
  1. 解释观察者模式的概念。

观察者模式定义了对象之间的一对多依赖关系,使得当一个对象改变状态时,其依赖对象都会得到通知和自动更新。

  1. 请提供一个观察者模式的示例和实现。

以下是一个简单的观察者模式实现的例子:

import java.util.ArrayList;
import java.util.List;

public interface Observer {
    void update(String message);
}

public class User implements Observer {
    private String name;

    public User(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received a message: " + message);
    }
}

public class Blog {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}
  1. 解释适配器模式的概念。

适配器模式用于将一个类的接口转换成客户端所期望的另一个接口。
它通常用于现有类与不兼容类之间的协作。

  1. 请提供一个适配器模式的示例和实现。

以下是一个简单的适配器模式实现的例子:

public interface MediaPlayer {
    void play(String audioType, String fileName);
}

public interface AdvancedMediaPlayer {
    void playVlc(String fileName);
    void playMp4(String fileName);
}

public class VlcPlayer implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file: " + fileName);
    }

    @Override
    public void playMp4(String fileName) {
        // Do nothing
    }
}

public class Mp4Player implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        // Do nothing
    }

    @Override
    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file: " + fileName);
    }
}

public class MediaAdapter implements MediaPlayer {
    AdvancedMediaPlayer advancedMusicPlayer;

    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMusicPlayer = new VlcPlayer();
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMusicPlayer = new Mp4Player();
        }
    }

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMusicPlayer.playVlc(fileName);
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMusicPlayer.playMp4(fileName);
        }
    }
}

public class AudioPlayer implements MediaPlayer {
    MediaAdapter mediaAdapter;

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file: " + fileName);
        } else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) {
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType, fileName);
        } else {
            System.out.println("Invalid media. " + audioType + " format not supported.");
        }
    }
}
  1. 解释命令模式的概念。

命令模式是一种行为设计模式,将请求封装为对象,从而使您可以对客户端参数化方法调用。

  1. 请提供一个命令模式的示例和实现。

以下是一个简单的命令模式实现的例子:

public interface Command {
    void execute();
}

public class Light {
    public void turnOn() {
        System.out.println("Light turned on.");
    }

    public void turnOff() {
        System.out.println("Light turned off.");
    }
}

public class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }
}

public class LightOffCommand implements Command {
    private Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOff()
上一篇:视频主题分类


下一篇:k8s笔记28--快速在ubuntu上基于二进制和源码安装containerd