设计模式(二)结构模式(适配器模式、双向适配器模式、装饰模式)
2017-12-22 14:24
441 查看
创建模式是创建对象
结构模式是组合对象
行为模式是模块和模块之间发生行为
适配器模式适合主一对附多,装饰模式适合主多对附一
适配器模式 (spring)
//B到A里面,A主动,B为被动方会切换,叫单向适配器模式,主动方Adaptor,被动方Adaptee
class A{
public void funA(){
System.out.println("A");
}
}
interface IExtendModule{
public abstract void extendFun();
}
class B implements IExtendModule{
public void extendFun(){
System.out.println("B");
}
}
class C implements IExtendModule{
public void extendFun(){
System.out.println("B或者C");
}
}
class SubA extends A{
private IExtendModule iem;
public SubA(IExtendModule iem){
this.iem = iem;
}
public void funA(){
super.funA();//值得一提,这句代码如果去掉,就是著名的功能替换
iem.extendFun();
}
}
public class Adapter1{
public static void main(String args[]){
B b = new B();
//C c = new C();
SubA subA = new SubA(b);
//SubA subA = new SubA(c);
subA.funA();
}
}
==============================================================================
双向适配器模式
//B方法B1到A方法A1,A方法A2到B方法B2,叫双向适配器模式
//相当于打开一个A界面,然后再打开一个B界面,改变B的属性,可以浏览到A界面变动,点击取消可以恢复
变动
//缺陷扩展模块无法很好的应付主模块的切换
class A{
public void funA1(){
System.out.println("A.funA1");
}
public void funA2(){
System.out.println("A.funA2");
}
}
class B{
public void funB1(){
System.out.println("B.funB1");
}
public void funB2(){
System.out.println("B.funB1");
}
}
class AB{//组合A和B
private A a;
private B b;
public void setA(A a){
this.a = a;
}
public void setB(B b){
this.b = b;
}
public void funA1(){
a.funA1();
b.funB1();
}
public void funB2(){
b.funB2();
a.funA2();
}
}
public class Adapter2{
public static void main(String args[]){
AB ab = new AB();
ab.setA(new A());
ab.setB(new B());
//ab.funA1();
ab.funB2();
}
}
优化双向适配器模式
interface IA{
public abstract void funA1();
public abstract void funA2();
}
class A impelement IA{
public void funA1(){
System.out.println("A.funA1");
}
public void funA2(){
System.out.println("A.funA2");
}
}
interface IB{
public abstract void funB1();
public abstract void funB2();
}
class B impelement IB{
public void funB1(){
System.out.println("B.funB1");
}
public void funB2(){
System.out.println("B.funB1");
}
}
class AB implements IA,IB{//组合A和B
private IA ia;
private IB ib;
public void setIA(IA ia){
this.ia = ia;
}
public void setIB(IB ib){
this.ib = ib;
}
public void funA1(){
ia.funA1();//这句话如果替换就是功能替换
ib.funB1();
}
public void funB2(){
ib.funB2();//这句话如果替换就是功能替换
ia.funA2();
}
//面向接口编程后会丢方法,还需要重新其他功能
public void funA2(){
ia.funA2();
}
public void funB1(){
ib.funB1();
}
}
public class Adapter2{
public static void main(String args[]){
AB ab = new AB();
ab.setIA(new A());
ab.setIB(new B());
//ab.funA1();
ab.funB2();
}
}
=======================================================
装饰模式
要点:主模块接口注入扩展模块
interface IRead{
public abstract void read();
}
class ReadStrFromFile implements IRead{//主模块,可能会变动
public void read(){
System.out.println("读取字符串");
}
}
class ReadStrFromNet implements IRead{//主模块,可能会变动
public void read(){
System.out.println("读取字符串");
}
}
//可以用Spring装配,可以为任何实现了IRead接口的类服务
class Convert{//附模块,可以为主模块服务,或者其他主模块服务
private IRead iread;
public Convert(IRead iread){
this.iread = iread;
}
public void convertToUpper(){
iread.read();
System.out.println("转大写");
}
}
public class Decorator2{
public static void main(String args[]){
Convert convert = new Convert(new ReadStrFromFile());
convert.convertToUpper();
}
}
结构模式是组合对象
行为模式是模块和模块之间发生行为
适配器模式适合主一对附多,装饰模式适合主多对附一
适配器模式 (spring)
//B到A里面,A主动,B为被动方会切换,叫单向适配器模式,主动方Adaptor,被动方Adaptee
class A{
public void funA(){
System.out.println("A");
}
}
interface IExtendModule{
public abstract void extendFun();
}
class B implements IExtendModule{
public void extendFun(){
System.out.println("B");
}
}
class C implements IExtendModule{
public void extendFun(){
System.out.println("B或者C");
}
}
class SubA extends A{
private IExtendModule iem;
public SubA(IExtendModule iem){
this.iem = iem;
}
public void funA(){
super.funA();//值得一提,这句代码如果去掉,就是著名的功能替换
iem.extendFun();
}
}
public class Adapter1{
public static void main(String args[]){
B b = new B();
//C c = new C();
SubA subA = new SubA(b);
//SubA subA = new SubA(c);
subA.funA();
}
}
==============================================================================
双向适配器模式
//B方法B1到A方法A1,A方法A2到B方法B2,叫双向适配器模式
//相当于打开一个A界面,然后再打开一个B界面,改变B的属性,可以浏览到A界面变动,点击取消可以恢复
变动
//缺陷扩展模块无法很好的应付主模块的切换
class A{
public void funA1(){
System.out.println("A.funA1");
}
public void funA2(){
System.out.println("A.funA2");
}
}
class B{
public void funB1(){
System.out.println("B.funB1");
}
public void funB2(){
System.out.println("B.funB1");
}
}
class AB{//组合A和B
private A a;
private B b;
public void setA(A a){
this.a = a;
}
public void setB(B b){
this.b = b;
}
public void funA1(){
a.funA1();
b.funB1();
}
public void funB2(){
b.funB2();
a.funA2();
}
}
public class Adapter2{
public static void main(String args[]){
AB ab = new AB();
ab.setA(new A());
ab.setB(new B());
//ab.funA1();
ab.funB2();
}
}
优化双向适配器模式
interface IA{
public abstract void funA1();
public abstract void funA2();
}
class A impelement IA{
public void funA1(){
System.out.println("A.funA1");
}
public void funA2(){
System.out.println("A.funA2");
}
}
interface IB{
public abstract void funB1();
public abstract void funB2();
}
class B impelement IB{
public void funB1(){
System.out.println("B.funB1");
}
public void funB2(){
System.out.println("B.funB1");
}
}
class AB implements IA,IB{//组合A和B
private IA ia;
private IB ib;
public void setIA(IA ia){
this.ia = ia;
}
public void setIB(IB ib){
this.ib = ib;
}
public void funA1(){
ia.funA1();//这句话如果替换就是功能替换
ib.funB1();
}
public void funB2(){
ib.funB2();//这句话如果替换就是功能替换
ia.funA2();
}
//面向接口编程后会丢方法,还需要重新其他功能
public void funA2(){
ia.funA2();
}
public void funB1(){
ib.funB1();
}
}
public class Adapter2{
public static void main(String args[]){
AB ab = new AB();
ab.setIA(new A());
ab.setIB(new B());
//ab.funA1();
ab.funB2();
}
}
=======================================================
装饰模式
要点:主模块接口注入扩展模块
interface IRead{
public abstract void read();
}
class ReadStrFromFile implements IRead{//主模块,可能会变动
public void read(){
System.out.println("读取字符串");
}
}
class ReadStrFromNet implements IRead{//主模块,可能会变动
public void read(){
System.out.println("读取字符串");
}
}
//可以用Spring装配,可以为任何实现了IRead接口的类服务
class Convert{//附模块,可以为主模块服务,或者其他主模块服务
private IRead iread;
public Convert(IRead iread){
this.iread = iread;
}
public void convertToUpper(){
iread.read();
System.out.println("转大写");
}
}
public class Decorator2{
public static void main(String args[]){
Convert convert = new Convert(new ReadStrFromFile());
convert.convertToUpper();
}
}
相关文章推荐
- 设计模式之适配器模式 adapter 适配器模式分类概念角色详解 类适配器 对象适配器 接口适配器 双向适配器
- 菜鸟版JAVA设计模式—适配器模式,装饰模式,代理模式异同
- 设计模式之七:适配器模式—不兼容结构的协调
- 【设计模式】【狼和羊的爱情故事——双向适配器】
- 设计模式之类对象结构型 — ADAPTER (适配器)模式
- JAVA设计模式(06):结构型-适配器模式(Adapter)
- 23种设计模式 第二部分 结构模式(1) 适配器模式
- 结构型设计模式(一)(适配器模式,桥接模式,组合模式,装饰模式)
- java设计模式4.适配器模式、装饰器模式
- 装饰设计模式(适配器、动态代理等)编写步骤
- 设计模式(09) 适配器模式(简单入门 结构模式)
- 设计模式学习笔记之-适配器和装饰器的区别
- 编程常用设计模式详解--(中篇)(适配器、装饰、代理、外观、桥接、组合、享元)
- JAVA设计模式(11):结构型-装饰模式(Decorator)
- 23种设计模式3--结构型模式(适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式)
- C++设计模式——适配器模式(对象适配器、类适配器)
- 适配器模式-Adapter Pattern 不兼容结构的协调——适配器模式(三):类适配器,双向适配器
- java设计模式(工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式、适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式,。 行为型模式,共十一种:策略模式、模板方法)
- 【设计模式】 模式PK:装饰模式VS适配器模式
- 设计模式之结构型-装饰模式(7)