Java后端八股------设计模式

本文深入探讨了设计模式中的工厂方法和抽象工厂模式,通过Java代码示例详细解释了如何使用这些模式来创建对象,展示了产品接口、具体产品、工厂接口和具体工厂的实现方式。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

在这里插入图片描述在这里插入图片描述

Coffee可以设计成接口。
在这里插入图片描述

示例:

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 简单工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type == null) {
            return null;
        }
        if (type.equalsIgnoreCase("A")) {
            return new ConcreteProductA();
        } else if (type.equalsIgnoreCase("B")) {
            return new Product(new ConcreteProductB());
        }
        return null;
    }
}

// 客户端代码
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Product product = SimpleFactory.createProduct("A");
        product.use();
    }
}

在这里插入图片描述
示例:

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂
class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class FactoryMethodDemo {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactoryA();
        Product product = factory.createProduct();
        product.use();
    }
}

抽象工厂模式

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    Product createProduct();
}

// 具体工厂
class ConcreteFactory implements AbstractFactory {
    public Product createProduct() {
        // 决定创建哪种产品
        return new ConcreteProductA();
    }
}

// 客户端代码
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory();
        Product product = factory.createProduct();
        product.use();
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

单例

应用:线程池、数据库连接池、日志记录等。

饿汉式(线程安全)
public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();

    private HungrySingleton() {}

    public static HungrySingleton getInstance() {
        return instance;
    }
}
懒汉式
public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {}

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}
双重检查锁定(DCL)–线程安全
public class DoubleCheckedLockingSingleton {
    private static volatile DoubleCheckedLockingSingleton instance;

    private DoubleCheckedLockingSingleton() {}

    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}
静态内部类
public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {}

    private static class Holder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance() {
        return Holder.INSTANCE;
    }
}

工厂方法

简单工厂

例子:

// 图形接口
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 static 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;
    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("CIRCLE");
        circle.draw(); // 输出:Drawing a Circle

        Shape rectangle = ShapeFactory.getShape("RECTANGLE");
        rectangle.draw(); // 输出:Drawing a Rectangle
    }
}
方法工厂
// 图形接口
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 abstract class ShapeFactory {
    public abstract Shape createShape();
}

// 圆形工厂
public class CircleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// 矩形工厂
public class RectangleFactory extends ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

客户端实现

public class Client {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw(); // 输出:Drawing a Circle

        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        rectangle.draw(); // 输出:Drawing a Rectangle
    }
}
抽象工厂
// 图形接口
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 interface Color {
    void fill();
}

// 红色类
public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Red color");
    }
}

// 蓝色类
public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Blue color");
    }
}

// 抽象工厂类
public interface AbstractFactory {
    Shape createShape();
    Color createColor();
}

// 圆形工厂
public class CircleFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }

    @Override
    public Color createColor() {
        return new Red(); // 默认返回红色
    }
}

// 矩形工厂
public class RectangleFactory implements AbstractFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }

    @Override
    public Color createColor() {
        return new Blue(); // 默认返回蓝色
    }
}

客户端实现

public class Client {
    public static void main(String[] args) {
        AbstractFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        Color red = circleFactory.createColor();

        circle.draw(); // 输出:Drawing a Circle
        red.fill();    // 输出:Filling with Red color

        AbstractFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        Color blue = rectangleFactory.createColor();

        rectangle.draw(); // 输出:Drawing a Rectangle
        blue.fill();      // 输出:Filling with Blue color
    }
}

代理模式

静态代理的处理模式,在编译时就写死了,不足够灵活
JDK动态代理,靠接口实现(需要实现一些接口)
CGLIB动态代理,需要导入额外的包,

观察者模式

在这里插入图片描述

在这里插入图片描述
应用案例

  1. 事件监听
    在 GUI 应用程序中,按钮、文本框等组件通常使用观察者模式来处理用户事件。例如,按钮被点击时,所有注册的监听器都会被通知,执行相应的操作。
  2. 发布-订阅系统
    在消息推送系统中,观察者模式用于实现发布-订阅机制。发布者发布消息,所有订阅者收到通知并处理消息。例如,新闻网站发布新文章时,所有订阅用户都会收到通知。

策略模式

可以省掉很多的if-else

在这里插入图片描述

// 支付策略接口
public interface PaymentStrategy {
    void pay(int amount);
}
// 信用卡支付类
public class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;

    public CreditCardPayment(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card: " + cardNumber);
    }
}

// PayPal 支付类
public class PayPalPayment implements PaymentStrategy {
    private String email;

