首页 文章 精选 留言 我的

精选列表

搜索[动态构型]，共10005篇文章
优秀的个人博客,低调大师

设计模式（八）代理模式(结构型)

概述 为其他对象提供一种代理以控制对这个对象的访问。 抽象角色：声明真实对象和代理对象的共同接口； 代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。 真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。 类图 代码 IGamePlayer接口对游戏玩家进行抽象： 1 public interface IGamePlayer { 2 public void killBoss(); 3 public void UpGrade(); 4 } GamePlayer实现IGamePlayer接口中的方法： 1 public class GamePlayer implements IGamePlayer { 2 private String name = null; 3 public GamePlayer(String name) { 4 super(); 5 this.name = name; 6 } 7 @Override 8 public void killBoss() { 9 System.out.println(this.name+"正在killBoss"); 10 } 11 @Override 12 public void UpGrade() { 13 System.out.println(this.name+"突然UpGrade"); 14 } 15 } GamePlayerProxy是代理类： 1 public class GamePlayerProxy implements IGamePlayer { 2 private IGamePlayer player = null; 3 public GamePlayerProxy(IGamePlayer player) { 4 super(); 5 this.player = player; 6 } 7 // 记录日志 8 private void log() { 9 System.out.println(new Date().toString() + "的时候在打怪"); 10 } 11 @Override 12 public void killBoss() { 13 this.log(); 14 player.killBoss(); 15 } 16 @Override 17 public void UpGrade() { 18 player.UpGrade(); 19 this.count(); 20 } 21 private void count() { 22 System.out.println("升了1级"); 23 } 24 } 测试： 1 public class Main { 2 public static void main(String[] args) { 3 IGamePlayer player = new GamePlayer("张三"); 4 IGamePlayer proxy = new GamePlayerProxy(player); 5 proxy.killBoss(); 6 proxy.UpGrade(); 7 } 8 } 优点 职责清晰 真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。 代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的作用。 高扩展性 我是天王盖地虎的分割线 本文转自我爱物联网博客园博客，原文链接：http://www.cnblogs.com/yydcdut/p/3857245.html，如需转载请自行联系原作者
2017-09-03
优秀的个人博客,低调大师

设计模式（九）适配器(结构型)

概述 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。 角色 目标接口（Target）：客户所期待的接口。目标可以是具体的或抽象的类，也可以是接口。 需要适配的类（Adaptee）：需要适配的类或适配者类。 适配器（Adapter）：通过包装一个需要适配的对象，把原接口转换成目标接口。 类图 代码 水饺 package com.yydcdut; public class ShuiJiao { public void makeShuiJiao() { System.out.println("调制菜肉馅"); System.out.println("包面皮"); System.out.println("包饺子"); } } 混沌 package com.yydcdut; public interface HunDun { public void makeHunDun(); } 食品适配器 package com.yydcdut; public class FoodAdapter extends ShuiJiao implements HunDun { @Override public void makeHunDun() { super.makeShuiJiao(); System.out.println("混沌和水饺一样的是以面包馅的食品"); } } 测试 package com.yydcdut; public class Main { public static void main(String[] args) { HunDun h = new FoodAdapter(); h.makeHunDun(); } } 总结 优点 通过适配器，客户端可以调用同一接口，因而对客户端来说是透明的。这样做更简单、更直接、更紧凑。 复用了现存的类，解决了现存类和复用环境要求不一致的问题。 将目标类和适配者类解耦，通过引入一个适配器类重用现有的适配者类，而无需修改原有代码。 一个对象适配器可以把多个不同的适配者类适配到同一个目标，也就是说，同一个适配器可以把适配者类和它的子类都适配到目标接口。 缺点 对于对象适配器来说，更换适配器的实现过程比较复杂。 适用场景 系统需要使用现有的类，而这些类的接口不符合系统的接口。 想要建立一个可以重用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。 两个类所做的事情相同或相似，但是具有不同接口的时候。 旧的系统开发的类已经实现了一些功能，但是客户端却只能以另外接口的形式访问，但我们不希望手动更改原有类的时候。 使用第三方组件，组件接口定义和自己定义的不同，不希望修改自己的接口，但是要使用第三方组件接口的功能。 适配器模式与装饰者模式 它们都可以用来包装对象，本质区别在于 适配器模式：将一个接口转换成另外一个接口。 装饰者模式：不改变接口，只加入职责。 我是天王盖地虎的分割线 本文转自我爱物联网博客园博客，原文链接：http://www.cnblogs.com/yydcdut/p/3897164.html，如需转载请自行联系原作者
2017-09-30
优秀的个人博客,低调大师

Java设计模式系列-享元模式（结构型）

一、概述 享元模式：“享”就是分享之意，指一物被众人共享，而这也正是该模式的终旨所在。 享元模式有点类似于单例模式，都是只生成一个对象来被共享使用。这里有个问题，那就是对共享对象的修改，为了避免出现这种情况，我们将这些对象的公共部分，或者说是不变化的部分抽取出来形成一个对象。这个对象就可以避免到修改的问题。 享元的目的是为了减少不会要额内存消耗，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗。 二、示例 下面我们来看一个简单的例子： 建筑接口：JianZhu public interface Jianzhu { void use(); } 体育馆实现类：TiYuGuan public class TiYuGuan implements Jianzhu { private String name; private String shape; private String yundong; public TiYuGuan(String yundong){ this.setYundong(yundong); } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getShape() { return shape; } public void setShape(String shape) { this.shape = shape; } public String getYundong() { return yundong; } public void setYundong(String yundong) { this.yundong = yundong; } @Override public void use() { System.out.println("该体育馆被使用来召开奥运会" + " 运动为："+ yundong+" 形状为："+shape+ " 名称为："+name); } } 建筑工厂类：JianZhuFactory import java.util.*; public class JianZhuFactory { private static final Map<String,TiYuGuan> tygs = new HashMap<String,TiYuGuan>(); public static TiYuGuan getTyg(String yundong){ TiYuGuan tyg = tygs.get(yundong); if(tyg == null){ tyg = new TiYuGuan(yundong); tygs.put(yundong,tyg); } return tyg; } public static int getSize(){ return tygs.size(); } } 测试类：Clienter public class Clienter { public static void main(String[] args) { String yundong ="足球"; for(int i = 1;i <= 5;i++){ TiYuGuan tyg = JianZhuFactory.getTyg(yundong); tyg.setName("中国体育馆"); tyg.setShape("圆形"); tyg.use(); System.out.println("对象池中对象数量为："+JianZhuFactory.getSize()); } } } 执行结果： 该体育馆被使用来召开奥运会 运动为：足球 形状为：圆形 名称为：中国体育馆 对象池中对象数量为：1 该体育馆被使用来召开奥运会 运动为：足球 形状为：圆形 名称为：中国体育馆 对象池中对象数量为：1 该体育馆被使用来召开奥运会 运动为：足球 形状为：圆形 名称为：中国体育馆 对象池中对象数量为：1 该体育馆被使用来召开奥运会 运动为：足球 形状为：圆形 名称为：中国体育馆 对象池中对象数量为：1 该体育馆被使用来召开奥运会 运动为：足球 形状为：圆形 名称为：中国体育馆 对象池中对象数量为：1 三、模式解析 如上示例中，使用工厂模式进行配合，创建对象池，测试类中的循环，你可以想象成为要举行5场比赛，每场比赛的场地就是体育馆 通过执行结果可以看出，在这个对象池（HashMap）中，一直都只有一个对象存在，第一次使用的时候创建对象，之后的每次调用都用的是那个对象，不会再重新创建。 其实在Java中就存在这种类型的实例：String。 Java中将String类定义为final（不可改变的），JVM中字符串一般保存在字符串常量池中，这个字符串常量池在jdk 6.0以前是位于常量池中，位于永久代，而在JDK 7.0中，JVM将其从永久代拿出来放置于堆中。 我们使用如下代码定义的两个字符串指向的其实是同一个字符串常量池中的字符串值。 String s1 = "abc"; String s2 = "abc"; 如果我们以s1==s2进行比较的话所得结果为：true，因为s1和s2保存的是字符串常量池中的同一个字符串地址。这就类似于我们今天所讲述的享元模式，字符串一旦定义之后就可以被共享使用，因为他们是不可改变的，同时被多处调用也不会存在任何隐患。 四、使用场景 当我们项目中创建很多对象，而且这些对象存在许多相同模块，这时，我们可以将这些相同的模块提取出来采用享元模式生成单一对象，再使用这个对象与之前的诸多对象进行配合使用，这样无疑会节省很多空间。
2019-11-04
优秀的个人博客,低调大师

Java结构型模式（1）享元模式

2019年阿里云双11活动拼团：https://www.aliyun.com/1111/2019/group-buying-share 一、概述 享元模式：“享”就是分享之意，指一物被众人共享，而这也正是该模式的终旨所在。 享元模式有点类似于单例模式，都是只生成一个对象来被共享使用。这里有个问题，那就是对共享对象的修改，为了避免出现这种情况，我们将这些对象的公共部分，或者说是不变化的部分抽取出来形成一个对象。这个对象就可以避免到修改的问题。 享元的目的是为了减少不会要额内存消耗，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗。 二、示例 下面我们来看一个简单的例子： 建筑接口：JianZhu public interface Jianzhu { void use(); } 体育馆实现类：TiYuGuan public class TiYuGuan implements Jianzhu { private String name; private String shape; private String yundong; public TiYuGuan(String yundong){ this.setYundong(yundong); } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getShape() { return shape; } public void setShape(String shape) { this.shape = shape; } public String getYundong() { return yundong; } public void setYundong(String yundong) { this.yundong = yundong; } @Override public void use() { System.out.println("该体育馆被使用来召开奥运会" + " 运动为："+ yundong+" 形状为："+shape+ " 名称为："+name); } } 建筑工厂类：JianZhuFactory import java.util.*; public class JianZhuFactory { private static final Map<String,TiYuGuan> tygs = new HashMap<String,TiYuGuan>(); public static TiYuGuan getTyg(String yundong){ TiYuGuan tyg = tygs.get(yundong); if(tyg == null){ tyg = new TiYuGuan(yundong); tygs.put(yundong,tyg); } return tyg; } public static int getSize(){ return tygs.size(); } } 测试类：Clienter public class Clienter { public static void main(String[] args) { String yundong ="足球"; for(int i = 1;i <= 5;i++){ TiYuGuan tyg = JianZhuFactory.getTyg(yundong); tyg.setName("中国体育馆"); tyg.setShape("圆形"); tyg.use(); System.out.println("对象池中对象数量为："+JianZhuFactory.getSize()); } } } 执行结果： 该体育馆被使用来召开奥运会 运动为：足球 形状为：圆形 名称为：中国体育馆 对象池中对象数量为：1 该体育馆被使用来召开奥运会 运动为：足球 形状为：圆形 名称为：中国体育馆 对象池中对象数量为：1 该体育馆被使用来召开奥运会 运动为：足球 形状为：圆形 名称为：中国体育馆 对象池中对象数量为：1 该体育馆被使用来召开奥运会 运动为：足球 形状为：圆形 名称为：中国体育馆 对象池中对象数量为：1 该体育馆被使用来召开奥运会 运动为：足球 形状为：圆形 名称为：中国体育馆 对象池中对象数量为：1 三、模式解析 如上示例中，使用工厂模式进行配合，创建对象池，测试类中的循环，你可以想象成为要举行5场比赛，每场比赛的场地就是体育馆 通过执行结果可以看出，在这个对象池（HashMap）中，一直都只有一个对象存在，第一次使用的时候创建对象，之后的每次调用都用的是那个对象，不会再重新创建。 其实在Java中就存在这种类型的实例：String。 Java中将String类定义为final（不可改变的），JVM中字符串一般保存在字符串常量池中，这个字符串常量池在jdk 6.0以前是位于常量池中，位于永久代，而在JDK 7.0中，JVM将其从永久代拿出来放置于堆中。 我们使用如下代码定义的两个字符串指向的其实是同一个字符串常量池中的字符串值。 String s1 = "abc"; String s2 = "abc"; 如果我们以s1==s2进行比较的话所得结果为：true，因为s1和s2保存的是字符串常量池中的同一个字符串地址。这就类似于我们今天所讲述的享元模式，字符串一旦定义之后就可以被共享使用，因为他们是不可改变的，同时被多处调用也不会存在任何隐患。 四、使用场景 当我们项目中创建很多对象，而且这些对象存在许多相同模块，这时，我们可以将这些相同的模块提取出来采用享元模式生成单一对象，再使用这个对象与之前的诸多对象进行配合使用，这样无疑会节省很多空间。
2019-11-03
优秀的个人博客,低调大师

java设计模式之外观模式（门面模式）(结构型模式)

针对外观模式，在项目开发和实际运用中十分频繁，但是其极易理解，下面就简要介绍一下。 一、概念介绍 外观模式（Facade）,他隐藏了系统的复杂性，并向客户端提供了一个可以访问系统的接口。这种类型的设计模式属于结构性模式。为子系统中的一组接口提供了一个统一的访问接口，这个接口使得子系统更容易被访问或者使用。 二、角色及使用场景 简单来说，该模式就是把一些复杂的流程封装成一个接口供给外部用户更简单的使用。这个模式中，设计到3个角色。 1）.门面角色：外观模式的核心。它被客户角色调用，它熟悉子系统的功能。内部根据客户角色的需求预定了几种功能的组合。 2）.子系统角色:实现了子系统的功能。它对客户角色和Facade时未知的。它内部可以有系统内的相互交互，也可以由供外界调用的接口。 3）.客户角色:通过调用Facede来完成要实现的功能。 使用场景： 1- 为复杂的模块或子系统提供外界访问的模块； 2- 子系统相互独立； 3- 在层析结构中，可以使用外观模式定义系统的每一层的入口。 三、实例 下面，我们就通过一个简单的例子来实现该模式。 每个Computer都有CPU、Memory、Disk。在Computer开启和关闭的时候，相应的部件也会开启和关闭，所以，使用了该外观模式后，会使用户和部件之间解耦。如： 包体的创建： 代码实现 首先是子系统类： 【代码清单--1】 1 package com.huawei.facadeDesign.children; 2 3 import org.apache.log4j.Logger; 4 5 /** 6 * cpu子系统类 7 * @author Administrator 8 * 9 */ 10 public class CPU 11 { 12 public static final Logger LOGGER = Logger.getLogger(CPU.class); 13 public void start() 14 { 15 LOGGER.info("cpu is start..."); 16 } 17 18 public void shutDown() 19 { 20 LOGGER.info("CPU is shutDown..."); 21 } 22 } 【代码清单--2】 1 package com.huawei.facadeDesign.children; 2 3 import org.apache.log4j.Logger; 4 5 /** 6 * Disk子系统类 7 * @author Administrator 8 * 9 */ 10 public class Disk 11 { 12 public static final Logger LOGGER = Logger.getLogger(Disk.class); 13 public void start() 14 { 15 LOGGER.info("Disk is start..."); 16 } 17 18 public void shutDown() 19 { 20 LOGGER.info("Disk is shutDown..."); 21 } 22 } 【代码清单--3】 1 package com.huawei.facadeDesign.children; 2 3 import org.apache.log4j.Logger; 4 5 /** 6 * Memory子系统类 7 * @author Administrator 8 * 9 */ 10 public class Memory 11 { 12 public static final Logger LOGGER = Logger.getLogger(Memory.class); 13 public void start() 14 { 15 LOGGER.info("Memory is start..."); 16 } 17 18 public void shutDown() 19 { 20 LOGGER.info("Memory is shutDown..."); 21 } 22 } 然后是，门面类Facade 【代码清单--4】 1 package com.huawei.facadeDesign.facade; 2 3 import org.apache.log4j.Logger; 4 5 import com.huawei.facadeDesign.children.CPU; 6 import com.huawei.facadeDesign.children.Disk; 7 import com.huawei.facadeDesign.children.Memory; 8 9 10 /** 11 * 门面类（核心） 12 * @author Administrator 13 * 14 */ 15 public class Computer 16 { 17 public static final Logger LOGGER = Logger.getLogger(Computer.class); 18 19 private CPU cpu; 20 private Memory memory; 21 private Disk disk; 22 public Computer() 23 { 24 cpu = new CPU(); 25 memory = new Memory(); 26 disk = new Disk(); 27 } 28 public void start() 29 { 30 LOGGER.info("Computer start begin"); 31 cpu.start(); 32 disk.start(); 33 memory.start(); 34 LOGGER.info("Computer start end"); 35 } 36 37 public void shutDown() 38 { 39 LOGGER.info("Computer shutDown begin"); 40 cpu.shutDown(); 41 disk.shutDown(); 42 memory.shutDown(); 43 LOGGER.info("Computer shutDown end..."); 44 } 45 } 最后为，客户角色。 【代码清单--5】 1 package com.huawei.facadeDesign; 2 3 import org.apache.log4j.Logger; 4 5 import com.huawei.facadeDesign.facade.Computer; 6 7 /** 8 * 客户端类 9 * @author Administrator 10 * 11 */ 12 public class Cilent { 13 public static final Logger LOGGER = Logger.getLogger(Cilent.class); 14 public static void main(String[] args) 15 { 16 Computer computer = new Computer(); 17 computer.start(); 18 LOGGER.info("================="); 19 computer.shutDown(); 20 } 21 22 } 【代码清单--6】运行结果 从上面的实例来看，有了这个Facade类，也就是Computer类，用户就不用亲自去调用子系统中的Disk,Memory、CPU类了，不需要知道系统内部的实现细节，甚至都不用知道系统内部的构成。客户端只需要跟Facade交互就可以了。 四、优点 - 松散耦合 使得客户端和子系统之间解耦，让子系统内部的模块功能更容易扩展和维护； - 简单易用 客户端根本不需要知道子系统内部的实现，或者根本不需要知道子系统内部的构成，它只需要跟Facade类交互即可。 - 更好的划分访问层次 有些方法是对系统外的，有些方法是系统内部相互交互的使用的。子系统把那些暴露给外部的功能集中到门面中，这样就可以实现客户端的使用，很好的隐藏了子系统内部的细节。 五、延伸及应用（补充） ...
2019-11-03

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2026-04-11 大小: 211.28KB 下载: 56次
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2026-08-21 大小: 1MB 下载: 10次
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2026-08-21 大小: 5MB 下载: 2次
Rocky Linux

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2026-08-21 大小: 1.42GB 下载: 6次
热门标签
DeepSeek Jdk25 OpenAi HarmonyOS6 Nacos3 SpringBoot4 SpringCloud Docker Kubernetes Service Mesh Redis Gemini3 Rocky

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册