计算机网站建设易观数据
说明:本文介绍设计模式中,创建型中的原型模式;
飞机大战
创建型设计模式关注于对象的创建,原型模式也不例外。如简单工厂和工厂模式中提到过的飞机大战这个例子,游戏中飞机、坦克对象会创建许许多多的实例,每个实例除了坐标,是一模一样的,如果每次都用关键字new去创建,是非常消耗时间的。
(Enemy,敌人抽象类)
/*** 敌人抽象类*/
public abstract class Enemy {/*** 敌人的坐标*/protected int x;/*** 敌人的坐标*/protected int y;/*** 抽象方法*/public Enemy(int x, int y) {this.x = x;this.y = y;}/*** 绘制方法*/public abstract void show();
}
(AirPlane,飞机类)
/*** 飞机*/
public class AirPlane extends Enemy {public AirPlane(int x, int y) {super(x, y);}@Overridepublic void show() {System.out.println("飞机出现了,坐标是:" + x + "," + y);}
}
(Client,客户端类,循环创建对象,浪费资源,影响效率)
import java.util.ArrayList;
import java.util.List;
import java.util.Random;/*** 客户端*/
public class Client {public static void main(String[] args) {// 屏幕宽度int screenLength = 100;// 定义飞机集合List<AirPlane> airPlanes = new ArrayList<>();// 创建飞机for (int i = 0; i < 100000; i++) {airPlanes.add(new AirPlane(new Random().nextInt(screenLength), 0));}}
}
原型模式
原型模式,是使用了Object类里面的clone()方法,对原型对象,也就是创建的第一个对象进行了克隆,避免重复创建对象。如下:
(AirPlane,飞机类,实现Cloneable接口)
/*** 飞机*/
public class AirPlane extends Enemy implements Cloneable {public AirPlane(int x, int y) {super(x, y);}@Overridepublic void show() {System.out.println("飞机出现了,坐标是:" + x + "," + y);}/*** clone方法,调用父类的clone方法*/public AirPlane clone() {Object obj = null;try {obj = super.clone();return (AirPlane) obj;} catch (CloneNotSupportedException e) {System.out.println("克隆失败");return null;}}
}
(AirPlaneFactory,飞机工厂类,调用飞机的克隆方法)
/*** 飞机工厂*/
public class AirPlaneFactory {/*** 加载一个原型对象*/private static AirPlane airPlane = new AirPlane(0, 0);/*** 获取飞机* @param x* @return*/public static AirPlane getAirPlane(int x) {AirPlane clone = airPlane.clone();clone.setX(x);return clone;}
}
(客户端类,创建飞机实例对象)
import java.util.ArrayList;
import java.util.List;
import java.util.Random;/*** 客户端*/
public class Client {public static void main(String[] args) {// 屏幕宽度int screenLength = 100;// 定义飞机集合List<AirPlane> airPlanes = new ArrayList<>();// 创建飞机for (int i = 0; i < 100000; i++) {airPlanes.add(AirPlaneFactory.getAirPlane(new Random().nextInt(screenLength)));}// 比较两个飞机是否相等System.out.println(airPlanes.get(0) == airPlanes.get(1));}
}
克隆的实例,是不相等的;
以上就是通过原型模式实例化对象的过程,可以节约内存空间。
浅拷贝和深拷贝
在使用了clone()方法时,我们需要知道浅拷贝和深拷贝的概念。在Java中有基本数据类型和引用数据类型,其中基本数据类型有8种,分别是byte、short、int、long、float、double、char、boolean,除此之外的都是引用数据类型。
对于基本数据类型,浅拷贝和深拷贝都是创建一个新对象,而对于引用数据类型,浅拷贝是拷贝一个对象的指针,深拷贝是拷贝一个一模一样的对象。
例如,在上面的基础上,我创建一个机长类,在飞机类里面注入一个机长类对象,克隆之后,对飞机里面的机长对象进行判断,如下:
(机长类)
/*** 机长*/
public class Captain implements Cloneable{/*** 姓名*/private String name;/*** 年龄*/private Integer age;public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}
}
(注入一个机长类对象)
/*** 飞机*/
public class AirPlane extends Enemy implements Cloneable {/*** 机长*/private Captain captain;public AirPlane(int x, int y, Captain captain) {super(x, y);this.captain = captain;}@Overridepublic void show() {System.out.println("飞机出现了,坐标是:" + x + "," + y);}/*** clone方法,调用父类的clone方法*/public AirPlane clone() {Object obj = null;try {obj = super.clone();return (AirPlane) obj;} catch (CloneNotSupportedException e) {System.out.println("克隆失败");return null;}}public Captain getCaptain() {return captain;}
}
(克隆对象后,对飞机对象和飞机对象里面的机长对象进行判断)
// 比较两个飞机是否相等System.out.println(airPlanes.get(0) == airPlanes.get(1));// 比较两个飞机的机长是否相等System.out.println(airPlanes.get(0).getCaptain() == airPlanes.get(1).getCaptain());
结果是飞机对象是互不相同的,但是飞机对象中的引用数据类型,是相同的,是浅拷贝;
这肯定是不行的,每个实例的数据应该是封装独有的,不能“克隆了,但没完全克隆”。我们可以采用字节流的方式实现“深拷贝”,如下:
(敌人抽象类)
/*** 敌人抽象类*/
public abstract class Enemy {/*** 敌人的坐标*/protected int x;/*** 敌人的坐标*/protected int y;public int getX() {return x;}public void setX(int x) {this.x = x;}public int getY() {return y;}/*** 绘制方法*/public abstract void show();
}
(飞机类,使用IO流的方式来实现深拷贝)
import java.io.*;/*** 飞机*/
public class AirPlane extends Enemy implements Serializable {/*** 机长*/private Captain captain;public Captain getCaptain() {return captain;}public void setCaptain(Captain captain) {this.captain = captain;}@Overridepublic void show() {System.out.println("飞机出现了,坐标是:" + x + "," + y);}/*** 获取飞机* @param x* @return*/public AirPlane getAirPlane(int x) throws IOException, ClassNotFoundException {this.setX(x);// 创建对象输出流ByteArrayOutputStream bao = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(bao);oos.writeObject(this);// 返回克隆对象ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());ObjectInputStream ois = new ObjectInputStream(bis);return (AirPlane) ois.readObject();}
}
(机长类)
import java.io.Serializable;/*** 机长*/
public class Captain implements Serializable {/*** 姓名*/private String name;/*** 年龄*/private Integer age;public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}
}
创建对象,调用“克隆”方法,比较两个对象的地址和对象内的引用类型数据的地址;
import java.io.IOException;
import java.util.Random;/*** 客户端*/
public class Client {public static void main(String[] args) throws IOException, ClassNotFoundException {// 屏幕宽度int screenLength = 100;AirPlane airPlane = new AirPlane();airPlane.setCaptain(new Captain());AirPlane airPlaneNew = airPlane.getAirPlane(new Random().nextInt(screenLength));// 比较两个飞机是否相等System.out.println(airPlane == airPlaneNew);// 比较两个飞机的机长是否相等System.out.println(airPlane.getCaptain() == airPlaneNew.getCaptain());}
}
都为false,说明“深拷贝”已经实现。
深克隆的实现并未用到Object的clone方法,而是使用了IO流中的Object流的方式,对对象进行序列化来实现的。
原型管理器
原型管理器的构想是,创建一个管理器类,包含了所有需要克隆的对象,需要的时候可以直接调用管理器中的方法,取一个克隆的对象出来。代码如下:
(定义一个敌人接口,一个克隆方法,一个展示方法)
/*** 敌人接口*/
public interface Enemy extends Cloneable{/*** 克隆方法* @return*/Enemy clone();/*** 显示方法*/void show();
}
(分别定义敌人飞机、敌人坦克对象)
/*** 敌人飞机*/
public class AirPlane implements Enemy{@Overridepublic Enemy clone() {AirPlane airPlane = null;try {airPlane = (AirPlane) super.clone();} catch (CloneNotSupportedException e) {System.out.println("克隆失败");}return airPlane;}@Overridepublic void show() {System.out.println("敌人飞机");}
}/*** 敌人坦克*/
public class Tank implements Enemy{@Overridepublic Enemy clone() {Tank tank = null;try {tank = (Tank) super.clone();} catch (CloneNotSupportedException e) {System.out.println("克隆失败");}return tank;}@Overridepublic void show() {System.out.println("敌人坦克");}
}
(定义原型管理器,通过getKey()的方式获取到对应对象的克隆实例)
import java.util.Hashtable;/*** 原型管理类*/
public class PrototypeManagement {private Hashtable ht = new Hashtable();private static PrototypeManagement pm = new PrototypeManagement();/*** 添加敌人* @param key* @param enemy*/public void addEnemy(String key, Enemy enemy) {ht.put(key, enemy);}/*** 获取敌人* @param key* @return*/public Enemy getEnemy(String key) {Enemy enemy = (Enemy) ht.get(key);return enemy.clone();}public static PrototypeManagement getPrototypeManagement() {return pm;}
}
(客户端测试)
/*** 原型管理器客户端*/
public class Client {public static void main(String[] args) {PrototypeManagement pm = PrototypeManagement.getPrototypeManagement();// 添加敌人pm.addEnemy("airplane", new AirPlane());pm.addEnemy("tank", new Tank());AirPlane airplane = (AirPlane) pm.getEnemy("airplane");airplane.show();AirPlane airplaneNew = (AirPlane) pm.getEnemy("airplane");airplaneNew.show();System.out.println(airplane == airplaneNew);System.out.println("====================================");Tank tank = (Tank) pm.getEnemy("tank");tank.show();Tank tankNew = (Tank) pm.getEnemy("tank");tankNew.show();System.out.println(tank == tankNew);}
}
通过克隆获取实例,地址不相等;
此时,如果需要增加一个Boss,非常简单,只需要新增一个类实现Enemy接口即可;
总结
本文参考《设计模式的艺术》、《秒懂设计模式》两书