设计模式之结构型模型

设计模式之结构型模型
强烈推介IDEA2020.2破解激活,IntelliJ IDEA 注册码,2020.2 IDEA 激活码

设计模式之结构型模型

桥接模式
尽可能不要使用类的继承,而尽可能使用 合成/聚合
描述: 继承方法子类与父类的高依赖性限制了复用和程序的灵活性。
这里写图片描述
选择不同的接口实现选择不同的业务类型

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

在这里插入图片描述

本文来源蹊源的奇思妙想,由架构君转载发布,观点不代表Java架构师必看的立场,转载请标明来源出处:https://javajgs.com/archives/14733

发表评论