设计模式之结构型模式

一，适配器模式

对象适配器，类适配器模式。

举个例子：
有一台电脑要安装键盘，但是电脑的键盘USB插口与键盘的外接接口不一致，那么就需要一种叫做适配器的东西，将电脑和键盘连接起来，此时适配器就必须具备有键盘一致的接口和与电脑插口一致的接口。

/**
 * 被适配的类
 * (相当于例子中的，PS/2键盘)
 *
 */
public class Adaptee {  
    public void request(){
        System.out.println("可以完成客户请求的需要的功能！");
    }
}
//适配器的两种写法
/**1.（采用继承方式）
 * 适配器 (类适配器方式)
 * (相当于usb和ps/2的转接器)
 */
public class Adapter extends Adaptee implements Target {    
    @Override
    public void handleReq() {
        super.request();
    }   
}

/**
 * 2.适配器 (对象适配器方式,使用了组合的方式跟被适配对象整合)
 * (相当于usb和ps/2的转接器)
 * @author Administrator
 *
 */
public class Adapter2  implements Target {  
    private Adaptee adaptee;    
    @Override
    public void handleReq() {
        adaptee.request();
    }

    public Adapter2(Adaptee adaptee) {
        super();
        this.adaptee = adaptee;
    }   
}
//适配器类接口
public interface Target {
    void handleReq();
}

/**
 * 客户端类
 * (相当于例子中的电脑，只有USB接口)
 * @author Administrator
 *
 */
public class Client {   
    public void test1(Target t){
        t.handleReq();
    }   
    public static void main(String[] args) {
        Client  c = new Client();

        Adaptee a = new Adaptee();

//      Target t = new Adapter();

        Target t = new Adapter2(a);

        c.test1(t);     
    }   
}

二，代理模式

1.静态代理

举个例子：歌手要参加演出，那么就需要签合同谈价钱一系列工作，但是这一系列的工作要是老是由歌手来处理，歌手肯定不干，所以就出现了经纪人这一职，经纪人就是代理，要处理关于演出的一系列工作，而歌手之需要做着一系列工作中的演唱即可。

public interface Star {
    /**
     * 面谈
     */
    void confer();
    /**
     * 签合同
     */
    void signContract();
    /**
     * 订票
     */
    void bookTicket();
    /**
     * 唱歌
     */
    void sing();
    /**
     * 收钱
     */
    void collectMoney();
}

//歌手类
public class RealStar implements Star {

    @Override
    public void bookTicket() {
        System.out.println("RealStar.bookTicket()");
    }

    @Override
    public void collectMoney() {
        System.out.println("RealStar.collectMoney()");
    }

    @Override
    public void confer() {
        System.out.println("RealStar.confer()");
    }

    @Override
    public void signContract() {
        System.out.println("RealStar.signContract()");
    }

    @Override
    public void sing() {
        System.out.println("RealStar(周杰伦本人).sing()");
    }
}

//代理类
public class ProxyStar implements Star {

    private Star star;

    @Override
    public void bookTicket() {
        System.out.println("ProxyStar.bookTicket()");
    }

    @Override
    public void collectMoney() {
        System.out.println("ProxyStar.collectMoney()");
    }

    @Override
    public void confer() {
        System.out.println("ProxyStar.confer()");
    }

    @Override
    public void signContract() {
        System.out.println("ProxyStar.signContract()");
    }

    @Override
    public void sing() {
        star.sing();
    }
}

2.动态代理

//真实角色和代理角色都要实现抽象角色Star
//实现JDK提供的接口  

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class StarHandler implements InvocationHandler {
    //处理器接口
    Star realStar;

    public StarHandler(Star realStar) {
        super();
        this.realStar = realStar;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)//接口需要实现这个函数
            throws Throwable {
        Object object = null;

        System.out.println("真正的方法执行前！");
        System.out.println("面谈，签合同，预付款，订机票");

        if(method.getName().equals("sing")){//到唱歌环节的时候就需要调用真实角色的函数
            object = method.invoke(realStar, args);
        }

        System.out.println("真正的方法执行后！");
        System.out.println("收尾款");
        return object;
    }

}


/**
 * 模拟动态生成的代理的结构
 */
public class ProxyStar implements Star {

    StarHandler handler;

    public ProxyStar(StarHandler handler) {
        super();
        this.handler = handler;
    }

    public void bookTicket() {
//      handler.invoke(this,当前方法 , args);
    }

    public void collectMoney() {
//      handler.invoke(this,当前方法 , args);
    }

