设计模式之结构型模型

设计模式之结构型模型

桥接模式
尽可能不要使用类的继承，而尽可能使用 合成/聚合
描述: 继承方法子类与父类的高依赖性限制了复用和程序的灵活性。

选择不同的接口实现选择不同的业务类型

import org.junit.Test;
public class 桥接模式 {
       @Test
       public void test()
       {
             ColocalateFactory a=new BlackFactory();
             a.ColocalateMarking();
             ColocalateFactory b=new WhilteFactory();
             b.ColocalateMarking();
       }
       
       
       
}
interface ColocalateFactory
{
void ColocalateMarking();  
}
class BlackFactory implements ColocalateFactory
{
       @Override
       public void ColocalateMarking() {
             // TODO Auto-generated method stub
             System.out.println("生产黑色巧克力");
       }
       
}
class WhilteFactory implements ColocalateFactory
{
       @Override
       public void ColocalateMarking() {
             // TODO Auto-generated method stub
             System.out.println("生产白色巧克力");
       }
       
}

适配器模式
描述：维护人员处理功能相同或者相似，但方法不同。进行接口的统一调用。

• 注入需要适配的类的时候，使用set方法而不是new实例化对象，从而防止固化。

• 适配类的方法与要被适配类的方法不是平行关系而是调用关系。

public interface Charger {
       void GetPower();
}
//充电器A
public class ChargerA implements Charger {
       @Override
       public void GetPower() {
             // TODO Auto-generated method stub
             System.out.println("使用220V经行充电");
       }
}
//充电器B
public class ChargerB implements Charger {
       @Override
       public void GetPower() {
             // TODO Auto-generated method stub
             System.out.println("使用200V进行充电");
       }
}

//万能充电器
import org.junit.Test;
public class MultCharger implements Charger {
       
       private Charger charger;
       
       public void setCharger(Charger charger) {
             this.charger = charger;
       }
       @Override
       public void GetPower() {
             // TODO Auto-generated method stub
             this.charger.GetPower();
       }
       
       @Test
       public void test()
       {
             Charger a=new ChargerA();
             Charger b=new ChargerB();
             
             MultCharger Multcharger=new MultCharger();
             Multcharger.setCharger(a);
        Multcharger.GetPower();
        Multcharger.setCharger(b);
        Multcharger.GetPower();
       }
}

装饰器模式
描述：在不改变原有类文件和使用继承的情况下，动态扩展某个对象的功能。（这样决定了不能直接添加类方法）

• 适配器模式 适配对象和被适配器对象可以不存在实现统一接口的关系（即兄弟类）。 目的是：兼容
• 装饰器模式：是继承的一种替代方法，相对而言更加灵活。目的是：增强

import org.junit.Test;
public class 装饰器模式 {
       
       @Test
       public void test()
       {
             Soldier s=new SmallSoldier();
             BigSoldier b=new BigSoldier();
             b.setSoldier(s);
             b.fighting();
       }
       
       
}
interface Soldier
{
       void fighting();
}
class SmallSoldier implements Soldier
{
       @Override
       public void fighting() {
             // TODO Auto-generated method stub
             System.out.println("普通士兵在战斗");
       }
       }
class BigSoldier implements Soldier
{
       
       private Soldier soldier;
       
       public void setSoldier(Soldier soldier) {
             this.soldier = soldier;
       }
       @Override
       public void fighting() {
             // TODO Auto-generated method stub
             soldier.fighting();
             System.out.println("配置了远程兵在辅助");
       }
       }

组合模式
利用递归的思想
描述：将对象组合成树形结构以表示”部分-整体“的层次结构
补充：并且提供给了增加子节点、移除子节点、展示结构的三种方法。
应用场景：出现树形结构的地方，如文件目录显示，多级目录呈现等树形结构数据的操作。
方法：通过继承抽象类来实现

public abstract class Node {
            protected String name;//名称
            
            //构造器赋名
             public Node(String name){
                 this.name = name;
             }
            //新增节点：文件节点无此方法，目录节点重写此方法
            public void addNode(Node node) throws Exception{
                throw new Exception("Invalid exception");
            }
           
            //删除节点
            public void removeNode(Node node)throws Exception{
                throw new Exception("Invalid exception");
            }
            //显示节点：文件与目录均实现此方法
            abstract void display();
}

//文件结点
public class Filer extends Node {
       public Filer(String name) {
             super(name);
             // TODO Auto-generated constructor stub
       }
       
       
       @Override
       void display() {
             // TODO Auto-generated method stub
       System.out.println(name);  
       }
}

