创建型模式
工厂方法模式(Factory Method)
工厂方法模式分为三种 :普通工厂模式,多个工厂方法模式,静态工厂方法模式
普通工厂模式
--- 发送邮件和短信- 接口public interface Sender{ public void Send();}
- 实现类public class MailSender implements Sender{ @Override public void Send(){ System.out.println("MailSender Method"); }}------------------------------------------------------------------------------------------------------------------------------------------------------------------------public class SmsSender implements Sender{ @Override public void Send(){ System.out.println("SmsSender Method"); }}
- 工厂类public class SendFactory{ public Sender produce(String type){ if("mail".equals(type)){ return new MailSender(); }else if("sms".equals(type)){ return new SmsSender(); }else{ System.out.println("Please input right type!"); } }}
- 测试类public class FactoryTest{ public static void main(String[] args){ SendFactory factory=new SendFactory(); Sender sender=factory.produce("sms"); sender.Send(); }}
复制代码
多个工厂方法模式
- SendFactory类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(); }}
复制代码
静态工厂方法模式
- SendFactorypublic class SendFactory{ public static Sender produceMail(){ return new MailSender(); }
public static Sender produceSms(){ return new SmsSender(); }}
- FactoryTestpublic class FActoryTest{ public static void main(String[] args){ Sender sender=SenderFactory.produceMail(); sender.Send(); }}
复制代码
总结
工厂模式适合出现大量的产品需要创建,并且具有共同的接口,可以通过工厂方法模式创建:
普通工厂模式: 如果传入字符串有误,就不能创建对象
静态工厂方法模式相对于多个工厂方法模式 ,不需要实例化工厂类
大多数情况下,采用静态工厂方法模式
抽象工厂模式(Abstract Factory)
工厂方法模式问题: 类的创建依赖工厂类.如果想要扩展程序,必须对工厂类进行修改,这违背了闭包原则
抽象工厂模式: 创建多个工厂类,一旦需要增加新的功能,直接增加工厂类就可以,不需要修改之前的工厂类
- Senderpublic interface Sender{ public void Sender();}
- 两个实现类 - MailSender public class MailSender implements Sender { @Override public void Send(){ System.out.println("This is MailSender!"); }}
- SmsSenderpublic class SmsSender implements Sender{ @Override public void Send(){ System.out.println("This is SmsSender!"); }}
- 两个工厂类 - 工厂类接口:public interface Provider{ public Sender produce();} - SendMailFactorypublic class SendMailFactory implements Provider{ @Override public Sender produce(){ return new MailSender(); }} - SendSmsFactorypublic class SendSmsFactory implements Provider{ @Override public Sender produce(){ return new SmsSender(); }}
- Testpublic class Test{ public static void main(String[] args){ Provider provider=new SendMailFactory(); Sender sender=provider.produce(); sender.Send(); }}
复制代码
抽象工厂模式的优点就是拓展性强:
如果需要增加一个功能,例如:发及时信息
只需做一个实现类, 实现 Sender 接口
做一个工厂类, 实现 Provider 接口
单例模式(Singleton)
单例模式 :保证在一个 JVM 中,一个单例对象只有一个实例存在
单例模式的优点:
某些类创建比较繁琐,对于一些大型对象,可以减少很大的系统开销
省去了 new 操作符,降低了系统内存的使用频率,减轻 GC(Garbage Collection-垃圾回收)压力
有些类比如交易所的核心交易引擎,控制着交易流程,如果该类可以创建多个,系统会完全混乱,所有只有使用单例模式,才能保证核心交易服务器独立控制整个流程
- 单例类public class Singleton{ /* 私有静态实例,防止被引用,赋值为null,目的是实现延迟加载 */ private static Singleton instance=null;
/* 私有构造方法,防止被实例化 */ private Singleton(){ }
/* 静态工厂方法,创建实例 */ public static Singleton getInstance(){ if(instance==null){ instance=new Singleton(); }
return instance; }
/* 如果该对象被用于序列化,可以保证对象在序列化前后保持一致 */ public Object ReadResolve(){ return instance; }}
复制代码
public static synchronized Singleton getInstance(){ if(instance==null){ instance=new Singleton(); } return instance;}
复制代码
由于 synchronized 锁住的是这个对象,这样的用法,每次调用 getInstance(),都要对对象上锁,在性能上会有所下降.
public static Singleton getInstance(){ if(instance==null){ synchronized(instance){ if(instance==null){ instance=new Singleton(); } } } return instance;}
复制代码
这样似乎解决了问题,将 synchronized 关键字加入内部,这样在调用的时候是不需要加锁的,只有在 instance 为 null,并创建对象的时候才需要的加锁,性能得到了提升,但是这样的情况还是有问题的
存在这样的情况:
在 Java 中创建对象和赋值操作是分开进行的
即 instance=new Singleton()是分两步执行的
JVM 并不保证这两个操作的先后顺序:
有可能 JVM 会为新的 Singleton 实例分配空空间,然后直接赋值给 instance 成员
然后再去初始化这个 Singleton 实例
这样就可能会出错
示例:
A,B 两个线程
A,B 线程同时进入第一个 if 判断
A 首先进入 synchronized 块,由于 instance 为 null, 执行 instance=new Singleton()
由于 JVM 内部的优化机制 ,JVM 先划出一些分配给 Singleton 的空白内存,并赋值给 instance 成员,此时还没有开始初始化这个实例,然后 A 离开了 synchronized 块
B 进入 synchronized, 由于 instance 此时不是 null, 因此它马上离开了 synchronized 块并将结果返回给调用该方法的程序
此时 B 线程打算使用 Singleton 实例,发现它还没有初始化,于是产生错误
代码需要进一步优化:
private static class SingletonFactory{ private static Singleton instance=new Singleton();}
public static Singleton getInstance(){ return SingletonFactory.instance;}
复制代码
实际情况是:
单例模式使用内部类来维护单例的实现
JVM 内部的机制能够保证当一个类被加载的时候,这个类的加载过程是互斥的
当第一次调用 getInstance 时,JVM 能够保证 instance 只被创建一次,并且会保证把赋值给 instance 的内存初始化完毕
该方法也只会在第一次调用的时候采用互斥机制,可以完美解决低性能的问题
public class Singleton{ /* 私有构造方法,防止被实例化 */ private Singleton(){}
/* 使用内部类维护单例 */ private static class SingletonFactory{ private static Singleton instance=new Singleton(); }
/* 获取实例 */ public static Singleton getInstance(){ return SingletonFactory.instance; }
/* 如果该对象被序列化,可以保证对象在序列化前后保持一致 */ public Object readResolve(){ return getInstance(); }}
复制代码
这种方法,如果在构造函数中抛出异常,实例将永远不会创建,也会出错.只能根据实际场景,选择最适合应用场景的实现方法
public class SingletonTest{ private static SingletonTest instance=null;
private SingletonTest(){}
private static synchronized void syncInit(){ if(instance==null){ instance=new SingletonTest(); } }
public static SingletonTest getInstance(){ if(instance==null){ syncInit(); } return instance; }}
复制代码
public class SingletonTest{ private static SingletonTest instance=null; private Vector properties=null; public Vector getProperties(){ return properties; }
private SingletonTest(){}
private static synchronized void syncInit(){ if(instance==null){ instance=new SingletonTest(); } }
public static SingletonTest getInstance(){ if(intance==null){ syncInit(); } return instance; }
public void updateProperties(){ SingletonTest shadow=new SingletonTest(); properties=shadow.getProperties(); }}
复制代码
单例模式的特点:
单例模式理解起来简单,具体实现起来是有一定难度的\
同步
异步
synchronized 关键字锁定的是对象,使用的时候要在恰当的地方使用:
注意需要使用锁的对象和过程,有时候不是整个对象及整个过程都需要锁
采用类的静态方法,可以实现单例模式的效果
类的静态方法和单例模式的区别:
静态类不能实现接口:
从类的角度说,是可以的,但是这样就会破坏静态了
接口中不允许有 static 修饰的方法,即使实现了也是非静态的
单例可以被延迟启动:
静态类在第一次加载时初始化
单例延迟加载,是因为有些类比较庞大,延迟加载有助于提升性能
单例可以被继承:
单例中的方法可以被重写
静态类内部方法都是 static,无法重写
单例比较灵活:
从实现上讲,单例只是一个普通的 Java 类,只要满足单例的基本要求,可以随心所欲地实现其它功能
静态类不行
单例模式内部可以就是用一个静态类实现
建造者模式(Builder)
工厂模式提供的是创建单个类的模式
建造者模式: 将各种产品集中起来进行管理,用来创建复合对象
复合对象: 指某个类具有不同的属性
建造者模式就是抽象工厂类模式和 Test 类结合起来得到的
代码实现: 一个 Sender 接口,两个实现类 MailSender 和 SmsSender
- Builderpublic 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); }}
复制代码
原型模式(Prototype)
原型模式: 将一个对象作为原型,进行复制,克隆,产生一个和原对象类似的新对象
原型模式虽然是创建型模式,但是与工厂模式没有关系
在 Java 中,复制对象是通过 clone() 实现的
- 原型类public class Prototype implements Cloneable{ public Object clone() throws CloneNotSupportedException{ Prototype proto=(Prototype)super.clone(); return proto; }}
复制代码
一个原型类,只需要实现 Cloneable 接口,重写 clone() 方法
clone 方法可以改写为任何名称,因为 Cloneable 接口是个空接口,可以任意定义实现类的方法名
重点是 super.clone():
super.clone() 方法调用的是 Object 的**clone() ** 方法
在 Object 类中 ,clone() 方法时 native 的
对象的深复制和浅复制:
深复制:
将一个对象复制后,不论是基本类型还是引用类型,都是重新创建的
深复制会进行完全彻底的复制
浅复制:
将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型指向的还是原对象的引用
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 clone() throws IOException,ClassNotFoundException{ /* 写出当前对象的二进制流 */ ByteArrayOutputStream bos=new ByteArrayOutputStream(); ObjectOutputStream oos=new ObjectOutputStream(bos); oos.writeObject(this);
/* 读入二进制流产生的新对象 */ ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray()); OnjectInputStream 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; }
复制代码
要实现深复制:
要采用流的形式读入当前对象的二进制输入
再写出二进制数据对应的对象
评论