一.原型模式
原型模式(Prototype Pattern):用原型实例指定创建对象的种类,并且通过拷贝这个原型创建新的对象。
其核心是一个 clone方法,通过该方法进行对象拷贝,java提供一个Cloneable接口来标识这个对象可拷贝。
优点:
1.性能优良,原型模式是在内存二进制流中拷贝,要比直接new一个对象性能好很多;
2.逃避构造函数的约束,直接在内存中拷贝,构造函数是不回执行的
注意:使用原型模式时,引用的成员变量必须满足两个条件才不会拷贝:
1.类的成员变量,而不是方法内的变量;
2.必须是一个可变的引用对象,而不是一个原始类型或不可变对象。
要使用clone方法,类的成员变量上不要增加final关键字
上代码:
public class PrototypePattern {
/**
* 基本用法
*/
public class PrototypeClass implements Cloneable{
@Override
public PrototypeClass clone() throws CloneNotSupportedException {
PrototypeClass prototypeClass =null;
try{
prototypeClass =(PrototypeClass) super.clone();
}catch (Exception e){
e.printStackTrace();
}
return prototypeClass;
}
}
/****************浅拷贝**********************/
/**
* 浅拷贝
*/
public class PrototypeDemo implements Cloneable {
private ArrayList<String> mArrayList = new ArrayList<>();
@Override
public com.sh.lynn.hz.deginpattern.prototype.PrototypeDemo clone() throws CloneNotSupportedException {
com.sh.lynn.hz.deginpattern.prototype.PrototypeDemo paper =null;
try{
paper =(com.sh.lynn.hz.deginpattern.prototype.PrototypeDemo) super.clone();
}catch (Exception e){
e.printStackTrace();
}
return paper;
}
public void setValue(String text){
mArrayList.add(text);
}
public ArrayList<String> getValue(){
return mArrayList;
}
}
/**
*
* @return
*/
public String getCloneText (){
PrototypeDemo prototypeDemo = new PrototypeDemo();
prototypeDemo.setValue("Hello!");
try {
PrototypeDemo prototypeDemoClone = prototypeDemo.clone();
prototypeDemoClone.setValue("World!");
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
StringBuffer stringBuffer = new StringBuffer();
ArrayList<String> list= prototypeDemo.getValue();
for (String text:list){
stringBuffer.append(text+" ");
}
return stringBuffer.toString();
}
/****************深拷贝**********************/
public class PrototypeDemoDeep implements Cloneable {
private ArrayList<String> mArrayList = new ArrayList<>();
@Override
public com.sh.lynn.hz.deginpattern.prototype.PrototypeDemoDeep clone() throws CloneNotSupportedException {
com.sh.lynn.hz.deginpattern.prototype.PrototypeDemoDeep paper =null;
try{
paper =(com.sh.lynn.hz.deginpattern.prototype.PrototypeDemoDeep) super.clone();
paper.mArrayList =(ArrayList<String>)this.mArrayList.clone();
}catch (Exception e){
e.printStackTrace();
}
return paper;
}
public void setValue(String text){
mArrayList.add(text);
}
public ArrayList<String> getValue(){
return mArrayList;
}
}
/**
* 深拷贝
* @return
*/
public String getCloneTextDeep (){
PrototypeDemoDeep prototypeDemo = new PrototypeDemoDeep();
prototypeDemo.setValue("Hello!");
try {
PrototypeDemoDeep prototypeDemoClone = prototypeDemo.clone();
prototypeDemoClone.setValue("World!");
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
StringBuffer stringBuffer = new StringBuffer();
ArrayList<String> list= prototypeDemo.getValue();
for (String text:list){
stringBuffer.append(text+" ");
}
return stringBuffer.toString();
}
}
二.中介者模式
定义:用一个中介对象封装一系列的对象交互,中介者使各对象不需要显示相互作用,
从而使其耦合松散,而且可以独立地改变它们之间的交互。
中介者模式的组成部分:
1.Mediator 抽象中介者角色 定义统一的接口,用于各同事角色之间的通信。
2.Concrete Mediator 具体中介者角色 通过协调各同事角色实现协作行为
3.Colleague 同事角色
每一个同事角色都知道中介者角色,而且与其它的同事角色通信时候,一定通过中介者角色协作。
同事类行为:
(1).同事类本身行为,比如改变对象本身的状态,处理自己的行为等,自有方法
(2).必须依赖中介者才能完成的行为 ,依赖方法
上代码:
//抽象中介者
public abstract class Mediator {
//定义同事类
protected ConcreteColleague1 mColleague1;
protected ConcreteColleague2 mColleague2;
public ConcreteColleague1 getColleague1() {
return mColleague1;
}
public void setColleague1(ConcreteColleague1 colleague1) {
mColleague1 = colleague1;
}
public ConcreteColleague2 getColleague2() {
return mColleague2;
}
public void setColleague2(ConcreteColleague2 colleague2) {
mColleague2 = colleague2;
}
//中介者模式的业务逻辑
public abstract void doSomething1();
public abstract void doSomething2();
}
//具体中介者
public class ConcreteMediator extends Mediator {
@Override
public void doSomething1() {
super.mColleague1.selfMethod1();
super.mColleague2.selfMethod2();
}
@Override
public void doSomething2() {
super.mColleague1.selfMethod1();
super.mColleague2.selfMethod2();
}
}
//抽象同事类
public abstract class Colleague {
protected Mediator mMediator;
public Colleague(Mediator _mediator){
this.mMediator=_mediator;
}
}
//同事类
public class ConcreteColleague1 extends Colleague {
public ConcreteColleague1(Mediator _mediator) {
super(_mediator);
}
//自有方法
public void selfMethod1(){
//处理自身业务逻辑
}
//依赖方法 dep-method
public void depMethod1(){
//处理自己的业务逻辑
//自己不能处理的业务逻辑,委托中介者处理
super.mMediator.doSomething1();
}
}
//同事类
public class ConcreteColleague2 extends Colleague {
public ConcreteColleague2(Mediator _mediator) {
super(_mediator);
}
//自有方法
public void selfMethod2(){
//处理自身业务逻辑
}
//依赖方法 dep-method
public void depMethod2(){
//处理自己的业务逻辑
//自己不能处理的业务逻辑,委托中介者处理
super.mMediator.doSomething2();
}
}
三.命令模式
命令模式:将一个请求封装成一个对象,从而让你使用不同的请求把客户端参数化,
对请求排队或者记录请求日志,可以提供命令的撤销和恢复功能。
命令模式三个角色:
Receive 接收者角色
Command 命令角色
Invoker 调用者角色
上代码:
public class CommandPattern {
public String doSomething(){
//声明调用者Invoker
Invoker invoker = new Invoker();
//定义接收者
Receiver receiver1 = new ConcreteReceiver1();
//定义一个发送给接收者的命令
Command command1 = new ConcreteCommand1(receiver1);
invoker.setCommand(command1);
String result1 = invoker.action();
//定义接收者
Receiver receiver2 = new ConcreteReceiver2();
//定义一个发送给接收者的命令
Command command2 = new ConcreteCommand2(receiver2);
invoker.setCommand(command2);
String result2 = invoker.action();
return result1+"\n"+result2;
}
}
public abstract class Receiver {
//抽象接收者,定义每个接收者都必须完成的业务
public abstract String doSomething();
}
public class ConcreteReceiver1 extends Receiver {
@Override
public String doSomething() {
return "ConcreteReceiver1 doSomething ";
}
}
public class ConcreteReceiver2 extends Receiver {
@Override
public String doSomething() {
return "ConcreteReceiver2 doSomething ";
}
}
public abstract class Command {
//每个命令类都必须有个执行命令的方法
public abstract String execute();
}
public class ConcreteCommand1 extends Command {
//对哪个Receiver类进行命令处理
private Receiver receiver;
public ConcreteCommand1(Receiver _receiver){
receiver = _receiver;
}
@Override
public String execute() {
return this.receiver.doSomething();
}
}
public class ConcreteCommand2 extends com.sh.lynn.hz.deginpattern.commandpattern.Command {
//对哪个Receiver类进行命令处理
private com.sh.lynn.hz.deginpattern.commandpattern.Receiver receiver;
public ConcreteCommand2(com.sh.lynn.hz.deginpattern.commandpattern.Receiver _receiver){
receiver = _receiver;
}
@Override
public String execute() {
return this.receiver.doSomething();
}
}
public class Invoker {
private Command mCommand;
//接收命令
public void setCommand(Command _command){
this.mCommand=_command;
}
public String action(){
return this.mCommand.execute();
}
}
四.责任链模式
责任链模式:使多个对象都有机会处理请求,从而避免了请求的发送者和接收者之间的耦合关系。
将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止。
public class ChainPattern {
public String doSomething(){
Handler handler1 = new ConcreteHandler1();
Handler handler2 = new ConcreteHandler2();
Handler handler3 = new ConcreteHandler3();
handler1.setNextHandler(handler2);
handler2.setNextHandler(handler3);
//注意这里的调用 都是handle1
Response response1 = handler1.handleMessage(new Request(Level.HIGHT,"hight request"));
Response response2 = handler1.handleMessage(new Request(Level.LOW,"low request"));
Response response3 = handler1.handleMessage(new Request(Level.MID,"mid request"));
return response1.getResult()+"\n"+response2.getResult()+"\n"+response3.getResult();
}
}
public class Request {
private Level mLevel;
private String msg ;
public Request(Level _level,String _msg){
mLevel=_level;
msg=_msg;
}
public Level getRequestLevel(){
return mLevel;
}
public String getMsg(){
return msg;
}
}
public enum Level {
LOW ,MID,HIGHT
}
public class Response {
private String result;
public String getResult() {
return result;
}
public void setResult(String result) {
this.result = result;
}
}
public abstract class Handler {
private Handler nextHandler;
//每个处理者都必须对请求做出处理
public final Response handleMessage(Request request) {
Response response = null;
//判断是否是自己的处理级别
if (getHandlerLevel().equals(request.getRequestLevel())) {
response = echo(request);
} else {
//下一个处理者
if (this.nextHandler != null) {
response = this.nextHandler.handleMessage(request);
} else {
}
}
return response;
}
//设置下一个处理者是谁
public void setNextHandler(Handler _handler) {
this.nextHandler = _handler;
}
//每个处理者都有一个处理级别
protected abstract Level getHandlerLevel();
//每个处理者都必须实现处理任务
protected abstract Response echo(Request request);
}
public class ConcreteHandler1 extends Handler {
@Override
protected Level getHandlerLevel() {
return Level.LOW;
}
@Override
protected Response echo(Request request) {
Response response = new Response();
response.setResult(request.getMsg());
return response;
}
}
public class ConcreteHandler2 extends Handler {
@Override
protected Level getHandlerLevel() {
return Level.MID;
}
@Override
protected Response echo(Request request) {
Response response = new Response();
response.setResult(request.getMsg());
return response;
}
}
public class ConcreteHandler3 extends Handler {
@Override
protected Level getHandlerLevel() {
return Level.HIGH;
}
@Override
protected Response echo(Request request) {
Response response = new Response();
response.setResult(request.getMsg());
return response;
}
}