//目录结点
public class Noder extends Node{
       //内部节点列表（包括文件和下级目录）
       List<Node> nodeList = new ArrayList<Node>();
       public Noder(String name) {
             super(name);
             // TODO Auto-generated constructor stub
       }
       //新增节点
       public void addNode(Node node) throws Exception{
             nodeList.add(node);
       }
       //删除节点
       public void removeNode(Node node)throws Exception
       {
             nodeList.remove(node);
       }
    //向下递归打印名称
       @Override
       void display() {
             System.out.println(name);
             for(Node node:nodeList){
                    node.display();
             }
       }
}

//测试类
import java.io.File;
public class Clienter {
          public static void createTree(Node node) throws Exception{
                         File file = new File(node.name);
                         File[] f = file.listFiles();
                        for(File fi : f){
                              //判断结点是不是文件
                            if(fi.isFile()){ 
                                //利用绝对路径给结点命名
                                 Filer filer = new Filer(fi.getAbsolutePath());
                                 node.addNode(filer);
                            }
                            //判断结点是不是目录
                            if(fi.isDirectory()){
                             //利用绝对路径给结点命名
                                Noder noder = new Noder(fi.getAbsolutePath());
                                node.addNode(noder);
                                createTree(noder);//使用递归生成树结构
                            }
                        }
                    }
                    public static void main(String[] args) {
                        Node noder = new Noder("G://WeGame");
                       try {
                            createTree(noder);
                       } catch (Exception e) {
                           e.printStackTrace();
                       }
                        noder.display();
                    }
}

享元模式
描述：用一个类存储共享资源， 运行共享技术有效地支持大量细粒度对象的复用
方式：通过Map集合存储（HashMap）
提供 增加put、获取get 方法

public class Student {
       private String name;
       private int  age;
       
       public Student(String name,int age)
       {
             this.name=name;
             this.age=age;
             
       }
       public String getName() {
             return name;
       }
       public void setName(String name) {
             this.name = name;
       }
       public int getAge() {
             return age;
       }
       public void setAge(int age) {
             this.age = age;
       }
       @Override
       public String toString() {
             return "Student [name=" + name + ", age=" + age + "]";
       }
}

import java.util.HashMap;
import org.junit.Test;
public class StudentFactory {
       static HashMap <String,Student>map=new HashMap<>();
       
       public static Student getStudent(String name)
       {
             
             if(map.get(name)!=null)
             {
                    return map.get(name);
             }
             return null;
             
       }
       
       public static void addStudent(Student s)
       {
             map.put(s.getName(), s);
       }
       
       public static void display()
       {
             System.out.println(map.entrySet());
       }
       
       @Test
       public void test001()
       {
       StudentFactory.addStudent(new Student("luo", 18));   
       StudentFactory.addStudent(new Student("li", 17));    
    Student s=      StudentFactory.getStudent("luo");
       System.out.println(s);
     StudentFactory.display();
       }
       
}

外观模式
不改变旧的类的内容，通过一个外观类对相关联的方法经行业务重组。
般用在子系统与访问之间，用于对访问屏蔽复杂的子系统调用，采用耳目一新的外观类提供的简单的调用方法，具体的实现由外观类去子系统调用。（业务逻辑整合）

import org.junit.Test;
public class 外观模式{
       private FactoryA a=new FactoryA();
       private FactoryB b=new FactoryB();
       public void lookplay()
       {
             a.funcA();
             b.funcB();
       }
       
       
       @Test
       public void test()
       {
             new 外观模式().lookplay();
       }
}
class FactoryA
{
       public void funcA()
       {
             System.out.println("向别人表白"); 
       }
}
class FactoryB
{
       public void funcB()
       {
             System.out.println("答应别人的表白");
       }
}

代理模式
描述：为第三方对象提供一种代理以控制对象的访问（第三方翻墙行为）
注：适配器是一对多，代理器是一对一的关系。

public interface FactoryInterface {
       void Breakmaking();
}

public class Factory implements FactoryInterface{
       @Override
       public void Breakmaking() {
             // TODO Auto-generated method stub
             System.out.println("生产面包");
       }
}

import org.junit.Test;
public class AgentFactory implements FactoryInterface{
       FactoryInterface f =new Factory();
       @Override
       public void Breakmaking() {
             // TODO Auto-generated method stub
             f.Breakmaking();
       }
       
       @Test
       public void test()
       {
             new AgentFactory().Breakmaking();
       }
}