Menu
浅谈程序设计模式让你的程序开发更上一层楼
        浅谈程序设计模式让你的程序开发更上一层楼,设计模式的使用不仅能够简化代码,而且能够是代码效率更高,程序的灵活性,复用性大幅度提高,灵活使用设计模式是进入程序开发高层次阶段的必备知识
适配器模式
 
       适配器模式是将一个类的方法接口转换成客户端期望的接口表示。我们可以约定,把客户端期望的接口叫做目标Targetable,被转换的类叫source。适配器模式可以分为:类的适配器模式,对象的适配器,接口的适配器。
 
类的适配器模式
 
已有的被转换的类:
 
public class SourceClass {
 
    public void method1() {
        System.out.print("Hi, I am a method in sourceClass");
    }
 
}
 
期望的目标:
 
public interface Targetable {
    void method1();
    void method2();
}
 
实现目标,进行适配
 
public class AdapterClass extends SourceClass implements Targetable {
 
    @Override
    public void method2() {
        System.out.print("Hi All, I am a method in adapterClass");
    }
}
 
这样子就将SourceClass按照意愿Targetable适配转换成了AdapterClass,AdapterClass具有了SourceClass的所有的功能,同时也达到了扩展SourceClass。由于类的适配器模式是通过继承实现的,它具有了继承的优缺点。关于缺点,比如通过AdapterClass对象可以调用属于SourceClass而在Targetable接口中没有的方法。
 
对象的适配器模式
 
对象的适配器模式,就是将原来类的对象转换为目标接口的对象。对象适配器模式没有继承被转换类,而是持有被转换类的对象。这可以避免继承被带来的副作用。
 
public class AdapterObjectClass implements Targetable{
 
    private SourceClass mSourceClass;
 
    public AdapterObjectClass(SourceClass mSourceClass) {
        this.mSourceClass = mSourceClass;
    }
 
    @Override
    public void method2() {
        System.out.print("hi all, i am a method in AdapterObjectClass");
    }
 
    @Override
    public void method1() {
        mSourceClass.method1();
    }
}
 
接口的适配器模式
 
当一个接口有很多的抽象方法时,当我们写这个接口的实现类,必须实现该接口的全部方法。而有时候接口中并不是所有的抽象方法都是我们必须的,而我们只需要实现其中的某一些方法。为了解决这个问题,我们可以使用接口的适配器模式,引入一个抽象类,这个抽象类提供了接口所有抽象方法的空实现。我们可以继承这个抽象类,并只重写我们需要的方法即可。
 
比如,在上面我们只要Targetable的method2方法。
 
public abstract class AdapterInterfaceClass implements Targetable{
 
    @Override
    public void method1() {
 
    }
 
    @Override
    public void method2() {
 
    }
}
 
public class AdapterWraper extends AdapterInterfaceClass {
 
    @Override
    public void method1() {
        System.out.print("hi all, I am a method in AdapterWraper class");
    }
}
 
锚点装饰者模式
 
装饰者模式的核心思想是,装饰者和被装饰者实现同一个接口,将被装饰者注入装饰者中,可以在装饰者中扩展被装饰者。
 
public interface Person {
    void eat();
}
 
被装饰者:
 
public class Man implements Person {
 
    @Override
    public void eat() {
        System.out.print("There is a man who is eating");
    }
}
 
装饰者:
 
public class ManDecorator implements Person {
 
    private Person mPerson;
 
    public ManDecorator(Person person) {
        mPerson = person;
    }
 
    @Override
    public void eat() {
        mPerson.eat();
        drinkWater();
        System.out.print("I finish my lunch");
    }
 
    private void drinkWater() {
        System.out.print("Man is drinking water");
    }
}
 
使用:
 
Man man = new Man();
ManDecorator manDecorator = new ManDecorator(man);
manDecorator.eat();
 
输出的结果:
 
There is a man who is eating
Man is drinking water
I finish my lunch
 
锚点代理模式
 
注意区别代理模式和动态代理。
 
生活中代理的例子。比如如果你要租房子,你可能不知道该地区的房子信息,这时你可以找一个熟悉的人来帮忙,这个帮你的人就是代理;又比如,打官司时,我们可能并不精通法律知识,这时我们可以找一个代理律师来帮我们。等等。。对于,代理的工作可以抽象为一个接口。
 
public interface WorkInterface {
    void rentHouse();
}
 
一个房东:
 
public class LandLady implements WorkInterface {
 
    @Override
    public void rentHouse() {
        System.out.print("您好!我是房东。我这里有房子出租!");
    }
}
 
代理房东的代理类:
 
public class Proxy implements WorkInterface {
 
    private LandLady mLandLady;
 
    public Proxy() {
        mLandLady = new LandLady();
    }
 
    @Override
    public void rentHouse() {
        mLandLady.rentHouse();
    }
}
 
租客去找代理租房子:
 
WorkInterface proxy = new Proxy();
proxy.rentHouse();
1
2
锚点外观模式
 
在医院里的前台接待员就是一个外观模式的体现。由于病人来到医院可能对医院内部和流程并不熟悉,那么可以由熟悉这些的接待员来帮病人来完成这些事情。
 
部门1
 
