在本例中，创建一个能够根据所传参数对象不同而具有不同行为方法，被称为策略设计模式。这类方法包含所要执行的算法中不变的部分，而“策略”包含变化的部分。策略就是传递进去的参数对象，它包含要执行的代码。这里，Processor对象就是一个策略，在main()中有两种不同类型的策略应用到了String类型的s对象上。
现在有一组电子滤波器，它们的代码可能适用于Apply.process()方法。
class Waveform{ private static long counter; private final long id = counter++; public String toString() { return "Waveform:" + id;} } class Filter{ public String name() { return getClass().getSimpleName();} public Waveform process(Waveform input) { return input;} } class LowPass extends Filter{ private double cutoff; public LowPass(double cutoff) { this.cutoff = cutoff;} @Override public Waveform process(Waveform input) { return input;} } class HighPass extends Filter{ private double cutoff; public HighPass(double cutoff) { this.cutoff = cutoff;} @Override public Waveform process(Waveform input) { return input;} }Filter和Processor具有相同的接口，但是因为Filter不是继承自Processor的，所以不能将Filter应用于Apply.process()方法。Filter不能使用Apply.process()方法的主要原因在于：Apply.process()方法和Processor之间的耦合性过于紧密，导致复用Apply.process()代码时被禁止。
但是，如果将Processor换成是一个接口，那么这些限制便会松动，也就可以复用Apply.process()方法。
public interface Processor{ String name(); Object process(Object input); }复用代码的第一种方式就是客户端程序员遵循接口来编写类。
public abstract class StringProcessor implements Processor{ @Override public String name() { return getClass().getSimpleName(); } public abstract String process(Object input); public static void main(String[] args) { String s = "This Road is Long."; Apply.process(new Upcase(), s); Apply.process(new Downcase(), s); } } class Upcase extends StringProcessor{ @Override public String process(Object input) { return ((String)input).toUpperCase(); } } class Downcase extends StringProcessor{ @Override public String process(Object input) { return ((String)input).toLowerCase(); } }有时候就会遇见无法修改到类，在这种情况下，就可以使用适配器设计模式。适配器中的代码将接受你所拥有的接口，并产生你所需要的接口。比如，修改电子滤波器使其可以使用Apply.process()。
class FilterAdapter implements Processor{ Filter filter; public FilterAdapter(Filter filter) { this.filter = filter; } public String name() { return filter.name();} public Waveform process(Object input) { return filter.process((Waveform)input); } } public class FilterProcessor { public static void main(String[] args) { Waveform w = new Waveform(); Apply.process(new FilterAdapter(new LowPass(1.0)), w); Apply.process(new FilterAdapter(new HighPass(2.0)), w); } } /* output: Using Processor LowPass Waveform:0 Using Processor HighPass Waveform:0 */在这种使用适配器的方式中，FilterAdapter的构造器接受Filter的所有接口，然后生成需要的Processor接口对象。
将接口从具体实现中解耦使得接口可以应用于多种不同的具体实现，因此代码也就更具可复用性。
Java中的多重继承接口是没有任何具体实现的，即没有任何与接口相关的存储。因此，多个接口便可以组合使用。
使用具体类和多个接口的例子：
interface CanFight{ void fight(); } interface CanSwim{ void swim(); } interface CanFly{ void fly(); } class ActionCharacter{ public void fight(); //与CanFight具有相同的方法特征签名 } class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly{ public void swim(){} public void fly(){} } public class Adventure{ public static void fi(CanFight x){ x.fight(); } public static void sw(CanSwim x){ x.swim(); } public static void fl(CanFly x){ x.fly();} public static void ac(AcionCharacter x){ x.fight();} public static void main(String args[]){ Hero h = new Hero(); fi(h); sw(h); fl(h); ac(h); } }