Java面试题（含答案）9.设计模式类型篇

最新推荐文章于 2024-08-01 19:53:10 发布

知昂可

最新推荐文章于 2024-08-01 19:53:10 发布

阅读量1.3k

点赞数 13

分类专栏： java面试题文章标签： java 设计模式开发语言

本文链接：https://blog.csdn.net/pythontxt/article/details/137182132

版权

java面试题专栏收录该内容

13 篇文章 1 订阅

订阅专栏

1. 什么是设计模式？为什么我们需要设计模式？

答案：
设计模式是在软件开发中解决特定问题的最佳实践。它们是在长期软件开发中积累的经验的总结，可以帮助我们更高效地编写可维护、可扩展和可重用的代码。设计模式使代码结构更加清晰，提高了代码的可读性和可维护性，同时也有助于开发人员之间的沟通和协作。

2. 请解释单例模式，并给出一个Java实现示例。

答案：
单例模式确保一个类仅有一个实例，并提供一个全局访问点。

public class Singleton {  
    private static Singleton instance;  
  
    private Singleton() {} // 私有构造方法，防止外部实例化  
  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

注意：上面的实现是线程安全的，但性能较差。在实际应用中，通常会使用双重检查锁定或静态内部类等方式来实现线程安全且高效的单例。

3. 请解释工厂模式，并给出一个Java实现示例。

答案：
工厂模式用于封装对象的创建过程，将对象的创建与使用分离。

public interface Car {  
    void drive();  
}  
  
public class BMW implements Car {  
    @Override  
    public void drive() {  
        System.out.println("Driving BMW");  
    }  
}  
  
public class CarFactory {  
    public static Car createCar() {  
        return new BMW(); // 可以根据需要返回不同的Car实现  
    }  
}

4. 请解释观察者模式，并给出一个Java实现示例。

答案：
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象状态发生变化时，它的所有依赖者（观察者）都会自动收到通知并更新。

import java.util.ArrayList;  
import java.util.List;  
  
public interface Observer {  
    void update(String message);  
}  
  
public class Subject {  
    private List<Observer> observers = new ArrayList<>();  
    private String message;  
  
    public void attach(Observer observer) {  
        observers.add(observer);  
    }  
  
    public void detach(Observer observer) {  
        observers.remove(observer);  
    }  
  
    public void notifyObservers() {  
        for (Observer observer : observers) {  
            observer.update(message);  
        }  
    }  
  
    public void setMessage(String message) {  
        this.message = message;  
        notifyObservers();  
    }  
}

然后你可以创建实现了Observer接口的类，并将其附加到Subject上，以便在主题状态变化时接收通知。

5. 请解释建造者模式，并给出一个Java实现示例。

答案：
建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

public class Computer {  
    private String ram;  
    private String hdd;  
    private String cpu;  
  
    private Computer(Builder builder) {  
        this.ram = builder.ram;  
        this.hdd = builder.hdd;  
        this.cpu = builder.cpu;  
    }  
  
    public static class Builder {  
        private String ram;  
        private String hdd;  
        private String cpu;  
  
        public Builder setRam(String ram) {  
            this.ram = ram;  
            return this;  
        }  
  
        public Builder setHdd(String hdd) {  
            this.hdd = hdd;  
            return this;  
        }  
  
        public Builder setCpu(String cpu) {  
            this.cpu = cpu;  
            return this;  
        }  
  
        public Computer build() {  
            return new Computer(this);  
        }  
    }  
}

使用建造者模式创建Computer对象：

Computer computer = new Computer.Builder()  
    .setRam("8GB")  
    .setHdd("500GB")  
    .setCpu("Intel Core i7")  
    .build();

6. 请解释适配器模式，并给出一个Java实现示例。

答案：
适配器模式将一个类的接口转换成客户端所期望的另一种接口，使得原本由于接口不兼容而无法一起工作的类能够一起工作。

public interface Target {  
    void request();  
}  
  
public class Adaptee {  
    public void specificRequest() {  
        System.out.println("Called specificRequest()");  
    }  
}  
  
public class Adapter implements Target {  
    private Adaptee adaptee;  
  
    public Adapter(Adaptee adaptee) {  
        this.adaptee = adaptee;  
    }  
  
    @Override  
    public void request() {  
        adaptee.specificRequest();  
    }  
}

7. 请解释原型模式，并给出一个Java实现示例。

答案：
原型模式用于创建重复的对象，同时又能保证性能。这种模式涉及将一个对象用作创建新对象的原型，然后复制这个原型对象来创建更多相同类型的对象。

public class Prototype implements Cloneable {  
    private String name;  
  
