遵义网站建设制作公司,凡客诚品网站建设策划书,网站建设方案如何写,wordpress 自动内链 代码1、适配器模式
#xff08;1#xff09;概述
适配器中有一个适配器包装类Adapter#xff0c;其包装的对象为适配者Adaptee#xff0c;适配器作用就是将客户端请求转化为调用适配者中的接口#xff1b;当调用适配器中的方法时#xff0c;适配器内部会调用适配者类的方法…1、适配器模式
1概述
适配器中有一个适配器包装类Adapter其包装的对象为适配者Adaptee适配器作用就是将客户端请求转化为调用适配者中的接口当调用适配器中的方法时适配器内部会调用适配者类的方法这个调用对客户端是透明实现了不同接口之间由于不兼容的类可以相互调用
2对象适配器
Target目标抽象类可以是一个抽象类或接口该类为客户端所需要的接口Adapter适配器类:Adapter可以调用另外一个接口对Target和Adaptee进行适配Target通过Adapter可以调用Adaptee中的业务逻辑对客户端是透明的Adaptee适配者类定义了一个已经存在的接口适配者类一般是一个具体的类包含了客户需要调用的业务方法Adapter和Adaptee是关联关系 //适配器
public class Adapter implements Target{private MySQLConnect mySQLConnect;//适配者对象public Adapter(MySQLConnect mySQLConnect){this.mySQLConnectmySQLConnect;}Overridepublic void connect() {mySQLConnect.mysqlConnect();}
}
public interface Target {public void connect();
}
//适配者
public class MySQLConnect {public void mysqlConnect(){System.out.println(数据库链接配置);}
}
//测试
public class Main {public static void main(String[] args) {Target targetnew Adapter(new MySQLConnect());target.connect();}
}
3类适配器
适配器和适配者之间的关系为继承适配器实现了Target接口继承了Adapteee类当Target不是接口而是抽象类则无法使用类适配器当Adaptee类被final修饰也不能使用类适配器
//适配器类其他代码和上一样
public class Adapter extends MySQLConnect implements Target{Overridepublic void connect() {mysqlConnect();}
}
3缺省适配器
ServiceInterface适配者接口为一个接口实现大量方法AbstractServiceClass缺省适配器类实现了适配者接口中所有方法使用空方法形式ConcreteServiceClass业务类为缺省适配器的子类在没有适配器之前该类需要实现ServiceInterface中所有方法引入适配器类后只需要继承适配器类实现对应的方法即可
public interface ServiceInterface {public void print();public void eat();public void smell();
}
public class AbstractService implements ServiceInterface{//缺省适配器Overridepublic void print() { }Overridepublic void eat() { }Overridepublic void smell() { }
}
public class ConcreteService extends AbstractService{Overridepublic void print() {//重写打印接口System.out.println(打印);}
}
4总结
优点
目标类和适配者类解耦通过引入一个适配器类来重用现有的适配者类无序修改原有代码结构增加了类的透明性和复用性将业务代码封装在适配者类中对于用户是透明的同时适配者类可以被多个不同系统调用灵活性和扩展性好通过配置文件切换适配器类可以在原有基础上添加新的适配器类符合开闭原则
缺点
类适配器中只能适配一个适配者类java不能多继承对象适配器在适配器重置换适配者类比较麻烦需要先创建一个适配者类的子类重写需要置换的方法然后再将适配器适配到这个子类
使用场景
系统需要使用已有的接口而这些接口不符合系统需求甚至没有源代码想创建一个可以重复使用的类用于一些彼此之间没有太大关联的一些类包括一些可能在将来引进的类一起工作
2、工厂方法模式
1概述
工厂方法定义一个创建对象的接口让实现该接口的子类取实例化对象。工厂方法将对象的实例化延迟到其子类创建
2角色
Product抽象产品定义产品接口某个类型产品是工厂方法模式中所有创建对象的公共父类ConcreteProduct具体产品实现抽象产品的接口即某种类型的具体产品与一个具体工厂一一对应Factory抽象工厂创建对象工厂的接口声明工厂方法Factory Method用于返回一个产品所有创建对象的工厂类都需要实现该接口ConcreteFactory具体工厂实现抽象工厂的工厂方法返回一个具体的产品 3实现
public interface Factory {public Product create();
}
public class MySQLFactory implements Factory{Overridepublic Product create() {return new MySQLProduct();}
}
public abstract class Factory {//抽象工厂public void connect(){//对客户端隐藏调用具体产品的方法Product product this.create();product.connect();}public abstract Product create();
}
public class MySQLFactory extends Factory{//具体工厂Overridepublic Product create() {return new MySQLProduct();}
}
public class Main {public static void main(String[] args) {Factory factorynew MySQLFactory();//可以通过配置文件配置进行工厂方法切换factory.connect();}
}4总结
优点
客户端只需要知道创建对象的工厂方法工厂方法隐藏具体具体对象被实例化的细节客户端无需关系对象如何创建甚至无需关心对象的具体类名当需要加入一个新的对象产品时无需修改原系统只需要新增一个具体对象类和对应的工厂类即可
缺点
每新增一个产品就需要新增对应的产品类和工厂类增加系统复杂度同时由更多类需要被系统加载会给系统带来一些而外的开销引入抽象层增加系统抽象性和可理解性
使用场景
客户端不知道他所需要的类抽象工厂类通过子类创建对象
3、抽象工厂模式
1概述
产品等级结构即产品的继承结构一个抽象产品多个相同的产品继承该抽象产品一个抽象产品与其子类构成一个产品等级结构。如电视机为抽象类则海尔电视机华普电视机创维电视机为其子类共同构成一个产品等级结构产品族产品族是由同一个工厂产生的位于不同产品等级结构的一组产品一个工厂负责生产一个产品族即下图颜色相同的抽象工厂会提供一个创建一系列相关或相互依赖的对象的接口而无需指定他们的具体实现类 2角色
AbstractFactory抽象工厂声明一些列创建产品族的方法每一个方法对应一个产品ConcreteFactory具体工厂实现抽象工厂中的方法用于创建一组具体产品这些具体产品构成一个产品族位于一个产品等级结构中AbstractProduct抽象产品为每种产品生成一种接口在抽象产品中声明了产品所具有的业务方法ConcreteProduct具体产品他定义具体工厂生成的产品对象实现抽象产品接口中声明的业务方法 3实现
public interface AbstractFactory {//抽象工厂public AbstractProductA createProductA();public AbstractProductB createProductB();
}
public class ConcreteProduct1 implements AbstractFactory{//具体工厂1Overridepublic AbstractProductA createProductA() {return new ProductA1();}Overridepublic AbstractProductB createProductB() {return new ProductB1();}
}
public class ConcreteProduct2 implements AbstractFactory{//具体工厂2Overridepublic AbstractProductA createProductA() {return new ProductA2();}Overridepublic AbstractProductB createProductB() {return new ProductB2();}
}
public interface AbstractProductA {//抽象产品Apublic void printA();
}
public class ProductA1 implements AbstractProductA{//具体产品A--1Overridepublic void printA() {System.out.println(产品A类--型号1类型);}
}
public class ProductA2 implements AbstractProductA{//具体产品A---2Overridepublic void printA() {System.out.println(产品A类--型号2类型);}
}
public interface AbstractProductB {//抽象产品Bpublic void printB();
}
public class ProductB1 implements AbstractProductB{//具体产品B--1Overridepublic void printB() {System.out.println(产品B类--型号1类型);}
}
public class ProductB2 implements AbstractProductB{//具体产品B--2Overridepublic void printB() {System.out.println(产品B类--型号2类型);}
}
public class Main {//测试类public static void main(String[] args) {System.out.println(工厂1生成对应1号类型的产品族);AbstractFactory factory1new ConcreteProduct1();factory1.createProductA().printA();factory1.createProductB().printB();System.out.println(工厂2生成对应的2号类型的产品族);AbstractFactory factory2new ConcreteProduct2();factory2.createProductA().printA();factory2.createProductB().printB();}
}
4总结
优点
客户端不需要知道产品如何创建如果需要切换产品更换一个具体工厂即可增加新的产品族十分方便无需修改原系统符合开闭原则
缺点
添加一个产品等级结构系列时需要从修改原有系统中的所有工厂方法不符合开闭原则
使用场景
一个系统不依赖对象的创建组合客户端无需知道对象如何创建系统中有多个产品族每次只使用一个产品族同一个产品族中的产品将在一起使用同一个产品族的产品可以没有任何关系但必须是有一总共同约束
4、装饰器模式
1概述
装饰模式可以在不改变原有对象的模式下增加额外行为可以动态给对象增加一些职责
2角色
Component抽象组件他是具体组件和装饰组件的父类声明了具体组件实现的业务方法为客户端提供以一致方式处理装饰前以及装饰后的组件ConcreteComponent具体组件Component的子类用于定义具体的组件方法装饰器类可以给他增加额外职责Decorator抽象装饰类Component子类用于给具体组件添加新的职责他维护一个指向抽象组件的应用通过该应用可以调用装饰之前的组件并通过起子类扩展职责ConcreteDecorator具体装饰类抽象装饰类的子类负责向具体组件添加新的职责 3实现
public interface Component {//抽象组件public void operation();
}
public class ConcreteComponent implements Component{//具体组件Overridepublic void operation() {System.out.println(组件操作);}
}
public class Decorator implements Component{//抽象装饰器private Component component;public Decorator(Component component){this.componentcomponent;}Overridepublic void operation() {component.operation();}
}
public class ConcreteDecoratorA extends Decorator{//具体装饰类public ConcreteDecoratorA(Component component) {super(component);}Overridepublic void operation() {super.operation();addState();}public void addState(){System.out.println(添加机器状态);}
}
public class ConcreteDecoratorB extends Decorator {//具体装饰类public ConcreteDecoratorB(Component component) {super(component);}Overridepublic void operation() {super.operation();addMoney();}public void addMoney(){System.out.println(加钱买更多机器投入操作);}
}
public class Main {//main方法public static void main(String[] args) {Component componentnew ConcreteComponent();System.out.println(装饰器A-----------);Decorator decoratornew ConcreteDecoratorA(component);decorator.operation();System.out.println(装饰器B---------------);decoratornew ConcreteDecoratorB(component);decorator.operation();}
}
4总结
优点
装饰器比继承更加灵活不会导致类个数急剧增加可以动态的扩展一个对象功能通过配置类可以在运行时选择不同的配置类从而实现不同行为可以对一个对象装饰多次采用不同1装饰类可以组装出多个不同的行为具体的组件类和装饰类可以独立添加可以根据需要添加新的构建类和组件类符合开闭原则
缺点
会产生大量的小对象这些小对象随着不断累积会消耗大量内存对于排错需要多级查找
使用场景
在不影响其他对象的情况下动态透明的给一个对象添加职责系统中存在大量独立的类不可以使用装饰器模式否则会产生大量的子类
5、建造者模式
1概述
将一个复杂对象的构建与他的表示分离使得同样构建过程可以创建不同的表示不同的具体建造者定义不同的创建过程且具体的建造者相互独立增加新的建造者非常方便
2角色
Builder抽象建造者他为建造复杂对象的各个部件定义接口在接口中声明方法中一类是buildProductX方法用于构建各个组件另外一类为getProduct方法用于获取构建后的对象既可以是接口也可以是抽象类Concretebuilder具体建造者实现Builder接口实现各个构造组件的方法并实现返回一个对象的方法Product产品具体的构建对象包含多个组件由ConcreteBuilder装配Director指挥者定义一个construct方法复杂组件装配的顺序返回构造好的对象一般该类与客户端进行交互内部维护一个Builder类复杂对象包含多个属性的对象 3实现
Data
public class Product {//产品类private String A;private String B;
}
public abstract class Builder {//建造者抽象类protected Product productnew Product();public abstract void buildPathA(String value);public abstract void buildPathB(String value);public Product getProduct(){return this.product;}
}
public class ConcreteBuilder extends Builder{//具体建造类Overridepublic void buildPathA(String value) {product.setA(value);}Overridepublic void buildPathB(String value) {product.setB(value);}
}
public class Director {//指挥者类private Builder builder;public Director(Builder builder){this.builderbuilder;}public Product construct(String A,String B){builder.buildPathA(A);builder.buildPathB(B);return builder.getProduct();}
}
public class Main {public static void main(String[] args) {Builder buildernew ConcreteBuilder();Product productnew Director(builder).construct(属性A,属性B);System.out.println(product.getA());System.out.println(product.getB());}
}
4总结
优点
在建造者模式中客户端不必直到内部如何构建将产品本身与产品构建之间解耦使得相同的构建过程可以构建不同的产品每一个构建者相对独立客户端可以很方便的添加新的构造者同时增加新的构造者不用修改原有的代码符合开闭原则
缺点
产品之间相差过大各个组成部分由较大差异不适合使用该模式产品的组件变化复杂需要定义过多的构造类来实现这种变化导致系统过于庞大
使用场景
需要生成复杂对象这些对象通常包含多个属性对象之间的属性相互依赖且由一定的顺序性隔离复杂对象的创建和使用使得相同的创建过程可以构建出不同的对象
6、组合模式
1概述
组合多个对象成为树形结构对于叶子对象和容器对象的操作都具有一致性当调用容器对象的某一个方法时将会遍历整个树寻找包含这个方法的成员变量使用递归对整个树结构进行调用叶子对象没有字节点容器对象包含多个叶子对象和多个容器对象
2角色
Component抽象构件为叶子构件和容器构件声明了接口定义了其子类共有的行为方法Leaf叶子构件实现了Component接口中的行为方法没有子节点Composite容器构件该节点有子节点子节点可以是容器节点也可以是叶子节点。有一个列表属性用于存储子节点实现了Component接口定义的行为方法该方法可以递归调用子节点的业务方法同时包含管理子构建的方法 3实现
public abstract class Component {//抽象组件public abstract void add(Component component);//添加构建public abstract void remove(Component component);//删除构建public abstract ListComponent getChild();//获取子类public abstract void print();//输出文件
}
public class OssLeaf extends Component{//叶子组件private String name;public OssLeaf(String name){this.namename;}Overridepublic void add(Component component) {System.out.println(异常处理);}Overridepublic void remove(Component component) {System.out.println(异常处理);}Overridepublic ListComponent getChild() {return null;}Overridepublic void print() {System.out.println(输出name文件);}
}
public class TxtLeaf extends Component{//叶子组件private String name;public TxtLeaf(String name){this.namename;}Overridepublic void add(Component component) {System.out.println(异常处理);}Overridepublic void remove(Component component) {System.out.println(异常处理);}Overridepublic ListComponent getChild() {return null;}Overridepublic void print() {System.out.println(输出name文件类型);}
}
public class Composite extends Component{//容器组件//记录该组件的子组件叶子组件、容器组件private ListComponent componentListnew ArrayList();private String name;public Composite(String name){this.namename;}Overridepublic void add(Component component) {componentList.add(component);}Overridepublic void remove(Component component) {componentList.remove(component);}Overridepublic ListComponent getChild() {return componentList;}Overridepublic void print() {System.out.println(输出name类型的文件输出如下);//调用子类的方法for (Component component : componentList) {component.print();}}
}
public class Main {//测试方法public static void main(String[] args) {OssLeaf ossLeaf1new OssLeaf(图片);OssLeaf ossLeaf2new OssLeaf(视频);TxtLeaf txtLeafnew TxtLeaf(txt);TxtLeaf txtLeaf1new TxtLeaf(docx);TxtLeaf txtLeaf2new TxtLeaf(pptx);Composite composite1new Composite(oss类型文件);composite1.add(ossLeaf1);composite1.add(ossLeaf2);composite1.print();Composite composite2new Composite(文本类型文件);composite2.add(txtLeaf);composite2.add(txtLeaf1);composite2.add(txtLeaf2);composite2.print();}
}
4总结
优点
在新增新的叶子组件或容器组件时无需修改原有代码符合开闭原则忽略客户端层次差异方便对整个层次进行控制
缺点新增新的组件时难以对组件的类型进行控制
使用场景
需要处理一个树型结构系统中可以分离出叶子组件和容器组件类型不固定需要增加一些新的类型整体和部分具有层次结构需要处理忽略他们的层次差使用客户端一致调用这些业务方法
7、观察者模式
1概述
定义一种一堆多的关系使得每当一个对象发生改变时会通知其关联对象并自动更新发生改变的对象为观察目标而被通知的对象为观察者这些观察者之间没有任何联系
2角色
Subject目标被观察的对象在目标中定义了一个观察者对象集合提供删除添加观察者的方法同时定义了通知方法notify可以是接口抽象类或具体类ConcreteSubject具体目标Subject的子类他包含发生改变的数据当该数据发生改变时会通知集合中的观察者同时还实现目标类中的抽象业务方法无需扩展目标类该类可以省略Observer抽象观察者观察者对改变做出响应一般为接口声明update方法ConcreteObserver具体观察者实现抽象观察者中的update方法同时维护一个ConcreteSubject对象的应用存储具体观察者有关状态该状态需要与目标对象状态一致 3实现
public abstract class Subject {//抽象目标public ListObserver observerListnew ArrayList();//观察者集合public void add(Observer observer){//添加观察者observerList.add(observer);}public void delete(Observer observer){//删除观察者observerList.remove(observer);}public abstract void notifyObserver(String name);}
public class ConcreteSubject extends Subject{//具体目标类Overridepublic void notifyObserver(String name) {//通知每一个观察者处理errorfor (Observer observer : observerList) {if (!((ConcreteObserver) observer).getName().equals(name)){observer.dealError();}}}
}
public interface Observer {//抽象观察者public void dealError();//在发生error时触发public void error(Subject subject);
}
public class ConcreteObserver implements Observer{//具体观察者private String name;public ConcreteObserver(String name){this.namename;}public String getName(){return this.name;}//处理错误Overridepublic void dealError() {System.out.println(name来处理error了);}//发生错误Overridepublic void error(Subject subject) {System.out.println(name发生error都来处理error);subject.notifyObserver(name);}
}
public class Main {public static void main(String[] args) {Subject subjectnew ConcreteSubject();Observer observer1new ConcreteObserver(A);Observer observer2new ConcreteObserver(B);Observer observer3new ConcreteObserver(C);subject.add(observer1);subject.add(observer2);subject.add(observer3);observer1.error(subject);}
}
4总结
优点
观察者适合广播通信目标对象发生改变时会通知所有订阅目标的观察者添加具体观察者无需修改原有代码每一个观察者之间无任何联系符合开闭原则
缺点
目标类如果有过多的观察者通知时会耗费大量时间观察者和目标之间存在循环依赖通知时会导致死循环观察者无法直到观察对象是如何变化的只能直到该对象发生了变化
使用场景
一个对象发生改变会影响多个对象而这些对象之间相互无任何联系链式触发如A影响BB影响C。。。
8、责任链模式
1概述
避免请求发送者和接收者耦合在一起让多个对象都可以接收请求将这些对象合成一条链并且沿着这条链传递请求直到有对象处理该请求为止
2角色
Handler抽象处理者定义了一个处理请求的接口不同的处理者对每一个请求的处理方式不同因此定义抽象处理者。每一个处理者的下一个还是处理者在抽象类中定义一个处理者对象用于对下一个处理者的调用ConcreteHandler具体处理者抽象处理者的实现类实现具体的请求处理方法处理请求之前需要先判断是否有权限处理有则处理否则将请求转发给下一个处理者 3实现
Data
public abstract class Handler {protected Handler handler;//下一个处理者protected String name;//姓名public Handler(String name){this.namename;}//处理请求逻辑方法public abstract void processorHandler(int money);
}
public class ConcreteHandlerA extends Handler{public ConcreteHandlerA(String name){super(name);}Override//可以审批5000元以下public void processorHandler(int money) {if (money5000){System.out.println(name进行审批审批通过);}else {System.out.println(name无法审批金额流转下一个审批者);handler.processorHandler(money);}}
}
public class ConcreteHandlerB extends Handler{public ConcreteHandlerB(String name){super(name);}Override//可以审批5000-20000public void processorHandler(int money) {if (money5000money20000){System.out.println(name进行审批审批通过);}else {System.out.println(name无法审批金额流转下一个审批者);handler.processorHandler(money);}}
}
public class ConcreteHandlerC extends Handler{public ConcreteHandlerC(String name){super(name);}Override//可以审批20000以上public void processorHandler(int money) {if (money20000){System.out.println(name进行审批审批通过);}else {System.out.println(name无法审批金额流转下一个审批者);handler.processorHandler(money);}}
}
public class Main {public static void main(String[] args) {Handler handlerAnew ConcreteHandlerA(主管);Handler handlerBnew ConcreteHandlerB(经理);Handler handlerCnew ConcreteHandlerC(董事长);//设置下一个处理者handlerA.setHandler(handlerB);handlerB.setHandler(handlerC);handlerA.processorHandler(30000);}
}
4总结
优点
发送者和接收者都没有对方的信息只知道请求会被处理降低系统耦合度职责链的处理更加灵活可以动态增加和删除处理者来改变处理一个请求的职责增加一个新的请求者无需修改原有代码只需添加新连接即可符合开闭原则
缺点
请求没有明确接收者可能导致请求走完职责链也并未被处理请求处理需要多个对象进行处理系统性能将受一定的影响创建的连接不当可能会造成系统死循环
使用场景
多个对象处理一个请求请求需要等到运行时才能确定哪一个处理者处理不明确处理者对象向多个对象提交一个请求指定一组对象进行处理客户端可以动态添加处理对象并且可以改变顺序
