Java之------常用的设计模式

标签：

一、单例模式

a、单例模式：单例是最简单的很常用的一种设计模式，保证了一个类在内存中只能有一个对象。
思路：
  1) 如果其他程序能够随意用new创建该类对象，那么就无法控制个数。因此，不让其他程序用new创建该类的对象。
  2) 既然不让其他程序new该类对象，那么该类在自己内部就要创建一个对象，否则该类就永远无法创建对象了。
  3) 该类将创建的对象对外(整个系统)提供，让其他程序获取并使用。
步骤：
  1) 将该类中的构造函数私有化。
  2) 在本类中创建一个本类对象。
  3) 定义一个方法，返回值类型是本类类型。让其他程序通过该方法就可以获取到该类对象。
1、饿汉式：在类造成之初就新建了一个对象，并且将构造方法设置成私有的，因此外界无法通过new对象的方式过的实例，只能通过getInstance()的方法获得对象实例。

package pattern.singleton.one;

public class TestSingle {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
        Single s1=Single.getInstance();
        Single s2=Single.getInstance();
        System.out.println(s1==s2);
	}
}
class Single {
	/**
	 * 饿汉式
	 */
    private static final Single s=new Single();
    private Single(){
    }
    public static Single getInstance(){
    	return s;
    }
}

public class Single2 {
    /**
     * 懒汉式
     */
	private static Single2 s=null;
	private Single2(){
	}
	public static Single2 getInstance(){
		
		if (s==null){
			s=new Single2();
		}
		return s;
	}
}

<pre name="code" class="java">public class Single2 {
    /**
     * 懒汉式
     */
	private static Single2 s=null;
	private Single2(){
	}
	public static synchronized Single2 getInstance(){
		//synchronized互斥锁，只能一个一个地拿，防止线程多个拿到相同实例
		if (s==null){
			s=new Single2();
		}
		return s;
	}
}

import java.util.HashMap;
import java.util.Map;

public class A {
   private static final Map<String, A> map= new HashMap<String, A>();
   public static A getInstance(String key){
	   A a = map.get(key);
	   if(a==null){
		   a = new A();
		   map.put(key, a);
	   }
	   return a;
   }
}

import java.util.HashMap;
import java.util.Map;

public class A {
    //容器
	private static final Map<Integer, A> map 
	                                 = new HashMap<Integer, A>();
	private static int num=1;//代表池中目前将要被使用的对象的序号
	private static final int MAX=4;//控制容器中所能使用对象的总个数
	public static A getInstance(){
		A a = map.get(num);
		if(a==null){
			a = new A();
			map.put(num, a);
		}
		num++;
		if(num>MAX){
			num = 1;
		}
		
		return a;
	}
	
}

Java开发讲究的是面向接口编程，需要通过一个工厂类隐藏具体的实现类

先创建接口(接口在设计之初就要定好，开发过程中不允许随意改动接口)：

<span style="font-size:14px;">public interface DepApi {
   public String t1();
</span><p><span style="font-size:14px;">}</span></p>

public class DepImpl1 implements DepApi {
	@Override
	public String t1() {
		System.out.println("Api impl1....");
		return "1111111";
	}
}	

public class DepFactory {
	// 工厂方法,命名规范：createDepApi,geDepApi,getDepInstance
	public static DepApi getDepApi() {
		return new DepImpl1();
	}
}

public class Client {
	public static void main(String[] args) {
         DepApi api = DepFactory.getDepApi();
         System.out.println(api.t1());
         
	}
}

DepApi impl1....

<span style="font-size:14px;">1111111</span>

三、值对象模式

值对象的本质是“封装数据”

基本的编写步骤：

第1步：写一个类，实现可序列化（如果以后数据是往数据库里存的，那么可以不序列化，节省资源）
第2步：私有化所有属性，保持一个默认构造方法(public无参)
第3步：为每个属性提供get()、set()方法（如果是boolean型变量，最好把get改成is）
第4步：推荐覆盖实现equals()、hashCode()和toString()方法

import java.io.Serializable;

public class User implements Serializable{//只能将支持 java.io.Serializable 接口的对象写入流中
	private String userId;
	private String tel;
	private String address;
    private int age;
    private boolean isMale;
    
	public User(String userId, String tel, String address, int age) {
		super();
		this.userId = userId;
		this.tel = tel;
		this.address = address;
		this.age = age;
	}
	public User(){
		
	}
	
	public String getUserId() {
		return userId;
	}
	public void setUserId(String userId) {
		this.userId = userId;
	}
	public String getTel() {
		return tel;
	}
	public void setTel(String tel) {
		this.tel = tel;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public boolean isMale() {
		return isMale;
	}
	public void setMale(boolean isMale) {
		this.isMale = isMale;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((userId == null) ? 0 : userId.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (userId == null) {
			if (other.userId != null)
				return false;
		} else if (!userId.equals(other.userId))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "User [userId=" + userId + ", tel=" + tel + ", address="
				+ address + ", age=" + age + "]";
	}
	
}

四、装饰模式

装饰模式：在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

例：写一个MyBufferedReader类，使它能够对字符流(如FileReader、InputStreamReader和PipedReader等)进行功能增强：

(1) 提供带缓冲的myRead()方法，对原有的read()方法进行增速；
(2)提供一个能够每次读取一行字符的myReadLine()方法。

类体系对比：

import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PipedReader;
import java.io.Reader;

public class MyBufferedReader extends Reader{// ★
	private Reader r;// 封装  ★
	private char[] buf = new char[1024];
	private int count = 0;// 记录当前缓冲区中的字符个数
	private int pos = 0;// 游标，数组下标，当前读取的是数组中的哪个元素

	public MyBufferedReader(Reader r) { // ★
		super();
		this.r = r;
	}

	public int myRead() throws IOException {
		// 当缓冲区为空时，用r对象到文件中去读取一组数据到缓冲区中
		if (count <= 0) {
			count = r.read(buf);
			if (count < 0) {
				return -1;
			}
			pos = 0;
		}

		// 从缓冲区中取一个字符出去
		char ch = buf[pos];
		pos++;
		count--;
		return ch;
	}

	public String myReadLine() throws IOException {
		StringBuilder strBuild = new StringBuilder();
		int ch = 0;
		while ((ch = myRead()) != -1) {
			if (ch == '\r') {// 回车
				continue;
			}
			if (ch == '\n') {// 换行
				return strBuild.toString();
			}
			strBuild.append((char)ch);
		}
		if (strBuild.length() != 0) {
			return strBuild.toString();
		}

		return null;
	}

	public void MyClose() throws IOException {
		r.close();
	}

	@Override
	public int read(char[] cbuf, int off, int len) throws IOException {
		return r.read(cbuf, off, len);
	}

	@Override
	public void close() throws IOException {
		r.close();
	}
	
}

五、DAO模式

1、DAO其实是利用组合工厂模式来解决问题的，并没有带来新的功能，所以学的其实就是个思路。

2、DAO理论上是没有层数限制的。

3、DAO的各层理论上是没有先后的。

六、常见设计模式应用

Java之------常用的设计模式

标签：

原文地址：http://blog.csdn.net/x121850182/article/details/51232271