设计模式--结构型模式

//=============
//Target接口，就是我们想把其他类的功能放到这个接口
public interface Robot
{
    public void cry();
    public void move();
}

//=====================
//别人的类，假装不懂怎么实现，相当于不适合咱们的原装插座，怎没能力把它改成合适的，只能看见插口(方法的名称，参数，返回值)
public class Dog
{
    public void wang()
    {
        System.out.println("狗汪汪叫！");
    }
    
    public void run()
    {
        System.out.println("狗快快跑！");
    }
}

//===============
//适配器登场了，这是类适配器，继承未知类
public class DogAdapter extends Dog implements Robot
{
    public void cry()
    {
        System.out.print("机器人模仿：");
        super.wang();
    }
    
    public void move()
    {
        System.out.print("机器人模仿：");
        super.run();
    }
}

//===============
//用户端使用
public class Client
{
    public static void main(String args[])
    {
        Robot robot=new DogAdapter();
        robot.cry();
        robot.move();
    }
}

//===============
//对象是配置器，与上面代码唯一不同就是适配器不继承未知类，而是把他的对象引用当成自身属性
public class Adapter extends Target
{
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee)
    {
        this.adaptee=adaptee;
    }
    public void request()
    {
        adaptee.specificRequest();
    }
} 

//============
//这次我们先看使用时的样子
public class Client
{
    public static void main(String a[])
    {
        Color color;//是接口，有不同颜色的实现类，所谓实现部分
        Pen pen;//是个抽象类，有大小类型的子类实现，所谓抽象部分
        
        color=new Blue();
        pen=new BigPen();
        
        pen.setColor(color);//为毛笔选择颜料
        pen.draw("鲜花");//使用毛笔
    }
}

//==============
//pen接口，里面有Color引用
public abstract class Pen
{
    protected Color color;
    public void setColor(Color color)
    {
        this.color=color;
    }
    public abstract void draw(String name);
} 

//================
//bigPen的实现，想在draw中不光体现"大号"，也想体现颜色，所以在draw()方法实际调用内部的Color实现，这样能同时体现这两项内容
public class BigPen extends Pen
{
    public void draw(String name)
    {
        String penType="大号毛笔绘制";
        this.color.bepaint(penType,name);            
    }    
}

//==============
//color的接口
public interface Color
{
    void bepaint(String penType,String name);
}


//==================
//Blue颜料的实现
public class Blue implements Color
{
    public void bepaint(String penType,String name)
    {
        System.out.println(penType + "蓝色的"+ name + ".");
    }
}

//====================
//MyElement，水果与盘子共同的方法
public abstract class MyElement
{
    public abstract void eat();
}

//===============
//水果比较简单，直接吃就可以了
public class Apple extends MyElement
{
    public void eat()
    {
        System.out.println("吃苹果！");
    }
}

//===============
//盘子除了吃(调用盘子装的元素),还要对盘中元素有基本的管理操作
public class Plate extends MyElement
{
    private ArrayList list=new ArrayList();
    
    public void add(MyElement element)
    {
       list.add(element);    
    }
    
    public void delete(MyElement element)
    {
        list.remove(element);
    }

    public void eat()
    {
        for(Object object:list)
        {
            ((MyElement)object).eat();
        }
    }
}

//====================
//站在用户端，吃就完事了
public class Client
{
    public static void main(String a[])
    {
        MyElement obj1,obj2,obj3,obj4,obj5;
        Plate plate1,plate2,plate3;
        
        obj1=new Apple();
        obj2=new Pear();
        plate1=new Plate();
        plate1.add(obj1);
        plate1.add(obj2);
        
        obj3=new Banana();
        obj4=new Banana();
        plate2=new Plate();
        plate2.add(obj3);
        plate2.add(obj4);
        
        obj5=new Apple();
        plate3=new Plate();
        plate3.add(plate1);
        plate3.add(plate2);
        plate3.add(obj5);
            
        plate1.eat();
    }
}

//==============
//要魔改的方法，用接口用抽象类都一样，，吧
public interface Transform
{
    public void move();
}

//===============
//开始固定的类，也就是基础小汽车形态
//Car()是创建的时候输出一下
public final class Car implements Transform
{
    public Car()
    {
        System.out.println("变形金刚是一辆车！");
    }
    
    public void move()
    {
        System.out.println("在陆地上移动！");    
    }
}

//======================
//这里的装饰器保留了move()原功能没有动，只是加入了额外的功能
public class Changer implements Transform
{
    private Transform transform;
    
    public Changer(Transform transform)
    {
        this.transform=transform;//为了使用Car的方法
    }
    
    public void move()
    {
        transform.move();    
    }
}

//===============
//变身小飞机，多加了一个fly()方法
public class Airplane extends Changer
{
    public Airplane(Transform transform)
    {
        super(transform);
        System.out.println("变成飞机！");
    }
    
    public void fly()
    {
        System.out.println("在天空飞翔！");    
    }
}

//=================
//客户端使用
public class Client
{
    public static void main(String args[])
    {
        Transform camaro;
        camaro=new Car();
        camaro.move();
        System.out.println("-----------------------------");
        
        Airplane bumblebee=new Airplane(camaro);
        bumblebee.move();//注意这里变成飞机还可以在地上跑
        bumblebee.fly();
    }
}

