初学者对Java设计模式的认识(二)

1.适配器模式

将一个类的接口转换成客户希望的另外一个接口，使得原本接口不兼容而不能一起工作的那些类能一起工作。
适配器模式分为类的适配器模式、对象的适配器模式、接口的适配器模式。

1.1类的适配器模式

将适配的类的API转换为目标类的API，创建一个适配类，继承原有类，实现新接口。

public interface Targetable {
	public void method1();
	public void method2(); //新添加的方法
}
public class Source {
	public void method1() {
		System.out.println("this is method1");
	}
}
//保证原有接口不变，利用适配器生成新的接口
public class Adapter extends Source implements Targetable {
	public void method2() {
		System.out.println("this is method2");
	}
}

public class Client {
	public static void main(String []args) {
			Targetable adapter =new Adapter();
			adapter.method1();
			adapter.method2();
	}
}

1.2对象的适配器模式

使用委派关系连接，适配类实现新接口，并将初始化原本类，方法直接利用原本类的实例去调用。

public interface Targetable {
	public void method1();
	public void method2(); //新增方法
}
public class Source {
	public void method1() {
		System.out.println("this is method1");
	}
}
public class Wrapper implements Targetable {
	
	private Source source;
	
	public Wrapper(Source source) {
		this.source = source;
	}
	public void method1() {
		source.method1();
	}
	public void method2() {
		System.out.println("this is method2");
	}
}

public class Client {
	public static void main(String []args) {
			Targetable wrapper =new Wrapper(new Source());
			wrapper.method1();
			wrapper.method2();
	}
}

1.3接口的适配器模式

不希望接口实现所有的方法，可以创建一个抽象类Wrapper，实现所有的方法，我们写别的类时，继承抽象类即可。

public interface Targetable {
	public void method1();
	public void method2();
}
public class Wrapper implements Targetable {
	public void method1() {}
	public void method2() {}
}
public class Source extends Wrapper {
	public void method1() {
		System.out.println("this is method1");
	}
}
public class Source1 extends Wrapper{
	public void method2() {
		System.out.println("this is method2");
	}
}

public class Client {
	public static void main(String []args) {
			Source source =new Source();
			source.method1();
			source.method2();
			Source1 source1 =new Source1();
			source1.method1();
			source1.method2();
	}
}

2.装饰模式

给一个对象添加新的功能，相当于装饰类实现原有接口重写方法，方法里边需要有原有类的实现。

public interface Sourceable {
	public void method();
}
public class Source implements Sourceable {
	public void method() {
		System.out.println("this is method");
	}
}
public class Decorator implements Sourceable {
	private Source source;
	public Decorator(Source source) {
		// TODO Auto-generated constructor stub
		super();
		this.source = source;
	}
	@Override
	public void method() {
		// TODO Auto-generated method stub
		System.out.println("before");
		source.method();
		System.out.println("after");
		
	}

}

public class Client {
	public static void main(String []args) {
			Sourceable sourceable = new Decorator(new Source());
			sourceable.method();
	}
}

3.代理模式

给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。个人感觉和装饰模式很类似，只是代理模式可能做的更加的具体。

public interface Sourceable {
	public void method();
}
public class Source implements Sourceable {
	public void method() {
		System.out.println("this is method");
	}
}
public class Proxy implements Sourceable {
	private Source source;
	public Proxy(Source source) {
		this.source = source ;
	}
	public void method() {
		before();
		source.method();
		after();
		
	}
	public void before() {
		System.out.println("one");
	}
	public void after() {
		System.out.println("two");
	}
}

public class Client {
	public static void main(String []args) {
			Sourceable sourceable = new Proxy(new Source());
			sourceable.method();
	}
}

4.外观模式

为了解决类与类之间的依赖关系，就像spring一样，将类与类之间的关系配置到配置文件中，外观模式就是将他们的关系放在一个类里边，降低类与类之间的耦合度。

public class CPU {
	public void startup() {
		System.out.println("CPU启动");
	}
	public void shutdown() {
		System.out.println("CPU关闭");
	}
}
public class Memory {
	public void startup() {
		System.out.println("Memory启动");
	}
	public void shutdown() {
		System.out.println("Memory关闭");
	}
}
public class Disk {
	public void startup() {
		System.out.println("Disk启动");
	}
	public void shutdown() {
		System.out.println("Disk关闭");
	}
}
public class Computer {
	private CPU cpu;
	private Memory memory;
	private Disk disk;
	public Computer() {
		cpu = new CPU();
		memory = new Memory();
		disk = new Disk();
	}
	public void startup() {
		cpu.startup();
		memory.startup();
		disk.startup();
	}
	public void shutdown() {	
		disk.shutdown();
		memory.shutdown();
		cpu.shutdown();
	}
}

