Java中两种常用的设计模式详解！

目录

一、Java中抽象类应用之模版方法设计模式

二、讲解一下Java中接口应用之策略设计模式

---

一、Java中抽象类应用之模版方法设计模式

在Java中，抽象类应用之模版方法设计模式是一种常用的设计模式。它主要用于定义算法的骨架，而将一些具体步骤延迟到子类中实现。这种设计模式的优点是它可以将一些通用的逻辑放到抽象类中，从而避免在子类中重复编写这些逻辑。

以下是模版方法设计模式的简单实现：

1. 首先，我们创建一个抽象类，定义算法的骨架。在这个例子中，我们创建一个抽象类`AbstractClass`，包含一个名为`templateMethod`的抽象方法，以及两个普通方法`abstractMethod1`和`abstractMethod2`。

public abstract class AbstractClass {
    public void templateMethod() {
        abstractMethod1();
        abstractMethod2();
        System.out.println("这是模板方法");
    }

    protected abstract void abstractMethod1();
    protected abstract void abstractMethod2();
}

2. 然后，我们创建一个子类`SubClass`，继承自`AbstractClass`，并实现`abstractMethod1`和`abstractMethod2`方法。

public class SubClass extends AbstractClass {
    @Override
    protected void abstractMethod1() {
        System.out.println("这是子类实现的方法1");
    }

    @Override
    protected void abstractMethod2() {
        System.out.println("这是子类实现的方法2");
    }
}

3. 在客户端代码中，我们创建一个`SubClass`的对象，并调用`templateMethod`方法。

public class Main {
    public static void main(String[] args) {
        AbstractClass obj = new SubClass();
        obj.templateMethod();
    }
}

输出结果：

这是子类实现的方法1
这是子类实现的方法2
这是模板方法

通过这个例子，我们可以看到模版方法设计模式是如何在Java中实现的。通过使用抽象类，我们可以将算法骨架放到抽象类中，而将具体的实现延迟到子类中。这样可以保证算法的稳定性，又可以允许子类根据需要修改算法的某些步骤。

二、讲解一下Java中接口应用之策略设计模式

在Java中，接口应用之策略设计模式是一种常用的设计模式。它主要用来将算法家族分开，使它们之间可以互相替换。策略模式允许用户将算法封装在一个对象中，并将这个对象作为参数传递给另一个对象。

以下是策略设计模式的简单实现：

1. 首先，我们创建一个接口`Strategy`，定义算法家族的通用接口。在这个例子中，我们创建一个接口`Comparator`，包含一个名为`compare`的方法。

public interface Comparator<T> {
    int compare(T o1, T o2);
}

2. 然后，我们创建多个实现`Comparator`接口的类，代表不同的比较策略。在这个例子中，我们创建两个类`LengthComparator`和`AgeComparator`，分别比较对象的长度和年龄。

public class LengthComparator implements Comparator<Object> {
    @Override
    public int compare(Object o1, Object o2) {
        if (o1 instanceof String && o2 instanceof String) {
            return ((String) o1).length() - ((String) o2).length();
        }
        return 0;
    }
}

public class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge() - o2.getAge();
    }
}

其中，`Person`类是一个简单的Person类，包含一个名字和年龄。

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

3. 在一个类中，我们可以使用策略模式来根据需要切换不同的比较策略。在这个例子中，我们创建一个`PersonController`类，包含一个名为`sort`的方法，接受一个`Comparator`对象作为参数，对`Person`对象进行排序。

public class PersonController {
    public List<Person> sort(List<Person> persons, Comparator<Person> comparator) {
        Collections.sort(persons, comparator);
        return persons;
    }
}

4. 在客户端代码中，我们创建一个`PersonController`的对象，并调用`sort`方法。

public class Main {
    public static void main(String[] args) {
        PersonController controller = new PersonController();
        List<Person> persons = Arrays.asList(
                new Person("张三", 25),
                new Person("李四", 30),
                new Person("王五", 20));

        System.out.println("按照年龄排序：");
        controller.sort(persons, new AgeComparator());
        persons.forEach(p -> System.out.println(p.getName() + "：" + p.getAge()));

        System.out.println("\n按照名字长度排序：");
        controller.sort(persons, new LengthComparator());
        persons.forEach(p -> System.out.println(p.getName() + "：" + p.getAge()));
    }
}

输出结果：

按照年龄排序：
王五：20
张三：25
李四：30

按照名字长度排序：
王五：20
李四：30
张三：25
 

通过这个例子，我们可以看到策略设计模式是如何在Java中实现的。通过使用接口，我们可以将算法家族分开，使它们之间可以互相替换。策略模式允许用户将算法封装在一个对象中，并将这个对象作为参数传递给另一个对象，从而实现算法的灵活切换。