    public PayPalPayment(String email) {
        this.email = email;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal: " + email);
    }
}
// 上下文类
public class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        if (paymentStrategy == null) {
            System.out.println("Payment strategy not set!");
            return;
        }
        paymentStrategy.pay(amount);
    }
}
public class Client {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        // 使用信用卡支付
        cart.setPaymentStrategy(new CreditCardPayment("1234-5678-9012-3456"));
        cart.checkout(100); // 输出:Paid 100 using Credit Card: 1234-5678-9012-3456

        // 使用 PayPal 支付
        cart.setPaymentStrategy(new PayPalPayment("user@example.com"));
        cart.checkout(200); // 输出:Paid 200 using PayPal: user@example.com
    }
}
### Java后端开发经典面试题及答案解析 #### 1. JRE 和 JDK 的区别是什么? JRE(Java Runtime Environment)是用于运行 Java 程序的环境,其中包括 JVM(Java Virtual Machine),以及支持 Applet 执行所需的浏览器插件[^1]。 JDK(Java Development Kit)则是完整的 Java 开发工具包,不仅包含 JRE,还提供了编译器、调试器以及其他开发工具(如 `javac` 编译器、`javadoc` 文档生成工具等),使开发者能够编写、编译并运行 Java 应用程序[^1]。 --- #### 2. 反射的作用及其实现原理是什么?如何获取反射对象? 反射机制允许在运行时动态加载类、创建实例、访问字段和调用方法。其实现依赖于 `java.lang.reflect` 包中的核心类(如 `Class`、`Field`、`Method` 等)。通过反射,可以在不知道具体类名的情况下操作类成员[^2]。 以下是获取反射对象的三种方式: - 使用 `Class.forName(String className)` 方法; - 调用某个类的 `.class` 属性; - 对象的 `.getClass()` 方法。 示例代码如下: ```java // 方式一:通过 Class.forName 获取 Class<?> clazz1 = Class.forName("java.util.ArrayList"); // 方式二:通过 .class 属性获取 Class<?> clazz2 = ArrayList.class; // 方式三:通过对象的 getClass() 方法获取 ArrayList<String> list = new ArrayList<>(); Class<?> clazz3 = list.getClass(); ``` --- #### 3. 解释 `==` 和 `equals()` 的区别,并举例说明。 `==` 是比较两个变量的内存地址或基本数据类型的值是否相等,而 `equals()` 默认也是比较地址,但在某些类(如 `String` 或包装类)中会被重写以比较内容是否相同。 例如: ```java Integer a = 10; Integer b = 10; System.out.println(a == b); // true (因为 Integer 在 [-128, 127] 范围内会缓存) Integer c = 129; Integer d = 129; System.out.println(c == d); // false (超出范围未被缓存) System.out.println(c.equals(d)); // true (比较的是数值本身) ``` --- #### 4. `wait()` 和 `sleep()` 的主要区别有哪些? 两者的差异体现在以下几个方面[^4]: - **所属类**:`wait()` 是 `Object` 类的方法,需配合锁使用;`sleep()` 则是 `Thread` 类的静态方法。 - **线程状态**:`wait()` 会使当前线程释放锁进入等待队列,直到其他线程唤醒它;`sleep()` 不会释放任何锁,仅让线程暂停指定时间。 - **异常抛出**:`wait()` 需要在同步块中调用,可能抛出 `InterruptedException`;`sleep()` 直接作用于线程,同样可能抛出该异常。 --- #### 5. `RuntimeException` 和受检异常的主要区别是什么? `RuntimeException` 是非受检异常的一部分,其特点是无需显式声明或捕获即可抛出。常见的子类包括 `NullPointerException`、`ArrayIndexOutOfBoundsException` 等。相比之下,受检异常(Checked Exception)必须在方法签名中声明(通过 `throws` 关键字)或在其发生处被捕获处理[^3]。 | 特性 | RuntimeException | Checked Exception | |-------------------|----------------------------------|-------------------------------| | 是否强制处理 | 否 | 是 | | 常见例子 | NullPointerException | IOException | --- #### 6. 如何理解单例模式?请给出一个懒汉式的实现。 单例模式是一种设计模式,确保某类只有一个实例存在,并提供全局访问点。通常分为饿汉式和懒汉式两种形式。其中懒汉式会在首次使用时才初始化实例,从而延迟资源分配[^3]。 示例代码如下: ```java public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } ``` --- #### 7. GC 的工作原理是什么?哪些情况下触发垃圾回收? GC(Garbage Collection)由 JVM 自动管理,负责清理不再使用的对象所占用的堆空间。当对象无法通过任何强引用到达时,即被认为是可回收的。触发条件主要包括但不限于以下几种情况: - 新对象分配失败(堆空间不足); - 明确调用了 `System.gc()` 提示系统进行垃圾回收(不保证立即执行)。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值