    public void confer() {
//      handler.invoke(this,当前方法 , args);
    }

    public void signContract() {
//      handler.invoke(this,当前方法 , args);
    }

    public void sing() {
//      handler.invoke(this,当前方法 , args);
    }

}


//测试

import java.lang.reflect.Proxy;

public class Client {
    public static void main(String[] args) {
        //固定套路
        Star realStar = new RealStar();
        StarHandler handler = new StarHandler(realStar);

        Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), 
                new Class[]{Star.class}, handler);

        proxy.sing();

    }

}

三，桥接模式

举例：有一家专门销售电脑的公司，分别销售有台式机，笔记本，平板电脑类型的机器，产品的品牌主要有联想，戴尔，神舟等，如果把每一种类型和品牌组合起来弄成一个一个类的话会显得十分的繁琐，因此可以采用桥接模式解决此问题。

上述例子违反了单一职责的原则
作用：处理多层继承结构，处理多维度变化的场景，将各个维度设计成独立的继承结构，使各个维度可以独立的扩展在抽象层建立关联。    


//未使用桥接模式
/**
 * 品牌
 * @author Administrator
 *
 */
public interface Brand {
    void sale();
}

class Lenovo implements Brand {

    @Override
    public void sale() {
        System.out.println("销售联想电脑");
    }

}
class Dell implements Brand {

    @Override
    public void sale() {
        System.out.println("销售Dell电脑");
    }

}

class Shenzhou implements Brand {

    @Override
    public void sale() {
        System.out.println("销售神舟电脑");
    }

}


//商品类

public interface Computer {
    void sale();
}

class Desktop implements Computer {
    @Override
    public void sale() {
        System.out.println("销售台式机！");
    }
}

class Laptop implements Computer {
    @Override
    public void sale() {
        System.out.println("销售笔记本！");
    }
}
class Pad implements Computer {
    @Override
    public void sale() {
        System.out.println("销售平板电脑！");
    }
}

class LenovoDesktop extends Desktop {
    @Override
    public void sale() {
        System.out.println("销售联想台式机");
    }
}
class LenovoLaptop extends Laptop {
    @Override
    public void sale() {
        System.out.println("销售联想笔记本");
    }
}
class LenovoPad extends Pad {
    @Override
    public void sale() {
        System.out.println("销售联想平板电脑");
    }
}
class ShenzhouDesktop extends Desktop {
    @Override
    public void sale() {
        System.out.println("销售神舟台式机");
    }
}
class ShenzhouLaptop extends Laptop {
    @Override
    public void sale() {
        System.out.println("销售神舟笔记本");
    }
}
class ShenzhouPad extends Pad {
    @Override
    public void sale() {
        System.out.println("销售神舟平板电脑");
    }
}


class DellDesktop extends Desktop {
    @Override
    public void sale() {
        System.out.println("销售戴尔台式机");
    }
}
class DellLaptop extends Laptop {
    @Override
    public void sale() {
        System.out.println("销售戴尔笔记本");
    }
}
class DellPad extends Pad {
    @Override
    public void sale() {
        System.out.println("销售戴尔平板电脑");
    }
}


//使用桥接模式

/**
 * 电脑类型的维度
 * @author Administrator
 *
 */
public class Computer2 {

    protected Brand brand;

    public Computer2(Brand b) {
        this.brand = b;
    }   
    public void sale(){
        brand.sale();
    }   
}
class Desktop2 extends Computer2 {

    public Desktop2(Brand b) {
        super(b);
    }

    @Override
    public void sale() {
        super.sale();
        System.out.println("销售台式机");
    }
}

class Laptop2 extends Computer2 {

    public Laptop2(Brand b) {
        super(b);
    }

    @Override
    public void sale() {
        super.sale();
        System.out.println("销售笔记本");
    }
}


//使用桥接模式后的测试代码如下：



package com.bjsxt.bridge;

public class Client {
    public static void main(String[] args) {
        //销售联想的笔记本电脑
        Computer2  c = new Laptop2(new Lenovo());
        c.sale();       
        //销售神舟的台式机
        Computer2 c2 = new Desktop2(new Shenzhou());
        c2.sale();      
    }
}

四，组合模式

组合模式（composite）:

应用场景：

    -把部分和整体的关系用到树形结构来表示，从而使客户端可以使用统一的方式处理部分对象和整体对象。

