问题解决+经验复用
设计模式原则:对扩展开放,对修改关闭,使用继承、抽象类、接口、低耦合

创建型模式:单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。

  • 1.单例

    确保一个类只有一个实例,并提供该实例的全局访问。

public class Singleton {
    private volatile static Singleton uniqueInstance;
    private Singleton() {
    }
    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}
//双重校验锁先判断 uniqueInstance 是否已经被实例化,如果没有被实例化,那么才对实例化语句进行加锁。
uniqueInstance = new Singleton(); 
1,分配内存空间
2,初始化对象
3,将 uniqueInstance 指向分配的内存地址
//由于 JVM 具有指令重排的特性,有可能执行顺序变为了 1>3>2.使用 volatile 可以禁止 JVM 的指令重排,保证在多线程环境下也能正常运行。
  • 2.工厂模式--类的创建依赖工厂类
  • 2.1简单工厂方法

    在创建一个对象时不向客户暴露内部细节,并提供一个实现的通用接口。

public interface Sender {
    public void Send();
}
public class MailSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}
public class SmsSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}
public class SendFactory {
    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        } else if ("sms".equals(type)) {
            return new SmSender();
        } else {
            System.out.println("请输入正确的类型!");
            return null;
        }
    }
}
public class FactoryTest {
    public static void main(String[] args) {
        SendFactory sendFactory = new SendFactory();
        Sender sender = sendFactory.produce("mail");
        sender.send();
    }
}
在main方法中通过指定参数调用工厂方法生成与参数对应的对象
  • 2.2多个工厂方法

    在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象

public class SendFactory {
    public Sender produceMail(){
        return new MailSender();
    }
    public Sender produceSms(){
        return new SmsSender();
    }
}    
public class FactoryTest {
    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        Sender sender = factory.produceMail();
        sender.Send();
    }
}
  • 2.3静态工厂方法--方便

    不需要创建实例,直接调用即可

public class SendFactory {

    public static Sender produceMail(){
        return new MailSender();
    }

    public static Sender produceSms(){
        return new SmsSender();
    }
}
public class FactoryTest {
    public static void main(String[] args) {    
        Sender sender = SendFactory.produceMail();
        sender.Send();
    }
}
  • 2.4抽象工厂

    避免对工厂类的直接修改,抽象工厂增加新的功能只需增加一个新的工厂类,而不需要修改原来的代码

public interface Sender {
    public void Send();
}
public class MailSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}
public class SmsSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}

程序只有一个发送的功能,SmsSender、MailSender两个端为功能的实现;现在需要再加一个新建对象的功能

public interface Provider {
    public Sender produce();
}
public class SendMailFactory implements Provider  implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
    @Override
    public Sender produce(){
        return new MailSender();
    }
}
public class SendSmsFactory implements Provider  implements Sender{

    @Override
    public Sender produce() {
        return new SmsSender();
    }
        @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}
  • 3.建造者模式

    建造者模式就是前面抽象工厂模式和最后的Test结合起来,将很多功能集成到一个类里,这个类可以创造出比较复杂的东西

public interface Sender {
    public void Send();
}
public class MailSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}
public class SmsSender implements Sender {
    @Override
    public void Send() {
        System.out.println("this is sms sender!");
    }
}
public class Builder {
    private List<Sender> list = new ArrayList<Sender>();
    public void produceMailSender(int count){
        for(int i=0; i<count; i++){
            list.add(new MailSender());
        }
    }
    public void produceSmsSender(int count){
        for(int i=0; i<count; i++){
            list.add(new SmsSender());
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Builder builder = new Builder();
        builder.produceMailSender(10);
    }
}
  • 4.原型模式

    将一个对象作为原型,对其进行复制、克隆,产生一个和原对象类似的新对象

public class Prototype implements Cloneable {
    public Object clone() throws CloneNotSupportedException {
        Prototype proto = (Prototype) super.clone();
        return proto;
    }
}

浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的。
深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。简单来说,就是深复制进行了完全彻底的复制,而浅复制不彻底。

public 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;
}