public class Client {
	public static void main(String []args) {
			Computer computer = new Computer();
			computer.startup();
			computer.shutdown();
	}
}

5.桥接模式

将抽象化与实现化解耦，使得二者可以独立变化。类似jdbc桥drivermanager一样。

public interface Sourceable {
	public void method();
}
public class Source implements Sourceable {
	public void method() {
		System.out.println("this is source");
	}
}
public class Source1 implements Sourceable{
	public void method() {
		System.out.println("this is source1");
	}
}
public abstract class Bridge {
	private Sourceable sourceable;

	public Sourceable getSourceable() {
		return sourceable;
	}

	public void setSourceable(Sourceable sourceable) {
		this.sourceable = sourceable;
	}
	
	public void method() {
		sourceable.method();
	}
}
public class MyBridge extends Bridge {
	public void method() {
		getSourceable().method();
	}
}

public class Client {
	public static void main(String []args) {
		Bridge bridge = new MyBridge();
		
		Sourceable sourceable1 = new Source();
		bridge.setSourceable(sourceable1);
		bridge.method();		
		
		Sourceable sourceable2 =new Source1();
		bridge.setSourceable(sourceable2);
		bridge.method();
	}
}

6.组合模式

将对象组合成树形结构以表示’部分-整体’的层次结构。

public class TreeNode {
	private String name;
	private TreeNode parent;
	private Vector<TreeNode> children = new Vector<TreeNode>();
	
	public TreeNode(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public TreeNode getParent() {
		return parent;
	}

	public void setParent(TreeNode parent) {
		this.parent = parent;
	}
	public void add(TreeNode node) {
		children.add(node);
	}
	public void remove(TreeNode node) {
		children.remove(node);
	}
	public Enumeration<TreeNode> getChildren(){
		return children.elements();
	}

}

public class Client {
	public static void main(String []args) {
		TreeNode nodeA = new TreeNode("A");
		TreeNode nodeB = new TreeNode("B");
		TreeNode nodeC = new TreeNode("C");
		
		nodeB.add(nodeC);
		nodeA.add(nodeB);
	}
}

7.享元模式

该模式可以实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。

//创建jdbc连接池
public class ConnectionPool {
	
	private Vector<Connection> pool;
	
	private String url = "jdbc:mysql://localhost:3306/bs";
	
	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;
	
	public ConnectionPool() {
		pool = new Vector<Connection>(poolSize);
		
		for(int i=0;i<poolSize;i++) {
			try {
				Class.forName(driverClassName);
				conn = DriverManager.getConnection(url,username,password);
				pool.add(conn);
			}catch (ClassNotFoundException e) {
				// TODO: handle exception
				e.printStackTrace();
			}catch (SQLException e) {
				// TODO: handle exception
				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;
	}

}

//比较连接池与普通的连接方式(100次)
public class Client {
	public static void main(String []args) {
		 try {  
             /*使用连接池创建100个连接的时间*/             
			 ConnectionPool  connPool= new ConnectionPool();
               // SQL测试语句  
              String sql = "Select * from search";  
              // 设定程序运行起始时间  
              long start = System.currentTimeMillis();  
                    // 循环测试100次数据库连接  
                     for (int i = 0; i < 100; i++) {  
                         Connection conn = connPool.getConnection(); // 从连接库中获取一个可用的连接  
                         Statement stmt = conn.createStatement();  
                         ResultSet rs = stmt.executeQuery(sql);  
                         while (rs.next()) {  
                             String name = rs.getString("title"); 
                             System.out.println("title"+name);
                          //  System.out.println("查询结果" + name);  
                         }  
                         rs.close();  
                         stmt.close();  
                         connPool.release();// 连接使用完后释放连接到连接池  
                     }  
                     System.out.println("经过100次的循环调用，使用连接池花费的时间:"+ (System.currentTimeMillis() - start) + "ms");  
                     
                     // 设定程序运行起始时间  
                     start = System.currentTimeMillis();  
                       
                     /*不使用连接池创建100个连接的时间*/  
                    // 导入驱动  
                     Class.forName("com.mysql.jdbc.Driver");  
                     for (int i = 0; i < 100; i++) {  
                         // 创建连接  
                        Connection conn = DriverManager.getConnection(  
                                 "jdbc:mysql://localhost:3306/bs", "root", "root");  
                         Statement stmt = conn.createStatement();  
                         ResultSet rs = stmt.executeQuery(sql);  
                        while (rs.next()) {  
                         }  
                        rs.close();  
                        stmt.close();  
                        conn.close();// 关闭连接  
                    }  
                    System.out.println("经过100次的循环调用，不使用连接池花费的时间:"  
                            + (System.currentTimeMillis() - start) + "ms");  
                } catch (SQLException e) {  
                   e.printStackTrace();  
                } catch (ClassNotFoundException e) {  
                    e.printStackTrace();  
               }  
	}
}