精华内容
下载资源
问答
  • 这种星形耦合器不但能提供巨大的端口数,而且由其构成的波分复用(WDM)星网具有极大的组网灵活,能方便地实现网络的在线扩容、升级,满足未来超大规模双向波分复用网络系统的需求,同时也适用于目前广泛应用的单向...
  • 我们研究共形耦合到洛伦兹弯曲的背景时空的N $$ \ mathcal {N} $$ = 6超共的Chern-Simons物质场理论(ABJM理论)。 为了支持刚性超对称,此类背景必须允许扭转旋子。 在古典水平上,该理论的对称可以用共...
  • 提出了一种基于圆形Kong耦合贴片的双频带频率选择表面(FSS)。 该技术基于使用两个具有不同大小的相同结构。 提出了一种特殊的拓扑结构来排列两个不同大小的结构。 每个结构由两个圆形贴片和一个圆形耦合Kong组成...
  • 平面空间上的电磁极限理论的整体对称包括无限维的伽利略共代数和U(1)电流代数的任何维度。 对于壳上GED理论,这种对称降低了,但维数仍然是无限的,而壳外仅保留了Galilei代数加上两个扩张。 因此,一个人...
  • 我们在所有维度上证明了共形耦合标量场方程在(壳外)Kerr-Newman-Unti-Tamburino-anti-de Sitter时空的可分。 可分离的内在特征是存在一套完整的相互换向的保波算子,它们可以根据主要的Killing-Yano张量的...
  • 具有耦合谐振器引起的透明的θ超细纤维谐振器中的可控群延迟
  • 煤层开采初始阶段岩体渗透增加区域在底板呈"W"分布,在顶板岩体渗透增加区域呈"M"分布;当含水层渗透增加区与下方顶板渗透增加区相交时,形成导水裂隙;在渗透增加区内岩体形成了相对"膨胀区",而在渗透...
  • 将一个短的D光纤短截线平行放置,并与包含弱倾斜布拉格光栅(TFBG)的另一根标准圆形光纤紧密接触。 TFBG将来自圆形光纤纤芯的光耦合到其包层中,并在那里保持导引。除了通过接触界面进行直接光耦合之外,通过引导...
  • 采用基于边界构的内缩法,实现了三维畸变网格的重新划分;...在此基础之上,开发了面向叶片精锻过程的三维刚粘塑热力耦合有限元模拟分析系统(3D-CTM).系统的可靠得到了圆柱体镦粗的验证.对
  • 作为在[1]中给出的N = 1超重中广义Fayet-Iliopoulos项的最新构造的扩展,我们提出了与多重共形耦合到共超重的向量的自相互作用。 它们用于为自发破坏的局部超对称构造新模型。
  • 还通过抗原-抗体相互作用实验来验证表面结合React的敏感。 在我们的实验中,检测到的AFP(甲胎蛋白)浓度的灵敏度已达到接近临床浓度的25 ng / ml。 GENA生物传感器芯片在无标签化学和生物医学领域,尤其是癌症...
  • 在任意拉格朗日-欧拉描述下,结合索膜结构的风振响应特点,采用流固耦合问题数值计算方法,实现了三维情况下索膜结构风场的数值模拟。结果表明:耦合作用对风压的分布形式影响不明显。在迎风面出现负压区,边缘附近风压较...
  • 最近有人争辩说,平坦时空的共不变暗示了单一理论在一般... 此外,我们明确表明,当a场理论以Weyl不变的方式耦合到重力时,each场理论中相关的或边际的每个主标量算子在弯曲背景下都对应Weyl协变算子。
  • 对于一连串的SYK模型,当它们均匀地耦合到热浴时,我们表明蝶速度显示出从较高温度下的T $$ \ sqrt {T} $$-依赖到线性T依赖的交叉 在低温下,交叉温度也受与热浴的耦合强度控制。 如果仅将SYK链的末端耦合到...
  • 在动力学系统中描述了具有均匀弗雷德曼-罗伯逊-沃克对称的宇宙演化过程,该对称充满了正压尘埃物质和具有恒势函数的非最小耦合标量场,使用de Sitter状态的不变流形来获得降维的精确解。 动力学。 利用来自遥远...
  • 我们考虑在重力的弱耦合理论中对引力子三点耦合进行更高的导数校正。 洛伦兹不变允许爱因斯坦理论中存在的结构以外的其他结构。 我们认为这些受因果关系的约束。 我们设计了一个思维实验,涉及一个高能散射过程,...
  • 在本文中,我们显示了有色SYK模型及其张量模型的表亲,即在大N展开中次要的阶在强耦合状态下保留了两点函数的共不变。 由于对称的显着破坏而导致伪金石玻色子的贡献,这已经在前导四点函数中看到了。 我们还...
  • 这是通过共非最小耦合实现的,它在五个维度上破坏了量规的对称。 我们通过考虑共不变的扭转进一步考虑模型的一般化。 通过将扭力非最小耦合到费米子,我们获得了两个手性的局部零模,从而完成了模型的一致...
  • 提出一种修正方法,即根据耦合模理论,拓展光纤耦合器传输矩阵的定义,通过实验测量确定其值,进一步计算得到反映光纤耦合器传输光谱特性的窗函数,用于FFTS的光谱修正。采用此修正方法不但拓宽了FFTS的工作带宽,提高了...
  • 耦合器设计 微带耦合器 微带耦合耦合器couplers(有时又叫混合环Hybrids)是微波电路中常用的无源器件,它们一般有四个端口,且每一端口为匹配负载端接条件,也就是说在给定频率范围内,端口的反射系数是很小的。...

    耦合器设计 微带耦合器 微带耦合器 耦合器couplers(有时又叫混合环Hybrids)是微波电路中常用的无源器件,它们一般有四个端口,且每一端口为匹配负载端接条件,也就是说在给定频率范围内,端口的反射系数是很小的。 耦合器参数定义 耦合器是四端口网络,四个端口是输入端口、直通端口、耦合端口与隔离端口。设P1是馈入端口1的功率,P2、P3、P4分别在端口2、3、4可得到的功率,描述该端口的网络参数主要有: 耦合系数(dB) 方向性(dB) 隔离度(dB) 通过率(dB) 各个端口的反射系数s11、s22、s33、s44 (dB) 微带分支电桥的工作原理 环形分支电桥原理 对于3dB耦合器,并联臂和串联臂的阻抗分别为Zp=Z0、 Zr=Z0/ ,Z0是输入端和输出端特征阻抗。所以串联臂微带线导带宽度更宽,如图5-47a。微带双分支定向耦合器也可做成圆形结构,叫做环形分支电桥,如图5-47b。从1臂的输入功率平分到2、3臂,它们到4臂路径相差半个波长即?/2,相位相反,故4臂没有输出,为隔离臂。从1臂到2臂、3臂的功率相等,但路径相差?/4,因而有90?相位差。方形分支电桥、环形分支电桥,在混频器电路中应用甚广。 图5-47 (a)方形分支电桥; (b)圆形分支电桥 平行耦合线耦合器 平行耦合线耦合器(见图5-48)具有两种对称性:1、对称面上电流=0,电压最大,相当于开路,称为偶对称;2、另一种分布,对称面上电压=0,电流最大,相当于短路,称为奇对称。耦合线上任何场分布都可看成奇模与偶模场分布的组合。基于奇、偶模分析可得到耦合线结构3dB定向耦合器的设计方程,如下。 平行耦合线耦合器 对于准TEM模,输入匹配条件为 以及 耦合器的耦合系数及方向性都是频率的函数 式中 下标e、o表示属于偶模even和奇模odd的量。 ?e、?o是偶模和奇模的传播常数。 当方向性达到最佳。因此从方向性考虑,希望奇模与偶模具有相同的相速。为此在耦合两端并联电容C1、C2,并联电容对偶模不起作用,对奇模相移有影响,其增加的相移??o为 式中f0是耦合器中心频率。 平面结构的螺旋耦合器、折叠线型耦合器 耦合器结构型式众多,如平面结构的螺旋耦合器和折叠线型耦合器。 (a)(b) 图5-50 (a)螺旋耦合器;(b)折叠线型耦合器 3dB交叉指lange耦合器 图5-44(d)所示3dB交叉指lange耦合器。端口1输入,端口2和3输出功率相等,但有90?相移,其特点是频带宽,设计公式为 C是电压耦合系数,R为阻抗比,Z为归一化奇模阻抗,R、Z与耦合系数C关系见图5-49,N为导体数,一般为4,Z0e、Z0o表示偶模、奇模阻抗,Z0为端口阻抗,当N=2, ,当N?2时,这个关系不成立。 交叉指耦合器的耦合段有两个短指和长指,短指长度取工作频段内最高频率的?gh/4,而长指应为最低工作频率的?gL/4。连接相应耦合指的跳线为几十?m直径的金丝或铝丝,叉指尺寸W、S由要求奇、偶模阻抗决定。 波导结构耦合器---魔T * 图5-44 微波混合环与耦合器 (a)分支线混合环; (b)集总参数分支混合环; (c)平行耦合定向耦合器; (d)3dB lange耦合器 图5-45 A B D C ?/4 y01=1 y02=1/R ?/4 y0 = b y0 = b y0 = a1 y0 = a2 y04=1 y03=1/R 对称 平面 (1) (2) (4) (3) (a) ?/4 ?/8 ?/8 1 b 1/R a1 a2 A B (d) ?/4 ?/8 ?/8 1 b 1/R a1 a2 A B (e) (b) 开路 (c) 短路 图2-46 微带双分支定向耦合器 图5-48 集中电容补偿微带耦合器 图5-48 集中电容补偿微带耦合器 *

    展开全文
  • 我们开发了可积技术来计算这些图的分歧部分,并使用它来将维数的弱耦合展开表示为非常高的阶数。 然后,我们应用精确的方程式来计算J = 3时的异常尺寸,从而在任何耦合情况下几乎不受限制。 这些方程式还描述了一...
  • 我们探索了这样一种想法,即物质与时空之间的耦合比爱因斯坦最初设想的更为复杂。 我们建议这种耦合在爱因斯坦场方程中... 作为示例,我们表明,在共引力的情况下,广义耦合能够解决物质与引力部分之间的相容问题。
  • 我们探索了5D共不变重力中自发对称破裂的可能,其作用包括一个标量场,该标量场与曲率及其势能最小耦合。 通过ADM分解执行尺寸缩减,我们发现该模型允许产生4D Minkowski真空的精确解。 利用高斯翘曲因子利用共...
  • 耦合度越低越好吗?

    千次阅读 2019-05-21 08:49:18
    他的想法同如下代码: XXBusiness{ public List select(){ XXDao mXXDao = new XXDao (); return mXXDao .select(); } } 这么看看好像是降低了XXBusiness和XXDao的耦合度!但耦合度真的越低越好吗? 这...

    先说说3层架构,一般数据层,业务层,表示成。
    一般针对某一机能,一般分3个类,XXView,XXBusiness,XXDao。
    通常的情况下,XXBusiness和XXDao是组合关系,即XXBusiness有一个XXDao的对象。
    一般情形如下
    XXBusiness{
    private XXDao mXXDao ;
    public XXBusiness(){
    XXDao = new XXDao ();
    }
    public List select(){
    return mXXDao .select();
    }
    }
    今天突然有人问我。XXBusiness内部不保存mXXDao ,每次都用的时候就new行不?
    这个问题,说实话,我还真没考虑过,还真没有这么用过。
    他的想法形同如下代码:
    XXBusiness{
    public List select(){
    XXDao mXXDao = new XXDao ();
    return mXXDao .select();
    }
    }
    这么看看好像是降低了XXBusiness和XXDao的耦合度!但耦合度真的越低越好吗?
    这个耦合度适合这个业务需求吗?
    这里明显是把组合的关系变成了依赖的关系。耦合度视乎降低了。
    但是真实业务的耦合度,实际没有变化。
    我这里先下一个结论。耦合度并不是越低越好,而是适合需求。
    通常情况下XXDao就是为XXBusiness提供数据服务的。
    这里是事实上的紧密关系,强行的降低关系实际上是破坏了他俩的正常关系。
    就比如社会中的关系,父亲和儿子的关系就应该是亲密,就应该住在一起的。
    这时候你就让他俩分开住,这是不合适的。
    在社会而样,有父子这样的亲密关系,反而使社会变得简单,如果强行的降低父子关系,反而会使社会的复杂度增加。
    这里也是同样的到来,耦合度是适当,而不是降得越来越低。
    对于设计,耦合应该是尽量减少,联系,和依赖的关系,而不是消除组合和聚合的关系,组合和聚合,通常会形成新的内聚团体,都整体架构不会增加复杂度。

    关于上面的问题,我首先从耦合度的角度发表了我自己的看法。
    下面在从性能的角度做一下分析。
    这是首要的问题,就是成员对象的价值。
    如果在一个对象的生命周期中,只用一次当然几乎没有必要定义一个成员。
    但是如果用多次呢,多多少次呢,从性能的角度我们就要考虑是否用一个成员对象了。
    从性能的角度讲,超过两次,我们就可以设置一个成员对象了。
    这里的两次通常有可以有两种选择,时间维度和空间维度。
    时间维度指,一个函数会再对象的生命周期内被多次调用,这个函数依赖的对象会多次创建和销毁。
    空间维度,在一个对象内的函数中会多处依赖另一个对象。
    空间维度通常是要考虑一个代码容易的问题,因为两处使用了相同且冗余的代码,通常是要把这两个函数用到的共同的其他对象变成成员对象的。

    当然基于性能的考虑往往需要有一个设计中对性能要求的基调,
    因为设计的过程中会面临很多设计和性能的选择。
    关于这个问题,就说这些了。
    在有想法在补。

    其实这里的两次或两处调用其他对象的方式,其实是由很多选择的
    1.静态单实例其他对象
    class A{
    static A mA = new A();
    static A getA(){
    return mA;
    }
    public fun();
    }
    class B{
    public fun(){
    A. getA().fun();
    }
    }
    2.静态其他函数
    class A{
    static public fun();
    }
    class B{
    public fun(){
    A.fun();
    }
    }
    3.本对象内其他对象单实例
    class A{
    static A mA = new A();
    static A getA(){
    return mA;
    }
    public fun();
    }
    class B{
    A mA=null ;
    A getA(){
    if(null == mA){
    mA = new A();
    }
    return mA;
    }
    public fun(){
    getA().fun();
    }
    }
    这3种方案其实都是等同于B持有A成员变量的设计。但是针对性能做了些选择。
    1.静态单实例其他对象
    这种方案,是保证对象只创建一次,是空间换时间的性能设计,因为有一个对象常驻空间。
    2.静态其他函数
    这也是空间换时间,一个对象本身就放在了静态区。
    3.本对象内其他对象单实例
    哦,这也是空间换时间,3个种方式都是空间换时间的做法。
    差别在于,空间的生命周期略有不同
    2.静态其他函数>1.静态单实例其他对象>3.本对象内其他对象单实例
    在从空间生命周期尽量小的角度考虑,3的解决方案是相对更合理。
    针对最初的问题:XXBusiness内是否要保存XXDao 的成员对象?用方案3与其做一下对比吧。
    为了对比给这个方案起个名:降耦合方案
    XXBusiness{
    public List select(){
    XXDao mXXDao = new XXDao ();
    return mXXDao .select();
    }
    }
    假设XXBusiness超过一次使用XXDao。

    降耦合方案 :因为多次创建对象,消除对象,时间复杂度增加。
    本对象内其他对象单实例:时间复杂度,降低,但XXDao常驻内存的时间较长。
    个人观点:选择方案3,与普通成员对象比,XXDao的创建时间延长了,但是不在重复创建对象,节省了时间效率。如果空间不紧张的情况下,无疑用这个方案是没有任何坏处的,唯一的坏处,XXDao占用内存是时间有点常,但是也会随着XXBusiness的结束而结束,并不会常驻内存。

    展开全文
  • 耦合与解耦

    2020-03-24 23:23:32
    程序耦合与解耦合 耦合 分类 (1) 内容耦合 (2) 公共耦合 (3) 外部耦合 (4) 控制耦合 (5) 标记耦合 (6) 数据耦合 (7) 非直接耦合 解耦 思路 实例 耦合 耦合性(Coupling),也叫耦合度,是对模块间关联...

    耦合

    耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。
    耦合的强弱取决于模块间接口的复杂性、调 用模块的方式以及通过界面传送数据的多少。
    模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系、数据传递关系。
    模块间联系越多,其耦合性越强,同时表明其独立性越差( 降低耦合性,可以提高其独立 性)。
    在软件工程中,耦合指的就是就是对象之间的依赖性。对象之间的耦合越高,维护成本越高。因此对象的设计应使类和构件之间的耦合最小。
    软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个 准则就是高内聚低耦合。

    分类

    (1) 内容耦合

    当一个模块直接修改或操作另一个模块的数据时,或一个模块不通过正常入口而转入另 一个模块时,这样的耦合被称为内容耦合。内容耦合是最高程度的耦合,应该避免使用之。

    (2) 公共耦合

    两个或两个以上的模块共同引用一个全局数据项,这种耦合被称为公共耦合。在具有大 量公共耦合的结构中,确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。

    (3) 外部耦合

    一组模块都访问同一全局简单变量而不是同一全局数据结构,而且不是通过参数表传 递该全局变量的信息,则称之为外部耦合。

    (4) 控制耦合

    一个模块通过接口向另一个模块传递一个控制信号,接受信号的模块根据信号值而进 行适当的动作,这种耦合被称为控制耦合。

    (5) 标记耦合

    若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数,那么称模块 B 和 C 之间 存在一个标记耦合。

    (6) 数据耦合

    模块之间通过参数来传递数据,那么被称为数据耦合。数据耦合是最低的一种耦合形 式,系统中一般都存在这种类型的耦合,因为为了完成一些有意义的功能,往往需要将某些模块的输出数据作为另
    一些模块的输入数据。

    (7) 非直接耦合

    两个模块之间没有直接关系,它们之间的联系完全是通过主模块的控制和调用来实 现的。

    解耦

    降低程序之间的依赖

    思路

    1)第一步
    使用反射来创建对象,而避免使用new关键字
    2)第二步
    通过读取配置文件来获取要创建的对象全限定类名

    实例

    使用工厂模式进行解耦

    展开全文
  • 继承的耦合性更大,比如一个父类后来添加实现一个接口或者去掉一个接口,那子类可能会遭到毁灭的编译错误,但如果只是组合聚合,只是引用类的方法,就不会有这种巨大的风险,同时也实现了复用。 三、创建型模式 ( ...

    目录

    一、概述

    二、7个设计原则

    1、单一职责原则 ( SRP )

    2、开闭原则 ( OCP )

    3、里氏替换原则 ( LSP )

    4、依赖倒置原则 ( DIP )

    5、接口隔离原则 ( ISP )

    6、最少知道原则(迪米特原则)

    7、合成/聚合复用(CARP)

    三、创建型模式 ( 5种 )

    1.单例模式

    2.工厂方法模式

    3.抽象工厂模式

    4.建造者模式

    5.原型模式

    四、结构型模式(7种)

    1.适配器模式

    2.桥接模式

    3.装饰模式

    4.组合模式

    5.外观模式

    6.享元模式

    7.代理模式

    五、行为型模式 ( 11种 )

    1.模板方法模式

    2.命令模式

    3.迭代器模式

    4.观察者模式

    5.中介者模式

    6.备忘录模式

    7.解释器模式

    8.状态模式

    9.策略模式

    10.责任链模式

    11.访问者模式

    前言

    编程思想中,入门心法就是面向对象思想,而最高心法就是设计模式思想。如果你能够参悟明白设计模式,并且能熟练掌握灵活运用它们,那你读各种库源码的时候会忽然发现并不难懂了。设计模式追求的目的就是“高内聚、低耦合”,在实际编程中运用设计模式能够使我们工程代码更规范、重用性更高,同时也能保证代码的可靠性、提高开发效率。

    一、概述

    面向对象编程有七大原则,即经常提到的设计模式(Design Pattern),提倡它的根本原因是为了代码复用,增加可维护性。设计模式就是实现了这些原则,从而达到了代码复用、增加可维护性的目的。

    设计模式是继面向对象思想提升的更高级编程思想,分为三类 :创建型、结构型、行为型  。常用的有如下:1、创建型是为了隐藏类的创建,不再直接 new 对象实例。例如,单例模式、工厂模式、建造者模式。2、结构型是为了隐藏调用对象的方法,不再直接访问对象实例。例如,代理模式、适配器模式、装饰者模式。3、行为型是为了优化对象与对象之间一对多调用关系。例如,观察者模式、中介者模式、访问者模式。

    二、7个设计原则

    1、单一职责原则 ( SRP )

    SRP(Single Responsibility Principle),表示,定义是一个类应该只有一个引起它变化的原因。类变化的原因就是职责,如果一个类承担的职责过多,就等于把这些职责耦合在一起了。一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计,当发生变化时,设计会遭受到意想不到的破坏。而如果想要避免这种现象的发生,就要尽可能的遵守单一职责原则。此原则的核心就是解耦和增强内聚性。

    2、开闭原则 ( OCP )

    OCP(Open Close Principle),定义是软件实体(包括类、模块、函数等)应该对于扩展时开放的,对于修改是封闭的。开闭原则是是面向对象设计中最重要的原则之一,其它很多的设计原则都是实现开闭原则的一种手段。

    3、里氏替换原则 ( LSP )

    LSP(Liskov Substitution Principle) ,是面向对象设计的基本原则之一。 定义是任何基类可以出现的地方,子类一定可以出现。LSP 是继承复用的基石,只有当派生类可以替换掉基类,且软件单位的功能不受到影响时,基类才能真正被复用,而派生类也能够在基类的基础上增加新的行为。里氏替换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化,而基类与子类的继承关系就是抽象化的具体实现,所以里氏替换原则是对实现抽象化的具体步骤的规范。

    4、依赖倒置原则 ( DIP )

    DIP (Dependence Inversion Principle) ,这个原则是开闭原则的基础,依赖倒置原则就是要求调用者和被调用者都依赖抽象,这样两者没有直接的关联和接触,在变动的时候,一方的变动不会影响另一方的变动。依赖倒置强调了抽象的重要性,针对接口编程,依赖于抽象而不依赖于具体。

    5、接口隔离原则 ( ISP )

    ISP(Interface Segregation Principle) ,这个原则的意思是使用多个隔离的接口,比使用单个接口要好。目的就是降低类之间的耦合度,便于软件升级和维护。

    6、最少知道原则(迪米特原则)

    一个实体应当尽量少地与其他实体之间发生相互作用,使得系统功能模块相对独立。通俗地说就是不要和陌生人说话,即一个对象应对其他对象有尽可能少的了解。迪米特法则的初衷在于降低类之间的耦合。由于每个类尽量减少对其他类的依赖,因此,很容易使得系统的功能模块功能独立,相互之间不存在(或很少有)依赖关系。

    7、合成/聚合复用(CARP)

    CARP(Composite Reuse Principle) ,合成/聚合复用原则经常又叫做合成复用原则。合成/聚合复用原则的潜台词是:我只是用你的方法,我们不一定是同类。继承的耦合性更大,比如一个父类后来添加实现一个接口或者去掉一个接口,那子类可能会遭到毁灭性的编译错误,但如果只是组合聚合,只是引用类的方法,就不会有这种巨大的风险,同时也实现了复用。

    三、创建型模式 ( 5种 )

    创建型模式是指这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式,而不是使用新的运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

    1.单例模式

    定义

    确保某一个类只有一个实例,并自行实例化向整个系统提供这个实例。

    简介

    单例模式理解起来不难,典型例子有一个公司只能有一个CEO。它主要是为了保证一个类仅有一个实例,这个类中自己提供一个返回实例的方法,方法中先判断系统是否已经有这个单例,如果有则返回,如果没有则创建。如果创建多个实例会消耗过多的资源或者某种类型的对象只应该有且只有一个时,应该考虑使用单例模式。

    实现

    单例模式理解起来不难,重要的是需要掌握它的几种常见写法。

    1

    2 写法一、懒汉式写法3

    4 public classSingleton {5

    6 private staticSingleton instance;7

    8 //构造函数私有

    9 privateSingleton (){10 }11

    12 public static synchronizedSingleton getInstance() {13 if (instance == null) {14 instance = newSingleton();15 }16 returninstance;17 }18 }19

    20 写法二、DCL(Double Check Lock) 双重校验锁21

    22 public classSingleton {23

    24 private volatile staticSingleton singleton;25

    26 privateSingleton (){27 }28

    29 public staticSingleton getSingleton() {30

    31 if (singleton == null) {32 synchronized (Singleton.class) {33 if (singleton == null) {34 singleton = newSingleton();35 }36 }37 }38 returnsingleton;39 }40 }41

    42 写法三、静态内部类单例模式43

    44 public classSingleton {45

    46 privateSingleton (){47 }48

    49 public static finalSingleton getInstance() {50 returnSingletonHolder.INSTANCE;51 }52

    53 private static classSingletonHolder {54 private static final Singleton INSTANCE = newSingleton();55 }56 }

    View Code

    上面只列出了单例模式常见的三种写法,单例模式还有好几种别的写法,这里就不全部列出了。上面的第一种懒汉式写法做到了延迟创建和线程安全,缺点是每次调用getInstance()时都必须进行同步,效率不佳。第二种DCL方式比较常见,两次判空,第一次判空避免了不必要的同步,第二次保证了单例创建,这种方式比较不错,但是在高并发环境下有时会出现问题。第三种方法最被推荐,线程安全也保证了实例唯一。

    2.工厂方法模式

    定义

    定义一个用于创建对象的接口,让子类决定实例化哪一个类。

    举例

    工厂方法模式的典型例子,自行车分为山地自行车和公路自行车等,当需要买自行车时,我们直接去自行车厂里告诉厂长我们需要的自行车即可。

    例子

    1 1、定义一个接口自行车,Bike。2

    3 public interfaceBike{4 voidride();5 }6

    7 2、定义实现类山地自行车,MBike8

    9 public class MBike implementsBike{10 @Override11 public voiddraw() {12 System.out.println("MBike Rides... ");13 }14 }15

    16 3、定义实现类公路自行车,RBike17

    18 public class RBike implementsBike{19 @Override20 public voiddraw() {21 System.out.println("RBike Rides... ");22 }23 }24

    25 4、工厂类,负责创建对象26 public classBikeFactory {27 //使用 getShape 方法获取形状类型的对象

    28 publicBike getBike(String bikeType){29

    30 if(bikeType == null){31 return null;32 }33

    34 if(bikeType.equalsIgnoreCase("MBike")){35 return newMBike();36 }else if(shapeType.equalsIgnoreCase("RBike")){37 return newRBike();38 }39

    40 return null;41 }42 }43

    44 5、子类决定实例化哪一个类45

    46 public classFactoryPatternDemo {47 public static voidmain(String[] args) {48

    49 BikeFactory bikeFactory = newBikeFactory();50

    51 Bike bike1 = bikeFactory.getBike("MBike");52 bike1.ride();53

    54 Bike bike2= bikeFactory.getBike("RBike");55 bike2.ride();56 }57 }

    View Code

    3.抽象工厂模式

    定义

    提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

    简介

    抽象工厂模式主要解决接口选择的问题,典型例子是手机和电脑问题,假设抽象产品1是手机,具体产品是Android手机和iOS手机,抽象产品2是电脑,具体产品是Windows电脑和Mac电脑,抽象工厂是同时生产手机和电脑的公司,具体工厂是联想公司和苹果公司。

    抽象工厂的优点是当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。缺点是产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象工厂里加代码,又要在具体工厂里加代码。

    4.建造者模式

    定义

    将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。

    简介

    建造者模式主要解决在软件系统中一个复杂对象的创建工作。通常一个复杂对象是由各个部分的子对象用一定的算法构成,由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定。

    建造者模式的一个典型例子是Android中的AlertDialog的构建过程。还有个例子是计算机的组装,计算机是个复杂的对象,它是有很多零件组装而成,显示器、操作系统,鼠标等,通过创建Builder接口来控制零件的组装过程,这样当组件发生变化时,虽然经过同样的构建过程,但是最后得到的结果不同。

    5.原型模式

    定义

    用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。

    简介

    原型模式不难理解,它主要是用在实例创建的时候,因为有的时候我们通过new创建一个对象时可能成本过高,这时我们可以考虑直接通过直接克隆实例快速创建对象。克隆后的实例与原实例内部属性一致。原型模式需要注意一个深拷贝和浅拷贝的问题。

    四、结构型模式(7种)

    结构型模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。

    结构型模式

    1.适配器模式

    定义

    适配器模式使得原本由于对象接口不同而不能一起工作的那些类可以一起工作。

    简介

    适配器模式包括两种类型,类适配器模式和对象适配器模式。这里主要介绍对象适配器模式,因为它更灵活。查看更多

    例子

    1 //播放动作

    2 public interfaceMediaPlayer {3 public voidplay(String audioType, String fileName);4 }5

    6

    7 public classMp3Player{8 public voidplayMp3(String fileName) {9 //播放文件fileName

    10 }11

    12 }13

    14 public classMp4Player {15 public voidplayMp4(String fileName) {16 //播放文件fileName

    17 }18 }19

    20 //音频播放适配器

    21 public class MediaAdapter implementsMediaPlayer {22

    23 privateMp3Player mp324 privateMp4Player mp4;25 publicMediaAdapter(Mp4Player mp4, Mp3Player mp3){26 this.mp3 =mp3;27 this.mp4 =mp4;28 }29

    30 @Override31 public voidplay(String audioType, String fileName) {32

    33 if(audioType.equalsIgnoreCase("mp3")){34 mp3.playMp3(fileName);35 }else if(audioType.equalsIgnoreCase("mp4")){36 mp4.playMp4(fileName);37 }38 }39 }40

    41 //Main 方法入口

    42 public static voidmain(String[] args) {43 MediaAdapter adapter = new MediaAdapter(new Mp4Player() , newMp3Player());44

    45 adapter.play("mp3", "beyond.mp3");46 adapter.play("mp4", "alone.mp4");47 }

    View Code

    2.桥接模式

    定义

    将抽象部分与实现部分分离,使它们都可以独立的变化。

    -简介

    在软件系统中,某些类型由于自身的逻辑,它具有两个或多个维度的变化,那么如何应对这种“多维度的变化”?这就要使用桥接模式。桥接模式需要重点理解的抽象部分,实现部分,脱耦。一个典型的例子是咖啡加糖问题,抽象部分有Coffee,其下有LargeCoffee,SmallCoffee,实现部分是CoffeeAdd,其下有Sugar,Normal,抽象类Coffee中引用CoffeeAdd,这样CoffeeAdd其实就是一个桥接。

    3.装饰模式

    定义

    动态地给一个对象添加一些额外的职责。就增加功能来说,Decorator模式相比生成子类更为灵活。

    简介

    装饰模式是作为现有的类的一个包装,它允许向一个现有的对象添加新的功能,同时又不改变其结构。这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。装饰模式主要是装饰器类Decorator的设计,它对指定对象进行装饰。

    案例

    1 //形状 绘制 接口

    2 public interfaceShape {3 voiddraw();4 }5 //矩形 继承 绘制

    6 public class Rectangle implementsShape {7 @Override8 public voiddraw() {9 System.out.print("Rectangle");10 }11 }12 //圆形 继承 绘制

    13 public class Circle implementsShape {14 @Override15 public voiddraw() {16 System.out.print("Circle");17 }18 }19 //装饰者父类

    20 public abstract class ShapeDecorator implementsShape {21 //被装饰者

    22 protectedShape shape;23 publicShapeDecorator(Shape shape){24 this.shape =shape;25 }26

    27 public voidshapeDraw(){28 shape.draw();29 }30 }31 //装饰者子类 加 红色

    32 public class RedShapeDecorator extendsShapeDecorator {33 publicRedShapeDecorator(Shape shape) {34 super(shape);35 }36

    37 @Override38 public voiddraw() {39 super. shapeDraw(); //调用父方法

    40 setRedBorder(shape);//加红色

    41 }42

    43 private voidsetRedColor(Shape shape){44 System.out.println(" Add Color Red");45 }46 }47 //Main 方法

    48 public static voidmain(String[] args) {49

    50 Shape redCircle = new RedShapeDecorator(newCircle());51 Shape redRectangle = new RedShapeDecorator(newRectangle());52

    53 redCircle.draw();54 //打印结果: Circle Add Color Red

    55 redRectangle.draw();56 //打印结果: Rectangle Add Color Red

    57 }

    View Code

    4.组合模式

    定义

    将对象组合成树形结构以表示“部分-整体”的层次结构,使得用户对单个对象和组合对象的使用具有一致性。

    简介

    组合模式理解起来相对简单,典型的例子就是假设公司A,里面有不同的部门,不同的部分下有不同的员工,这样一个部门下的所有员工组合成了一个部门,所有部门组合成了整个公司。

    5.外观模式

    定义

    为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

    简介

    外观模式的一个典型例子是去医院看病,挂号、门诊、划价、取药,让患者或患者家属觉得很复杂,如果有提供接待人员,只让接待人员来处理,就很方便。

    6.享元模式

    定义

    运用共享技术有效地支持大量细粒度的对象。

    简介

    在有大量对象时,有可能会造成内存溢出,我们把其中共同的部分抽象出来,如果有相同的业务请求,直接返回在内存中已有的对象,避免重新创建。

    7.代理模式

    定义

    为其他对象提供一个代理类以控制对这个对象的访问。

    简介

    代理模式主要解决一个类在直接访问对象时带来的问题。例如,博物馆展示一张无价的古画,为了避免古画被游客破坏,故制作一张高仿的画进行展示,而且可以随意对假画?进行政治化修改,这样才能发挥文化的更大效果。

    例子

    1 //展示图片动作

    2 public interfaceImage {3 voiddisplay();4 }5

    6 //真画

    7 public class RealImage implementsImage {8

    9 privateString fileName;10

    11 publicRealImage(String fileName){12 this.fileName =fileName;13 }14

    15 @Override16 public voiddisplay() {17 //展示

    18 }19 }20

    21 //假画(代理类)

    22 public class ProxyImage implementsImage{23

    24 privateRealImage realImage;25 privateString fileName;26

    27 publicProxyImage(String fileName){28 this.fileName =fileName;29 }30

    31 @Override32 public voiddisplay() {33 if(realImage == null){34 realImage = newRealImage(fileName);35 }36 realImage.display();37 }38 }39

    40 //Main 方法入口

    41 public static voidmain(String[] args) {42 //创建假画实例

    43 Image image = new ProxyImage("test_10mb.jpg");44 image.display();45 }

    View Code

    五、行为型模式 ( 11种 )

    这些设计模式特别关注对象之间的通信。

    1.模板方法模式

    定义

    一个操作中的算法的框架,而将一些步骤延迟到子类中,使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

    例子

    模板方法模式一个典型例子就是Android中的异步任务类AsyncTask,它对异步任务的执行进行了流程封装,子类继承它时,只需在指定的流程中实现具体的操作即可。

    2.命令模式

    定义

    将一个请求封装为一个对象,从而可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可取消的操作

    简介

    命令模式主要是通过调用者调用接受者执行命令,这个模式中需要理解的是三个角色:(1) Receiver 真正的命令执行对象 (2) Command 持有一个对Receiver的引用,调用Receiver的相关方法。(3) Invoker 请求者,持有一个对Command的引用,调用Command的方法执行具体命令。

    3.迭代器模式

    定义

    提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。

    简介

    在Java集合框架中我们知道对于一个指定的集合类,我们可以使用一个特定的Iterator迭代器来对集合中的所有元素进行遍历。这样结合来看,迭代器模式很好理解了。

    4.观察者模式

    定义

    定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

    简介

    观察者模式其实很容易理解,因为是对象之间一对多的通信关系,就很像我们常见的教室里,一个老师站在讲台被台下所有同学关注着,一旦老师喊‘举手’,同学们纷纷响应

    例子

    Teacher.Class 老师类

    1 public classTeacher {2 //创建同学们的观察者集合

    3 private Listobservers4 = new ArrayList();5

    6 private boolean isNotify;//发起通知举手

    7

    8

    9 public void setNotify(booleanisNotify) {10 this. isNotify =isNotify;11 notifyAllObservers();12 }13

    14 //依赖添加新的同学

    15 public voidattach(Students observer){16 observers.add(observer);17 }18

    19 //循环通知每位观察者们

    20 public voidnotifyAllObservers(){21 for(Students observer : observers) {22 observer.update();23 }24 }25 }

    View Code

    Student.Class 同学类

    1 public abstract classStudent {2

    3 //抽象方法必须实现

    4 public abstract voidupdate();5

    6 protectedTeacher teacher;7 }

    View Code

    1 //子类:具体同学——小明

    2 public class xiaoMingObserver extendsStudent{3

    4 publicxiaoMingObserver(Teacher teacher){5 this.teacher =teacher;6 this.teacher.attach(this);7 }8

    9 @Override10 public voidupdate() {11 //小明举手

    12 }13 }14

    15 //子类:具体同学——小红

    16 public class xiaoHongObserver extendsStudent{17

    18 publicxiaoHongObserver(Teacher teacher){19 this.teacher =teacher;20 this.teacher.attach(this);21 }22

    23 @Override24 public voidupdate() {25 //小红举手

    26 }27 }

    View Code

    Main 方法调用

    1 public static voidmain(String[] args) {2

    3 Teacher teacher = newTeacher();4

    5 newxiaoMingObserver(teacher);6 newxiaoHongbserver(teacher);7

    8 teacher.setNotify(ture);//通知

    9 }

    View Code

    5.中介者模式

    定义

    用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

    简介

    中介者模式的典型例子就是未加入 WTO 之前各个国家相互贸易,结构复杂,大家都加入WTO后是各个国家通过 WTO 来互相贸易,变得规范。

    6.备忘录模式

    定义

    在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。

    简介

    备忘录模式的典型例子就是git版本管理工具,它帮我们保存了每次提交后的项目状态,在必要的时候我们可以回退到指定的版本中。

    7.解释器模式

    定义

    给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。

    简介

    解释器的典型例子是在编译原理中的应用,如果一种特定类型的问题发生的频率足够高,那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器,该解释器通过解释这些句子来解决该问题。

    8.状态模式

    定义

    允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

    简介

    状态模式主要解决对象的行为依赖于它的状态(属性),并且可以根据它的状态改变而改变它的相关行为。典型的例子是一个人在不同的状态下完成一件事的结果可能是不同的。

    9.策略模式

    定义

    定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

    简介

    从策略模式的定义可以看到它主要是将算法和客户独立开,一个典型的例子是排序算法,我们给定一个数组,输出排序后的结果,但是过程中我们可以采取不同的排序算法,这些算法其实就是策略。

    10.责任链模式

    定义

    使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。

    简介

    责任链模式,避免请求发送者与接收者耦合在一起,让多个对象都有可能接收请求,将这些对象连接成一条链,并且沿着这条链传递请求,直到有对象处理它为止。

    11.访问者模式

    定义

    封装一些作用于某种数据结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

    简介

    访问者模式是一种将数据操作和数据结构分离的设计模式,它通常使用在对象结构比较稳定,但是经常需要在此对象结构上定义新的操作,或者需要对一个对象结构中的对象进行很多不同的并且不相关的操作,而需要避免让这些操作"污染"这些对象的类,使用访问者模式将这些封装到类中。点击查看更多

    例如,老师要进行家访送出学生的成绩单。每个家长都提供接受家访的接口,老师调用家访接口,

    例子

    1 //接受老师访问的接口

    2 public interfaceHomeVisiting {3

    4 //接受老师的访问

    5 voidaccept(TeacherVisitor visitor);6 }7

    8 //小明家

    9 public class XiaoMingHome implementsHomeVisiting {10 public String homeName ="XiaoMing";11 private String homePager ="";//成绩

    12 @Override13 public voidaccept(TeacherVisitor visitor) {14 //老师进行访问

    15 visitor.visit(this);16 }17 }18

    19 //小红家

    20 public class XiaoHongHome implementsHomeVisiting {21 public String homeName ="XiaoHong";22 private String homePager ="";//成绩

    23

    24 @Override25 public voidaccept(TeacherVisitor visitor) {26 //老师进行访问

    27 visitor.visit(this);28 homePager =visitor.paper;29 }30 }31

    32 //老师家访动作

    33 public interfaceTeacherVisitor{34 public voidvisit(HomeVisiting home);35 }36

    37 //老师进行家访

    38 public class Teacher implementsTeacherVisitor{39 public String paper ="成绩单";40 @Override41 public voidvisit(HomeVisiting home){42 //这个家庭home 的访问情况 + home.gethomeName

    43 }44 }45

    46 //Main 方法入口

    47 public static voidmain(String[] args) {48 //创建老师访问者

    49 TeacherVisitor teacher = newTeacher();50 //创建家庭被访问者

    51 HomeVisiting home =newXiaoMingHome();52

    53 home.accept(teacher);//接受访问

    54

    55 home = newXiaoHongHome();56

    57 home.accept(teacher);58 }

    View Code

    展开全文
  • 我们的目的是研究连接体结构和功能之间的适度耦合是神经系统的基本属性还是当前脑网络模型的局限。我们开发了一个新的深度学习框架来预测个体的大脑功能的结构体,达到的预测精度,大大超过了最先进的生物物理模型。...
  • 通过采用线性化质量共引力耦合到源的无质量极限,我们证明了该理论不受vDVZ不连续的影响。 当我们采用理论的重力势的无质量极限时,这一结果得到了证实,该极限在原点是有限的。
  • 该方法通过构造桥面分段连续函数,得到了移动力作用下桥梁动力响应的解析表达;在计算中通过对Duhamel积分的分解变换,利用积分的可加,极大地减少了计算时间,并可方便地获得多个移动力下桥梁的共振和相消条件。 2)...
  • 物质拉格朗日式由共协变张量的迹线构造而成,该共协变张量根据度量和标量场定义,并具有黎曼张量的对称。 当动作函数中没有Weyl平方项时,我们找到了该理论的精确,中性和带电拓扑黑洞解决方案。 在共...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,216
精华内容 12,486
关键字:

形性耦合