来源 设计模式之禅---作者-秦小波
import java.util.ArrayList;
import java.util.Vector;
public class T {
}
////1.单例模式
//
//class Sigleton {
// private static final Sigleton sigleton = new Sigleton();
// //限制产生多个对象
// private Sigleton(){
//
// }
//
// public static Sigleton getSigleton(){
// return sigleton;
// }
//
// public static void doSomething(){
//
// }
//}
//
//
////2.工厂方法
//
//abstract class Product{
// //产品类的公共方法
// public void method1(){
//
// }
// //抽象方法
// public abstract void method2();
//}
//
//class ConcreteProduct1 extends Product {
//
// @Override
// public void method2() {
// //业务处理逻辑
// }
//}
//
//class ConcreteProduct2 extends Product{
//
// @Override
// public void method2() {
// //业务处理逻辑
// }
//}
//
//abstract class Creator{
// //创建一个产品
// public abstract <T extends Product> T createProduct(Class<T> c);
//}
//
//class ConcreteCreator extends Creator {
//
// @Override
// public <T extends Product> T createProduct(Class<T> c) {
// Product product = null;
// try {
// product = (Product)Class.forName(c.getName()).newInstance();
// }catch (Exception e){
// //异常处理
// }
// return (T)product;
// }
//}
//
////场景类（main）
//class client{
// public static void main(){
// Creator creator = new ConcreteCreator();
// Product product = creator.createProduct(ConcreteProduct1.class);
// //继续业务
// }
//}
//
//
////3.抽象工厂模式
//abstract class AbstractProductA{
// //每个产品共用的方法
// public void shareMethod(){
//
// }
// //每个产品相同方法不同实现
// public abstract void doSomething();
//}
//
//class ProductA extends AbstractProductA {
//
// @Override
// public void doSomething() {
// System.out.println("产品A1的实现方法");
// }
//}
//
//class ProductB extends AbstractProductA{
//
// @Override
// public void doSomething() {
// System.out.println("产品A2的实现方式");
// }
//}
//
//abstract class AbstractCreator{
// //创建A产品家族
// public abstract AbstractProductA createProductA();
//}
//
//class Creator1 extends AbstractCreator {
//
// @Override
// public AbstractProductA createProductA() {
// return new ProductA();
// }
//}
//
//class Creator2 extends AbstractCreator {
//
// @Override
// public AbstractProductA createProductA() {
// return new ProductB();
// }
//}
//
////4.模板方法模式
//
//abstract class AbstractClass {
// //基本方法
// protected abstract void doSomething();
// //基本方法
// protected abstract void doAnyThing();
// //模板方法 为了防止恶意操作，一般模板方法都加上final关键字，不允许被覆写
// public final void templeteMethod(){
// //调用基本方法完成相关的逻辑
// this.doAnyThing();
// this.doSomething();
// }
//}
//
//class ConcreteClass1 extends AbstractClass {
//
// @Override
// protected void doSomething() {
// //业务逻辑处理
// }
//
// @Override
// protected void doAnyThing() {
// //业务逻辑处理
// }
//}
//class ConcreteClass2 extends AbstractClass {
//
// @Override
// protected void doSomething() {
// //业务逻辑处理
// }
//
// @Override
// protected void doAnyThing() {
// //业务逻辑处理
// }
//}
//class client4 {
// public static void main(String[] args){
// AbstractClass class1 = new ConcreteClass1();
// AbstractClass class2 = new ConcreteClass2();
// //调用模板方法
// class1.templeteMethod();
// class2.templeteMethod();
// }
//}
//*******************分割线分割线分割线分割线分割线分割线分割线分割线***************************//
//class Product {
// public void doSomething(){
// //独立业务处理
// }
//}
//
//abstract class Builder{
// //设置产品的不同部分，以获得不同的产品
// public abstract void setPart();
// //建造产品
// public abstract Product buildProduct();
//}
//
////注意：有多少个产品类就有几个具体的构建者
//class ConcreteProduct extends Builder {
// private Product product = new Product();
// @Override
// public void setPart() {
// //产品类内的逻辑处理
// }
//
// //组建一个产品
// @Override
// public Product buildProduct() {
// return product;
// }
//}
//
////导演者,起到封装的作用，避免高层模块深入到建造者内部的实现类。
//class Director {
// private Builder builder = new ConcreteProduct();
// //构建不同的产品
// public Product getAproduct(){
// builder.buildProduct();
// //设置不同的零件，产生不同的产品
// return builder.buildProduct();
// }
//}
//
////6.代理模式
//interface Subject {
// //定义一个方法
// void request();
//}
//class RealSubject implements Subject {
//
// @Override
// public void request() {
// //业务逻辑处理
// }
//}
//
//class Proxy implements Subject {
// //要代理哪个实现类
// private Subject subject = null;
// //默认被代理者
// public Proxy(){
// this.subject=new Proxy();
// }
// public Proxy(Object ...objects){
// }
// public Proxy(Subject subject){
// this.subject = subject;
// }
//
// @Override
// public void request() {
// this.before();
// this.subject.request();
// this.after();
// }
//
// //预处理
// private void before(){
//
// }
// //善后处理
// private void after(){
//
// }
//}
//
////7.原型模式
//
//class PrototypeClass implements Cloneable{
//
// //覆写父类Object方法
// @Override
// protected Object clone() {
// PrototypeClass prototypeClass = null;
// try {
// prototypeClass = (PrototypeClass) super.clone();
// }catch (CloneNotSupportedException e){
//
// }
// return prototypeClass;
// }
//}
//
////8.中介者模式
//
////抽象中介者模式
//abstract class Mediator {
// //定义同事类
// protected ConcreteColleague1 c1;
// protected ConcreteColleague2 c2;
// //通过getter和setter把同事类注入进来;
// public ConcreteColleague1 getC1(){
// return c1;
// }
// public void setC1(ConcreteColleague1 c1){
// this.c1 = c1;
// }
// public ConcreteColleague2 getC2() {
// return c2;
// }
//
// public void setC2(ConcreteColleague2 c2){
// this.c2 = c2;
// }
//
// //中介者模式的业务;
// public abstract void doSomething1();
// public abstract void doSomething2();
//
//}
//
//
//class ConcreteMediator extends Mediator{
//
// @Override
// public void doSomething1() {
// //调用同事的方法只要是public都可以调用
// super.c1.selfMethod();
// super.c2.selfMethod();
// }
//
// @Override
// public void doSomething2() {
// super.c1.selfMethod();
// super.c2.selfMethod();
// }
//}
//
//
////抽象同事类
//abstract class Colleague {
// protected Mediator mediator;
// public Colleague(Mediator mediator){
// this.mediator = mediator;
// }
//}
//
//class ConcreteColleague1 extends Colleague {
//
// public ConcreteColleague1(Mediator mediator) {
// super(mediator);
// }
// public void selfMethod(){
// //处理自己的业务逻辑
// }
// public void depMethod1(){
// //处理自己的业务逻辑
// //自己不能处理的委托给中介者处理
// super.mediator.doSomething1();
// }
//
//}
//
//class ConcreteColleague2 extends Colleague {
//
// public ConcreteColleague2(Mediator mediator) {
// super(mediator);
// }
//
// public void selfMethod(){
// //处理自己的业务逻辑
// }
// public void depMethod1(){
// //处理自己的业务逻辑
// //自己不能处理的委托给中介者处理
// super.mediator.doSomething2();
// }
//}
//
//
////9.命令模式
//abstract class Receiver {
// //抽象接收者，定义每个接收者都必须完成的业务
// public abstract void doSomething();
//}
//
//class CurrentReceiver1 extends Receiver{
// //每个接收者必须处理一定的业务
// @Override
// public void doSomething() {
//
// }
//}
//class CurrentReceiver2 extends Receiver {
// //每个接收者必须处理一定的业务
// @Override
// public void doSomething() {
//
// }
//}
//abstract class Command{
// //每个命令类都必须有一个执行的事
// public abstract void execute();
//}
//class ConcreteCommand1 extends Command {
// private Receiver receiver;
//
// public ConcreteCommand1(Receiver receiver){
// this.receiver = receiver;
// }
// @Override
// public void execute() {
// this.receiver.doSomething();
// }
//}
//
//class ConcreteCommand2 extends Command {
// private Receiver receiver;
//
// public ConcreteCommand2(Receiver receiver){
// this.receiver = receiver;
// }
// @Override
// public void execute() {
// this.receiver.doSomething();
// }
//}
//
//class Invoker {
// private Command command;
// //受气包，接收命令
// public void setCommand(Command command){
// this.command = command;
// }
// //执行命令
// public void action(){
// this.command.execute();
// }
//}
//class Client9 {
// public static void main(String[] args){
// //首先声明调用者Invoker
// Invoker invoker = new Invoker();
// //定义接收者
// Receiver receiver = new CurrentReceiver1();
// //定义一个发送给接收者的命令
// Command command = new ConcreteCommand1(receiver);
// invoker.setCommand(command);
// invoker.action();
// }
//}
//
////10.责任链模式
//abstract class Handler {
// private Handler nextHandler;
// //设置下一个处理者是谁
// public void setNext(Handler handler){
// this.nextHandler = handler;
// }
// protected abstract Level getHandlerLevel();
// //每个处理者都必须要处理任务
// protected abstract Response echo(Request request);
// //每个处理者都必须对请求做出处理
// public final Response handleMessage(Request request){
// Response response = null;
// if(this.getHandlerLevel().equals(request.getRequestLevel())){
// response = this.echo(request);
// }
// if(this.nextHandler != null){
// response = this.nextHandler.handleMessage(request);
// }else {
// //没有适当的处理者，业务自行处理
// }
// return response;
//
// }
//}
//class Level{
// //定义一个请求和处理等级
//}
//class Request{
// //请求的等级
// public Level getRequestLevel(){
// return null;
// }
//}
//class Response {
// //处理者返回的数据
//}
//
//class ConcreteHandler1 extends Handler {
//
// @Override
// protected Level getHandlerLevel() {
// return null;
// }
//
// @Override
// protected Response echo(Request request) {
// return null;
// }
//}
//class ConcreteHandler2 extends Handler {
//
// @Override
// protected Level getHandlerLevel() {
// return null;
// }
//
// @Override
// protected Response echo(Request request) {
// return null;
// }
//}
//
//class ConcreteHandler3 extends Handler {
//
// @Override
// protected Level getHandlerLevel() {
// return null;
// }
//
// @Override
// protected Response echo(Request request) {
// return null;
// }
//}
//
//class client10{
// public static void main(String[] args){
// Handler handler1 = new ConcreteHandler1();
// Handler handler2 = new ConcreteHandler2();
// Handler handler3 = new ConcreteHandler3();
// handler1.setNext(handler2);
// handler2.setNext(handler3);
// Response response = handler1.handleMessage(new Request());
// }
//}
////////////////*********************************分割线***************************************//////
//11.装饰者模式
///*抽象构件
//abstract class Component {
// public abstract void operate();
//}
//
//class ConcreteComponent extends Component {
//
// @Override
// public void operate() {
// System.out.println("do something");
// }
//}
////抽象装饰者
//abstract class Decorator extends Component {
// private Component component = null;
// public Decorator(Component component){
// this.component = component;
// }
//
// @Override
// public void operate() {
// this.component.operate();
// }
//}
//
//class ConcreteDecorator1 extends Decorator {
//
// public ConcreteDecorator1(Component component) {
// super(component);
// }
//
// private void method1(){
// System.out.println("method1修饰");
// }
//
// @Override
// public void operate() {
// this.method1();
// super.operate();
// }
//}
//
//class ConcreteDecorator2 extends Decorator {
//
// public ConcreteDecorator2(Component component) {
// super(component);
// }
//
// private void method1(){
// System.out.println("method1修饰");
// }
//
// @Override
// public void operate() {
// this.method1();
// super.operate();
// }
//}
//
//class Client11{
// public static void main(String[] args){
// Component component = new ConcreteComponent();
// component = new ConcreteDecorator1(component);
// component = new ConcreteDecorator2(component);
// component.operate();
// }
//}
//
////12.策略模式
//
//interface Strategy{
// public void doSomething();
//}
//
//class ConcreteStrategy1 implements Strategy {
//
// @Override
// public void doSomething() {
// System.out.println("具体策略1的运算法则");
// }
//}
//class ConcreteStrategy2 implements Strategy {
//
// @Override
// public void doSomething() {
// System.out.println("具体策略1的运算法则");
// }
//}
//class Context {
// //抽象策略
// private Strategy strategy = null;
// public Context(Strategy strategy){
// this.strategy = strategy;
// }
//
// public void doAnything(){
// this.strategy.doSomething();
// }
//
//}
//
//class Client12 {
// public static void main(String[] args){
// Strategy strategy = new ConcreteStrategy1();
// Context context = new Context(strategy);
// context.doAnything();
// }
//}
//
////13.适配器模式
//interface Target{
// void request();
//}
//
//class ConcreteTarget implements Target {
//
// @Override
// public void request() {
// System.out.println("if you need help,please call me!");
// }
//}
//
//class Addaptee{
// public void dosomething(){
// System.out.println("i'm kind of busy,leave me alone ,pls");
// }
//}
//class Adapter extends Addaptee implements Target {
//
// @Override
// public void request() {
// super.dosomething();
// }
//}
//
//class Client13 {
// public static void main(String[] args){
// //原有的业务逻辑
// Target target = new ConcreteTarget();
// target.request();
// //现在增加了适配器角色后的逻辑
// Target target2 = new Adapter();
// target2.request();
// }
//}
//14.迭代器模式 省略
//15.组合模式
abstract class Component {
//个体和整体都具有的共享
public void dosomething(){}
}
//树枝构建
class Composite extends Component {
//构件容器
private ArrayList<Component> componentArrayList = new ArrayList<>();
//
public void add(Component component){
this.componentArrayList.add(component);
}
//删除一个叶子构件或树枝构件
public void remove(Component component){
this.componentArrayList.remove(component);
}
public ArrayList<Component> getChildren(){
return this.componentArrayList;
}
}
class Leaf extends Component{
@Override
public void dosomething() {
super.dosomething();
}
}
class Client15 {
public static void main(String[] args){
Composite root = new Composite();
root.dosomething();
Composite branch = new Composite();
Leaf leaf = new Leaf();
root.add(branch);
branch.add(leaf);
}
//递归遍历
public static void display(Composite root){
for(Component item : root.getChildren()){
if(item instanceof Leaf){
item.dosomething();
}else {
display((Composite)item);
}
}
}
}
//16.观察者模式
abstract class Subject {
//定义一个观察者数组
private Vector<Observer> obsVector = new Vector<>();
public void addObserver(Observer o){
obsVector.add(o);
}
public void delObserver(Observer o){
obsVector.remove(o);
}
//通知所有观察者
public void notifyObservers(){
for(Observer item : obsVector){
item.update();
}
}
}
class ConcreteSubject extends Subject{
public void dosomething(){
/**
* do something
*/
super.notifyObservers();
}
}
interface Observer{
void update();
}
class ConcreteObserver implements Observer {
@Override
public void update() {
System.out.println("接收到消息，并进行处理!");
}
}
class client{
public static void main(String[] args){
ConcreteSubject subject = new ConcreteSubject();
Observer o = new ConcreteObserver();
subject.addObserver(o);
subject.dosomething();
}
}
//17.门面模式
class ClassA{
public void doSomethingA(){
//业务逻辑
}
}
class ClassB{
public void doSomethingB(){}
}
class ClassC{
public void doSomethingC(){
}
}
class Facade{
//被委托的对象
private ClassA a = new ClassA();
private ClassB b = new ClassB();
private ClassC c = new ClassC();
//提供给外部访问的方法
public void doSomethingA(){
this.a.doSomethingA();
}
public void doSomethingB(){
this.b.doSomethingB();
}
public void doSomethingC(){
this.c.doSomethingC();
}
}
//18.备忘录模式
class Originator {
//内部状态
private String state = "";
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
//创建一个备忘录
public Memento createMemento(){
return new Memento(this.state);
}
//恢复一个备忘录
public void restoreMemento(Memento memento){
this.setState(memento.getState());
}
}
class Memento{
private String state = "";
public Memento(String state){
this.state = state;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
}
//备忘录管理员角色
class Caretaker {
private Memento memento;
public Memento getMemento() {
return memento;
}
public void setMemento(Memento memento) {
this.memento = memento;
}
}
class Client18 {
public static void main(String[] args){
//定义出发起人
Originator originator = new Originator();
//定义出备忘录管理员
Caretaker caretaker = new Caretaker();
//创建出一个备忘录
caretaker.setMemento(originator.createMemento());
originator.restoreMemento(caretaker.getMemento());
}
}
////19.访问者模式
//
////抽象元素
//abstract class Element {
// //定义业务逻辑
// abstract void doSomething();
// abstract
//}
网友评论