使用Groovy的Adapter模式来处理遗留代码

使用Groovy的Adapter模式来处理遗留代码

如果使用Java语言，针对一个遗留的类Circle，需要建立一个接口，再建立新类和遗留类的适配器实现该接口，再建立一个控制器：

/**/ /*

 * Adapter模式经常用来处理遗留代码

 */

package  com.XiongYi.designPatterns;

//遗留代码 Circle类 方法drawCircle() 这个类不便做更改

class Circle... {

    public void draw()...{

        System.out.println("I'm a circle...");

    }

}

// 现要由于新的需要 要加入一些和Circle地位等价类，比如其中一个叫做Rect

// 并要让另一个扮演控制角色的Person类的方法draw()来统一操纵它们

//于是，创建接口Drawable，并让Circle的适配器和Rect的适配器代替他们各自工作

interface Drawable... {

    public void draw();

}

//再让原有Circle的适配器CircleAdapter实现Drawable

class CircleAdapter implements Drawable... {

    private Circle circle;

    public CircleAdapter()...{

        circle = new Circle();

    }

    public void draw() ...{

        circle.draw();

    }

}

//加入的Rect类

class Rect... {

    public void draw()...{

        System.out.println("I'm a rect...");

    }

}

//同样也让Rect的适配器RectAdapter实现Drawable

class RectAdapter implements Drawable... {

    private Rect rect;

    public RectAdapter()...{

        rect = new Rect();

    }

    public void draw()...{

        rect.draw();

    }

}

// 最后扮演控制角色的Person类，

//它可以通过work方法根据传入的实现了Drawable接口的对象来统一控制它们工作了

class Person... {

    private Drawable drawable;

    public Person(Drawable drawable)...{

        this.drawable = drawable;

    }

    public void work()...{

        drawable.draw();

    }

}

public class Adapter ... {

    public static void main(String[] args)...{

        

        new Person(new CircleAdapter()).work();

        new Person(new RectAdapter()).work();

        

    }

}

而使用Groovy的话，则变得超级简单：

package  com.XiongYi.groovy.designPatters

//遗留代码 Circle类 方法drawCircle() 这个类不便做更改

class Circle... {

    def draw()...{

        println "I'm a circle..."

    }

}

//现在加入Rect类

class Rect... {

    def draw()...{

        println "I'm a rect..."

    }

}

//Person类扮演控制者的角色

class Person... {

    private def graphic

    Person(args)...{

        graphic = args

    }

    def draw()...{

        try...{

            graphic.draw()

        }catch(MissingMethodException e)...{

            println "U can't draw..."

        }

    }

}

class Adapter ... {

    static void main(args) ...{

        new Person(new Circle()).draw()

        new Person(new Rect()).draw()

    }

}

可见，正是Groovy的动态语言特性，可以将类型判定一直延后到运行时进行，代码变得如此简单。

欢迎讨论。