设计模式(23种，java)

工厂模式

设计模式的介绍的详细博客。
http://blog.csdn.net/longyulu/article/details/9159589

工厂模式，主要是在不知道哪个具体的对象去某个事情的时候，我们需要一个帮助类去管理这些对象，因为这些对象都可以干这件事情，只是具体做法不同而已，如果我们每次都去new一个对象的化，代码变的非常繁杂和无序，而通过工厂类的办法，我们只需要修改类名，就可以轻松的完成功能了，这就是工厂模式。具体看代码，好好体会一下了。

package com.ation;

//动物接口
interface IAnimal {
    public void eatFood();
}

//具体的对象，人类
class People implements IAnimal {
    @Override
    public void eatFood() {
    // TODO Auto-generated method stub
    System.out.println("吃米饭");
    }
}
//狗
class Dog implements IAnimal {
    @Override
    public void eatFood() {
    // TODO Auto-generated method stub
    System.out.println("吃骨头");
    }
}
//猫
class Cat implements IAnimal {
    @Override
    public void eatFood() {
    // TODO Auto-generated method stub
    System.out.println("吃鱼");
    }
}

//工厂类,作用，主要在我们不知道具体类的情况下，我们只知道有个事情需要有人去做，比如eatFood，但我们不知道谁去做，可能是人，狗，猫
//如果我们没有工厂类的情况下，我们可能每次都需要new一个实体对象出来，然后去做某个事情。现在我只需要知道名字，就可以派人去做，随时可以更换

class Factory {
    public static IAnimal getInstance(String type) {
    if ("Cat".equals(type)) {
        return new Cat();
    }else if("Dog".equals(type)){
        return new Dog();
    }else if("People".equals(type)){
        return new People();
    }else{
        System.out.println("输出类型不对，请检查！");
        return null;
    }
    }
}

public class Test {
    public static void main(String[] args) {
        IAnimal animal = Factory.getInstance("Cat");
        animal.eatFood();       
    }
}

抽象工厂模式

抽象工厂模式和工厂模式很像，但是有点区别，就在与我们设计的时候工厂模式对象的往往是某一个事情，而往往抽象工厂模式对应的确实有多个相关的产品需要去做，但我们也不想每次都需要new一个对象，我们希望有个单独的对象去做这个事情，我们只需要管理这个对象就ok了。这个类就是抽象工厂模式。

interface IMobliePhone {
    public void puduct();
}

interface IUSB {
    public void puduct();
}


class MobliePhone implements IMobliePhone{
    @Override
    public void puduct() {
        // TODO Auto-generated method stub
    System.out.println("生产手机");
    }
}
class Usb implements IUSB{
    @Override
    public void puduct() {
        // TODO Auto-generated method stub
        System.out.println("生产USB");
    }
}

interface IAbstraFactory{
    public IMobliePhone createMobliePhone();
    public IUSB     createUSB();
}

class AbstraFactory implements IAbstraFactory{
    @Override
    public IMobliePhone createMobliePhone() {
        // TODO Auto-generated method stub
        return new MobliePhone();
    }
    @Override
    public IUSB createUSB() {
        // TODO Auto-generated method stub
        return new Usb();
    }
}

public class Test {
    public static void main(String[] args) {

    AbstraFactory factory = new AbstraFactory();
    factory.createMobliePhone().puduct();
    factory.createUSB().puduct();
    }
}

单例模式

单例模式顾名思义，我们知道这种模式表示，程序中只能存在一个对象，不能够重复创建，例如生活中常见的战斗机飞行员一般只能存在一个在控制飞行，多了，就会发生危险。
这种设计模式，一般特点是构造函数私有化。

// 单例模式，构造方法私有化是主要特点
class Singleton {
    // 私有静态实例，外界无法访问，在第一个访问为null,分配实例
    private static Singleton instance = null;

    // 构造方法私有化
    private Singleton() {
    }
    //静态调用
    public static Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
    }

    public void showInfo() {
    System.out.println("单例模式");
    }
}

//测试
public class Test {
    public static void main(String[] args) {
    Singleton.getInstance().showInfo(); 
    }
}

原型模式

原型模式意思很简单：就是对当前对象进行复制，因为这个复制产生的消耗比new要小的多，所以一般会有原型模式的使用

// 原型模式（Prototype），对当前存在的对象进行复制
//浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
//深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。
class Prototype implements Cloneable, Serializable {  

    private static final long serialVersionUID = 1L;  
    private String string;  

    private SerializableObject obj;  

    /* 浅复制 */  
    public Object clone() throws CloneNotSupportedException {  
        Prototype proto = (Prototype) super.clone();  
        return proto;  
    }  

    /* 深复制 *，二进制流复制*/  
    public Object deepClone() throws IOException, ClassNotFoundException {  

        /* 写入当前对象的二进制流 */  
        ByteArrayOutputStream bos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = new ObjectOutputStream(bos);  
        oos.writeObject(this);  

        /* 读出二进制流产生的新对象 */  
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
        ObjectInputStream ois = new ObjectInputStream(bis);  
        return ois.readObject();  
    }  

    public String getString() {  
        return string;  
    }  

    public void setString(String string) {  
        this.string = string;  
    }  

    public SerializableObject getObj() {  
        return obj;  
    }  

    public void setObj(SerializableObject obj) {  
        this.obj = obj;  
    }  

}  

class SerializableObject implements Serializable {  
    private static final long serialVersionUID = 1L;  
}  

建造者模式

建造者模式教程
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。