Java设计模式-----结构型模式
一、代理模式：
??用一个代理来隐藏具体实现类的实现细节，通常还用于在真实的实现的前后添加一部分逻辑。既然说是代理，那就要对客户端隐藏真实实现，由代理来负责客户端的所有请求。当然，代理只是个代理，它不会完成实际的业务逻辑，而是一层皮而已，但是对于客户端来说，它必须表现得就是客户端需要的真实实现。
public interface FoodService {
Food makeChicken();
Food makeNoodle();
}public class FoodServiceImpl implements FoodService {
public Food makeChicken() {
Food f = new Chicken()
f.setChicken("1kg");
f.setSpicy("1g");
f.setSalt("3g");
return f;
}
public Food makeNoodle() {
Food f = new Noodle();
f.setNoodle("500g");
f.setSalt("5g");
return f;
}
}// 代理要表现得“就像是”真实实现类，所以需要实现 FoodService
public class FoodServiceProxy implements FoodService {// 内部一定要有一个真实的实现类，当然也可以通过构造方法注入
private FoodService foodService = new FoodServiceImpl();
public Food makeChicken() {
System.out.println("我们马上要开始制作鸡肉了");
// 如果我们定义这句为核心代码的话，那么，核心代码是真实实现类做的，
// 代理只是在核心代码前后做些“无足轻重”的事情
Food food = foodService.makeChicken();
System.out.println("鸡肉制作完成啦，加点胡椒粉");
// 增强
food.addCondiment("pepper");
return food;
}
public Food makeNoodle() {
System.out.println("准备制作拉面~");
Food food = foodService.makeNoodle();
System.out.println("制作完成啦")
return food;
}
}
客户端调用：
// 这里用代理类来实例化
FoodService foodService = new FoodServiceProxy();
foodService.makeChicken();
文章图片
代理模式说白了就是做 “方法包装” 或做 “方法增强”。
二、适配器模式： ?①、默认适配器模式：
??用 Appache commons-io 包中的 FileAlterationListener 做例子，此接口定义了很多的方法，用于对文件或文件夹进行监控，一旦发生了对应的操作，就会触发相应的方法。
public interface FileAlterationListener {
void onStart(final FileAlterationObserver observer);
void onDirectoryCreate(final File directory);
void onDirectoryChange(final File directory);
void onDirectoryDelete(final File directory);
void onFileCreate(final File file);
void onFileChange(final File file);
void onFileDelete(final File file);
void onStop(final FileAlterationObserver observer);
}
??复制代码此接口的一大问题是抽象方法太多了，如果要用这个接口，意味着要实现每一个抽象方法，如果只是想要监控文件夹中的文件创建和文件删除事件，可是还是不得不实现所有的方法，很明显，这不是想要的。所以，需要下面的一个适配器，它用于实现上面的接口，但是所有的方法都是空方法，这样，就可以转而定义自己的类来继承下面这个类即可。
public class FileAlterationListenerAdaptor implements FileAlterationListener {
public void onStart(final FileAlterationObserver observer) { }
public void onDirectoryCreate(final File directory) { }
public void onDirectoryChange(final File directory) { }
public void onDirectoryDelete(final File directory) { }
public void onFileCreate(final File file) { }
public void onFileChange(final File file) { }
public void onFileDelete(final File file) { }
public void onStop(final FileAlterationObserver observer) { }
}
??复制代码比如可以定义以下类，仅仅需要实现想实现的方法就可以了：
public class FileMonitor extends FileAlterationListenerAdaptor {
public void onFileCreate(final File file) {
// 文件创建
doSomething();
}public void onFileDelete(final File file) {
// 文件删除
doSomething();
}
}
?②、对象适配器模式：
??对于下面这个例子，怎么将鸡适配成鸭，这样鸡也能当鸭来用。因为，现在鸭这个接口，我们没有合适的实现类可以用，所以需要适配器。
public interface Duck {
public void quack();
// 鸭的呱呱叫
public void fly();
// 飞
}public interface Cock {
public void gobble();
// 鸡的咕咕叫
public void fly();
// 飞
}public class WildCock implements Cock {
public void gobble() {
System.out.println("咕咕叫");
}
public void fly() {
System.out.println("鸡也会飞哦");
}
}
??鸭接口有 fly() 和 quare() 两个方法，鸡 Cock 如果要冒充鸭，fly() 方法是现成的，但是鸡不会鸭的呱呱叫，没有 quack() 方法。这个时候就需要适配了：
// 毫无疑问，首先，这个适配器肯定需要 implements Duck，这样才能当做鸭来用
public class CockAdapter implements Duck {Cock cock;
// 构造方法中需要一个鸡的实例，此类就是将这只鸡适配成鸭来用
public CockAdapter(Cock cock) {
this.cock = cock;
}// 实现鸭的呱呱叫方法
@Override
public void quack() {
// 内部其实是一只鸡的咕咕叫
cock.gobble();
}@Override
public void fly() {
cock.fly();
}
}
??客户端的调用：
public static void main(String[] args) {
// 有一只野鸡
Cock wildCock = new WildCock();
// 成功将野鸡适配成鸭
Duck duck = new CockAdapter(wildCock);
...
}
文章图片
?③、类适配器模式：
文章图片
??通过继承的方法，适配器自动获得了所需要的大部分方法。这个时候，客户端使用更加简单，直接 Target t = new SomeAdapter(); 就可以了。
?④、结构型模式总结：
?1、类适配和对象适配的异同： 类适配采用继承，对象适配采用组合；
类适配属于静态实现，对象适配属于组合的动态实现，对象适配需要多实例化一个对象。
总体来说，对象适配用得比较多。
?2、适配器模式和代理模式的异同： ??在代码结构上，它们很相似，都需要一个具体的实现类的实例。但是它们的目的不一样，代理模式做的是增强原方法的活；适配器做的是适配的活，为的是提供“把鸡包装成鸭，然后当做鸭来使用”，而鸡和鸭它们之间原本没有继承关系。
文章图片
三、桥梁模式：
文章图片
四、装饰模式：
文章图片
??从图中可以看到，接口 Component 其实已经有了 ConcreteComponentA 和 ConcreteComponentB 两个实现类了，但是，如果我们要增强这两个实现类的话，我们就可以采用装饰模式，用具体的装饰器来装饰实现类，以达到增强的目的。
??所有的具体装饰者们 ConcreteDecorator 都可以作为 Component 来使用，因为它们都实现了 Component 中的所有接口。它们和 Component 实现类 ConcreteComponent 的区别是，它们只是装饰者，起装饰作用。
举个例子：
快乐柠檬的饮料分为三类：红茶、绿茶、咖啡，在这三大类的基础上，又增加了许多的口味，什么金桔柠檬红茶、金桔柠檬珍珠绿茶、芒果红茶、芒果绿茶、芒果珍珠红茶、烤珍珠红茶、烤珍珠芒果绿茶、椰香胚芽咖啡、焦糖可可咖啡等等，在这个例子中，红茶、绿茶、咖啡是最基础的饮料，其他的像金桔柠檬、芒果、珍珠、椰果、焦糖等都属于装饰用的。
定义饮料抽象基类：
public abstract class Beverage {
// 返回描述
public abstract String getDescription();
// 返回价格
public abstract double cost();
}
三个基础饮料实现类，红茶、绿茶和咖啡：
public class BlackTea extends Beverage {
public String getDescription() {
return "红茶";
}
public double cost() {
return 10;
}
}public class GreenTea extends Beverage {
public String getDescription() {
return "绿茶";
}
public double cost() {
return 11;
}
}public class Coffee extends Beverage {
public String getDescription() {
return "咖啡";
}
public double cost() {
return 12;
}
}
定义调料，也就是装饰者的基类，此类必须继承自 Beverage：
// 调料
public abstract class Condiment extends Beverage {}定义柠檬、芒果等具体的调料，它们属于装饰者，都需要继承Condiment类：
public class Lemon extends Condiment {
private Beverage bevarage;
// 这里很关键，需要传入具体的饮料，如需要传入没有被装饰的红茶或绿茶，
// 当然也可以传入已经装饰好的芒果绿茶，这样可以做芒果柠檬绿茶
public Lemon(Beverage bevarage) {
this.bevarage = bevarage;
}
public String getDescription() {
// 装饰
return bevarage.getDescription() + ", 加柠檬";
}
public double cost() {
// 装饰
return beverage.cost() + 2;
// 加柠檬需要 2 元
}
}public class Mango extends Condiment {
private Beverage bevarage;
public Mango(Beverage bevarage) {
this.bevarage = bevarage;
}
public String getDescription() {
return bevarage.getDescription() + ", 加芒果";
}
public double cost() {
return beverage.cost() + 3;
// 加芒果需要 3 元
}
}public class Pearl extends Condiment {
private Beverage bevarage;
public Pearl(Beverage bevarage) {
this.bevarage = bevarage;
}
public String getDescription() {
return bevarage.getDescription() + ", 加珍珠";
}
public double cost() {
return beverage.cost() + 4;
// 加珍珠需要 4元
}
}
客户端调用
public static void main(String[] args) {
// 首先，我们需要一个基础饮料，红茶、绿茶或咖啡
Beverage beverage = new GreenTea();
// 开始装饰
beverage = new Lemon(beverage);
// 先加一份柠檬
beverage = new Mongo(beverage);
// 再加一份芒果System.out.println(beverage.getDescription() + " 价格：￥"
+ beverage.cost());
//"绿茶, 加柠檬, 加芒果 价格：￥16"
}
//如果需要芒果珍珠双份柠檬红茶：
Beverage beverage = new Mongo(
new Pearl(
new Lemon(
new Lemon(
new BlackTea()))));
文章图片
五、门面模式： ??通常情况下，画圆和画长方形方法：
定义接口：
public interface Shape {
void draw();
}
定义实现类：
public class Circle implements Shape {@Override
public void draw() {
System.out.println("Circle::draw()");
}
}public class Rectangle implements Shape {@Override
public void draw() {
System.out.println("Rectangle::draw()");
}
}
客户端调用：
public static void main(String[] args) {
// 画一个圆形
Shape circle = new Circle();
circle.draw();
// 画一个长方形
Shape rectangle = new Rectangle();
rectangle.draw();
}
采用门面模式时：
先定义一个门面：
public class ShapeMaker {
private Shape circle;
private Shape rectangle;
private Shape square;
public ShapeMaker() {
circle = new Circle();
rectangle = new Rectangle();
square = new Square();
}/**
* 下面定义一堆方法，具体应该调用什么方法，由这个门面来决定
*/public void drawCircle(){
circle.draw();
}
public void drawRectangle(){
rectangle.draw();
}
public void drawSquare(){
square.draw();
}
}
客户端调用：
public static void main(String[] args) {
ShapeMaker shapeMaker = new ShapeMaker();
// 客户端调用现在更加清晰了
shapeMaker.drawCircle();
shapeMaker.drawRectangle();
shapeMaker.drawSquare();
}
六、组合模式： ??每个员工都有姓名、部门、薪水这些属性，同时还有下属员工集合（虽然可能集合为空），而下属员工和自己的结构是一样的，也有姓名、部门这些属性，同时也有他们的下属员工集合。设计该集合：
public class Employee {
private String name;
private String dept;
private int salary;
private List subordinates;
// 下属public Employee(String name,String dept, int sal) {
this.name = name;
this.dept = dept;
this.salary = sal;
subordinates = new ArrayList();
}public void add(Employee e) {
subordinates.add(e);
}public void remove(Employee e) {
subordinates.remove(e);
}public List getSubordinates(){
return subordinates;
}public String toString(){
return ("Employee :[ Name : " + name + ", dept : " + dept +
", salary :" + salary+" ]");
}
}
??这种类需要定义 add(node)、remove(node)、getChildren() 这些方法。其实这就是组合模式。
七、享元模式： 【Java设计模式-----结构型模式】??享元分开来说就是 共享 元器件，也就是复用已经生成的对象，这种做法当然也就是轻量级的了。复用对象最简单的方式是，用一个 HashMap 来存放每次新生成的对象。每次需要一个对象的时候，先到 HashMap 中看看有没有，如果没有，再生成新的对象，然后将这个对象放入 HashMap 中。
八、结构型模式总结：； 1、代理模式是做方法增强的； 2、适配器模式是把鸡包装成鸭这种用来适配接口的； 3、桥梁模式做到了很好的解耦； 4、装饰模式从名字上就看得出来，适合于装饰类或者说是增强类的场景； 5、门面模式的优点是客户端不需要关心实例化过程，只要调用需要的方法即可； 6、组合模式用于描述具有层次结构的数据； 7、享元模式是为了在特定的场景中缓存已经创建的对象，用于提高性能。
推荐阅读
- JAVA（抽象类与接口的区别&重载与重写&内存泄漏）
- 事件代理
- Java|Java OpenCV图像处理之SIFT角点检测详解
- java中如何实现重建二叉树
- 数组常用方法一
- 【Hadoop踩雷】Mac下安装Hadoop3以及Java版本问题
- Java|Java基础——数组
- RxJava|RxJava 在Android项目中的使用（一）
- java之static、static|java之static、static final、final的区别与应用
- Java基础-高级特性-枚举实现状态机