public class ModuleA {
 
    //提供给外部调用的方法
    public void a1() {}
 
    //内部完成工作的实现
    private void a2() {}
    private void a3() {}
}
 
部门2
 
public class ModuleB {
 
    //提供给外部调用的方法
    public void b1() {}
 
    //内部完成工作的实现
    private void b2() {}
    private void b3() {}
}
 
部门3
 
public class ModuleC {
 
    //提供给外部调用的方法
    public void c1() {}
 
    //内部完成工作的实现
    private void c2() {}
    private void c3() {}
}
 
外观类:
 
public class ModuleFacade {
 
    private ModuleA mModuleA = new ModuleA();
    private ModuleB mMBModuleB = new ModuleB();
    private ModuleC mMCModuleC = new ModuleC();
 
    public void a1() {
        mModuleA.a1();
    }
 
    public void b1() {
        mMBModuleB.b1();
    }
 
    public void c1() {
        mMCModuleC.c1();
    }
 
}
 
当我们需要ModuleA,ModuleB, ModuleC的功能时,我们并不直接和他们打交道,也不需要了解部门的功能是如何实现的,而我们只需要去找外观类沟通即可。
 
外观模式的关键点是整合。
 
锚点桥接模式
 
桥接模式,提供一个解耦或者连接抽象化和实现化的一个桥梁,使得二者可以独立变化。
 
一个接口作为桥,一个抽象类持有桥。桥和抽象类两者可以独立变化。
 
桥:
 
public interface Qiao {
    void toArea();
}
 
抽象类:
 
public abstract class FromArea {
    public Qiao qiao;
    abstract public void fromArea();
}
 
QiaoC.java
 
public class QiaoC implements Qiao {
 
    @Override
    public void toArea() {
        System.out.print("I want to go Area C");
    }
}
 
QiaoD.java
 
public class QiaoD implements Qiao {
 
    @Override
    public void toArea() {
        System.out.print("I want to go Area D");
    }
}
 
FromAreaA.java
 
public class FromAreaA extends FromArea {
 
    @Override
    public void fromArea() {
        System.out.print("I come from area A");
    }
}
 
FromAreaB.java
 
public class FromAreaB extends FromArea {
 
    @Override
    public void fromArea() {
        System.out.print("I come from area B");
    }
}
 
使用:
 
FromAreaA fromAreaA = new FromAreaA();
QiaoC qiaoC = new QiaoC();
fromAreaA.qiao = qiaoC;
 
fromAreaA.fromArea();
fromAreaA.qiao.toArea();
 
QiaoD qiaoD = new QiaoD();
fromAreaA.qiao = qiaoD;
 
fromAreaA.fromArea();
fromAreaA.qiao.toArea();
 
从上面可以看出,Qiao和FromArea两者是独立变化的,它们的抽象和实现是分离的。
 
如果有更多的Qiao和FromArea的实现,只要扩展它们即可。
 
锚点组合模式
 
组合模式,又叫“整体-部分设计模式”。它一般用于实现树形结构。
 
节点
 
public class TreeNode {
 
    private String name;
    private TreeNode parent;
    private Vector children = new Vector<>();
 
    public TreeNode(String name) {
        this.name = name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    public void setParent(TreeNode parent) {
        this.parent = parent;
    }
 
    public TreeNode getParent() {
        return parent;
    }
 
    public void addChild(TreeNode child) {
        children.add(child);
    }
 
    public boolean removeChild(TreeNode child) {
        return children.remove(child);
    }
 
    public Enumeration getChildren() {
        return children.elements();
    }
 
}
 
整体,建立一棵树:
 
public class Tree {
    TreeNode root = null;
 
    public Tree(String name) {
        root = new TreeNode(name);
    }
 
    public static void main(String[] args) {
        Tree tree = new Tree("A");
        TreeNode nodeB = new TreeNode("B");
        TreeNode nodeC = new TreeNode("C");
 
        nodeB.addChild(nodeC);
        tree.root.addChild(nodeB);
        System.out.println("build the tree finished!");
    }
}
 
锚点享元模式
 
享元模式主要是实现对象的共享。联想数据库的连接池。
 
public class ConnectionPool {  
 
    private Vector pool;  
 
     
    private String url = "jdbc:mysql://localhost:3306/test";  
    private String username = "root";  
    private String password = "root";  
    private String driverClassName = "com.mysql.jdbc.Driver";  
 
    private int poolSize = 100;  
    private static ConnectionPool instance = null;  
    Connection conn = null;  
 
     
    private ConnectionPool() {  
        pool = new Vector(poolSize);  
 
        for (int i = 0; i < poolSize; i++) {  
            try {  
                Class.forName(driverClassName);  
                conn = DriverManager.getConnection(url, username, password);  
                pool.add(conn);  
            } catch (ClassNotFoundException e) {  
                e.printStackTrace();  
            } catch (SQLException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
 
     
    public synchronized void release() {  
        pool.add(conn);  
    }  
 
     
    public synchronized Connection getConnection() {  
        if (pool.size() > 0) {  
            Connection conn = pool.get(0);  
            pool.remove(conn);  
            return conn;  
        } else {  
            return null;  
        }  
    }  
}