结构型模式

/计算机只能读sd卡
public class Computer {
    //从SD卡读取数据
    public String readSD(SDCard sdCard){
        if(sdCard==null){
            throw new NullPointerException("sd card can not  be null");
        }
        return sdCard.readSD();
    }

}

//目标者接口
public interface SDCard {
    //从SD卡中读取数据
    String readSD();
    //向SD卡写数据
    void writeSD(String msg);
}

public class SDCardImpl implements SDCard {
    @Override
    public String readSD() {
        String msg = "SDCard read msg: hello world!";
        return msg;
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("SDCard write msg:" + msg);
    }
}

//适配者类的接口
public interface TFCard {
    //从TF卡中读取数据
    String readTF();
    //向TF卡中写数据
    void writeTF(String msg);
}

//实现适配者接口
public class TFCardImpl implements TFCard{
    @Override
    public String readTF() {
        String msg="TFCard read msg: hello world TFCard!";
        return msg;
    }

    @Override
    public void writeTF(String msg) {
        System.out.println("TFCard write msg: "+msg);
    }
}

//适配器
//使用继承不太好，造成了违背合成复用原则
public class SDAdapterTF extends TFCardImpl implements SDCard {

    @Override
    public String readSD() {
        System.out.println("adapter read tf card");
        //实际上适配器是去读TF卡中的数据
        return readTF();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("adapter write tf card");
        writeTF(msg);
    }
}

//计算机只能读sd卡
public class Computer {
    //从SD卡读取数据
    public String readSD(SDCard sdCard){
        if(sdCard==null){
            throw new NullPointerException("sd card can not  be null");
        }
        return sdCard.readSD();
    }

}

//目标者接口
public interface SDCard {
    //从SD卡中读取数据
    String readSD();
    //向SD卡写数据
    void writeSD(String msg);
}

public class SDCardImpl implements SDCard {
    @Override
    public String readSD() {
        String msg = "SDCard read msg: hello world!";
        return msg;
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("SDCard write msg:" + msg);
    }
}

//适配者类的接口
public interface TFCard {
    //从TF卡中读取数据
    String readTF();
    //向TF卡中写数据
    void writeTF(String msg);
}

//实现适配者接口
public class TFCardImpl implements TFCard {
    @Override
    public String readTF() {
        String msg="TFCard read msg: hello world TFCard!";
        return msg;
    }

    @Override
    public void writeTF(String msg) {
        System.out.println("TFCard write msg: "+msg);
    }
}

//适配器
//不需要使用继承
public class SDAdapterTF implements SDCard {

    //声明适配者类
    private TFCard tfCard;

    public SDAdapterTF(TFCard tfCard) {
        this.tfCard = tfCard;
    }

    @Override
    public String readSD() {
        System.out.println("adapter read tf card");
        //实际上适配器是去读TF卡中的数据
        return tfCard.readTF();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("adapter write tf card");
        tfCard.writeTF(msg);
    }
}

//抽象的操作系统类，抽象化角色
public abstract class OperatingSystem {
    //声明VideoFile变量
    protected VideoFile videoFile;

    public OperatingSystem(VideoFile videoFile) {
        this.videoFile = videoFile;
    }

    public abstract void play(String fileName);
}

//扩展抽象化角色
public class Windows extends OperatingSystem {
    public Windows(VideoFile videoFile) {
        super(videoFile);
    }

    @Override
    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}

public class Mac extends OperatingSystem {
    public Mac(VideoFile videoFile) {
        super(videoFile);
    }

    @Override
    public void play(String fileName) {
        videoFile.decode(fileName);
    }
}

//视频文件格式，实现化角色
public interface VideoFile {
    //解码功能
    void decode(String fileName);
}

//rmvb视频文件类，具体实现化角色
public class RmvbFile implements VideoFile {
    @Override
    public void decode(String fileName) {
        System.out.println("rmvb视频文件：" + fileName);
    }
}

//avi视频文件，具体的实现化角色
public class AviFile implements VideoFile {

    @Override
    public void decode(String fileName) {
        System.out.println("avi视频文件：" + fileName);
    }
}

//快餐类,抽象构建角色
public abstract class FastFood {
    private float price;//价格
    private String desc;//具体的描述

    public abstract float cost();

    public FastFood() {
    }

    public FastFood(float price, String desc) {
        this.price = price;
        this.desc = desc;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }


}

//炒饭，具体构建角色
public class FriedRice extends FastFood{
    public FriedRice(){
        //基础价格和描述
        super(10,"炒饭");
    }
    @Override
    public float cost() {
        return getPrice();
    }
}

//炒面，具体构建角色
public class FriedNoodles extends FastFood {

    public FriedNoodles() {
        super(12, "炒面");
    }

    @Override
    public float cost() {
        return getPrice();
    }
}

//装饰类,抽象，因为会有许多不同的具体装饰配料，抽象装饰
public abstract class Garnish extends FastFood {
    //声明快餐类变量
    private FastFood fastFood;

    public FastFood getFastFood() {
        return fastFood;
    }

    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }

    public Garnish(FastFood fastFood) {
        this.fastFood = fastFood;
    }

    public Garnish(FastFood fastFood, float price, String desc) {
        super(price, desc);
        this.fastFood = fastFood;
    }


}

//第一个装饰配料鸡蛋，具体装饰者角色
public class Egg extends Garnish {
    public Egg(FastFood fastFood) {
        super(fastFood, 1, "鸡蛋");
    }

