企业展示型网站有哪些,北京seo外包,济南网络seo公司,angular 做的网站1 创建型
如何合理的创建对象#xff1f;
1.1 单例模式
字面意思就是只能创建一个对象实例时使用。
例如#xff0c;Windows中只能打开一个任务管理器#xff0c;这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费#xff0c;或出现各个窗口显示内容的不一致等…1 创建型
如何合理的创建对象
1.1 单例模式
字面意思就是只能创建一个对象实例时使用。
例如Windows中只能打开一个任务管理器这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费或出现各个窗口显示内容的不一致等错误。
特点全局就这一个对象时
懒汉式的实现方式如下
/*** 懒汉单例模式*/
public class SingleLazyDemo {//避免在外部被实例化private SingleLazyDemo() {}private static volatile SingleLazyDemo instance null;//实例化public static synchronized SingleLazyDemo getInstance(){if(instance null){instance new SingleLazyDemo();}return instance;}}
测试效果如下 饿汉式实现方式如下
public class SingleHungryDemo {//避免在外部被实例化private SingleHungryDemo() {}private static final SingleHungryDemo instance ;//一旦加载就创建一个单例static {instance new SingleHungryDemo();}//实例化public static synchronized SingleHungryDemo getInstance(){return instance;}
}
饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用以后不再改变所以是线程安全的可以直接用于多线程而不会出现问题。
1.2 原型模式
特点应用于克隆型对象创建拷贝原型创建新的对象
原型模式的克隆分为浅克隆和深克隆Java中的Object类提供了浅克隆的clone()方法具体原型类只要实现Cloneable接口就可实现对象的浅克隆。
浅克隆的实现方式如下
import lombok.Data;Data
public class PrototypeShallowDemo implements Cloneable{private String name;private String describe;public PrototypeShallowDemo(String name,String describe){this.name name;this.describe describe;}Overridepublic String toString(){return my name is name , my info is describe;}protected Object clone() throws CloneNotSupportedException{return super.clone();}}
测试效果如下 浅拷贝的特点
对于数据类型是基本数据类型的成员变量浅拷贝会直接进行值传递也就是将该属性值复制一份给新的对象对于数据类型是引用数据类型的成员变量比如说成员变量是某个数组、某个类的对象等那么浅拷贝会进行引用传递即克隆一份地址。
深拷贝可以使用对象序列化的方式实现
Data
public class PrototypeDeepDemo implements Cloneable, Serializable {private String name;private PrototypeShallowDemo prototypeShallowDemo;Overrideprotected Object clone() throws CloneNotSupportedException {Object object super.clone();PrototypeDeepDemo prototypeDeepDemo (PrototypeDeepDemo) object;prototypeDeepDemo.prototypeShallowDemo (PrototypeShallowDemo) prototypeShallowDemo.clone();return object;}
}
1.3 工厂方法模式
特点创建于使用分离将创建的对象作为“产品”把创建产品的对象称为“工厂”。
满足“开闭原则”的前提下客户随意增删或改变对软件相关对象的使用。
首先实现要生产的产品
//定一个产品类
public interface Product {public String Show();
}//具体产品1
public class ProductCoffee implements Product{Overridepublic String Show() {return this is coffee;}
}//具体产品2
public class ProductPhone implements Product{Overridepublic String Show() {return this is phone;}
}
然后实现生产工厂
//定义一个抽象工厂使用接口interface或者抽象abstract
public interface AbstractFactory {public Product CreateProduct();
}//具体的生产工厂1
public class FactoryCoffee implements AbstractFactory{Overridepublic Product CreateProduct() {return new ProductCoffee();}
}//具体的生产工厂2
public class FactoryPhone implements AbstractFactory{Overridepublic Product CreateProduct() {return new ProductPhone();}
}测试实例调用不同的工厂生产产品 GetMapping(/demo4)public String demo4() {FactoryCoffee factoryCoffee new FactoryCoffee();Product product factoryCoffee.CreateProduct();FactoryPhone factoryPhone new FactoryPhone();return product.Show() ______ factoryPhone.CreateProduct().Show();} 1.4 抽象工厂模式
抽象工厂模式是工厂方法模式的升级版本工厂方法模式只生产一个等级的产品而抽象工厂模式可生产多个等级的产品。
使用抽象工厂模式一般要满足以下条件。
① 系统中有多个产品族每个具体工厂创建同一族但属于不同等级结构的产品。
② 系统一次只可能消费其中某一族产品即同族的产品一起使用。 在抽象工厂模式包含如下几个角色
AbstractFactory抽象工厂它声明了一组用于创建一族产品的方法每一个方法对应一种产品。ConcreteFactory具体工厂它实现了在抽象工厂中声明的创建产品的方法生成一组具体产品这些产品构成了一个产品族每一个产品都位于某个产品等级结构中。AbstractProduct抽象产品它为每种产品声明接口在抽象产品中声明了产品所具有的业务方法ConcreteProduct具体产品它定义具体工厂生产的具体产品对象实现抽象产品接口中声明的业务方法。
1创建抽象产品和具体产品
//抽象产品1
public abstract class Animal {public abstract void getName();public abstract void addFood();public abstract void getColor();
}//具体动物1
public class Horse extends Animal{Overridepublic void getName() {System.out.println(this name is horse);}Overridepublic void addFood() {System.out.println(添加食物);}Overridepublic void getColor() {System.out.println(白色);}
}//具体动物2
public class Cattle extends Animal{Overridepublic void getName() {System.out.println(this name is cattle);}Overridepublic void addFood() {System.out.println(添加食物);}Overridepublic void getColor() {System.out.println(黑色);}
}//抽象产品2
public abstract class Plant {public abstract void getName();public abstract void addWater();
}//具体植物1
public class Fruit extends Plant{Overridepublic void getName() {System.out.println(这是水果);}Overridepublic void addWater() {System.out.println(浇水);}
}//具体植物2
public class Vegetable extends Plant{Overridepublic void getName() {System.out.println(这是蔬菜);}Overridepublic void addWater() {System.out.println(浇水);}
}
2抽象工厂
public interface Farm {public Plant createPlant();public Animal createAnimal();
}
3具体工厂
//具体工厂1
public class HongXingFarm implements Farm{Overridepublic Plant createPlant() {System.out.println(蔬菜产生);return new Vegetable();}Overridepublic Animal createAnimal() {System.out.println(牛产生);return new Cattle();}
}//具体工厂2
public class MingLeFarm implements Farm{Overridepublic Plant createPlant() {System.out.println(水果产生);return new Fruit();}Overridepublic Animal createAnimal() {System.out.println(马产生);return new Horse();}
}4测试 GetMapping(/demo5)public void demo5(){Farm farm ;Animal animal;Plant plant;farm new HongXingFarm();animal farm.createAnimal();plant farm.createPlant();animal.getName();animal.addFood();plant.getName();plant.addWater();} 1.5 建造者模式
背景在软件开发过程中有时需要创建一个复杂的对象这个复杂对象通常由多个子部件按一定的步骤组合而成。例如计算机是由CPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的。
它是将一个复杂的对象分解为多个简单的对象然后一步一步构建而成。它将变与不变相分离即产品的组成部分是不变的但每一部分是可以灵活选择的。
建造者模式的主要角色如下
产品角色Product它是包含多个组成部件的复杂对象由具体建造者来创建其各个组成部件。抽象建造者Builder它是一个包含创建产品各个子部件的抽象方法的接口通常还包含一个返回复杂产品的方法getResult()。具体建造者Concrete Builder实现Builder接口完成复杂产品的各个部件的具体创建方法。指挥者Director它调用建造者对象中的部件构造与装配方法完成复杂对象的创建在指挥者中不涉及具体产品的信息。
1设计产品构成
public class Product {private String partA;private String partB;private String partC;public void setPartA(String partA) {this.partA partA;}public void setPartB(String partB) {this.partB partB;}public void setPartC(String partC) {this.partC partC;}public void show(){System.out.println(partA partB partC);}
}
2建造者负责进行产品的组装
public abstract class Builder {//创建产品对象protected Product productnew Product();public abstract void buildPartA();public abstract void buildPartB();public abstract void buildPartC();//返回产品对象public Product getResult() {return product;}
}
3具体构造者实现具体的构建细节
public class HongXIngBuilder extends Builder{Overridepublic void buildPartA() {product.setPartA(建造PartA);}Overridepublic void buildPartB() {product.setPartB(建造PartB);}Overridepublic void buildPartC() {product.setPartC(建造PartC);}
}4指挥者选择具体构建者进行构建
public class Director {private Builder builder;public Director(Builder builder) {this.builderbuilder;}//产品构建与组装方法public Product construct() {builder.buildPartA();builder.buildPartB();builder.buildPartC();return builder.getResult();}
}
5使用 GetMapping(/demo6)public void demo6(){//选择HongXIngBuilderBuilder builder1 new HongXIngBuilder();Director director1 new Director(builder1);Product product1 director1.construct();product1.show();}2 结构型
结构型模式字面意思就是设计程序结构的。
2.1 代理模式
代理就类似于中介某些情况下不能或者不想直接访问另一个对象这时需要找一个中介帮忙完成某项任务这个中介就是代理对象。
代理模式的主要角色如下:
抽象主题Subject类通过接口或抽象类声明真实主题和代理对象实现的业务方法。真实主题Real Subject类实现了抽象主题中的具体业务是代理对象所代表的真实对象是最终要引用的对象。代理Proxy类提供了与真实主题相同的接口其内部含有对真实主题的引用它可以访问、控制或扩展真实主题的功能。
1抽象主题
public interface Subject {void Request();void GetInfo();
}
2真实主题
public class RealSubject implements Subject{Overridepublic void Request() {System.out.println(【*】开始访问 );}Overridepublic void GetInfo() {System.out.println(【info】信息展示 new Date());}
}
3代理
public class Proxy implements Subject{private RealSubject realSubject;Overridepublic void Request() {if(realSubject null){realSubject new RealSubject();}preRequest();realSubject.Request();postRequest();}Overridepublic void GetInfo() {if(realSubject null){realSubject new RealSubject();}realSubject.GetInfo();}4使用 GetMapping(/demo7)public void demo7(){Proxy proxy new Proxy();proxy.GetInfo();proxy.Request();} 2.2 适配器模式
开发中两个对象因接口不兼容而不能在一起工作的实例这时需要第三者进行适配。适配器模式就是将一个类的接口转换成客户希望的另外一个接口使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
适配器模式包含以下主要角色
目标Target接口当前系统业务所期待的接口它可以是抽象类或接口。适配者Adaptee类它是被访问和适配的现存组件库中的组件接口。适配器Adapter类它是一个转换器通过继承或引用适配者的对象把适配者接口转换成目标接口让客户按目标接口的格式访问适配者。
1目标接口
public interface Target {void Request();
}2适配目标类
public class Adapter {public void specificRequest(){System.out.println(适配具体请求);}} 3适配器
public class TargetAdapter extends Adapter implements Target {Overridepublic void Request() {specificRequest();}
}
4使用 GetMapping(/demo8)public void demo8(){Target target new TargetAdapter();target.Request();}
2.3 桥接模式
将抽象与实现分离使它们可以独立变化。它是用组合关系代替继承关系来实现从而降低了抽象和实现这两个可变维度的耦合度。
桥接Bridge模式包含以下主要角色
抽象化Abstraction角色定义抽象类并包含一个对实现化Implementor角色的引用。Abstraction 充当桥接类。扩展抽象化Refined Abstraction角色是抽象化Abstraction角色的子类实现父类中的业务方法并通过组合关系调用实现化Implementor角色中的业务方法。实现化Implementor角色定义实现化角色的接口供扩展抽象化Refined Abstraction角色调用。具体实现化Concrete Implementor角色给出实现化Implementor角色接口的具体实现。
比如4种类型画笔3种颜色实现一个画板
实现方式1: 四种画笔每种画笔创建三种颜色共4 *3 12 个类
实现方式2:如下四个形状具体实现类三个颜色具体实现类然后定义双继承也是12个类 实现方式3如下用个“桥”去拼接形状和颜色只有一座“桥”所以类的数量就看上面的437 //实现化角色
public interface Impl {public void ImplInfo();
}//具体实现化角色
public class TypeOneImpl implements Impl{Overridepublic void ImplInfo() {System.out.println(具体实现1);}
}//抽象化角色
public abstract class Abstr {protected Impl impl;protected Abstr(Impl impl){this.impl impl;}public abstract void Operation();
}//扩展抽象化角色
public class AbstrOne extends Abstr{public AbstrOne(Impl impl) {super(impl);}Overridepublic void Operation() {System.out.println(扩展抽象化访问);impl.ImplInfo();}}//使用GetMapping(/demo9)public void demo9(){Impl impl new TypeOneImpl();Abstr abstr new AbstrOne(impl);abstr.Operation();}
2.4 装饰模式
在不改变现有对象结构的情况下动态地给该对象增加一些职责即增加其额外功能的模式。
装饰模式主要包含以下角色
抽象构件Component角色定义一个抽象接口以规范准备接收附加责任的对象。具体构件Concrete Component角色实现抽象构件通过装饰角色为其添加一些职责。抽象装饰Decorator角色继承抽象构件并包含具体构件的实例可以通过其子类扩展具体构件的功能。具体装饰Concrete Decorator角色实现抽象装饰的相关方法并给具体构件对象添加附加的责任。 1抽象构件角色
public interface Shape {void draw();
}
2具体构件角色未被修饰的原本的内容
public class Rectangle implements Shape{Overridepublic void draw() {System.out.println(Shape: Rectangle);}
}public class Circle implements Shape{Overridepublic void draw() {System.out.println(Shape: Circle);}
}
3抽象修饰角色
public abstract class ShapeDecorator implements Shape{protected Shape shape;public ShapeDecorator(Shape shape){this.shape shape;}public void draw(){shape.draw();}
}
4具体修饰角色添加修饰类型——颜色修饰
public class RedShapeDecorator extends ShapeDecorator{public RedShapeDecorator(Shape shape) {super(shape);}Overridepublic void draw(){shape.draw();setRedBorder(shape);}private void setRedBorder(Shape shape){System.out.println(Border Color: Red);}}
5使用 GetMapping(/demo10)public void demo10(){Shape shapeCircle new Circle();ShapeDecorator redCircle new RedShapeDecorator(new Circle());ShapeDecorator redRectangle new RedShapeDecorator(new Rectangle());shapeCircle.draw();System.out.println(-----);redCircle.draw();redRectangle.draw();} 2.5 外观模式
当一个系统的功能越来越强子系统会越来越多客户对系统的访问也变得越来越复杂。这时如果系统内部发生改变客户端也要跟着改变这违背了“开闭原则”也违背了“迪米特法则”所以有必要为多个子系统提供一个统一的接口从而降低系统的耦合度。
外观模式包含以下主要角色
外观Facade角色为多个子系统对外提供一个共同的接口。子系统Sub System角色实现系统的部分功能客户可以通过外观角色访问它。客户Client角色通过一个外观角色访问各个子系统的功能。
1外观角色
public interface Shape {void draw();
}
2子系统
public class Rectangle implements Shape {Overridepublic void draw() {System.out.println(Rectangle::draw());}
}public class Square implements Shape {Overridepublic void draw() {System.out.println(Square::draw());}
}
3客户角色
public class ShapeMaker {private Shape circle;private Shape rectangle;public ShapeMaker() {circle new Circle();rectangle new Rectangle();square new Square();}public void drawCircle(){circle.draw();}public void drawRectangle(){rectangle.draw();}}
4使用 ShapeMaker shapeMaker new ShapeMaker();shapeMaker.drawCircle();shapeMaker.drawRectangle();
2.6 享元模式
在面向对象程序设计过程中有时会面临要创建大量相同或相似对象实例的问题。
运用共享技术来有效地支持大量细粒度对象的复用。
享元模式的主要角色有如下
抽象享元角色Flyweight是所有的具体享元类的基类为具体享元规范需要实现的公共接口非享元的外部状态以参数的形式通过方法传入。具体享元Concrete Flyweight角色实现抽象享元角色中所规定的接口。非享元Unsharable Flyweight角色是不可以共享的外部状态它以参数的形式注入具体享元的相关方法中。享元工厂Flyweight Factory角色负责创建和管理享元角色。当客户对象请求一个享元对象时享元工厂检查系统中是否存在符合要求的享元对象如果存在则提供给客户如果不存在的话则创建一个新的享元对象。
1非享元
public class UnSharedFlyweight {private String info;public UnSharedFlyweight(String info){this.info info;}public String getInfo(){return info;}public void setInfo(String info){this.info info;}
}
2抽象享元
public interface AbstractFlyweight {void operation(UnSharedFlyweight unSharedFlyweight);
}3具体享元
public class ConcreteFlyweight implements AbstractFlyweight{private String key;public ConcreteFlyweight(String key){this.key key;System.out.println(具体享元 key 被创建);}Overridepublic void operation(UnSharedFlyweight unSharedFlyweight) {System.out.print(具体享元 key 被调用, );System.out.println(非享元信息是 unSharedFlyweight.getInfo());}
}
4享元工厂
public class FlyweightFactory {private HashMapString,AbstractFlyweight flyweights new HashMapString,AbstractFlyweight();public AbstractFlyweight getFlyweight(String key){AbstractFlyweight flyweight flyweights.get(key);if(flyweight ! null){System.out.println(具体享元 key 已经存在获取成功);}else{flyweight new ConcreteFlyweight(key);flyweights.put(key,flyweight);}return flyweight;}}
5使用 GetMapping(/demo11)public void demo11(){FlyweightFactory factory new FlyweightFactory();AbstractFlyweight flyweight1 factory.getFlyweight(a);AbstractFlyweight flyweight2 factory.getFlyweight(a);AbstractFlyweight flyweight3 factory.getFlyweight(b);AbstractFlyweight flyweight4 factory.getFlyweight(b);AbstractFlyweight flyweight5 factory.getFlyweight(b);flyweight1.operation(new UnSharedFlyweight(第一次调用a));flyweight2.operation(new UnSharedFlyweight(第二次调用a));flyweight3.operation(new UnSharedFlyweight(第一次调用b));flyweight4.operation(new UnSharedFlyweight(第二次调用b));flyweight5.operation(new UnSharedFlyweight(第三次调用b));} 实例应用棋子ChessPieces类是抽象享元角色它包含了一个落子的DownPieces(Graphics g,Point pt)方法白子WhitePieces和黑子BlackPieces类是具体享元角色它实现了落子方法Point是非享元角色它指定了落子的位置WeiqiFactory是享元工厂角色它通过ArrayList来管理棋子并且提供了获取白子或者黑子的getChessPieces(String type)方法。
2.7 组合模式
有时又叫作部分-整体模式它是一种将对象组合成树状的层次结构的模式用来表示“部分-整体”的关系使用户对单个对象和组合对象具有一致的访问性。
透明组合模式
//抽象构件
interface Component {public void add(Component c);public void remove(Component c);public Component getChild(int i);public void operation();
}//树叶构件
class Leaf implements Component {private String name;public Leaf(String name) {this.name name;}public void add(Component c) {}public void remove(Component c) {}public Component getChild(int i) {return null;}public void operation() {System.out.println(树叶 name 被访问);}
}//树枝构件
class Composite implements Component {private ArrayListComponent children new ArrayListComponent();public void add(Component c) {children.add(c);}public void remove(Component c) {children.remove(c);}public Component getChild(int i) {return children.get(i);}public void operation() {for (Object obj : children) {((Component) obj).operation();}}
}//使用Component c0 new Composite();Component c1 new Composite();Component leaf1 new Leaf(1);Component leaf2 new Leaf(2);Component leaf3 new Leaf(3);c0.add(leaf1);c0.add(c1);c1.add(leaf2);c1.add(leaf3);c0.operation();
3 行为型模式
3.1 模版方法模式
场景设计一个系统时知道了算法所需的关键步骤而且确定了这些步骤的执行顺序但某些步骤的具体实现还未知或者说某些步骤的实现与具体的环境相关。又例如例如简历模板、论文模板、Word中模板文件等。
模版方法模式特点如下定义一个操作中的算法骨架而将算法的一些步骤延迟到子类中使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
模板方法模式包含以下主要角色
1抽象类Abstract Class负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下 ① 模板方法定义了算法的骨架按某种顺序调用其包含的基本方法。 ② 基本方法是整个算法中的一个步骤包含以下几种类型。
2具体子类Concrete Class实现抽象类中所定义的抽象方法和钩子方法它们是一个顶级逻辑的一个组成步骤。
//抽象类
public abstract class StencilAbstract {public void TemplateMethod() { //模版方法SpecificMethod();abstractMethod1();abstractMethod2();}public void SpecificMethod(){ //具体方法System.out.println(抽象类中的具体方法被调用);}public abstract void abstractMethod1();public abstract void abstractMethod2();
}//具体子类
public class ConcreteStencil extends StencilAbstract {Overridepublic void abstractMethod1() {System.out.println(抽象方法1的实现调用);}Overridepublic void abstractMethod2() {System.out.println(抽象方法2的实现调用);}
}//调用GetMapping(/demo12)public void demo12(){StencilAbstract sa new ConcreteStencil();sa.TemplateMethod();}
3.2 策略模式
当实现某一个功能存在多种算法或者策略我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能。
策略模式定义了一系列算法并将每个算法封装起来使它们可以相互替换且算法的变化不会影响使用算法的客户。
策略模式的主要角色如下
抽象策略Strategy类定义了一个公共接口各种不同的算法以不同的方式实现这个接口环境角色使用这个接口调用不同的算法一般使用接口或抽象类实现。具体策略Concrete Strategy类实现了抽象策略定义的接口提供具体的算法实现。环境Context类持有一个策略类的引用最终给客户端调用。
1抽象策略类
public interface AbstractStrategy {public void strategyMethod();
}
2具体策略类
//具体实现方法2
public class ConcreteStrategyA implements AbstractStrategy{Overridepublic void strategyMethod() {System.out.println(具体策略A的策略方法被访问);}
}//具体实现方法1
public class ConcreteStrategyB implements AbstractStrategy{Overridepublic void strategyMethod() {System.out.println(具体策略B的策略方法被访问);}
}
3环境类
public class EnvironmentContext {private AbstractStrategy strategy;public AbstractStrategy getStrategy(){return strategy;}public void setStrategy(AbstractStrategy getStrategy){this.strategy strategy;}public void strategyMethod(){strategy.strategyMethod();}
}
4调用 GetMapping(/demo13)public void demo13(){EnvironmentContext context new EnvironmentContext();AbstractStrategy strategy new ConcreteStrategyA();context.setStrategy(strategy);context.strategyMethod();System.out.println(_______________);strategy new ConcreteStrategyB();context.setStrategy(strategy);context.strategyMethod();} 3.3 命令模式
背景在软件开发系统中常常出现“方法的请求者”与“方法的实现者”之间存在紧密的耦合关系。
命令模式将一个请求封装为一个对象使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通这样方便将命令对象进行储存、传递、调用、增加与管理。
命令模式包含以下主要角色
抽象命令类Command角色声明执行命令的接口拥有执行命令的抽象方法execute()。具体命令角色Concrete Command角色是抽象命令类的具体实现类它拥有接收者对象并通过调用接收者的功能来完成命令要执行的操作。实现者/接收者Receiver角色执行命令功能的相关操作是具体命令对象业务的真正实现者。调用者/请求者Invoker角色是请求的发送者它通常拥有很多的命令对象并通过访问命令对象来执行相关请求它不直接访问接收者。
1抽象命令类
//抽象命令
public interface Command {public abstract void execute();
}
2具体命令类
public class ConcreteCommand implements Command{private Receiver receiver;public ConcreteCommand(){receiver new Receiver();}Overridepublic void execute() {receiver.action();}
}
3调用者发起请求的地方
public class Invoker {private Command command;public Invoker (Command command){this.command command;}public void setCommand(Command command){this.command command;}public void call(){System.out.println(调用者治性命令);command.execute();}
}
4接收者真正实现业务的地方
public class Receiver {public void action(){System.out.println(接受者的action()方法被调用);}
}
5调用实现 GetMapping(/demo14)public void demo14(){Command cmd new ConcreteCommand();Invoker invoker new Invoker(cmd);invoker.call();}
3.4 职责链模式
背景一个请求有多个对象可以处理但每个对象的处理条件或权限不同。例如Struts2的拦截器、JSP和Servlet的Filter。
职责链模式为了避免请求发送者与多个请求处理者耦合在一起将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链当有请求发生时可将请求沿着这条链传递直到有对象处理它为止。
职责链模式主要包含以下角色
抽象处理者Handler角色定义一个处理请求的接口包含抽象处理方法和一个后继连接。具体处理者Concrete Handler角色实现抽象处理者的处理方法判断能否处理本次请求如果可以处理请求则处理否则将该请求转给它的后继者。客户类Client角色创建处理链并向链头的具体处理者对象提交请求它不关心处理细节和请求的传递过程。
1抽象处理者
public abstract class RCAbstractHandler {private RCAbstractHandler next;public void setNext(RCAbstractHandler next){this.next next;}public RCAbstractHandler getNext(){return next;}//处理请求的方法public abstract void handleRequest(String request);}
2具体处理者
//具体处理者1
public class ConcreteHandle1 extends RCAbstractHandler{Overridepublic void handleRequest(String request) {if(request.contains(a)){System.out.println(ConcreteHandle1 开始处理);}else {if(getNext() ! null){getNext().handleRequest(request);}else{System.out.println(无处理);}}}}//具体处理者2
public class ConcreteHandle2 extends RCAbstractHandler{Overridepublic void handleRequest(String request) {if(request.contains(b)){System.out.println(ConcreteHandle2 开始处理);}else {if(getNext() ! null){getNext().handleRequest(request);}else{System.out.println(无处理);}}}
}
3调用 GetMapping(/demo15)public void demo15(RequestParam(content) String content){RCAbstractHandler handler1 new ConcreteHandle1();RCAbstractHandler handler2 new ConcreteHandle2();handler1.setNext(handler2);handler1.handleRequest(content);} 3.5 状态模式
背景应用程序中的有些对象可能会根据不同的情况做出不同的行为我们把这种对象称为有状态的对象。
状态模式对有状态的对象把复杂的“判断逻辑”提取到不同的状态对象中允许状态对象在其内部状态发生改变时改变其行为。
状态模式包含以下主要角色
环境Context角色也称为上下文它定义了客户感兴趣的接口维护一个当前状态并将与状态相关的操作委托给当前状态对象来处理。抽象状态State角色定义一个接口用以封装环境对象中的特定状态所对应的行为。具体状态Concrete State角色实现抽象状态所对应的行为。
1环境角色
public class StateContext {private State state;public StateContext(){this.state new ConcreteStateA();}public void setState(State state){this.state state;}public State getState(){return state;}public void Handle(State state){state.Handle(this,state);}
}
2抽象状态
public abstract class State {public abstract void Handle(StateContext context,State state);
}3具体状态
//具体算法A
public class ConcreteStateA extends State{Overridepublic void Handle(StateContext context,State state) {System.out.println(this is A);context.setState(state);}
}//具体算法B
public class ConcreteStateB extends State{Overridepublic void Handle(StateContext context,State state) {System.out.println(this is B);context.setState(state);}
}
4调用 GetMapping(/demo16)public void demo16(){StateContext context new StateContext();context.Handle(new ConcreteStateA());context.Handle(new ConcreteStateA());context.Handle(new ConcreteStateB());} 3.6 观察者模式
背景在现实世界中许多对象并不是独立存在的其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变
观察者订阅者模式指多个对象间存在一对多的依赖关系当一个对象的状态发生改变时所有依赖于它的对象都得到通知并被自动更新。
观察者模式的主要角色如下
抽象主题Subject角色也叫抽象目标类它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法以及通知所有观察者的抽象方法。具体主题Concrete Subject角色也叫具体目标类它实现抽象目标中的通知方法当具体主题的内部状态发生改变时通知所有注册过的观察者对象。抽象观察者Observer角色它是一个抽象类或接口它包含了一个更新自己的抽象方法当接到具体主题的更改通知时被调用。具体观察者Concrete Observer角色实现抽象观察者中定义的抽象方法以便在得到目标的更改通知时更新自身的状态。
1抽象主题角色
public abstract class ObserverSubject {protected ListObserver observersnew ArrayListObserver();//增加观察者方法public void add(Observer observer){observers.add(observer);}//删除观察者方法public void remove(Observer observer){observers.remove(observer);}public abstract void notifyObserver(String info); //通知观察者方法
}
2具体主题
public class ObConcreteSubject extends ObserverSubject {Overridepublic void notifyObserver(String info) {System.out.println(具体目标发生改变...);System.out.println(--------------);for(Object obs:observers){((Observer)obs).response(info);}}
}
3抽象观察者
public interface Observer {void response(String info);
}4具体观察者角色
//具体观察者1
public class ObConcreteObserver1 implements Observer{Overridepublic void response(String info) {System.out.println(具体观察者1作出反应: info);}
}//具体观察者2
public class ObConcreteObserver1 implements Observer{Overridepublic void response(String info) {System.out.println(具体观察者1作出反应: info);}
}
5调用 GetMapping(/demo17)public void demo17(){ObserverSubject subject new ObConcreteSubject();Observer observer1 new ObConcreteObserver1();Observer observer2 new ObConcreteObserver2();subject.add(observer1);subject.add(observer2);subject.notifyObserver(降价了);} 3.7 中介模式
背景在现实生活中常常会出现好多对象之间存在复杂的交互关系这种交互关系常常是“网状结构”它要求每个对象都必须知道它需要交互的对象。
中介模式调停模式定义一个中介对象来封装一系列对象之间的交互使原有对象之间的耦合松散且可以独立地改变它们之间的交互。
中介者模式包含以下主要角色
抽象中介者Mediator角色它是中介者的接口提供了同事对象注册与转发同事对象信息的抽象方法。具体中介者Concrete Mediator角色实现中介者接口定义一个List来管理同事对象协调各个同事角色之间的交互关系因此它依赖于同事角色。抽象同事类Colleague角色定义同事类的接口保存中介者对象提供同事对象交互的抽象方法实现所有相互影响的同事类的公共功能。具体同事类Concrete Colleague角色是抽象同事类的实现者当需要与其他同事对象交互时由中介者对象负责后续的交互。
1中介者
//抽象中介者
public abstract class AbstractMediator {public abstract void register(AbstractCollege college);public abstract void replay(AbstractCollege cl);
}//具体中介者
public class ConcreteMediator extends AbstractMediator{private ListAbstractCollege colleges new ArrayList();Overridepublic void register(AbstractCollege college) {if(!colleges.contains(college)){colleges.add(college);college.setMediator(this);}}Overridepublic void replay(AbstractCollege cl) {for(AbstractCollege college : colleges){if(!college.equals(cl)){college.receive();}}}
}
2同事类
//抽象
public abstract class AbstractCollege {protected AbstractMediator mediator;public void setMediator(AbstractMediator mediator){this.mediator mediator;}public abstract void receive();public abstract void send();
}//具体1
public class ConcreteCollege1 extends AbstractCollege{Overridepublic void receive() {System.out.println(college1 收到请求 );}Overridepublic void send() {System.out.println(college1 发出请求 );mediator.replay(this);//转发}
}//具体2
public class ConcreteCollege2 extends AbstractCollege {Overridepublic void receive() {System.out.println(college2 收到请求 );}Overridepublic void send() {System.out.println(college2 发出请求 );mediator.replay(this);}
}
3调用 GetMapping(/demo18)public void demo18(){AbstractMediator mediator new ConcreteMediator();AbstractCollege c1,c2;c1 new ConcreteCollege1();c2 new ConcreteCollege2();mediator.register(c1);mediator.register(c2);c1.send();c2.send();}
不同对象之间的信息沟通 3.8 迭代器模式
提供一个对象来顺序访问聚合对象中的一系列数据而不暴露聚合对象的内部表示。
迭代器模式主要包含以下角色
抽象聚合Aggregate角色定义存储、添加、删除聚合对象以及创建迭代器对象的接口。具体聚合Concrete Aggregate角色实现抽象聚合类返回一个具体迭代器的实例。抽象迭代器Iterator角色定义访问和遍历聚合元素的接口通常包含hasNext()、first()、next()等方法。具体迭代器Concrete Iterator角色实现抽象迭代器接口中所定义的方法完成对聚合对象的遍历记录遍历的当前位置。
1抽象聚合
public interface IteratorAggregate {public void add(Object obj);public void remove(Object obj);public Iterator getIterator();
}2具体聚合
public class ConcreteAggregate implements IteratorAggregate{private ListObject list new ArrayList();Overridepublic void add(Object obj) {list.add(obj);}Overridepublic void remove(Object obj) {list.remove(obj);}Overridepublic Iterator getIterator() {return new ConcreteIterator(list);}
}
3抽象迭代器
public interface Iterator {Object first();Object next();boolean hashNext();
}
4具体迭代器 public class ConcreteIterator implements Iterator{private ListObject list new ArrayList();private int index 0;public ConcreteIterator(ListObject list){this.list list;}Overridepublic Object first() {index 0;Object object list.get(index);return object;}Overridepublic Object next() {Object object null;if(this.hashNext()){object list.get(index);}return object;}Overridepublic boolean hashNext() {if(index list.size()){return false;}else {return true;}}
}
5调用 GetMapping(/demo19)public void demo19(){IteratorAggregate ag new ConcreteAggregate();ag.add(中山大学);ag.add(华南理工);ag.add(清华大学);ag.add(北大大学);Iterator it ag.getIterator();while(it.hashNext()){Object ob it.next();System.out.println(ob.toString() \n);}Object ob it.first();System.out.println(\nFirst ob.toString());}
3.9 访问者模式
背景有些集合对象中存在多种不同的元素且每种元素也存在多种不同的访问者和处理方式。
访问者模式定义将作用于某种数据结构中的各元素的操作分离出来封装成独立的类使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作为数据结构中的每个元素提供多种访问方式。
访问者模式包含以下主要角色:
抽象访问者Visitor角色定义一个访问具体元素的接口为每个具体元素类对应一个访问操作visit()该操作中的参数类型标识了被访问的具体元素。具体访问者Concrete Visitor角色实现抽象访问者角色中声明的各个访问操作确定访问者访问一个元素时该做什么。抽象元素Element角色声明一个包含接受操作accept()的接口被接受的访问者对象作为accept()方法的参数。具体元素Concrete Element角色实现抽象元素角色提供的accept()操作其方法体通常都是visitor.visit(this)另外具体元素中可能还包含本身业务逻辑的相关操作。对象结构Object Structure角色是一个包含元素角色的容器提供让访问者对象遍历容器中的所有元素的方法通常由List、Set、Map等聚合类实现。
1抽象访问者
public interface AbstractVisitor {void visit(ConcreteElementA element);void visit(ConcreteElementB element);
}
2具体访问者
//具体访问者A
public class ConcreteVisitorA implements AbstractVisitor{Overridepublic void visit(ConcreteElementA element) {System.out.println(具体A访问者访问 element.Operation());}Overridepublic void visit(ConcreteElementB element) {System.out.println(具体A访问者访问 element.Operation());}
}//具体访问者B
public class ConcreteVisitorB implements AbstractVisitor{Overridepublic void visit(ConcreteElementA element) {System.out.println(具体B访问者访问 element.Operation());}Overridepublic void visit(ConcreteElementB element) {System.out.println(具体B访问者访问 element.Operation());}
}
3抽象元素
public interface Element {void accept(AbstractVisitor visitor);
}4具体元素
//具体元素A
public class ConcreteElementA implements Element{Overridepublic void accept(AbstractVisitor visitor) {visitor.visit(this);}public String Operation(){return 具体元素A的操作;}
}//具体元素B
public class ConcreteElementB implements Element{Overridepublic void accept(AbstractVisitor visitor) {visitor.visit(this);}public String Operation(){return 具体元素B的操作;}
}
5对象结构元素
public class ObjectStructure {private ListElement list new ArrayListElement();public void accept(AbstractVisitor visitor){IteratorElement element list.iterator();while(element.hasNext()){element.next().accept(visitor);}}public void add(Element element){list.add(element);}public void remove(Element element){list.remove(element);}
}
6调用 GetMapping(/demo20)public void demo20(){ObjectStructure obs new ObjectStructure();obs.add(new ConcreteElementA());obs.add(new ConcreteElementB());AbstractVisitor visitorA new ConcreteVisitorA();obs.accept(visitorA);AbstractVisitor visitorB new ConcreteVisitorB();obs.accept(visitorB);} 3.10 备忘录模式
备忘录模式快照模式能记录一个对象的内部状态当用户后悔时能撤销当前操作使数据恢复到它原先的状态。
备忘录模式的主要角色如下
发起人Originator角色记录当前时刻的内部状态信息提供创建备忘录和恢复备忘录数据的功能实现其他业务功能它可以访问备忘录里的所有信息。备忘录Memento角色负责存储发起人的内部状态在需要的时候提供这些内部状态给发起人。管理者Caretaker角色对备忘录进行管理提供保存与获取备忘录的功能但其不能对备忘录的内容进行访问与修改。
1备忘录
public class Memento {private String state;public Memento (String state){this.state state;}public void setState(String state){this.state state;}public String getState(){return state;}
}
2发起人
public class Originator {private String state;public void setState(String state){this.state state;}public String getState(){return state;}public Memento createMemento(){return new Memento(state);}public void restoreMemento(Memento m){this.setState(m.getState());}
}
3管理者
public class Caretaker {private Memento memento;public void setMemento(Memento m){this.memento m;}public Memento getMemento(){return memento;}
}
4调用 GetMapping(/demo21)public void demo21(){Originator or new Originator();Caretaker cr new Caretaker();or.setState(S0);System.out.println(初始状态 or.getState());cr.setMemento(or.createMemento()); //保存状态or.setState(S1);System.out.println(新的状态 or.getState());or.restoreMemento(cr.getMemento()); //恢复状态System.out.println(恢复状态 or.getState());}
