精华内容
下载资源
问答
  • 参数化设计的意义——Autodriver

    千次阅读 热门讨论 2018-03-15 13:34:50
    关键字:南京东岱 参数化设计 Autodriver什么是参数化?在参数化设计系统中,设计人员根据工程关系和几何关系来指定设计要求。要满足这些设计要求,不仅需要考虑尺寸或工程参数的初值,而且要在每次改变这些设计参数...

    关键字:南京东岱  参数化设计   Autodriver

    什么是参数化?

    在参数化设计系统中,设计人员根据工程关系和几何关系来指定设计要求。要满足这些设计要求,不仅需要考虑尺寸或工程参数的初值,而且要在每次改变这些设计参数时来维护这些基本关系,即将参数分为两类:其一为各种尺寸值,称为可变参数;其二为几何元素间的各种连续几何信息,称为不变参数。参数化设计的本质是在可变参数的作用下,系统能够自动维护所有的不变参数。因此,参数化模型中建立的各种约束关系,正是体现了设计人员的设计意图。
    参数化设计可以大大提高模型的生成和修改的速度,在产品的系列设计、相似设计及专用CAD系统开发方面都具有较大的应用价值。目前,参数化设计中的参数化建模方法主要有变量几何法和基于结构生成历程的方法,前者主要用于平面模型的建立,而后者更适合于三维实体或曲面模型。

    Autodriver背景及操作应用

    我们了解了参数化的意义,就应该明白了,参数化会给我们企业带来哪些好处!Autodriver是南京东岱公司是solidworks软件的代理商,根据众多客户提出的参数化设计要求,在solidworks上二次开发做出来的一款参数化软件,符合绝大多数的solidworks用户。

    Autodriver只要把已经画好的三维模型导入到autodriver里面,通过添加全局变量,然后添加各个尺寸的链接,方程式,让所有的尺寸特征全部关联,这样就可以输入全局变量,来驱动整个模型,变成其他的模型。这样我们就可以快速的完成新的项目图纸,可以直接下发图纸。

    软件就先介绍到这里,下次小编将会录制一个视屏介绍autodriver这个软件。

     

     

    展开全文
  • 该参数化后的斜齿圆柱齿轮可以通过改变各个相应驱动参数,能够快速得到不同参数的斜齿圆柱齿轮零件,体现了参数化设计快捷的优点。通过机构的运动仿真,可以看到运动仿真过程中是否出现干涉现象,有利于机构优化和提高...
  • 参数化设计是快速研究与开发同类产品的重要手段。...该全参数化设计的直齿圆柱齿轮通过PROGRAM命令修改其中的几个主要参数,能够快速得到相应参数的直齿圆柱齿轮,体现了全参数化设计快捷、方便的优点
  • 参数化设计优点是对设计人员的初始设计要求低,无需精确绘图,只需勾绘草图,... 2.参数化模板设计主要技术特征 参数化模板设计主要技术特征是:基于特征、全尺寸约束、尺寸驱动设计修改、全数据相关。 ① 基于特征:...
  • 关于QTP中的参数化

    千次阅读 2011-02-15 16:48:00
    方法一、DataTable方法这是QTP提供的一种方法,也是最容易实现参数化的一种方式。QTP针对DataTable对象提供了很多方法,可以对DataTable进行灵活的操作。DataTable分为Global和Local两种,Global所有的Action...

    方法一、DataTable方法

    这是QTP提供的一种方法,也是最容易实现参数化的一种方式。QTP针对DataTable对象提供了很多方法,可以对DataTable进行灵活的操作。DataTable分为GlobalLocal两种,Global所有的Action都可以用,而Local就是只能Action自己用。

    通过DataTable做参数化最直接的方法就是在Keyword View视图下通过选项进行,这样即方便又减少出错的几率。单击要参数化项目的value列,选择出现的箭头弹出Value Configuration Option对话框,在这里可以很方便的进行参数化。

    Parameters选择数据来源类型。DataTable是从数据表中取值,Environment是从环境变量中取值,Random Number是选择随机值。下拉列表选择DataTable后,选择所要使用的数据表Global还是local,最后选择name,参数取自哪列,点击确定后即可完成参数化过程。

    Dialog("Login").WinEdit("Agent Name:").Set DataTable("UserName", dtGlobalSheet)

    这是最简单最直接的方式。用这种方式需要注意,在File---Seting---Run需要做相应设置,否则运行结果很容易出错,使实际取到的参数值和预期的不一样或是循环不正确的错误。最好的方式是通过写语句来控制迭代过程中的取值。在脚本开发过程中,这种方式是最常用的。类似如下代码:

    For i=0 to DataTable.GetCurrentRow

    Dialog("Login").WinEdit("Agent Name:").Set DataTable("UserName", dtGlobalSheet)

    DataTable.SetNextRow

    Next

     

    DataTable提供了很多相关的方法和属性,具体参考帮助文档。帮助目录下的Utility.chm文档中有关于DataTable对象的详细介绍。

    方法二、环境变量实现参数化

    Environment对象提供对环境变量的访问。环境变量的来源有两种方式:内部环境变量和用户定义的环境变量,其中后者支持从外部导入,格式为XML文件。用环境变量做参数化有一定的局限性,因为环境变量对数据的操作没有方法一灵活,所以环境变量用的最多还是数据的共享。在此暂作为一种方式来学习,灵活运用就好。

    首先说内部环境变量。它是QTP默认定义的一组变量,包括一些系统信息、项目信息等。目前用到最多的是TestDir,利用这个可以实现一个相对目录的目的。具体应用,在做一个数据驱动的脚本时,将数据文件放到脚本文件夹中,然后利用Environment("TestDir")+DataName导入数据文件。这样可以很方便的移植,而不需要考虑将数据文件放到具体目录下。

    用户定义的环境变量,需要自己定义变量名和值。定义好后就可以用这些变量去参数化脚本中的常量。

    Dialog("Login").WinEdit("Agent Name:").Set Environment("test1")

     

    这样做参数时,每个参数值都需要指定,而且不能批量的生成。所以它有一定的应用场景:当一个Test中的不同Action需要同样一个参数,用环境变量去参数化常量是很好的一种方式;其次就是不同的Test需要用到同样的参数时,用环境变量可以很好的解决这个问题。

    方法三、外部数据源实现参数化

    利用外部数据驱动脚本的运行,这是经常用到的方法,这样可以很方便的组织测试数据。相对前两种方法,这种方式数据的读取、控制稍有些麻烦。下面以常见的几种方式进行说明。(以下代码并不复杂,没做注释)

    1.      数据文件以Excel组织

    Excel组织测试数据是最常用的了。此种驱动可以采用两种方式,将数据ImportDataTab中或是利用com来操纵Excel文件。下面给出这两种方式的示例代码。(输入flight用户名和密码)

    方式一、导入到DataTable

          '获得数据文件路径,并将数据文件导入到DataTable运行表中

          DataStr= Environment("TestDir")&"/data.xls"

          DataTable.AddSheet("TestData")

          DataTable.ImportSheet DataStr,"Sheet1","TestData"

          '输入用户名和密码

          For i=1 to DataTable.GetSheet("TestData").GetRowCount

                 DataTable.SetCurrentRow i

                 UserName=DataTable.Value("UserName","TestData")

                 PassWord=DataTable.Value("PassWord","TestData")

                 Dialog("Login").WinEdit("Agent Name:").Set UserName

                 Dialog("Login").WinEdit("Password:").SetSecure PassWord

          Next

    方式二、利用com操纵Excel

          DataStr= Environment("TestDir")&"/data.xls"

          Set ExlObj=CreateObject("Excel.Application")

          ExlObj.Visible = True

          ExlObj.DisplayAlerts = FALSE

          Set book=ExlObj.Workbooks.Open(DataStr)

          Set sheet=book.Worksheets("Sheet1")

          For i=2 to sheet.usedrange.rows.count

                 UserName=ExlObj.WorkSheets("Sheet1").Cells(i,1)

                 PassWord=ExlObj.WorkSheets("Sheet1").Cells(i,2)

                 Dialog("Login").WinEdit("Agent Name:").Set UserName

                 Dialog("Login").WinEdit("Password:").SetSecure PassWord

          Next

          ExlObj.Quit

          Set ExlObj = nothing

     

    2.      数据文件以txt组织

    不多说,直接附上代码。

    Const ForReading=1

    TFilePath= Environment("TestDir")&"/data.txt"

    Set Fso3 = CreateObject("Scripting.FileSystemObject")

    Set DataFile= Fso3.OpenTextFile(TFilePath,ForReading,False)

    DataFile.SkipLine

    Do while DataFile.AtEndOfLine<>true

          ReadString = DataFile.ReadLine

          DataStr=split(ReadString,",")

          Dialog("Login").WinEdit("Agent Name:").Set DataStr(0)

          Dialog("Login").WinEdit("Password:").SetSecure DataStr(1)

    loop

    DataFile.close

    Set Fso3=Nothing

    3.      数据文件以数据库组织

    下面代码是用Access做的,其他类型数据库类似。不多说继续贴出代码。

    strDB="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:/Documents and Settings/zilingold/桌面/Testdata.mdb;Persist Security Info=False"

    strTableName="data"

    SetConn=createobject("adodb.connection")

    Set Rst=createobject("adodb.recordset")

    Conn.open strDB

    Rst.open "select * from "+strTableName,Conn,2,2

    Dim strTest(1)

    Rst.MoveFirst

    Do while not Rst.eof

          strTest(0)=trim(cstr(Rst.fields(0)))

          strTest(1)=trim(cstr(Rst.fields(1)))

          Dialog("Login").WinEdit("Agent Name:").Set strTest(0)

          Dialog("Login").WinEdit("Password:").SetSecure strTest(1)

          Rst.MoveNext

    Loop

    Rst.close

    SetConn=nothing

    4.      数据文件以XML组织

    XML也是会经常用到的一种方式。继续贴代码。

    Dim xmlDoc 'As DOMDocument需要引用xml对象

    set xmldoc=CreateObject("microsoft.xmldom")

    xmldoc.load(Environment("TestDir")&"/testdata.xml")

    Set Root=xmldoc.documentElement

    For i = 0 To Root.childNodes.Length-1

                 Set TestCases = Root.childNodes.Item(i)

                        For j = 0 To TestCases.childNodes.Length-1

                               Set TestCase = TestCases.childNodes.Item(j)

                                      If cstr(TestCase.nodeName)="UserName" Then

                                             Dialog("Login").WinEdit("Agent Name:").Set TestCase.text      

                                      end if

                                      If cstr(TestCase.nodeName)="PassWord" Then

                                             Dialog("Login").WinEdit("Password:").SetSecure TestCase.text                                                             End If                         

                        Next

          Next

    Set root=nothing

    Set xml=nothing

    <SPAN lang=EN-US style="mso-b

    展开全文
  • 参数化设计的突出优点在于可以通过变更参数的方法来方便地修改设计意图,从而修改设计结果。关系式是参数化设计中的另外一项重要内容,它体现了参数之间相互制约的【父子】关系,本章将全面介绍参数化设计的基本方法...
  • 设计模式是软件大师们根据多年来的软件开发经验,对软件开发领域包括合理复用、提高健壮性、减少BUG等各方面作的抽象总结,不同的设计模式方法适合于不同的应用场景,是汇结了他们最宝贵的经验总结。最早的开发模式...

    设计模式是软件大师们根据多年来的软件开发经验,对软件开发领域包括合理复用、提高健壮性、减少BUG等各方面作的抽象总结,不同的设计模式方法适合于不同的应用场景,是汇结了他们最宝贵的经验总结。最早的开发模式是1994年GOF四人共同完成的《Design Patterns - Elements of Reusable Object-Oriented Software》一书提及的23种经典设计模式,至今仍是设计模式方面,经典中的经典著作。

     

    一、设计模式的六大原则:
    总原则-开闭原则
    对扩展开放,对修改封闭。在程序需要进行拓展的时候,不能去修改原有的代码,而是要扩展原有代码,实现一个热插拔的效果。所以一句话概括就是:为了使程序的扩展性好,易于维护和升级。
    想要达到这样的效果,我们需要使用接口和抽象类等,后面的具体设计中我们会提到这点。

    1、单一职责原则
    不要存在多于一个导致类变更的原因,也就是说每个类应该实现单一的职责,否则就应该把类拆分。

    2、里氏替换原则(Liskov Substitution Principle)
    任何基类可以出现的地方,子类一定可以出现。里氏替换原则是继承复用的基石,只有当衍生类可以替换基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。
    里氏代换原则是对“开-闭”原则的补充。实现“开闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。里氏替换原则中,子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构,通过这个规范的接口与外界交互,子类不应该随便破坏它。

    3、依赖倒转原则(Dependence Inversion Principle)
    面向接口编程,依赖于抽象而不依赖于具体。写代码时用到具体类时,不与具体类交互,而与具体类的上层接口交互。

    4、接口隔离原则(Interface Segregation Principle)
    每个接口中不存在子类用不到却必须实现的方法,如果不然,就要将接口拆分。使用多个隔离的接口,比使用单个接口(多个接口方法集合到一个的接口)要好。

    5、迪米特法则(最少知道原则)(Demeter Principle)
    一个类对自己依赖的类知道的越少越好。无论被依赖的类多么复杂,都应该将逻辑封装在方法的内部,通过public方法提供给外部。这样当被依赖的类变化时,才能最小的影响该类。
    最少知道原则的另一个表达方式是:只与直接的朋友通信。类之间只要有耦合关系,就叫朋友关系。耦合分为依赖、关联、聚合、组合等。我们称出现为成员变量、方法参数、方法返回值中的类为直接朋友。局部变量、临时变量则不是直接的朋友。我们要求陌生的类不要作为局部变量出现在类中。

    6、合成复用原则(Composite Reuse Principle)
    尽量首先使用合成/聚合的方式,而不是使用继承,即组合优于继承.

     

    按照类型,可分为3类:

    1、创建型模式:抽象工厂、建造者模式、工厂方法、原型模式、单例模式;
    创建型模式抽象了实例化的过程。创建性模式隐藏了这些类的实例是如何被创建和放在一起,整个系统关于这些对象所知道的是由抽象类所定义的接口。这样,创建性模式在创建了什么、谁创建它、她是怎么被创建的、以及何时创建方面提供了灵活性。创建相应数目的原型并克隆她们通常比每次用适合的状态手工实例化该类更方便。

    2、结构型模式:适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式;

    3、行为型模式:观察者模式、模板方法、命令模式、状态模式、职责链模式、解释器模式、中介者模式、访问者模式、策略模式、备忘录模式、迭代器模式。

    4、MVC模式:集观察者、组合、策略为一体,是多种模式的综合应用,算是一种架构模式。

     

    下面按照【概念】+【原则】+【场景】+【优点】+【缺点】+【应用】分别简述一下24种设计模式:

     
    1、抽象工厂模式(Abstract Factory)

    提供一个创建一系列相关或互相依赖对象的接口,而无需指定它们具体的类。
    原则:
        LSP 里氏替换原则
    场景:
        创建不同的产品对象,客户端应使用不同的具体工厂。
    优点:
        1、改变具体工厂即可使用不同的产品配置,使改变一个应用的具体工厂变得很容易。
        2、让具体的创建实例过程与客户端分离,客户端通过抽象接口操作实例,产品的具体类名也被具体工厂的实现分离。
    缺点:
        如果要新增方法,改动极大。
    应用:
        1、jdk中连接数据库的代码是典型的抽象工厂模式,每一种数据库只需提供一个统一的接口:Driver(工厂类),并实现其中的方法即可。不管是jdbc还是odbc都能够通过扩展产品线来达到连接自身数据库的方法。
        2、java.util.Collection 接口中定义了一个抽象的 iterator() 方法,该方法就是一个工厂方法。对于 iterator() 方法来说 Collection 就是一个抽象工厂。

     

    2、建造者模式(Builder)【又名,生成器模式】

    将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
    原则:
        依赖倒转原则
    场景:
        如果需要将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。建造者模式是当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用的模式。
    优点:
        使得建造代码与表示代码分离。
    缺点:
        1、增加代码量;
        2、Builder只是一个替代构造器的选择,不能直接用于降低非构造函数方法的参数数量。
    应用:
        StringBuilder和StringBuffer的append()方法

     

    3、工厂方法模式(Factory Method)

    定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类。
    原则:
        开放封闭原则
    场景:
        不改变工厂和产品体系,只是要扩展产品(变化)。
    优点:
        是简单工厂模式的进一步抽象和推广,既保持了简单工厂模式的优点(工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类。对于客户端来说,去除了与具体产品的依赖),而且克服了简单工厂的缺点(违背了开放封闭原则)。
    缺点:
        每增加一个产品,就需要增加一个产品工厂的类,增加了额外的开发。(用反射可以解决)。
    应用:
        1、Collection中的iterator方法;
        2、java.lang.Proxy#newProxyInstance()
        3、java.lang.Object#toString()
        4、java.lang.Class#newInstance()
        5、java.lang.reflect.Array#newInstance()
        6、java.lang.reflect.Constructor#newInstance()
        7、java.lang.Boolean#valueOf(String)
        8、java.lang.Class#forName()

     

    4、原型模式(prototype):【又名,生成器模式】

    用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。
    原则:
    场景:
        在初始化信息不发生变化的情况,用克隆进行拷贝。
    优点:
        隐藏了对象创建的细节,大大提升了性能。不用重新初始化对象,而是动态的获得对象运行时的状态。
    缺点:
        深复制 or 浅复制 。
    应用:
        JDK中的Date类。

     

    5、单例模式(Singleton)

    保证一个类仅有一个实例,并提供一个访问它的全局访问点。
    原则:
        封装
    场景:
        通常,我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象,一个最好的办法就是,让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建,而且它可以提供一个访问该实例的方法。
    优点:
        对唯一实例的受控访问。
    缺点:
        饿汉式/懒汉式  多线程同时访问时可能造成多个实例。
    应用:
        1、java.lang.Runtime; GUI中也有一些(java.awt.Toolkit#getDefaultToolkit() java.awt.Desktop#getDesktop())

     

    6、适配器模式(Adapter)

    将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。在GoF的设计模式中,适配器有两种类型,类适配器模式和对象适配器模式。
        1、类适配器模式:通过多重继承对一个接口与另一个接口进行匹配,而C#,Java等语言都不支持多重继承,也就是一个类只有一个父类。
        2、Java一般都指的是 对象适配器模式
    场景:
        适配器是为了复用一些现有的类。系统的数据和行为都正确,但是接口不符,这时采用适配器模式,使原有对象和新接口匹配。
    优点:
        能够复用现存的类,客户端统一调用同一接口,更简单、直接、紧凑。
    缺点:
        适配器模式有点儿“亡羊补牢”的感觉,设计阶段要避免使用。
    应用:
        在Java jdk中,适配器模式使用场景很多,如
        集合包中Java.util.Arrays#asList()、
        IO包中java.io.InputStreamReader(InputStream)、java.io.OutputStreamWriter(OutputStream) 等

     

    7、桥接模式(Bridge)

    将抽象部分与它的实现部分分离,使它们都可以独立的变化。
    原则:
        合成/聚合复用原则
    场景:
        实现系统可能有多角度分类,每一种分类都有可能变化,那么就把这种多角度分离出来让它们独立变化,减少它们之间的耦合。
    优点:
        减少各部分的耦合。 分离抽象和实现部分,更好的扩展性,可动态地切换实现、可减少子类的个数。
    缺点:
        1、桥接模式的引入会增加系统的理解与设计难度,由于聚合关联关系建立在抽象层,要求开发者针对抽象进行设计与编程。 
        2、桥接模式要求正确识别出系统中两个独立变化的维度,因此其使用范围具有一定的局限性
    应用:
        Collections类中的sort()方法;AWT;JDBC数据库访问接口API;

     

    8、组合模式(Composite)

    将对象组合成树形结构以表示“部分-整体”的层次结构。
    场景:
        需求中体现部分与整体层次结构时,以及希望用户可以忽略组合对象与单个对象的不同,统一使用组合结构中的所有对象时,就应该考虑使用组合模式了。
    优点:
        组合模式让客户可以一致的使用组合结构和单个对象。
    缺点:
        使设计变得更加抽象,对象的业务规则如果很复杂,则实现组合模式具有很大挑战性,而且不是所有的方法都与叶子对象子类都有关联。
    应用:
        JDK中AWT包和Swing包的设计是基于组合模式,在这些界面包中为用户提供了大量的容器构件(如Container)和成员构件(如Checkbox、Button和TextComponent等),他们都是继承、关联自抽象组件类Component。

     

    9、装饰模式(Decorator)

    动态地给一个对象添加一些额外的职责,就增加功能来说,装饰模式比生成子类更灵活。
    场景:
        装饰模式是为了已有功能动态地添加更多功能的一种方式,当系统需要新功能的时候,是向旧类中添加新的代码,这些新的代码通常装饰了原有类的核心职责或主要行为。装饰着模式把每个要装饰的功能放在单独的类中,并让这个类包装它所要装饰的对象,当需要执行特殊行为时,客户代码就可以在运行时根据需要有选择的、按顺序地使用装饰功能包装对象。
    优点:
        把类中的装饰功能从类中搬移出去,简化原有的类。有效的把类的核心职责和装饰功能区分开,去除相关类中重复的装饰逻辑。
    缺点:
        利用装饰器模式,常常造成设计中有大量的小类,数量实在太多,可能会造成使用此API程序员的困扰。
    应用:
        Java I/O使用装饰模式设计,JDK中还有很多类是使用装饰模式设计的,如:Reader类、Writer类、OutputStream类等。

     

    10、外观模式(facade)

    为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。
    原则:
        完美的体现了依赖倒转原则和迪米特法则。
    场景:
        1、设计阶段:需有意识的将不同的两个层分离。
        2、开发阶段:增加外观façade提供一个简单的接口,应对子类的重演和演化。
        3、维护期间:使用façade类,为遗留代码提供清晰简单的接口,让新系统与façade交互,façade与遗留代码交互所有复杂的工作。
    优点:
        1、客户对子系统的使用变得简单了,减少了与子系统的关联对象,实现了子系统与客户之间的松耦合关系。 
        2、只是提供了一个访问子系统的统一入口,并不影响用户直接使用子系统类 
        3、降低了大型软件系统中的编译依赖性,并简化了系统在不同平台之间的移植过程。
    缺点:
        1、不能很好地限制客户使用子系统类,如果对客户访问子系统类做太多的限制则减少了可变性和灵活性   
        2、在不引入抽象外观类的情况下,增加新的子系统可能需要修改外观类或客户端的源代码,违背了“开闭原则”。

     

    11、享元模式(Flyweight)

    运用共享技术有效的支持大量细粒度的对象。
    场景:
        如果一个应用程序使用了大量的对象,而大量的这些对象造成了很大存储开销时就应该考虑使用享元模式;还有就是对象大多数状态都可为外部状态,如果删除对象的外部状态,那么可以用相对较少的共享对象取代很多组对象,此时可以考虑使用享元模式。
    优点:
        享元模式可以避免大量非常相似类的开销。程序中,大量细粒度的类实例来表示数据,如果它们除了几个参数外基本相同,那么把它们转移到类实例的外面,在方法调用时将它们传递进来,就可以通过共享大幅度减少单个实例的数目。
    缺点:
        1、由于享元模式需要区分外部状态和内部状态,使得应用程序在某种程度上来说更加复杂化了。
        2、为了使对象可以共享,享元模式需要将享元对象的状态外部化,而读取外部状态使得运行时间变长。
    应用:
        String 类。

     

    12、代理模式(proxy)

    为其他对象提供一种代理以控制对这个对象的访问。
    原则:
        代理模式就是在访问对象时引入一定程度的间接性。(迪米特法则?)
    场景:
        1、远程代理:为一个对象在不同的地址空间提供局部代表,这样可以隐藏一个对象存在于不同地址空间的事实。【WebService,客户端可以调用代理解决远程访问问题】
        2、虚拟代理:根据需要创建开销很大的对象,通过它来存放实例化需要很长时间地真实对象。【比如Html网页的图片,代理存储的是真实图片的路径和尺寸】
        3、安全代理:用来控制真实对象的访问权限。
        4、智能指引:当调用真实的对象时,代理处理另一些事。【如计算机真实对象的引用次数,代理在访问一个对象的时候回附加一些内务处理,检查对象是否被锁定、是否该释放、是否该装入内存等等】
    优点:
        1、代理模式能将代理对象与真正被调用的对象分离,在一定程度上降低了系统的耦合度。
        2、代理模式在客户端和目标对象之间起到一个中介作用,这样可以起到保护目标对象的作用。代理对象也可以对目标对象调用之前进行其他操作。
    缺点:
        1、在客户端和目标对象增加一个代理对象,会造成请求处理速度变慢。
        2、增加了系统的复杂度。
    应用:
        java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

     

    13、观察者模式(Publish/Subscribe) 【又名 发布-订阅模式】

    定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时,会通知所有观察者对象,让它们能够自动更新自己。
    场景:
        将一个系统分割成一系列互相协作的类,有一个缺点:需要维护相关对象间的一致性。紧密的耦合会给维护和扩展带来不便。观察者模式就是为了解耦而诞生的,让原本一个对象依赖另一个对象的关系,变成了两方都依赖于抽象,而不再依赖于具体,从而使得各自的变化都不会影响另一边的变化。
    优点:
        解耦。
    缺点:
        如果在被观察者之间有循环依赖的话,被观察者会触发它们之间进行循环调用,导致系统崩溃。在使用观察者模式是要特别注意这一点。
    应用:
        java.util.Observer, java类库实现观察着(Observer)模式的类和接口。

     

    14、模板方法模式(Template Method)

    定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。
    原则:
        代码复用平台。
    场景:
        遇到由一系列步骤构成的过程需要执行,这个过程从高层次上看是相同的,但是有些步骤的实现可能不同,这个时候就需要考虑用模板方法模式了。
    优点:
        模板方法模式是通过把不变行为搬移到超类,去除子类中重复代码来实现它的优势,提供了一个代码复用平台,帮助子类摆脱重复的不变行为的纠缠。
    缺点:
        如果父类中可变的基本方法太多,将会导致类的个数增加,系统更加庞大。
    应用:
        AbstractClass抽象类里面的TemplateMethod()就是模板方法。

     

    15、命令模式(command)

    将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作。
    原则:
        敏捷开发原则
    场景:
        对请求排队或记录请求日志,以及支持可撤销的操作等行为。
    优点:
        1、命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开。
        2、它能较容易的设计一个命令队列。
        3、在需要的情况下,可以较容易的将命令记入日志。
        4、允许接收请求的一方决定是否要否决请求。
        5、可以容易的实现对请求的撤销和重做。
        6、由于加进新的具体命令类不影响其他类,因此增加新的具体命令类很容易。
    缺点:
        会增加系统的复杂性,这里的复杂性应该主要指的是类的数量。
    应用:
        1、java.util.Timer类中scheduleXXX()方法
        2、java Concurrency Executor execute()方法
        3、java.lang.reflect.Methodinvoke()方法

     

    16、状态模式(state)

    当一个对象的内在状态改变时,允许改变其行为,这个对象看起来像是改变了其类。
    原则:
        单一职责原则
    场景:
        当一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为时,可以考虑使用状态模式了。
    优点:
        状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中,可以把复杂的判断逻辑简化。【消除庞大的条件分支语句】。
    缺点:
        违背开放-封闭原则
    应用:
        1、java.util.Iterator
        2、javax.faces.lifecycle.LifeCycle#execute()

     

    17、职责链模式(chain of responsibility)

    使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。
    场景:
        当客户提交一个请求时,请求是沿链传递直至有一个对象负责处理它。
    优点:
        使得接收者和发送者都没有对方的明确信息,且链中对象自己也不知道链结构,结果是职责链可以简化对象的相互连接,它们只需要保持一个指向其后继者的引用,而不需要保持它所有的候选接收者的引用。开发者可以随时的增加或者修改处理一个请求的结构,增强了给对象指派职责的灵活性。
    缺点:
        一个请求极有可能到了链的末端都得不到处理,或者因为没有正确配置而得不到处理。

     

    18、解释器模式(interpreter)

    给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。
    原则:
        依赖倒转原则
    场景:
        如果一种特定类型问题发生的频率足够高,那么可能就值得将该问题的各个实例表述为一个简单语句中的句子。这样就可以构建一个解释器,该解释器通过解释这些句子来解决该问题。当一个语言需要执行,并且你可将该语言中的句子表示为一个抽象语法树时,可以用解释器模式。
    优点:
        解释器很容易改变和扩展文法,因为该模式使用类来表示文法规则,可以使用继承来改变或扩展文法,也比较容易实现文法。因为定义抽象语法树中各个节点的类的实现大体类似,这些类都易于直接编写。
    缺点:
        解释器模式为文法中的每一条规则至少定义了一个类,因此包含许多规则的文法可能难以管理和维护,建议当文法非常复杂时,使用其他技术(语法分析程序、编译器生成器)。
    应用:
        1、java.util.Pattern
        2、java.text.Normalizer
        3、java.text.Format
        4、javax.el.ELResolver

     

    19、中介者模式(mediator)

    用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示的相互引用,从而使其耦合松散,而且可以独立的改变它们之间的交互。
    场景:
        一般应用于一组对象以定义良好但是复杂的方式进行通信的场合,以及想定制一个分布在多个类的行为,而又不想生成太多子类的场合。【例如,Form窗体,或者aspx页面】。
    优点:
        1、抽象中介者类(Mediator)减少了抽象同事类(colleague)之间的耦合,是的可以独立的改变和复用各个类。
        2、由于把对象如何协作进行了抽象,将中介作为一个独立的概念并将其封装在一个对象中,这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来,也就是站在一个更宏观的角度去看待系统。
    缺点:
        控制集中化导致了中介者的复杂化。
    应用:
        1、java.util.Timer
        2、java.util.concurrent.Executor#execute()
        3、java.util.concurrent.ExecutorService#submit()
        4、java.lang.reflect.Method#invoke()

     

    20、访问者模式 (Vistor) 生成器模式

    (GoF中最复杂的一个模式)表示一个作用于某对象结构中的各元素的操作,它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
    场景:
        访问者模式适合有稳定的数据结构、又有易于变化的算法】访问者模式适用于数据结构相对稳定的系统,它把数据结构和作用于结构上的操作之间的耦合解脱开,是的操作集合可以相对自由的演化。访问者模式的目的是要把处理从数据结构中分离出来。
    优点:
        增加新的操作很容易。新的操作就是新的访问者。
    缺点:
        很难增加新的数据结构。
    应用:
        1、javax.lang.model.element.AnnotationValue和AnnotationValueVisitor
        2、javax.lang.model.element.Element和ElementVisitor
        3、javax.lang.model.type.TypeMirror和TypeVisitor

     

    21、策略模式(strategy)

    它定义了算法家族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化不会影响到使用算法的用户。
    场景:
        策略模式不仅可以用来封装算法,几乎可以封装缝合类型的规则,不同的业务逻辑都可以考虑用策略模式处理变化。
    优点:
        策略模式的策略类为上下文定义了一系列可供重用的算法或行为,继承有助于析取出这些算法中的公共功能。另外,策略模式简化了单元测试,因为每一个算法都有自己的类,可以通过自己的接口单独测试。当不同的行为堆砌在一个类中,很难避免使用switch语句。但是将这些行为封装在一个一个独立的策略类中,可以在使用这些行为的类中消除条件语句
    缺点:
        基本的策略模式,选择权在客户端,具体实现转给策略模式的上下文对象。这并不好。使用策略模式和工厂类结合,可以减轻客户端的职责。但是还是不够完美,使用反射才能真正快乐。
    应用:
        1、java.util.Comparator#compare()
        2、javax.servlet.http.HttpServlet
        3、javax.servlet.Filter#doFilter()

     

    22、备忘录模式(Memento)

    在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样以后就可将该对象恢复到原先保存的状态。
    场景:
        Memento封装要保存的细节,适合功能负责但需要维护或记录属性历史的类,或者是需要保存的属性只是众多属性中的一个小部分。
    优点:
        使用备忘录模式可以把复杂的发起人内部信息对其他的对象屏蔽起来,从而可以恰当地保持封装的边界。
    缺点:
        如果发起人角色的状态需要完整地存储到备忘录对象中,那么在资源消耗上面备忘录对象会很昂贵。
    应用:
        1、java.util.Date
        2、java.io.Serializable

     

    23、迭代器模式(Iterator)

    提供一种方法顺序访问一个聚合对象中各个元素,而又不暴露该对象的内部表示。
    场景:
        当需要对聚集有多种方式遍历时,可以考虑使用迭代器。
    优点:
        迭代器模式就是分离了集合对象的遍历行为,抽象出一个迭代器来负责,这样既可以做到不暴露集合的内部结构,又可以让外部代码透明的访问集合内部的数据。
    缺点:
        由于迭代器模式将存储数据和遍历数据的职责分离,增加新的聚合类需要对应增加新的迭代器类,类的个数成对增加,这在一定程度上增加了系统的复杂性。
    应用:
        collection容器使用了迭代器模式

     

     

    展开全文
  • 参数化模块库(LPM)的使用

    万次阅读 2009-10-12 10:27:00
    LPM(Library Parameterized Modules)即参数化的宏功能模块库。应用这些功能模块库可以大大提高IC设计的效率。LPM标准在1990年被推出,1993年4月,LPM作为电子设计交换格式(EDIF)的附属标准,纳入了电子工业协会(EIA)...

    LPM(Library Parameterized Modules)即参数化的宏功能模块库。应用这些功能模块库可以大大提高IC设计的效率。LPM标准在1990年被推出,1993年4月,LPM作为电子设计交换格式(EDIF)的附属标准,纳入了电子工业协会(EIA)的临时标准。

    在MAX+PLUS II 和 Quartus II中调用LPM库函数非常方便,用户既可以在图形输入法中直接调用,也可以在HDL源文件中调用。

    LPM库如表2-5所示。 它是MAX+PLUS II 和 Quartus II 提供的可供调用的一些功能模块。

    MAX+PLUS II  的LPM库所在的目录/maxplus2/max2lib/mega_lpm。
     
    Quartus II  的LPM库所在的目录/altera/quartus60/libraries/megas。

    表2-5LPM库单元列表

    模块分类宏单元简要说明
    门单元模块lpm_and参数化与门
     lpm_bustri参数化三态缓冲器
     lpm_clshift参数化组合逻辑移位器
     lpm_constant参数化常数产生器
     lpm_decode参数化译码器
     lpm_inv参数化反向器
     

     

    lpm_mux参数化多路选择器
     busmux参数化总线选择器
     mux多路选择器
     lpm_or参数化或门
     lpm_xor参数化异或门
    算术运算模块lpm_abs参数化绝对值运算
     lpm_add_sub参数化的加/减法器
     lpm_compare参数化比较器
     lpm_counter参数化计数器
     lpm_mult参数化乘法器
    存储器模块lpm_ff参数化D触发器
     

     

    lpm_latch参数化锁存器
     lpm_ram_dq输入输出分开的参数化RAM
     lpm_ram_io输入输出复用的参数化RAM
     lpm_rom参数化ROM
     lpm_shitreg参数化移位寄存器
     csfifo参数化先进先出队列
     csdpram参数化双口RAM
    其它功能模块pll参数化锁相环电路
     ntsc<NTSC图象控制信号产生器
     
     
     
    附录:用LPM库单元构造一个四位加法器

         下面介绍利用LPM库单元来构造一个四位加法器的方法。

    lpm_add_sub是参数化加/减法器,利用它既可以设计加法器,也可以设计减法器。先在图形编

    辑器中进行编辑,如图2-7所示。

    图2-7参数化的加/减法lpm_add_sub

          指定它的参数值如下,

          LPM_WIDTH = 4(模块信号宽度为4位)

          LPM_DIRECTION = “ADD”(将模块设置为加法器)

          LPM_REPRESENTATION = “UNSIGNED”(将输入输出数据设为无符号数)

         然后还要设定端口。这里只使用lpm_add_sub库单元的四个端口,分别是数据输入端

    data-a[]和data-b[]、数据输出端result[]和进位输出端cout。仿真结果如下图2-8所示。

    图2-8lpm_add_sub设置为加法器时的仿真图形

    展开全文
  • FA 工业自动设备设计基础

    千次阅读 2017-09-13 20:33:24
    读《FA 工业自动设备设计基础》记录 FA——工厂自动(Factory Automation) 自动设备主要是大量使用了现代自动元器件以及自动控制系统的各类设备,与传统的纯机械机构组成的设备有一定的区别。但是,也...
  • iOS 组件化,插件化设计思路分析 前言 随着用户的需求越来越多,对App的用户体验也变的要求越来越高。为了更好的应对各种需求,开发人员从软件工程的角度,将App架构由原来简单的MVC变成MVVM,VIPER等...
  • Java常见设计模式总结

    万次阅读 多人点赞 2021-09-18 17:18:54
    设计模式于己于人于系统都是多赢的,它使得代码编写真正工程,它是软件工程的基石,如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现实中都有相应的原理来与之对应,每种...
  • 23种设计模式:简单工厂模式,策略模式、装饰模式、代理模式、工厂方法模式、原型模式、模板方法模式、外观模式、建造者模式、观察者模式、抽象工厂模式、状态模式、适配器模式、备忘录模式、组合模式、迭代器模式、...
  • 组件化设计思路总结

    千次阅读 2019-04-16 14:15:26
    Q:组件开发的优点? A:可以很大程度上降低系统各个功能的耦合性,并且提高了功能内部的聚合性。这对前端工程及降低代码的维护来说,是有很大的好处的。 耦合性的降低,提高了系统的伸展性,降低了开发的复杂度,...
  • ui自动化设计思路

    千次阅读 2019-04-09 13:56:07
    本文将探讨ui自动化设计思路,主要围绕以下方面展开讲解,希望阅读前对ui自动化有个基本了解 1、单例模式的运用 2、ui自动化分层思想 2.1PageObject设计模式 2.2业务流程封装 3、测试数据的准备 ...
  • 向心参数化法,假设在一段曲线弧上的向心力与曲线切矢从该弧段始端至末端的转角成正比,加上一些简化假设,得到向心参数化法。此法尤其适用于非均匀型值点分布。 参数曲线的代数和几何形式 以三次参数曲线为例...
  • 【软件工程】第五章 结构化设计

    万次阅读 多人点赞 2019-02-23 12:48:43
    5.1 结构化设计的概念 5.1.1 设计的定义 何谓设计: 一种软件开发活动,定义实现需求规约所需的软件结构 目标: 依据需求规约在一个抽象层上建立系统软件模型,包括软件体系结构(数据和程序结构),以及详细...
  • 本系统设计是从低成本、低功耗、高效率等概念出发,采用32位单片机STM32F103C8T6为处理核心,在数据采集节点端控制一系列的传感器(如DS18B20、DHT11、MQ-135、光敏二极管、雨滴传感器、土壤水分传感器等)来采集...
  • 设计模式及其优缺点

    千次阅读 2018-06-29 16:31:10
    设计模式 1.单例模式: 实现方式: a) 将被实现的类的构造方法设计成private的。 b) 添加此类引用的静态成员...优点: 1.在单例模式中,活动的单例只有一个实例,对单例类的所有实例得到的都是相同的一个实...
  • 未知 第3章 用泛型实现参数化类型 本章内容 理解泛型类型和方法 泛型方法的类型推断 类型约束 反射和泛型 CLR行为 泛型的限制 与其他语言的对比 一个真实 1 的故事:前几天,我老婆和我准备去超市进行每周例行的...
  •  Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架  使用了MVC架构模式的思想,将web层进行职责解耦,基于请求驱动指的就是使用请求-响应模型  框架的目的就是帮助我们简化...
  • 浅析DDD(领域驱动设计)

    万次阅读 多人点赞 2017-03-15 20:34:50
    最近在做一些微服务相关的设计,内容包括服务的划分,Restful API的设计等。其中比较棘手的就是Service的职责划分:如何抽象具有统一业务范畴的Model,使其模块,又如何高度提炼并组合多模块,使得业务可独立服务...
  • 而对全局变量来说,它使变量局部(局部于本文件),但仍未静态存储方式。 register-寄存器变量 由于现在计算机的运行速度愈来愈快,性能愈来愈好,优化的编译系统能够识别使用频繁的变量,从而自动将...
  • Enum类型的策略枚举这种设计模式如何实现和优缺点 Enum支持序列吗支持,在Java中,只要一个类实现了java.io.Serializable接口,那么它就可以被序列。Enum底层实现当我们使用enmu来定义一个枚举类型的时候,...
  • 函数式编程的优点

    千次阅读 2014-03-27 09:49:01
     单元测试 ...因为函数式编程的每一个符号都是 final 的,没有函数产生过副作用。...这意味着函数求值的结果只是其返回值,而惟一影响其返回值的就是函数的参数。 这是单元测试者的梦中仙境
  • 模块化是在传统设计基础上发展起来的一种新的设计思想,现已成为一种新技术被广泛应用,尤其是信息时代电子产品不断推陈出新,模块化设计的产品正在不断涌现。如何使产品的模块化设计全方位地满足市场的多样化需求,...
  • 在一款APP产品的各个版本迭代中,兵马的启动指的是真正开始敲代码的时候,粮草先行则是指前期的需求,交互,UI等评审准备阶段,还有本文要说的接口的设计与评审。虽然很多时候一个api接口的业务,数据逻辑是后端提供...
  • Verilog的层次化设计

    千次阅读 2009-03-05 21:55:00
    在设计VORC时,发现对其进行层次化设计是一种好的方法。 VORC的层次化设计就是将各个子功能模块(乘法、加法等)设计成子模块,而在顶层只进行例化。这样层次清晰,逻辑关系明确,容易进行仿真和验证。在对VORC进行...
  • 系统设计:关于高可用系统的一些技术方案

    万次阅读 多人点赞 2017-09-17 09:22:32
    模块级自动测试 灰度发布 回滚 其他 总结 参考资料 系统设计:关于高可用系统的一些技术方案 可靠的系统是业务稳定、快速发展的基石。那么,如何做到系统高可靠、高可用呢?下面首先讲一下高可用需要...
  • C语言的优点和缺点

    万次阅读 多人点赞 2016-01-26 14:07:11
    C语言的优点和缺点

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 250,376
精华内容 100,150
关键字:

参数化设计的优点