一、策略设计模式
public class Apply {
public static void process(Processor p, Object s) {
System.out.println("Using Processor " + p.name());
System.out.println(p.process(s));
}
public static String s = "Disagreement with beliefs is by definition incorrect";
public static void main(String[] args) {
process(new Upcase(), s);
process(new Downcase(), s);
process(new Splitter(), s);
}
}
class Processor {
public String name() {
return getClass().getSimpleName();
}
Object process(Object input) {
return input;
}
}
class Upcase extends Processor {
String process(Object input) {
return ((String)input).toUpperCase();
}
}
class Downcase extends Processor {
String process(Object input) {
return ((String)input).toLowerCase();
}
}
class Splitter extends Processor {
String process(Object input) {
return Arrays.toString(((String)input).split(" "));
}
}
Output:
Using Processor Upcase
DISAGREEMENT WITH BELIEFS IS BY DEFINITION INCORRECT
Using Processor Downcase
disagreement with beliefs is by definition incorrect
Using Processor Splitter
[Disagreement, with, beliefs, is, by, definition, incorrect]
创建一个能够根据所传递的参数对象的不同而具有不同行为的方法,被称为策略设计模式。这类方法包含所要执行的算法中固定不变的部分,而“策略”包含变化的部分。策略就是传递进去的参数对象,它包含要执行的代码。这里Processor对象就是一个策略。
如上例子,可用接口改造如下:
interface Processor {
public String name();
Object process(Object input);
}
public abstract class StringProcessor implements Processor {
public String name() {
return getClass().getSimpleName();
}
public abstract Object process(Object input);
public static String s = "Disagreement with beliefs is by definition incorrect";
public static void main(String[] args) {
Apply.process(new Upcase(), s);
Apply.process(new Downcase(), s);
Apply.process(new Splitter(), s);
}
}
class Apply {
public static void process(Processor p, Object s) {
System.out.println("Using Processor " + p.name());
System.out.println(p.process(s));
}
}
class Upcase extends StringProcessor {
public String process(Object input) {
return ((String)input).toUpperCase();
}
}
class Downcase extends StringProcessor {
public String process(Object input) {
return ((String)input).toLowerCase();
}
}
class Splitter extends StringProcessor {
public String process(Object input) {
return Arrays.toString(((String)input).split(" "));
}
}
二、适配器设计模式
class FilterAdapter implements Processor {
Filter filter;
public FilterAdapter(Filter filter) {
this.filter = filter;
}
@Override
public String name() {
return filter.name();
}
@Override
public Waveform process(Object input) {
return filter.process((Waveform) input);
}
}
public class FilterProcessor {
public static void main(String[] args) {
Waveform waveform = new Waveform();
Apply.process(new FilterAdapter(new LowPass(1.0)), waveform);
Apply.process(new FilterAdapter(new HighPass(2.0)), waveform);
Apply.process(new FilterAdapter(new BandPass(3.0, 4.0)), waveform);
}
}
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 {
double cutoff;
public LowPass(double cutoff) {
this.cutoff = cutoff;
}
public Waveform process(Waveform input) {
return input;
}
}
class HighPass extends Filter {
double cutoff;
public HighPass(double cutoff) {
this.cutoff = cutoff;
}
public Waveform process(Waveform input) {
return input;
}
}
class BandPass extends Filter {
double lowCutoff, highCutoff;
public BandPass(double lowCutoff, double highCutoff) {
this.lowCutoff = lowCutoff;
this.highCutoff = highCutoff;
}
public Waveform process(Waveform input) {
return input;
}
}
Filter与Processor具有相同的接口元素,但是因为它并非继承自Processor,因此你不能将Filter用于Apply.process()方法。这时可以使用适配器设计模式。适配器中的代码将接受你所有的接口,并产生你所需要的接口。FilterAdapter的构造器接受你所拥有的接口Filter,然后生成具有你所需要的Processor接口的对象。而且,在FilterAdapter类中用到了代理。
三、单例模式
public class Singleton {
void testPrivate() {
// Soup1 soup1 = new Soup1();//私有构造器,无法实例化
}
void testStatic() {
Soup1 soup1 = Soup1.makeSoup();
}
void testSingleton() {
Soup2.access().f();
}
}
class Soup1 {
private Soup1() {}
public static Soup1 makeSoup() {
return new Soup1();
}
}
class Soup2 {
private Soup2() {}
private static Soup2 ps1 = new Soup2();
public static Soup2 access() {
return ps1;
}
public void f() {}
}
Soup2用到了所谓的单例设计模式,因为你始终只能创建它的一个对象。Soup2类的对象是作为Soup2的一个static private成员而创建的,所以有且仅有一个,而且除非是通过public方法access(),否则是无法访问它的。
四、工厂方法设计模式
public class Factories {
public static void serviceConsumer(ServiceFactory fact) {
Service s = fact.getService();
s.method1();
s.method2();
}
public static void main(String[] args) {
serviceConsumer(new Inpl1Factory());
serviceConsumer(new Inpl2Factory());
}
}
interface Service {
void method1();
void method2();
}
interface ServiceFactory {
Service getService();
}
class Impl1 implements Service {
public Impl1() {}
public void method1() {
System.out.println("Impl1 method1");
}
public void method2() {
System.out.println("Impl1 method2");
}
}
class Inpl1Factory implements ServiceFactory {
public Service getService() {
return new Impl1();
}
}
class Impl2 implements Service {
public Impl2() {}
public void method1() {
System.out.println("Impl2 method1");
}
public void method2() {
System.out.println("Impl2 method2");
}
}
class Inpl2Factory implements ServiceFactory {
public Service getService() {
return new Impl2();
}
}
接口是实现多重继承的途径,而生成遵循某个接口的对象的典型方式就是工厂方法设计模式。这与直接调用构造器不同,我们在工厂对象上调用的是创建方法,而该工厂对象将生成接口的某个实现的对象。如果不是用工厂方法,代码就必须在某处指定将要创建的Service的确切类型,以便调用合适的构造器。
摘自《Java编程思想》