[设计模式]结构型设计模式

简介

结构型设计模式：关注类或者类与对象之间的组合关系，以构建更加复杂的系统

代码

1. 适配器模式
   * 类适配器

    package me.maxiaolong.designpattern;
   
    /**
     * @author maxiaolong
     * created at 2020/7/4
     * 结构型设计模式：关注类或类与对象之间的组合以构成更加复杂的系统
     * 1. 类结构型设计模式：关注类之间的组合，类之间的组合一般只存在继承关系和实现关系
     * 2. 对象结构型设计模式：关注类与对象之间的组合，类与对象之间的关联可以使用组合和聚合，满足合成复用原则（大部分结构型设计模式为对象结构型设计模式）
     *
     * 适配器设计模式(Adapter/Wrapper)主要是将一个类的接口转换为用户希望的另一接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作
     */
    
    public class ClassAdapterClient {
        public static void main(String[] args) {
            Target target = new Adapter();
            target.request();
        }
    }
    
    class Adaptee{
        public void specialRequest(){
            System.out.println("special request");
        }
    }
    
    interface Target{
        /**
         * 客户端目标类所期望的请求方法
         */
        void request();
    }
    
    class Adapter extends Adaptee implements Target{
    
        @Override
        public void request() {
            specialRequest();
        }
    }
   

* 对象适配器
```java
package me.maxiaolong.designpattern;

/**
* @author maxiaolong
* created at 2020/7/4
*/
public class ObjectAdapterClient {
public static void main(String[] args) {
Target1 target1 = new Adapter1();
target1.request();
}
}

abstract class Target1{
public abstract void request();
}

class Adaptee1{
public void specialRequest(){
System.out.println("special request");
}
}

class Adapter1 extends Target1{
private Adaptee1 adaptee1 = new Adaptee1();

@Override
public void request() {
adaptee1.specialRequest();
}
}
2. 装饰模式 java
package me.maxiaolong.designpattern;

/**
* @author maxiaolong
* created at 2020/7/4
* 装饰模式是一种替换继承的技术，他通过一种无序定义子类的方式给对象动态增加职责，使用对象之间的关联关系取代类之间的继承关系（聚合）
*/
public class DecoratorClient {
public static void main(String[] args) {
//创建对象
Component concreteComponent = new ConcreteComponent();
Decorator concreteDecorator = new ConcreteDecorator2(concreteComponent);
//same method, add additional method
concreteDecorator.operation();
}
}

abstract class Component{
public abstract void operation();
}

class ConcreteComponent extends Component{

@Override
public void operation() {
System.out.println("concrete component operation");
}
}

class Decorator extends Component{

private Component component;

public Decorator(Component component){
this.component = component;
}

public Component getComponent() {
return component;
}

public void setComponent(Component component) {
this.component = component;
}

@Override
public void operation() {
component.operation();
}
}

class ConcreteDecorator1 extends Decorator{
private int addedState;

public ConcreteDecorator1(Component component) {
super(component);
}
}

class ConcreteDecorator2 extends Decorator{

public ConcreteDecorator2(Component component) {
super(component);
}

@Override
public void operation() {
getComponent().operation();
addedBehavior();
}

public void addedBehavior(){
System.out.println("add behavior");
}
}
3. 代理模式 java
package me.maxiaolong.designpattern;

/**
* @author maxiaolong
* created at 2020/7/4
* 代理模式：当直接访问某些对象存在问题是可以通过一个代理对象间接访问，为了保证客户端使用的透明性，所访问的真实对象与代理对象都要实现相同的接口（组合）
* 使用组合的方式(且使用的是真实对象作为类的声明，设置为私有)，代理类与真实类需要实现同样的接口，客户端应该完全无法接触真实客体
*/
public class ProxyClient {
public static void main(String[] args) {
Proxy proxy = new Proxy();
proxy.request();
}
}

abstract class Subject{
public abstract void request();
}

class RealSubject extends Subject{

@Override
public void request() {
System.out.println("real subject");
}
}

class Proxy extends Subject{

/**
* 一定要使用真实对象
*/
private RealSubject realSubject = new RealSubject();

@Override
public void request() {
beforeRequest();
realSubject.request();
afterRequest();
}

public void beforeRequest(){
System.out.println("before proxy");
}

public void afterRequest(){
System.out.println("after proxy");
}
}
```