目录
一、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中实现的。通过使用接口,我们可以将算法家族分开,使它们之间可以互相替换。策略模式允许用户将算法封装在一个对象中,并将这个对象作为参数传递给另一个对象,从而实现算法的灵活切换。