    @Override
    public float cost() {
        return getPrice() + getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

//第二个装饰配料培根，具体装饰者角色
public class Bacon extends Garnish {
    public Bacon(FastFood fastFood) {
        super(fastFood, 2, "培根");
    }

    @Override
    public float cost() {
        return getPrice() + getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

//菜单组件，属于抽象根节点
public abstract class MenuComponent {
    //菜单组件的名称
    protected String name;
    //菜单组件的层级
    protected int level;

    //添加子菜单
    public void add(MenuComponent menuComponent) {
        throw new UnsupportedOperationException();
    }

    //移除子菜单
    public void remove(MenuComponent menuComponent) {
        throw new UnsupportedOperationException();
    }

    //获取指定的子菜单
    public MenuComponent getChild(int index) {
        throw new UnsupportedOperationException();
    }

    //获取菜单或者菜单项的名称
    public String getName() {
        return name;
    }

    //打印菜单名称(包含所有子元素)
    public abstract void print();
}

//菜单类，属于树枝节点角色
public class Menu extends MenuComponent {
    //菜单可以有多个子菜单或者子菜单项
    private List<MenuComponent> menuComponentList = new ArrayList<MenuComponent>();

    public Menu(String name, int level) {
        this.name = name;
        this.level = level;
    }

    @Override
    public void add(MenuComponent menuComponent) {
        menuComponentList.add(menuComponent);
    }

    @Override
    public void remove(MenuComponent menuComponent) {
        menuComponentList.remove(menuComponent);
    }

    @Override
    public MenuComponent getChild(int index) {
        return menuComponentList.get(index);
    }

    @Override
    public void print() {
        //因为是菜单，所以要先打印菜单名称
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        System.out.println(name);
        //然后还要打印子菜单或者子菜单项名称
        for (MenuComponent component : menuComponentList) {
            component.print();
        }
    }
}

//菜单项类，叶子节点角色
public class MenuItem extends MenuComponent {
    public MenuItem(String name, int level) {
        this.name = name;
        this.level = level;
    }

    public void print() {
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        System.out.println(name);
    }

}

//电灯类
public class Light {
    //开灯方法
    public void on() {
        System.out.println("打开电灯");
    }

    public void off() {
        System.out.println("关闭电灯");
    }
}

public class TV {
    public void on(){
        System.out.println("打开电视");
    }

    public void off(){
        System.out.println("关闭电视");
    }
}

public class AirCondition {
    public void on() {
        System.out.println("打开空调");
    }

    public void off() {
        System.out.println("关闭空调");
    }

}

//抽象享元角色
public abstract class AbstractBox {
    //获取图形的方法
    public abstract String getShape();

    //显示图形和颜色
    public void display(String color) {
        System.out.println("方块形状:" + getShape() + "," + "颜色：" + color);
    }
}

public class IBox extends AbstractBox {

    @Override
    public String getShape() {
        return "I";
    }
}

public class LBox extends AbstractBox {

    @Override
    public String getShape() {
        return "L";
    }
}

public class OBox extends AbstractBox {

    @Override
    public String getShape() {
        return "O";
    }
}

//工厂类，将该类设计为单例
public class BoxFactory {
    public HashMap<String, AbstractBox> map;

    //在构造方法中进行初始化操作
    //单例，因此工厂私有
    private BoxFactory() {
        map = new HashMap<String, AbstractBox>();
        map.put("I", new IBox());
        map.put("L", new LBox());
        map.put("O", new OBox());
    }

    public static BoxFactory getInstance() {
        return boxFactory;
    }

    //饿汉式
    private static BoxFactory boxFactory = new BoxFactory();

    //根据名称获取图形对象
    public AbstractBox getShape(String name) {
        return map.get(name);
    }

}

//火车站类
public class TrainStation implements SellTicket {
    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}

//卖火车票的接口
public interface SellTicket {
    void sell();
}

//火车票代售点
public class ProxyPoint implements SellTicket {
    //声明火车站类对象
    private TrainStation trainStation = new TrainStation();

    @Override
    public void sell() {
        System.out.println("代售点收取一定的服务费用");
        trainStation.sell();
    }
}

//火车站类
public class TrainStation implements SellTicket {
    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}

//卖火车票的接口
public interface SellTicket {
    void sell();
}

//获取代理对象的工厂类
public class ProxyFactory {
    //声明目标对象
    private TrainStation trainStation = new TrainStation();

    //获取代理对象的方法
    public SellTicket getProxyObject() {
        //返回代理对象
        //jdk提供的动态代理方法
        /*
        ClassLoader loader: 类加载器,用于加载代理类,可以通过目标对象获取类加载器
        Class<?>[] interfaces: 代理类实现的接口字节码对象
        InvocationHandler h :代理对象调用处理程序
         */
        SellTicket proxyObject = (SellTicket) Proxy.newProxyInstance(
                trainStation.getClass().getClassLoader(),
                trainStation.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    /*
                    Object proxy: 代理对象，和proxyObject是同一个对象，在invoke方法中基本不用
                    Method method:对接口中的方法进行封装的method对象
                    Object[] args:调用方法的实际参数

                    返回值就是调用方法的返回值
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                        System.out.println("invoke方法执行了");
                        System.out.println("代售点收取一定的服务费用(jdk)动态代理");
                        //执行目标对象的方法
                        //此时sell方法无传递值，因此args是空
                        Object obj = method.invoke(trainStation, args);
                        //由于sell方法没有返回值，因此实际上obj这里就是null
                        return obj;
                    }
                }
        );
        return proxyObject;
    }
}