GOF23-创建模型式
都是用来帮助我们创建对象的!!!!
01.单例模式
保证一个类只有一个实例,并且提供一个访问该实例的全局访问点
1.饿汉式
public class SingletonDemo1 {
//类初始化立即加载
private static /*final*/ SingletonDemo1 instance = new SingletonDemo1();
//私有构造器
private SingletonDemo1() {
}
//方法没有同步,调用效率高
public static SingletonDemo1 getInstance() {
return instance;
}
}
2.懒汉式 延迟加载
public class SingletonDemo2 {
//类初始化时,不初始化对象,延迟加载
private static SingletonDemo2 instance;
//私有构造器
private SingletonDemo2() {
}
//方法同步,调用效率低
public static synchronized SingletonDemo2 getInstance() {
if(instance==null){
instance=new SingletonDemo2();
}
return instance;
}
}
3.双重检测锁实现
/*
双重检测锁实现 由于JVM底层内部原因 偶然会出问题
*/
public class SingletonDemo3 {
//类初始化时,不初始化对象
private static SingletonDemo3 instance = null;
//私有构造器
private SingletonDemo3() {
}
/*
这个模式将同步内容下方到if内部,提高了执行的效率,
不必每次获取对象时都进行同步,
只有第一次才同步,创建了以后就没有必要了
*/
public static SingletonDemo3 getInstance() {
if (instance == null) {
SingletonDemo3 sc;
synchronized (SingletonDemo3.class) {
sc = instance;
if (sc == null) {
synchronized (SingletonDemo3.class) {
if (sc == null) {
sc = new SingletonDemo3();
}
}
instance = sc;
}
}
}
return instance;
}
}
4.静态内部类实现
/*
单例模式:
静态内部类实现(是一种懒加载)
*/
public class SingletonDemo4 {
//类初始化延迟加载
private static class SinglentonClassInstance{
private static /*final*/ SingletonDemo4 instance = new SingletonDemo4();
}
//私有构造器
private SingletonDemo4() {
}
//方法没有同步,调用效率高
public static SingletonDemo4 getInstance() {
return SinglentonClassInstance.instance;
}
}
5.枚举单例
/*
单例模式:
枚举单例(没有延迟加载)
*/
public enum SingletonDemo5 {
//枚举本身就是天然的单例
INSTANCE;
//添加自己需要的操作
public void singletonOperation(){
}
}
6.测试消耗时间
import java.util.concurrent.CountDownLatch;
/*
测试消耗的时间
*/
public class Client3 {
public static void main(String[] args) throws InterruptedException {
long l = System.currentTimeMillis();
//同步辅助类 countDown()计数减一 await() 阻塞
int num = 10;
final CountDownLatch countDownLatch = new CountDownLatch(num);
for (int i = 0; i < num; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10000000; i++) {
//Object instance = SingletonDemo4.getInstance();
Object instance = SingletonDemo5.INSTANCE;
}
countDownLatch.countDown();
}
}).start();
}
countDownLatch.await();
long l2 = System.currentTimeMillis();
System.out.println("时间:" + (l2 - l));
}
}
测试时间:
饿汉:20
懒汉:3837
双重检测:20
静态:40
枚举:10
02.工厂方法模式
1.简单工厂
虽然某种情况不符合设计原则,但实际使用最多
//接口
public interface Car {
void run();
}
//1简单工厂类
public class CarFactory {
public Car createCar(String type){
if("奥迪".equals(type)){
return new Audi();
}else if ("比亚迪".equals(type)){
return new Byd();
}else {
return null;
}
}
}
//2简单工厂类(静态工厂模式)
public class CarFactory2 {
public static Car createAudi() {
return new Audi();
}
public static Car createByd() {
return new Byd();
}
}
//实现方法
public class Audi implements Car{
@Override
public void run() {
System.out.println("奥迪再跑!");
}
}
//实现方法
public class Byd implements Car{
@Override
public void run() {
System.out.println("比亚迪在跑!");
}
}
//根据设计理论建议:工厂方法模式,但实际上,我们一般用简单工厂模式
public class Client01 {
public static void main(String[] args) {
/* Car c1 = new Audi();
Car c2 = new Byd();
c1.run();
c2.run();*/
Car c1 = new CarFactory().createCar("比亚迪");
Car c2 = new CarFactory().createCar("奥迪");
c1.run();
c2.run();
}
}
代码效果:
比亚迪在跑!
奥迪再跑!
2.工厂方法
不改变以有内的前提,通过增加新的工厂类实现扩展
//工厂模式
public interface Car {
void run();
}
public class Audi implements Car {
@Override
public void run() {
System.out.println("奥迪再跑!");
}
}
public class Benz implements Car{
@Override
public void run() {
System.out.println("奔驰在跑!");
}
}
public class Byd implements Car {
@Override
public void run() {
System.out.println("比亚迪在跑!");
}
}
//工厂方法模式
public interface CarFactory03 {
Car createCar();
}
public class AudiFactory implements CarFactory03{
@Override
public Car createCar() {
return new Audi();
}
}
public class BenzFactory implements CarFactory03{
@Override
public Car createCar() {
return new Benz();
}
}
public class BydFactory implements CarFactory03{
@Override
public Car createCar() {
return new Byd();
}
}
public class Client01 {
public static void main(String[] args) {
Car c1 = new AudiFactory().createCar();
Car c2 = new BydFactory().createCar();
Car c3 = new BenzFactory().createCar();
c1.run();
c2.run();
c3.run();
}
}
代码效果:
奥迪再跑!
比亚迪在跑!
奔驰在跑!
03.抽象工厂模式
抽象工厂:不可以增加产品,可以增加产品族
public interface CarFactory {
Engine createEngine();
Seat createSeat();
Tyre createTyre();
}
//发动机接口
public interface Engine {
void run();
void start();
}
class LuxuryEngine implements Engine{
@Override
public void run() {
System.out.println("转的快!");
}
@Override
public void start() {
System.out.println("启动快,可以自动停止!");
}
}
class LowEngine implements Engine{
@Override
public void run() {
System.out.println("转的慢!");
}
@Override
public void start() {
System.out.println("启动慢,可以自动停止!");
}
}
//按摩椅接口
public interface Seat {
void massage();
}
class LuxurySeat implements Seat{
@Override
public void massage() {
System.out.println("可以自动按摩!");
}
}
class LowSeat implements Seat{
@Override
public void massage() {
System.out.println("不可以按摩!");
}
}
//轮胎接口
public interface Tyre {
void revolve();
}
class LuxuryTyre implements Tyre{
@Override
public void revolve() {
System.out.println("轮胎磨损慢!");
}
}
class LowTyre implements Tyre{
@Override
public void revolve() {
System.out.println("轮胎磨损快!");
}
}
//低端工厂
public class LowCarFactoy implements CarFactory {
@Override
public Engine createEngine() {
return new LowEngine();
}
@Override
public Seat createSeat() {
return new LowSeat();
}
@Override
public Tyre createTyre() {
return new LowTyre();
}
}
//高端工厂
public class LuxuryCarFactoy implements CarFactory {
@Override
public Engine createEngine() {
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
return new LowSeat();
}
@Override
public Tyre createTyre() {
return new LuxuryTyre();
}
}
//抽象工厂:不可以增加产品,可以增加产品族
public class Client {
public static void main(String[] args) {
CarFactory fa = new LowCarFactoy();
Engine e = fa.createEngine();
e.run();
e.start();
}
}
代码效果:
转的慢!
启动慢,可以自动停止!
04.建造者模式
分离了对象子组件的单独构造(由Builder来负责)和装配(有由Director负责)。从而可以构造出复杂的对象
public interface AirShipBuilder {
Engine builderEngine();
OrbitalModule builderOrbitalModule();
EscapeTower builderEscapeTower();
}
public interface AirShipDirector {
//组装飞船对象
AirShip directAirShip();
}
//飞船
public class AirShip {
private OrbitalModule orbitalModule;//轨道舱
private Engine engine;//发动机
private EscapeTower escapeTower;//逃逸塔
public void launch(){
System.out.println("发射!");
}
public OrbitalModule getOrbitalModule() {
return orbitalModule;
}
public void setOrbitalModule(OrbitalModule orbitalModule) {
this.orbitalModule = orbitalModule;
}
public Engine getEngine() {
return engine;
}
public void setEngine(Engine engine) {
this.engine = engine;
}
public EscapeTower getEscapeTower() {
return escapeTower;
}
public void setEscapeTower(EscapeTower escapeTower) {
this.escapeTower = escapeTower;
}
}
class OrbitalModule {
private String name;
public OrbitalModule(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Engine {
private String name;
public Engine(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class EscapeTower {
private String name;
public EscapeTower(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//构建
public class SxtAirShipBuilder implements AirShipBuilder{
@Override
public Engine builderEngine() {
System.out.println("构建发动机!");
return new Engine("发动机");
}
@Override
public OrbitalModule builderOrbitalModule() {
System.out.println("构建轨道舱!");
return new OrbitalModule("轨道舱");
}
@Override
public EscapeTower builderEscapeTower() {
System.out.println("构建逃逸塔");
return new EscapeTower("逃逸塔");
}
}
//装配
public class SxtAirshipDirector implements AirShipDirector{
private AirShipBuilder builder;
public SxtAirshipDirector(AirShipBuilder builder){
this.builder = builder;
}
@Override
public AirShip directAirShip() {
Engine e = builder.builderEngine();
OrbitalModule o = builder.builderOrbitalModule();
EscapeTower et = builder.builderEscapeTower();
//组装成飞船对象
AirShip ship = new AirShip();
ship.setEngine(e);
ship.setEscapeTower(et);
ship.setOrbitalModule(o);
return ship;
}
}
public class Client {
public static void main(String[] args) {
SxtAirshipDirector director = new SxtAirshipDirector(new SxtAirShipBuilder());
AirShip ship = director.directAirShip();
System.out.println(ship.getEngine().getName());
ship.launch();
}
}
效果:
构建发动机!
构建轨道舱!
构建逃逸塔
发动机
发射!
05.原型模式
通过new产生一个对象需要非常繁琐的数据准备或访问权限,则可以使用元新模式
import java.io.Serializable;
import java.util.Date;
//prototype 原型模式
public class Sheep implements Cloneable, Serializable {
private String name;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone();//直接调用object对象的clone()方法!
/* //深复制
Sheep s = (Sheep)obj;
s.birthday = (Date) this.birthday.clone();*/
return obj;
}
public Sheep(String nsme, Date birthday) {
this.name = nsme;
this.birthday = birthday;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
public class Client {
public static void main(String[] args) throws Exception {
Date date = new Date(12112352213L);
Sheep s1 = new Sheep("少你",date);
Sheep s2 = (Sheep)s1.clone();
System.out.println(s1);
System.out.println(s1.getName());
System.out.println(s1.getBirthday());
date.setTime(1256422122222L);
System.out.println(s1.getBirthday());
//Sheep s2 = (Sheep)s1.clone();
s2.setName("duli");
System.out.println(s2);
System.out.println(s2.getName());
System.out.println(s2.getBirthday());
}
}
效果:
job01.gof05.Sheep@73035e27
少你
Thu May 21 12:32:32 CST 1970
Sun Oct 25 06:08:42 CST 2009
job01.gof05.Sheep@3f2a3a5
duli
Sun Oct 25 06:08:42 CST 2009
//使用序列化和反序列化实现深复制
public class Client2 {
public static void main(String[] args) throws Exception {
Date date = new Date(12112352213L);
Sheep s1 = new Sheep("少你",date);
System.out.println(s1);
System.out.println(s1.getName());
System.out.println(s1.getBirthday());
//使用序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(s1);
byte[] bytes = bos.toByteArray();
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis);
Sheep s2 = (Sheep) ois.readObject();//克隆对象
System.out.println("修改");
date.setTime(12456455555L);
System.out.println(s1.getBirthday());
s2.setName("duli");
System.out.println(s2);
System.out.println(s2.getName());
System.out.println(s2.getBirthday());
}
}
效果:
job01.gof05.Sheep@73035e27
少你
Thu May 21 12:32:32 CST 1970
修改
Mon May 25 12:07:35 CST 1970
job01.gof05.Sheep@20e2cbe0
duli
Thu May 21 12:32:32 CST 1970
更多推荐
01GOF23-创建模型式
发布评论