    public Prototype(String name) {  
        this.name = name;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    @Override  
    protected Object clone() throws CloneNotSupportedException {  
        return super.clone();  
    }  
}

使用原型模式创建对象：

Prototype prototype = new Prototype("Original");  
Prototype clonedPrototype;  
  
try {  
    clonedPrototype = (Prototype) prototype.clone();  
    clonedPrototype.setName("Cloned");  
} catch (CloneNotSupportedException e) {  
    e.printStackTrace();  
}

8. 请解释模板方法模式，并给出一个Java实现示例。

答案：
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。

public abstract class AbstractClass {  
    public final void templateMethod() {  
        specificMethod1();  
        specificMethod2();  
    }  
  
    protected abstract void specificMethod1();  
    protected abstract void specificMethod2();  
}  
  
public class ConcreteClass extends AbstractClass {  
    @Override  
    protected void specificMethod1() {  
        System.out.println("ConcreteClass specificMethod1");  
    }  
  
    @Override  
    protected void specificMethod2() {  
        System.out.println("ConcreteClass specificMethod2");  
    }  
}

使用模板方法模式：

AbstractClass abstractClass = new ConcreteClass();  
abstractClass.templateMethod(); // 输出：ConcreteClass specificMethod1, ConcreteClass specificMethod2

9. 请解释策略模式，并给出一个Java实现示例。

答案：
策略模式定义了一系列的算法，并将每一个算法封装起来，使它们可以互相替换。策略模式使得算法可以独立于使用它的客户端变化。

public interface Strategy {  
    int doOperation(int num1, int num2);  
}  
  
public class OperationAdd implements Strategy {  
    @Override  
    public int doOperation(int num1, int num2) {  
        return num1 + num2;  
    }  
}  
  
public class OperationSubtract implements Strategy {  
    @Override  
    public int doOperation(int num1, int num2) {  
        return num1 - num2;  
    }  
}  
  
public class Context {  
    private Strategy strategy;  
  
    public Context(Strategy strategy) {  
        this.strategy = strategy;  
    }  
  
    public int executeStrategy(int num1, int num2) {  
        return strategy.doOperation(num1, num2);  
    }  
}

使用策略模式：

Context context = new Context(new OperationAdd());  
System.out.println("10 + 5 = " + context.executeStrategy(10, 5)); // 输出：10 + 5 = 15  
  
context = new Context(new OperationSubtract());  
System.out.println("10 - 5 = " + context.executeStrategy(10, 5)); // 输出：10 - 5 = 5

10. 请谈谈你对建造者模式的理解，并给出一个使用场景。

答案：
建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。建造者模式通常包含建造者接口、具体建造者类和产品类。

使用场景：在需要生成具有多个选项或配置的产品对象时，可以使用建造者模式。例如，在配置一个复杂的订单系统时，订单可能包含多个产品，每个产品又有多种可选配置，如颜色、尺寸、数量等。通过建造者模式，我们可以逐步构建一个订单对象，同时保持构建过程的灵活性和可读性。

11. 观察者模式是什么？请给出一个实际应用的例子。

答案：
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象状态发生改变时，它的所有依赖者（观察者）都会自动收到通知并更新。

实际应用例子：在GUI编程中，观察者模式常用于实现事件处理机制。例如，当用户点击一个按钮时，按钮（主题对象）会发出一个点击事件，所有注册了该事件的监听器（观察者）都会收到通知并执行相应的操作，如更新界面、执行命令等。

12. 请描述单例模式的实现方式，并讨论其线程安全性问题。

答案：
单例模式确保一个类仅有一个实例，并提供一个全局访问点。常见的实现方式包括饿汉式、懒汉式（双重检查锁定、静态内部类等）。

线程安全性问题：在多线程环境下，懒汉式实现可能会因为多个线程同时访问并创建实例而导致产生多个实例。为了确保线程安全，可以使用同步块或双重检查锁定等技术。双重检查锁定虽然可以提高性能，但需要注意正确实现以避免出现内存可见性和指令重排序问题。静态内部类方式是一种线程安全的单例实现方式，它利用了JVM的类加载机制来确保只创建一个实例。

13. 工厂方法和抽象工厂模式有何区别？

答案：
工厂方法模式定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。而抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

区别：工厂方法模式关注的是单个对象的创建，而抽象工厂模式关注的是一系列相关或依赖对象的创建。工厂方法模式通常只有一个抽象产品类，而抽象工厂模式可能有多个抽象产品类。因此，抽象工厂模式具有更高的灵活性和扩展性，但实现起来也更复杂。

14. 请谈谈你对装饰器模式的理解，并给出一个使用场景。

答案：
装饰器模式动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。装饰器模式是一种用于代替继承的技术，它通过一种无须修改已有类的方式来增加新功能。

使用场景：当需要动态地给一个对象增加功能，且这些功能可以动态地撤销时，可以使用装饰器模式。例如，在I/O流的设计中，Java的IO库使用了装饰器模式为基本的输入输出流类添加各种功能，如缓冲、同步等。