结构型模式

运动员代言 - 代理模式
/**
* @Classname IRunner
* @Created by 寂然
* @Description 抽象运动员
*/
public interface IRunner {
//主要工作就是跑步
public void run();
}
/**
* @Classname Runner
* @Created by 寂然
* @Description 具体短跑运动员
*/
public class Runner implements IRunner{
@Override
public void run() {
System.out.println("运动员训练赛进行中：动作很潇洒");}
}
/**
* @Classname RunnerAgent
* @Created by 寂然
* @Description =运动员代理人
*/
public class RunnerAgent implements IRunner{
private IRunner runner;
public RunnerAgent(IRunner runner) {
this.runner = runner;
}
//代理人是不会跑的，里面其实是调用对应的运动员
@Override
public void run() {
Random random = new Random();
//随机模拟结果
if (random.nextBoolean()){
System.out.println("正在与代理人沟通：沟通结果很顺利");
runner.run();
System.out.println("运动员训练赛观看完毕，沟通后续合作事宜");
} else {
System.out.println("没能和代理人谈妥，暂时无法安排训练赛");
}
}
}
/**
* @Classname Client
* @Created by 寂然
* @Description 场景类
*/
public class Client {
public static void main(String[] args) {
//定义一个短跑运动员
IRunner runner = new Runner();
RunnerAgent runnerAgent = new RunnerAgent(runner);
//要求运动员跑步
System.out.println("金主找到运动员的官方代理人，想看运动员的训练赛");
runnerAgent.run();
}
}
运动员代言 - 装饰者模式
/**
* @Classname IRunner
* @Created by 寂然
* @Description 抽象运动员
*/
public interface IRunner {
//主要工作就是跑步
public void run();
}
/**
* @Classname Runner
* @Created by 寂然
* @Description 具体短跑运动员
*/
public class Runner implements IRunner {
@Override
public void run() {
System.out.println("运动员训练赛进行中：动作很潇洒");
}
}
/**
* @Classname RunnerDecorator
* @Created by 寂然
* @Description 装饰类
*/
public class RunnerDecorator implements IRunner{
private IRunner runner;
public RunnerDecorator(IRunner runner) {
this.runner = runner;
}
@Override
public void run() {
System.out.println("为了加快运动员的速度，给运动员脚上增加喷气动力装置");
runner.run();
}
}
/**
* @Classname Client不同点：
代理模式负责限定是否可以调用目标角色以及是否对于目标角色前后进行必要业务逻辑处理，不对目标
类的功能做
任何处理，而装饰者模式着重是在接口不变的情况下增强/减弱目标类的功能，提供了比继承更有弹性
的扩展方案
装饰者模式vs适配器模式
丑小鸭 - 装饰者模式
* @Created by 寂然
* @Description I walk very slowly, but I never walk backwards
*/
public class Client {
public static void main(String[] args) {
//定义一个运动员
IRunner runner = new Runner();
//对运动员的速度进行增强
runner = new RunnerDecorator(runner);
System.out.println("看看增强后运动员的表现");
runner.run();
}
}
/**
* @Classname Swan
* @Created by 寂然
* @Description 天鹅通用接口
*
*/
public interface Swan {
//天鹅会飞
public void fly();
//天鹅会叫
public void cry();
//天鹅拥有美丽的外表
public void desAppearance();
}/**
* @Classname UglyDucking
* @Created by 寂然
* @Description 丑小鸭
*/
public class UglyDucking implements Swan{
@Override
public void fly() {
//丑小鸭还比较小
System.out.println("现在还在发育阶段，翅膀不硬，不能飞行");
}
@Override
public void cry() {
System.out.println("叫声是发出微弱的声音");
}
@Override
public void desAppearance() {
System.out.println("外表是脏兮兮的白色，毛茸茸的脑袋");
}
}
/**
* @Classname Decorator
* @Created by 寂然
* @Description 抽象的装饰者
*/
public class Decorator implements Swan{
private Swan swan;
//修饰的是谁？
public Decorator(Swan swan) {
this.swan = swan;
}
@Override
public void fly() {
swan.fly();
}
@Override
public void cry() {
swan.cry();
}
@Override
public void desAppearance() {swan.desAppearance();
}
}
/**
* @Classname BeautifyAppearance
* @Created by 寂然
* @Description 外形美化的具体装饰者
*/
public class BeautifyAppearance extends Decorator{
public BeautifyAppearance(Swan swan) {
super(swan);
}
@Override
public void desAppearance() {
System.out.println("外表变成纯白色的了！非常惹鸭喜爱");
}
}
/**
* @Classname StrongBehavior
* @Created by 寂然
* @Description 强化飞行能力的行为
*/
public class StrongBehavior extends Decorator{
public StrongBehavior(Swan swan) {
super(swan);
}
@Override
public void fly() {
System.out.println("慢慢发现自己可以飞行，开始低空盘旋了");
}
}
/**
* @Classname Client
* @Created by 寂然
* @Description 场景类
*/
public class Client {
public static void main(String[] args) {
System.out.println("很久很久以前，这里有一只丑陋自卑的鸭子");
Swan uglyDucking = new UglyDucking();
//展示一下小鸭子
uglyDucking.desAppearance();丑小鸭 - 适配器模式
uglyDucking.cry();
uglyDucking.fly();
System.out.println("终于发现丑小鸭原来是一只天鹅");
uglyDucking = new BeautifyAppearance(uglyDucking);
uglyDucking = new StrongBehavior(uglyDucking);
//装饰附加功能之后，再次展示小鸭子
uglyDucking.desAppearance();
uglyDucking.cry();
uglyDucking.fly();
}
}
丑小鸭 - 适配器模式
/**
* @Classname Duck
* @Created by 寂然
* @Description 鸭类接口
*/
public interface Duck {
//会叫
public void cry();
//描述鸭子的外形
public void desAppearance();
//描述鸭子的其他行为
public void desBehavior();
}
/**
* @Classname Swan
* @Created by 寂然
* @Description 天鹅接口
*/
public interface Swan {
//天鹅会飞
public void fly();
//天鹅会叫
public void cry();
//天鹅拥有美丽的外表
public void desAppearance();}
/**
* @Classname Ducking
* @Created by 寂然
* @Description 正宗的小鸭子
*/
public class Ducking implements Duck{
@Override
public void cry() {
System.out.println("鸭子的叫声是 ga ga ga");
}
@Override
public void desAppearance() {
System.out.println("鸭子的外形是黄白相间，嘴巴是扁扁的");
}
@Override
public void desBehavior() {
System.out.println("鸭子会游泳，chua chua chua");
}
}
/**
* @Classname WhiteSwan
* @Created by 寂然
* @Description 白天鹅
*/
public class WhiteSwan implements Swan{
@Override
public void fly() {
System.out.println("可以飞翔，咻咻咻----");
}
@Override
public void cry() {
System.out.println("叫声是很独特的");
}
@Override
public void desAppearance() {
System.out.println("外形是纯白色的，特别惹人喜爱");
}
}
/**
* @Classname UglyDucking* @Created by 寂然
* @Description 鸭妈妈把小天鹅当丑小鸭看待
*/
public class UglyDucking extends WhiteSwan implements Duck{
@Override
public void desBehavior() {
//丑小鸭不仅会游泳
System.out.println("会chua chua chua 游泳");
super.fly();
}
@Override
public void cry() {
super.cry();
}
@Override
public void desAppearance() {
super.desAppearance();
}
}
/**
* @Classname Client
* @Created by 寂然
* @Description 场景类
*/
public class Client {
public static void main(String[] args) {
System.out.println("鸭妈妈有很多孩子，其中其他的都长的差不多");
Ducking ducking = new Ducking();
ducking.cry();
ducking.desBehavior();
ducking.desAppearance();
System.out.println("有一只独特的小鸭子，刚开始很丑，其实长大后是这样的");
Duck uglyDucking = new UglyDucking();
uglyDucking.cry();
uglyDucking.desBehavior();
uglyDucking.desAppearance();
}
}
装饰者模式&适配器模式的不同点
意图不同
装饰者的意图是加强目标对象的功能
适配器的意图是两个不同接口的对象之间的转化
目标对象不同
装饰者模式装饰的对象必须是自己的同宗（相同的接口或者父类）
适配器模式适配的是两个不同接口的对象
场景不同
装饰者模式在任何时候都可以使用，只要是想增强类的功能
适配器模式更像是一种补救模式，作为一个紧急处理的手段来采用
扩展性不同
装饰者模式很容易扩展
适配器模式扩展性不如装饰者