设计模式中的创建型，主要解决对象的创建问题。那么接下来这篇文章主要讲下设计模式中的结构型，主要关系类与类之间的组合和组装。
主要有以下几个模式：代理模式，桥接模式，组合模式，享元模式，装饰器，适配器模式，门面模式。
代理模式
代理模式，分为静态代理、动态代理。我们一般用于添加一些非功能性的需求时，用代理模式。主要应用场景：aop/rpc调用等
public class TestProxy{
public static void main(String[] args){
Animal animal = (Animal) new AnimalProxy().createProxy(new Cat());
animal.name();
}
}
class AnimalProxy{
public Object createProxy(Object objectproxies){
return Proxy.newProxyInstance(objectproxies.getClass().getClassLoader(),objectproxies.getClass().getInterfaces(),new AnimalInvocation(objectproxies));
}
private class AnimalInvocation implements InvocationHandler{
Object object;
public AnimalInvocation(Object object){
this.object = object;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("method start");
Object result = method.invoke(object,args);
System.out.println("method enc");
return result;
}
}
}
桥接模式
当一个类处理两块相关的逻辑类时，通过组合的形式进行解耦。比如一个车，有奔驰，宝马，比亚迪，同时也有燃油，电动，混动。那么如果实现每一种车的话会有M*N个类，为了缓解这种依赖爆炸，则通过定义一个车，一个方式，然后通过桥接模式进行关联。
public class Brige {
public static void main(String[] args){
Car car = new BwmCar(new OilType());
car.name();
}
}
interface Car{
void name();
}
interface CarType{
String getType();
}
class OilType implements CarType{
public String getType() {
return "OilType";
}
}
class ElectType implements CarType{
public String getType() {
return "ElectType";
}
}
class MixedType implements CarType{
public String getType() {
return "MixedType";
}
}
class BwmCar implements Car{
String type;
public BwmCar(CarType carType){
this.type = carType.getType();
}
public void name() {
System.out.println("this is BwmCar,it's Type is "+type);
}
}
class BydCar implements Car{
String type;
public BydCar(CarType carType){
this.type = carType.getType();
}
public void name() {
System.out.println("this is BydCar,it's Type is "+type);
}
}
装饰器模式
装饰器模式，主要应用场景则是在继承同一个类，通过组合的方式增强方法。那为什么不是写在同一个接口里面呢。因为不是所有的方法都需要增强，这样更降低耦合
public class TestWapper {
public static void main(String[] args){
TelNotifitionWapper telNotifitionWapper = new TelNotifitionWapper();
telNotifitionWapper.notifyMsg();
}
}
interface Notifition{
void notifyMsg();
void getMsg();
}
class TelNotifition implements Notifition{
public void notifyMsg() {
System.out.println("call somebody telphone");
}
public void getMsg() {
System.out.println("wow");
}
}
class TelNotifitionWapper extends TelNotifition implements Notifition{
@Override
public void notifyMsg()
super.notifyMsg();
System.out.println("say helo");
}
}
适配器场景
适配器场景主要应用于不兼容的接口改为兼容的接口，主要适用的场景是，兼容老接口，统一多个接口等需要包一层来达到统一，作为一个补救措施。
public class TestAdapter {
public static void main(String[] args){
AIHome aiHome = new AIHome();
aiHome.goHome(new SpeakerSwitch());
aiHome.goHome(new SwitchButtonAdapter(new ListenSwich()));
}
}
class AIHome{
public void goHome(SwitchButton switchButton){
switchButton.open();
}
}
interface SwitchButton{
void open();
}
class SpeakerSwitch implements SwitchButton{
public void open() {
System.out.println("start speak..");
}
}
class ListenSwich {
public void push(){
System.out.println("start listen to music");
}
}
class SwitchButtonAdapter implements SwitchButton{
private ListenSwich listenSwich;
public SwitchButtonAdapter(ListenSwich listenSwich){
this.listenSwich = listenSwich;
}
public void open() {
listenSwich.push();
}
}
门面模式
当一个系统对外暴露多个接口，不易管理和维护，这个时候可以讲多个接口 包裹成一个接口方便使用。使用使用场景：提高接口的易用性，提高性能，解决分布式事务问题。
门面模式和适配器模式都是封装，那么我们可以看下区别。适配器模式主要适用于接口转换，门面模式适用于接口整合。
组合模式
主要适用于树形接口的存储。
class TreeNode{
private String name;
private String depth;
private List<TreeNode> treeNodeList = new ArrayList<TreeNode>();
}
享元模式
主要用于复用对象，对象为不可变的对象。和池化技术来比较的话，一个是为了对象复用，一个是重复使用节省效率
public class TestAdapter {
public static void main(String[] args){
Editor editor = new Editor();
editor.add("pwd");
editor.add("sh");
}
}
class Editor{
public static final List<String> history = new ArrayList<String>() ;
public void add(String words){
history.add(words);
}
public void delete(String words){
history.remove(history.size()-1);
}
}
以上就是设计模式中的结构型，主要侧重的类和类的组合和组装。