三、值对象模式

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

基本的编写步骤：

第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的各层理论上是没有先后的。

六、常见设计模式应用