Java 泛型设计模式

2024 年 9 月 10 日 | 阅读 7 分钟

Java 泛型引入了参数化类型的概念，彻底改变了程序员创建 Java 代码的方式。因此，编程进入了一个新时代，Java 代码更简洁、更灵活、类型更安全。为了实现这些优势，许多设计模式都利用了 Java 泛型。在本节中，我们将讨论一些流行的 Java 泛型设计模式。

工厂模式

工厂模式是一种创建型模式，它提供了一种生成对象的方法，而无需指定将要生成的对象的精确类型。相反，工厂会根据其接收到的输入参数来生成对象。使用 Java 泛型可以创建一个通用的工厂，该工厂可以生成实现特定接口的任何类的对象。

下面的代码演示了工厂模式中泛型的用法

FactoryPatternExample.java

public interface Vehicle {
   void drive();
}
public class Car implements Vehicle {
   public void drive() {
      System.out.println("Driving a car...");
   }
}
public class Truck implements Vehicle {
   public void drive() {
      System.out.println("Driving a truck...");
   }
}
public class VehicleFactory<T extends Vehicle> {
   public T createVehicle(Class<T> clazz) throws IllegalAccessException, InstantiationException {
      return clazz.newInstance();
   }
}
public class FactoryPatternExample {
   public static void main(String[] args) throws IllegalAccessException, InstantiationException {
      VehicleFactory<Car> carFactory = new VehicleFactory<>();
      Car car = carFactory.createVehicle(Car.class);
      car.drive();

      VehicleFactory<Truck> truckFactory = new VehicleFactory<>();
      Truck truck = truckFactory.createVehicle(Truck.class);
      truck.drive();
   }
}

输出

Driving a car...
Driving a truck...

在此示例中，Car 和 Truck 类都实现了 Vehicle 接口。下一步是构建通用的工厂类 VehicleFactory，它接受类型参数 T 并要求 T 扩展 Vehicle 接口。VehicleFactory 类的 createVehicle 函数会创建并返回参数中提供的类的实例。在 main 方法中，创建了用于汽车和卡车的 VehicleFactory 类，并用于创建相应类的实例。

策略模式

策略模式是一种行为型模式，它允许在运行时选择算法。通过开发描述算法的通用接口和实现该接口的各种算法实现的类集，可以使用 Java 泛型来实现此模式。

下面的代码演示了策略模式中泛型的用法

StrategyPatternExample.java

interface SortingStrategy {
    void sort(int[] array);
}
class BubbleSort implements SortingStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("Sorting using Bubble Sort...");
        // Implementation of bubble sort
    }
}
class QuickSort implements SortingStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("Sorting using Quick Sort...");
        // Implementation of quick sort
    }
}
class MergeSort implements SortingStrategy {
    @Override
    public void sort(int[] array) {
        System.out.println("Sorting using Merge Sort...");
        // Implementation of merge sort
    }
}
class Sorter {
    private SortingStrategy strategy;
    public void setStrategy(SortingStrategy strategy) {
        this.strategy = strategy;
    }
    public void sort(int[] array) {
        strategy.sort(array);
    }
}
public class StrategyPatternExample {
    public static void main(String[] args) {
        int[] array = { 5, 2, 8, 9, 1, 0, 3 };
        Sorter sorter = new Sorter();
        sorter.setStrategy(new BubbleSort());
        sorter.sort(array);
        sorter.setStrategy(new QuickSort());
        sorter.sort(array);
        sorter.setStrategy(new MergeSort());
        sorter.sort(array);
    }
}

输出

Sorting using Bubble Sort...
Sorting using Quick Sort...
Sorting using Merge Sort...

正如我们所见，Sorter 类使用选定的排序策略来对数组进行排序。

在此示例中，我们有一个名为 sort() 的接口 SortingStrategy。BubbleSort、QuickSort 和 MergeSort 这三个类都实现了该接口，每个类都有独特的 sort() 函数实现。

此外，还有一个名为 Sorter 的类，它有一个私有的 SortingStrategy 类型的变量。该类的 sort() 方法调用所选排序策略的 sort() 方法，而 setStrategy() 函数用于设置排序策略。

我们在 main() 方法中创建一个数字数组和一个 Sorter 对象。使用 setStrategy() 函数，我们将排序策略设置为 BubbleSort、QuickSort 和 MergeSort，然后我们在 Sorter 对象上运行 sort() 方法。

通过使用策略模式，我们可以在不更改 Sorter 类实现的情况下轻松切换不同的排序算法。

桥接模式

当抽象与其实现分离时，桥接设计允许它们独立更改。当一个类的实现需要更改而不影响其接口，或者当您希望向客户隐藏实现的细节时，此设计模式可能很有帮助。可以通过创建定义实现的参数化接口或抽象类和定义抽象的参数化实现类来使用泛型来实现桥接模式。可以使用类型参数指定正在实现和抽象的对象类型。

适配器模式