//================
//电扇
public class Fan
{
    public void on()
    {
        System.out.println("风扇打开！");    
    }
    
    public void off()
    {
        System.out.println("风扇关闭！");        
    }
    
}

//===============
//空调
public class AirConditioner
{
    public void on()
    {
        System.out.println("空调打开！");
    }
    
    public void off()
    {
        System.out.println("空调关闭！");
    }
}

//====================
//灯组
public class Light
{
    private String position;
    
    public Light(String position)
    {
        this.position=position;    
    }
    
    public void on()
    {
        System.out.println(this.position + "灯打开！");
    }
    
    public void off()
    {
        System.out.println(this.position + "灯关闭！");    
    }
}

//=============
//接下来就是万众期待的遥控器了
public class GeneralSwitchFacade {
    private Light lights[]=new Light[4];
    private Fan fan;
    private AirConditioner ac;
    private Television tv;
    
    public GeneralSwitchFacade()
    {
        lights[0]=new Light("左前");
        lights[1]=new Light("右前");
        lights[2]=new Light("左后");
        lights[3]=new Light("右后");    
        fan=new Fan();
        ac=new AirConditioner();
        tv=new Television();
    }
    
    public void on()
    {
        lights[0].on();
        lights[1].on();
        lights[2].on();
        lights[3].on();
        fan.on();
        ac.on();
        tv.on();
    } 
        
    public void off()
    {
        lights[0].off();
        lights[1].off();
        lights[2].off();
        lights[3].off();
        fan.off();
        ac.off();
        tv.off();        
    }   
}

//===================
//客户端使用
public class Client
{
    public static void main(String args[])
    {
        GeneralSwitchFacade gsf=new GeneralSwitchFacade();
        gsf.on();
        System.out.println("-----------------------");    
        gsf.off();
    }
}

//==================
//网络设别接口
//getType()返回是集线器还是交换机，因为这个接口被这两种设备继承，所以类型算内部状态，故没有参数也能得到
//use(Port port) 不管是集线器还是交换机，都要让计算机接入，还需要接口，但一个网络设备要供好多计算机使用，如果把port当做成员变量，需要List<Port> 好不好另说，本题的意思把Port当做外部状态，所以用作参数。
public interface NetworkDevice
{
    public String getType();
    public void use(Port port);
}

//===============
//port比较简单
public class Port
{
    private String port;
    
    public Port(String port)
    {
        this.port=port;    
    }
    
    public void setPort(String port)
    {
        this.port=port;
    }
    
    public String getPort()
    {
        return this.port;
    }
}

//===============
//交换机的实现
public class Switch implements NetworkDevice
{
    private String type;
    
    public Switch(String type)
    {
        this.type=type;
    }
    
    public String getType()
    {
        return this.type;
    } 
    
    public void use(Port port)
    {
        System.out.println("Linked by switch, type is " + this.type + ", port is " + port.getPort());
    }
}

//==============
//集线器
public class Hub implements NetworkDevice
{
    private String type;
    
    public Hub(String type)
    {
        this.type=type;
    }
    
    public String getType()
    {
        return this.type;
    } 
    
    public void use(Port port)
    {
        System.out.println("Linked by Hub, type is " + this.type + ", port is " + port.getPort());
    }    
}

//==================
//最重要的网络设备工厂，它实现了享元模式，只实例化了两个网络设备，然后用这两种网络设备实现所有计算机的接入，并且标注端口号，还记录网络设备和计算机(没调用一次网络设备工厂表示有一个计算机接入)的个数

public class DeviceFactory
{
    private ArrayList devices = new ArrayList();
    private int totalTerminal=0;
    
    public DeviceFactory()
    {
        NetworkDevice nd1=new Switch("Cisco-WS-C2950-24");
        devices.add(nd1);
        NetworkDevice nd2=new Hub("TP-LINK-HF8M");
        devices.add(nd2);
    }
    
    public NetworkDevice getNetworkDevice(String type)
    {
        if(type.equalsIgnoreCase("cisco"))
        {
            totalTerminal++;
            return (NetworkDevice)devices.get(0);
        }
        else if(type.equalsIgnoreCase("tp"))
        {
            totalTerminal++;
            return (NetworkDevice)devices.get(1);
        }
        else
        {
            return null;
        }
    }
    
    public int getTotalDevice()
    {
        return devices.size();
    }
    
    public int getTotalTerminal()
    {
        return totalTerminal;
    }
}

//================
//客户端的实例
public class Client
{
    public static void main(String args[])
    {
        NetworkDevice nd1,nd2,nd3,nd4,nd5;

        DeviceFactory df=new DeviceFactory();
        nd1=df.getNetworkDevice("cisco");
        nd1.use(new Port("1000"));
        
        nd2=df.getNetworkDevice("cisco");
        nd2.use(new Port("1001"));
        
        nd3=df.getNetworkDevice("cisco");
        nd3.use(new Port("1002"));
        
        nd4=df.getNetworkDevice("tp");
        nd4.use(new Port("1003"));
        
        nd5=df.getNetworkDevice("tp");
        nd5.use(new Port("1004"));
        
        System.out.println("Total Device:" + df.getTotalDevice());
        System.out.println("Total Terminal:" + df.getTotalTerminal());
    }
}