设计模式之结构型模型-CFANZ编程社区

设计模式之结构型模型

桥接模式

尽可能不要使用类的继承，而尽可能使用合成/聚合

描述: 继承方法子类与父类的高依赖性限制了复用和程序的灵活性。

设计模式之结构型模型_结构式模式

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

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();
       }
}

设计模式之结构型模型_适配模式_02