适配器模式将一个类的接口转换为客户端期望使用的另一个接口。如果您的一个类提供了特定功能，但其接口与您的代码库的其余部分不兼容，则此方法可能很有帮助。可以通过创建指定所需接口的抽象类或参数化接口和将不兼容的类转换为所需接口的参数化适配器类来使用泛型来实现适配器模式。可以使用类型参数指定正在修改的对象类型。

访问者模式

访问者模式将算法及其使用的对象结构分离开来。当您有一个复杂对象结构并希望对其组件执行各种操作而不更改定义该结构的类时，此模式可能很有用。通过创建描述操作的参数化接口或抽象类和为结构中的特定类型对象实现操作的参数化访问者类，可以使用泛型来实现访问者模式。可以使用类型参数指定访问者可以操作的对象类型。

建造者模式

建造者模式是一种创建型模式，它将一个对象的实际构造与其表示分离开来。当您需要将需要多个阶段的对象开发分解为更小、更易于管理的步骤，以使过程更简单时，此模式很有用。

为了在 Java 中生成具有多种类型参数的复杂对象，建造者模式经常与泛型结合使用。目标是创建一个通用的 Builder 类，该类可用于构建任何类型的对象。Builder 类的 build 函数将返回完成的对象，并提供用于设置正在构建的对象各种属性的方法。

以下是 Java 中建造者模式的示例实现

BuilderPatternExample.java

public class Car {
    private String make;
    private String model;
    private int year;
    private String color;
    private int mileage;
    private String transmission;
    public Car(String make, String model, int year, String color, int mileage, String transmission) {
        this.make = make;
        this.model = model;
        this.year = year;
        this.color = color;
        this.mileage = mileage;
        this.transmission = transmission;
    }
    public String getMake() {
        return make;
    }
    public String getModel() {
        return model;
    }
    public int getYear() {
        return year;
    }
    public String getColor() {
        return color;
    }
    public int getMileage() {
        return mileage;
    }
    public String getTransmission() {
        return transmission;
    }
    public static class CarBuilder {
        private String make;
        private String model;
        private int year;
        private String color;
        private int mileage;
        private String transmission;
        public CarBuilder() {}
        public CarBuilder setMake(String make) {
            this.make = make;
            return this;
        }
        public CarBuilder setModel(String model) {
            this.model = model;
            return this;
        }
        public CarBuilder setYear(int year) {
            this.year = year;
            return this;
        }
        public CarBuilder setColor(String color) {
            this.color = color;
            return this;
        }
        public CarBuilder setMileage(int mileage) {
            this.mileage = mileage;
            return this;
        }
        public CarBuilder setTransmission(String transmission) {
            this.transmission = transmission;
            return this;
        }
        public Car build() {
            return new Car(make, model, year, color, mileage, transmission);
        }
    }
}
public class BuilderPatternExample {
    public static void main(String[] args) {
        Car car = new Car.CarBuilder()
                    .setMake("Toyota")
                    .setModel("Camry")
                    .setYear(2018)
                    .setColor("White")
                    .setMileage(40000)
                    .setTransmission("Automatic")
                    .build();
        System.out.println("Make: " + car.getMake());
        System.out.println("Model: " + car.getModel());
        System.out.println("Year: " + car.getYear());
        System.out.println("Color: " + car.getColor());
        System.out.println("Mileage: " + car.getMileage());
        System.out.println("Transmission: " + car.getTransmission());
    }
}

输出

Make: Toyota
Model: Camry
Year: 2018
Color: White
Mileage: 40000
Transmission: Automatic

在此示例中，汽车的品牌、型号、年份、颜色、里程和变速箱都由 Car 类中的不同字段表示。此外，我们还有一个嵌套的 CarBuilder 类，它使我们能够以一种更易于阅读和维护的方式构建 Car 对象。

应用建造者模式的第一步是创建一个 CarBuilder 类的实例，并调用其 setter 方法来设置我们要构建的 Car 对象的所需属性。为了生成具有必要属性的 Car 对象，我们最后执行 build() 方法。此方法使对象创建更加清晰易读，尤其是在处理包含大量属性的类时。

结论

Java 泛型提供了一种强大且灵活的方法来创建可重用的、类型安全的代码。通过利用泛型设计模式，可以充分发挥泛型的全部潜力来创建更模块化、更灵活、更易于维护的代码。本文讨论的设计模式只是泛型如何用于解决常见编程问题的几个示例。许多其他设计模式都可以使用泛型来实现，只要稍加想象，您就可以创建自己的。

下一主题Java 泛型为何用于 Java

Java 泛型设计模式

工厂模式

策略模式

桥接模式

适配器模式

访问者模式

建造者模式

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 泛型设计模式

工厂模式

策略模式

桥接模式

适配器模式

访问者模式

建造者模式

结论

相关帖子

Java 全栈开发

Difference Between C and Java

Java 点运算符

如何在 Java 中将字符串转换为枚举

Java 中的 Iccanobif 数

Java 中的抽象工厂设计模式

Java 中的图像处理

Java 中的接口属性

Java Get Data From URL

如何在 Java 中交换或替换对象

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器