java 设计模式（迭代，原型，建造器，装饰）
尺有所短，寸有所长，物有所不足，智有所不明。
迭代器模式
定义：以一种一致的对集合内的元素进行遍历，而不用在乎集合内的数据结构
ArrayList 数组
LinkedList 链表
HashSet 数组+链表
TreeSet 二叉搜索树-》红黑树
public class Test {
public static void main(String[] args) {
//定义：以一种一致的对集合内的元素进行遍历，忽略底层数据结构
//ArratList 底层 数组
//LinkedList 链表
//HashSet 数组+链表
//Treeset 二叉搜索树->红黑树
ArrayList<Integer> integers = new ArrayList<>();
integers.add(2);
integers.add(3);
integers.add(5);
//两种遍历模式
for (Integer integer : integers) {
System.out.println(integer);
}
Iterator<Integer> iterator = integers.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
} 原型模式
原型模式就是讲一个对象作为原型，使用clone()方法来创建新的实例。
浅拷贝——>对象的属性仅仅是复制了地址，没有把内容新复制一份
public class User implements Cloneable {
//实现接口，
//浅拷贝
private String name;
private int age;
private Data Birthday;
public Data getBirthday() { return Birthday;
}
public void setBirthday(Date birthday) { Birthday = (Data) birthday;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// 重写父类Obj的一个方法（克隆方法g）
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
} 深拷贝——>拷贝一份内容，而不是地址。
import java.io.*;
import java.util.Date;
public class User2 implements Cloneable,Serializable {
private String name;
private int age;
private Date bir;
public String getName() { return name;
}
public void setName(String name) { this.name = name;
}
public int getAge() { return age;
}
public void setAge(int age) { this.age = age;
}
public Date getBir() { return bir;
}
public void setBir(Date bir) { this.bir = bir;
}
@Override
protected Object clone() throws CloneNotSupportedException {
ByteArrayOutputStream os = new ByteArrayOutputStream();
try {
//当前对象写入输出流
new ObjectOutputStream(os).writeObject(this);
//拿到字节数组
byte[] bytes = os.toByteArray();
ByteArrayInputStream is = new ByteArrayInputStream(bytes);
//对象输入流
ObjectInputStream ois = new ObjectInputStream(is);
return ois.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
}
return null;
}
}
import java.util.Date;
public class TestPrototype {
//根据已经有的对象，创建新的对象
//克隆
public static void main(String[] args) throws CloneNotSupportedException {
}
private static void copy() throws CloneNotSupportedException {
User user = new User();
user.setName("张三");
user.setAge(12);
user.setBirthday(new Date());
User cloneuser = (User) user.clone();
cloneuser.setBirthday(new Date(28));
System.out.println(user == cloneuser);//false 说明不知一个对象，克隆成功。
System.out.println(cloneuser.getAge());//12
System.out.println(cloneuser.getName());//张三
//当对象属性非常多，希望新创建的对象属性从已有的复制过来
// 而不是重新复制，使用原型模式（克隆）
// 修改其中的属性
System.out.println(cloneuser.getBirthday());
}
}
建造器模式
了解之前，先假设有一个问题，我们需要创建一个Person对象，属性有name,,sex,age,weight,height等属性，如果每一个属性都可以为空，也就是说我们可以只用一个name,也可以用一个weight,height,或者一个sex,age或者其他任意的赋值来创建一个学生对象，这时该怎么构造？
难道我们写6个1个输入的构造函数，15个2个输入的构造函数.......吗？这个时候就需要用到Builder模式了。给个例子，大家肯定一看就懂：
Person类
public class Person {
private String name;
private String sex;
private Integer weight;
private Integer height;
public Person(String name, String sex, Integer weight, Integer height) {
}
//建造器
public static class PersonBuider{
private String name;
private String sex;
private Integer weight;
private Integer height;
//返回值不再是void 而是建造器本身
public PersonBuider name(String name){
this.name=name;
return this;
}
public PersonBuider sex(String sex){
this.sex=sex;
return this;
}
public PersonBuider weight(Integer weight){
this.weight=weight;
return this;
}
@Override
public String toString() {
return "PersonBuider{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", weight=" + weight +
", height=" + height +
'}';
}
public PersonBuider height(Integer height){
this.height=height;
return this;
}
public Person build(){
//需要的信息收集齐了
return new Person(this.name,this.sex,this.weight,this.height);
}
}
public String getName() {
return name;
}
public String getSex() {
return sex;
}
public Integer getWeight() {
return weight;
}
public Integer getHeight() {
return height;
}
}
实现输出结果
package com.westos.Builder;
public class TestBuider {
public static void main(String[] args) {
Person.PersonBuider personBuider = new Person.PersonBuider().name("Jim").sex("nan").height(185).weight(88);
System.out.println(personBuider.toString());
//PersonBuider{name='Jim', sex='nan', weight=88, height=185}
}
}
装饰模式（Decorator）
给一类对象增加新的功能，装饰方法与具体的内部逻辑无关。
//装饰模式
//给一类对象增加新的功能，装饰方法与具体的内部逻辑无关
interface Source{void mathod();}
public class Decorator implements Source {
private Source source;
public void decotate1(){
System.out.println("decorate");
}
@Override
public void mathod() {
decotate1();
source.mathod();
}
}
查看6道真题和解析