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();
    }





}