在接口 interface 使用设计模式 -- 《JAVA编程思想》25

今天和大家一起分享本书《接口》一章中提到的三种设计模型，希望能对你理解接口有所启发：

1.策略设计模式
先来看下面一个通过接口实现多态的例子：

public interface Processor {
    Object process(Object input);
}

public class UpCase implements Processor {
    @Override
    public Object process(Object input) {
        return input.toString().toUpperCase();
    }
}

public class DownCase implements Processor {
    @Override
    public Object process(Object input) {
        return input.toString().toLowerCase();
    }
}

public class Splitter implements Processor {
    @Override
    public Object process(Object input) {
        return Arrays.toString(input.toString().split(" "));
    }
}

public class Apply {

    public static String s = " Do you want to use this method ? ";

    public static void process(Processor p, Object s) {
        System.out.println(" Using Process " + p.getClass().getSimpleName());
        System.out.println(p.process(s));
    }

    public static void main(String[] args) {
        process(new UpCase(), s);
        process(new DownCase(), s);
        process(new Splitter(), s);
    }
}

 Using Process UpCase
 DO YOU WANT TO USE THIS METHOD ? 
 Using Process DownCase
 do you want to use this method ? 
 Using Process Splitter
[, Do, you, want, to, use, this, method, ?]

Apply.process() 方法可以接收任何实现 Processor 接口的对象，如同本例：创建一个根据所传递参数对象的不同而具有不同行为的方法，被称为策略设计模式。Apply.process() 中的代码为固定不变的部分，而实现 Processor 接口类中的 process() 方法便是变化的部分，为根据不同场景制定的不同策略。

2.适配器模式

我们现有计算加法的 PlusUtil 类和 计算减法的MinusUtil 类，但这2个类都来自外部 jar 包，且不允许修改，但我们发现 CalculateUtil .process() 方法和 Processor.process() 方法存在相似之处，故想将2个类的 process() 方法集成至一块使用，这时该怎么办呢？

使用适配器模式，可以解除这个困扰。创建适配器 CalculateUtilAdapter 实现想调用的 Processor 接口，再在 CalculateUtilAdapter.process()中，调用具体的 CalculateUtil 类来处理业务，便可将不能修改的两份的业务代码合并在一起使用，这便是适配器模式。

public abstract class CalculateUtil {

    abstract int process(int number);
    
}

public class PlusUtil extends  CalculateUtil{

    public int process(int number) {
        return ++number;
    }
    
}

public class MinusUtil extends CalculateUtil {

    @Override
    int process(int number) {
        return --number;
    }

}

public class CalculateUtilAdapter implements Processor {

    private CalculateUtil calculateUtil;

    public CalculateUtilAdapter(CalculateUtil calculateUtil) {
        this.calculateUtil = calculateUtil;
    }

    @Override
    public Integer process(Object input) {
        return calculateUtil.process((int) input);
    }

    public static void main(String[] args) {
        Apply.process(new CalculateUtilAdapter(new PlusUtil()),10);
        Apply.process(new CalculateUtilAdapter(new MinusUtil()),10);
        String s = Apply.s;
        Apply.process(new UpCase(), s);
        Apply.process(new DownCase(), s);
        Apply.process(new Splitter(), s);
    }
    
}

 Using Process CalculateUtilAdapter
11
 Using Process CalculateUtilAdapter
9
 Using Process UpCase
 DO YOU WANT TO USE THIS METHOD ? 
 Using Process DownCase
 do you want to use this method ? 
 Using Process Splitter
[, Do, you, want, to, use, this, method, ?]

3.工厂模式

工厂模式主要是将方法的实例化过程延迟到子类进行，使客户端调用方不必关注对象是如何生成的，只需简单指定生成对象的工厂即可，主要运用于复杂对象的生成场景，若是对象生成的方式相对简单，则无需使用。

public interface Game {
    void move();
}

public interface GameFactory {
    Game getGame();
}

public class AGame implements Game {
    @Override
    public void move() {
        System.out.println("A move");
    }
}

public class AGameFactory implements GameFactory {
    @Override
    public Game getGame() {
        return new AGame();
    }
}

public class BGame implements Game {
    @Override
    public void move() {
        System.out.println("B move");
    }
}

public class BGameFactory implements GameFactory {
    @Override
    public Game getGame() {
        return new BGame();
    }
}

public class GameImpl {
    public static void playGame(Game game) {
        game.move();
    }
    public static void main(String[] args) {
        playGame(new AGameFactory().getGame());
        playGame(new BGameFactory().getGame());
    }
}

A move
B move

本次分享至此结束，希望本文对你有所帮助，若能点亮下方的点赞按钮，在下感激不尽，谢谢您的【精神支持】。

若有任何疑问，也欢迎与我交流，若存在不足之处，也欢迎各位指正！