组合模式核心：

    1）抽象构件（component）角色：定义了叶子和容器构件的共同点。

    2）叶子（leaf）构件角色：无子节点

    3）容器（composite）构件角色：有容器特征，可以包含子节点。

/**
 * 抽象组件
 * @author Administrator
 *
 */
public interface Component {
    void operation();
}

//叶子组件
interface Leaf extends Component {
}
//容器组件
interface Composite extends Component {
    void add(Component c);
    void remove(Component c);
    Component getChild(int index);
}






二，使用组合模式，模拟杀毒软件的架构设计！

import java.util.ArrayList;
import java.util.List;

//抽象构建
public interface AbstractFile {
    void killVirus();  //杀毒
}


class ImageFile implements AbstractFile {
    private String name;

    public ImageFile(String name) {
        super();
        this.name = name;
    }

    @Override
    public void killVirus() {
        System.out.println("---图像文件："+name+",进行查杀！");
    }

}
class TextFile implements AbstractFile {
    private String name;

    public TextFile(String name) {
        super();
        this.name = name;
    }

    @Override
    public void killVirus() {
        System.out.println("---文本文件："+name+",进行查杀！");
    }
}
class VideoFile implements AbstractFile {
    private String name;

    public VideoFile(String name) {
        super();
        this.name = name;
    }

    @Override
    public void killVirus() {
        System.out.println("---视频文件："+name+",进行查杀！");
    }
}

class Folder implements AbstractFile {
    private String name;
    //定义容器，用来存放本容器构建下的子节点
    private List<AbstractFile> list = new ArrayList<AbstractFile>();

    public Folder(String name) {
        super();
        this.name = name;
    }

    public void add(AbstractFile file){
        list.add(file);
    }
    public void remove(AbstractFile file){
        list.remove(file);
    }
    public AbstractFile getChild(int index){
        return list.get(index);
    }

    @Override
    public void killVirus() {
        System.out.println("---文件夹："+name+",进行查杀");

        for (AbstractFile file : list) {
            file.killVirus();
        }

    }

}



//测试



public class Client {
    public static void main(String[] args) {
        AbstractFile f2,f3,f4,f5;
        Folder f1 = new Folder("我的收藏");

        f2 = new ImageFile("老高的大头像.jpg");
        f3 = new TextFile("Hello.txt");
        f1.add(f2);
        f1.add(f3);

        Folder f11 = new Folder("电影");
        f4 = new VideoFile("笑傲江湖.avi");
        f5 = new VideoFile("神雕侠侣.avi");
        f11.add(f4);
        f11.add(f5);
        f1.add(f11);        
//      f2.killVirus();

        f1.killVirus();     
    }
}

五，装饰模式（decorator）：

职责：
动态的为一个对象增加新的功能。

装饰模式是一个用于代替继承的技术，无须通过继承增加子类就能扩展对象的新功能，使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。

/**
 * 抽象构建
 *
 */
public interface ICar {
    void move();
}
//ConcreteComponent 具体构件角色(真实对象)
class Car implements ICar {
    @Override
    public void move() {
        System.out.println("陆地上跑！");
    }
}
//Decorator装饰角色
class SuperCar implements ICar {
    protected ICar car;
    public SuperCar(ICar car) {
        super();
        this.car = car;
    }
    @Override
    public void move() {
        car.move();
    }
}
//ConcreteDecorator具体装饰角色
class FlyCar extends SuperCar {

    public FlyCar(ICar car) {
        super(car);
    }

    public void fly(){
        System.out.println("天上飞！");
    }

    @Override
    public void move() {
        super.move();
        fly();
    }   
}
//ConcreteDecorator具体装饰角色
class WaterCar extends SuperCar {

    public WaterCar(ICar car) {
        super(car);
    }

    public void swim(){
        System.out.println("水上游！");
    }

    @Override
    public void move() {
        super.move();
        swim();
    }

}
//ConcreteDecorator具体装饰角色
class AICar extends SuperCar {

    public AICar(ICar car) {
        super(car);
    }

    public void autoMove(){
        System.out.println("自动跑！");
    }

    @Override
    public void move() {
        super.move();
        autoMove();
    }   
}



//测试代码如下：

import java.io.FileInputStream;
import java.io.InputStreamReader;

public class Client {
    public static void main(String[] args) {
        Car car  = new Car();
        car.move();

        System.out.println("增加新的功能，飞行----------");
        FlyCar flycar = new FlyCar(car);
        flycar.move();

        System.out.println("增加新的功能，水里游---------");
        WaterCar  waterCar = new WaterCar(car);
        waterCar.move();

        System.out.println("增加两个新的功能，飞行，水里游-------");
        WaterCar waterCar2 = new WaterCar(new FlyCar(car));
        waterCar2.move();   

//      Reader r = new BufferedReader(new InputStreamReader(new FileInputStream(new File("d:/a.txt"))));

    }
}

六，外观模式

核心：为了系统提供统一的入口，封装子系统的复杂性，便于客户端调用。

public interface 工商局  {
    void checkName();  //核名
}
class 海淀区工商局 implements 工商局 {

    @Override
    public void checkName() {
        System.out.println("检查名字是否有冲突！");
    }
}



public interface 税务局 {
    void taxCertificate();  //办理税务登记证
}
class 海淀税务局 implements 税务局 {
    @Override
    public void taxCertificate() {
        System.out.println("在海淀税务局办理税务登记证！");
    }
}


public interface 银行 {
    void  openAccount();  //开户
}
class 中国工商银行 implements 银行 {
    @Override
    public void openAccount() {
        System.out.println("在中国工商银行开户！");
    }
}


public interface 质检局 {
    void  orgCodeCertificate();  //办理组织机构代码证
}
class 海淀质检局 implements 质检局 {
    @Override
    public void orgCodeCertificate() {
        System.out.println("在海淀区质检局办理组织机构代码证！");
    }
}




package com.bjsxt.facade;

/**
 * 办理注册公司流程的门面对象
 * @author Administrator
 *
 */
public class RegisterFacade {
    public void register(){
        工商局  a = new 海淀区工商局();
        a.checkName();
        质检局 b = new 海淀质检局();
        b.orgCodeCertificate();
        税务局  c  = new 海淀税务局();
        c.taxCertificate();
        银行  d = new 中国工商银行();
        d.openAccount();
    }
}



测试代码：


package com.bjsxt.facade;

public class Client1 {
    public static void main(String[] args) {
//      工商局  a = new 海淀区工商局();
//      a.checkName();
//      质检局 b = new 海淀质检局();
//      b.orgCodeCertificate();
//      税务局  c  = new 海淀税务局();
//      c.taxCertificate();
//      银行  d = new 中国工商银行();
//      d.openAccount();    
//相当于将上面代码封装到了RegisterFacade 中的register函数中  
    new RegisterFacade().register();        
    }
}

七，享元模式

核心：

    --享元模式一共享的方式高效地支持大量细粒度对象的重用。

    --享元模式对象能 做到共享的关键是区分内部状态和外部状态。

        -内部状态：可以共享，不会随环境变化而变化。

        -外部状态：不可以共享，会随着环境变化而改变。

//模拟棋盘
/**
 * 外部状态UnSharedConcreteFlyWeight
 * @author Administrator
 *
 */
public class Coordinate {
    private int x,y;

    public Coordinate(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }   
}



/**
 * 享元类
 * @author Administrator
 *
 */
public interface ChessFlyWeight {
    void setColor(String c);
    String getColor();
    void display(Coordinate c);
}
class ConcreteChess implements ChessFlyWeight {

    private String color;

    public ConcreteChess(String color) {
        super();
        this.color = color;
    }

    @Override
    public void display(Coordinate c) {
        System.out.println("棋子颜色："+color);
        System.out.println("棋子位置："+c.getX()+"----"+c.getY());
    }

    @Override
    public String getColor() {
        return color;
    }

    @Override
    public void setColor(String c) {
        this.color = c;
    }   
}


import java.util.HashMap;
import java.util.Map;

/**
 * 享元工厂类
 * @author Administrator
 *
 */
public class ChessFlyWeightFactory {
    //享元池
    private static Map<String,ChessFlyWeight> map = new HashMap<String, ChessFlyWeight>();

    public static ChessFlyWeight  getChess(String color){

        if(map.get(color)!=null){
            return map.get(color);
        }else{
            ChessFlyWeight cfw = new ConcreteChess(color);
            map.put(color, cfw);
            return cfw;
        }       
    }   
}



//测试代码：

public class Client {
    public static void main(String[] args) {
        ChessFlyWeight chess1 = ChessFlyWeightFactory.getChess("黑色");
        ChessFlyWeight chess2 = ChessFlyWeightFactory.getChess("黑色");
        System.out.println(chess1);
        System.out.println(chess2);

        System.out.println("增加外部状态的处理===========");
        chess1.display(new Coordinate(10, 10));
        chess2.display(new Coordinate(20, 20));     
    }
}