精华内容
下载资源
问答
  • 企业管理的六大关系和八大系统

    万次阅读 2021-01-21 12:15:01
    要解决好企业经营管理中的六大关系和八大系统,而解决好的前提是找到合适的人来解决这些问题。 何为企业的六大关系: 一是要解决与市场的关系,包括客户关系、竞争者关系、合作者关系, 二是要解决与政府的关系,...

    要解决好企业经营管理中的六大关系和八大系统,而解决好的前提是找到合适的人来解决这些问题。

    何为企业的六大关系:

    一是要解决与市场的关系,包括客户关系、竞争者关系、合作者关系,

    二是要解决与政府的关系,尤其是与拥有公权力部门的政府关系,           

    三是要解决与金融单位的关系,任何一家企业没有金融单位的支持是很难开展经营活动的,  

    四是要解决与员工的关系, 员工是企业的财富之源,要激励和爱护他们,使之能为企业尽心尽力工作,                     

    五是要解决与股东的关系, 他们是你利益的攸关方,                     

    六是要解决与新闻媒体的关系,所谓成也萧何败也萧何, 新闻媒体的作用就在这。至于如何解决,是仁者见仁,智者见智,这里就不多赘述了。
    创业者财务必备知识教程(访问密码:9856)

    何为企业的八大系统:         

    一是预算和计划系统,企业在进行任何一项经营活动之前必须要有合理的预算和计划方案比较,作出选择;

    二是组织系统,对企业内的每个岗位要进行明示,让每位员工清楚自己所处的位置;  

    三是企业文化系统,企业文化归根结底是如何形成每位员工(包括老总自己)的工作习惯和学习习惯, 这要看作为老总的你如何建设和推动,企业文化的建设和推动是经年累月的结果, 实现她可以使你的经营管理变的游刃有余;  

    四是垂直指挥系统;

    五是横向联络系统;

    六是检查反馈系统;

    七是招聘任用系统;

    八是培训系统。 总经理的角色就是要解决好六大关系和企业八大系统运营管理模式, 一般经过二到三年时间 的艰苦努力,就会形成自己企业的管理特色,你的企业在为社会创造物质财富,更是培养了一批有能力、有技术而又善于经营管理的职业经理团队,很多人才都愿意投身到你的企业中来,你的企业何愁不成功。

    展开全文
  • 人力资源管理六大模块体系解读

    千次阅读 2008-11-22 13:27:00
    作为这个有效体系的构成部分,HR各大模块体系的完善和工作的展开显得尤为重要! 1、人力资源规划-HR工作的航标兼导航仪 航行出海的船只都需要确立一个航标以定位目的地,同时需要一个有效的导航系统以确保它航行在...
      人力资源管理已经突破了传统的模式,把人上升到资源的角度进行配置和管理,如何实现对人力资源的有效管理和配置,构建一个有效的人力资源管理平台和体系成为企业HR工作的重点。作为这个有效体系的构成部分,HR各大模块体系的完善和工作的展开显得尤为重要! 

     1、人力资源规划-HR工作的航标兼导航仪

     航行出海的船只都需要确立一个航标以定位目的地,同时需要一个有效的导航系统以确保它航行在正确的路线之上。人力自资源管理也一样,需要确定HR工作目标定位和实现途径。人力资源规划的目的在于结合企业发展战略,通过对企业资源状况以及人力资源管理现状的分析,找到未来人力资源工作的重点和方向,并制定具体的工作方案和计划,以保证企业目标的顺利实现。人力资源规划的重点在于对企业人力资源管理现状信息进行收集、分析和统计,依据这些数据和结果,结合企业战略,制定未来人力资源工作的方案。正如航行出海的船只的航标的导航仪,人力资源规划在HR工作中起到一个定位目标和把握路线的作用!

     2、招聘与配置-“引”和“用”的结合艺术

     人员任用讲求的是人岗匹配,适岗适人。找到合适的人却放到了不合适的岗位与没有找到合适的人一样会令招聘工作失去意义。招聘合适的人才并把人才配置到合适的地方是才能算完成了一次有效的招聘。招聘和配置有各自的侧重点,招聘工作是由需求分析-预算制定-招聘方案的制定-招聘实施-后续评估等一系列步骤构成的,其中关键又在于做好需求分析,首先明确企业到底需要什么人,需要多少人,对这些人有什么要求,以及通过什么渠道去寻找公司所需要的这些人,目标和计划明确之后,招聘工作会变得更加有的放矢。人员配置工作事实上应该在招聘需求分析之时予以考虑,这样根据岗位“量身定做”一个标准,再根据这个标准招聘企业所需人才,配置工作将会简化为一个程序性的环节。招聘与配置不能被视为各自独立的过程,而是相互影响、相互依赖的两个环节,只有招聘合适的人员并进行有效的配置才能保证招聘意义的实现。

     3、培训与开发-帮助员工胜任工作并发掘员工的最大潜能

     对于新进公司的员工来说,要尽快适应并胜任工作,除了自己努力学习,还需要公司提供帮助。对于在岗的员工来说,为了适应市场形势的变化带来的公司战略的调整,需要不断调整和提高自己的技能。基于这两个方面,组织有效培训,以最大限度开发员工的潜能变得非常必要。就内容而言,培训工作有企业文化培训,规章制度培训,岗位技能培训以及管理技能开发培训。培训工作必须做到具有针对性,要考虑不同受训者群体的具体需求。对于新进员工来说,培训工作能够帮助他们适应并胜任工作,对于在岗员工来说,培训能够帮助他们掌握岗位所需要的新技能,并帮助他们最大限度开发自己的潜能,而对于公司来说,培训工作会让企业工作顺利开展,业绩不断提高。培训与开发工作的重要性显而易见。

     4、薪酬与福利-员工激励的最有效手段之一

     薪酬与福利的作用有两点:一是对员工过去业绩的肯定;二是借助有效的薪资福利体系促进员工不断提高业绩。一个有效的薪资福利体系必须具有公平性,保证外部公平、内部公平和岗位公平。外部公平会使得企业薪酬福利在市场上具有竞争力,内部公平需要体现薪酬的纵向区别,岗位公平则需要体现同岗位员工胜任能力的差距。对过去业绩公平地肯定会让员工获得成就感,对未来薪资福利的承诺会激发员工不断提升业绩的热情。薪酬福利必须做到物质形式与非物质形式有机地结合,这样才能满足员工的不同需求,发挥员工的最大潜能。

     5、绩效管理-不同的视角,不同的结局

     绩效考核的目的在于借助一个有效的体系,通过对业绩的考核,肯定过去的业绩并期待未来绩效的不断提高。传统的绩效工作只是停留在绩效考核的层面,而现代绩效管理则更多地关注未来业绩的提高。关注点的转移使得现代绩效工作重点也开始转移。体系的有效性成为HR工作者关注的焦点。一个有效的绩效管理体系包括科学的考核指标,合理的考核标准,以及与考核结果相对应的薪资福利支付和奖惩措施。纯粹的业绩考核使得绩效管理局限在对过去工作的关注,更多地关注绩效的后续作用才能把绩效管理工作的视角转移到未来绩效的不断提高!

     6、员工关系-实现企业和员工的共赢

     员工关系的处理在于以国家相关法规政策及公司规章制度为依据,在发生劳动关系之初,明确劳动者和用人单位的权利和义务,在合同期限之内,按照合同约定处理劳动者与用人单位之间权利和义务关系。对于劳动者来说,需要借助劳动合同来确保自己的利益得到实现,同时对企业尽到应尽的义务。对于用人单位来说,劳动合同法规更多地在于规范其用工行为,维护劳动者的基本利益。但是另一方面也保障了用人单位的利益,包括对劳动者供职期限的约定,依据适用条款解雇不能胜任岗位工作的劳动者,以及合法规避劳动法规政策,为企业节约人力资本支出等。总之,员工关系管理的目的在于明确双方权利和义务,为企业业务开展提供一个稳定和谐的环境,并通过公司战略目标的达成最终实现企业和员工的共赢!

      HR各大模块的工作各有侧重点,但是各大模块是不可分割的,就象生物链一样,任何一个环节的缺失都会影响整个系统的失衡。HR工作是一个有机的整体,各个环节的工作都必须到位,同时要根据不同的情况,不断地调整工作的重点,才能保证人力资源管理保持良性运作,并支持企业战略目标的最终实现!

    展开全文
  • 这正如coding的设计模式,其实coding本没有设计模式,用的人多了,也便成了设计模式 六大原则 设计模式(面向对象)有六大原则: 开闭原则(Open Closed Principle,OCP) 里氏代换原则(Liskov Substitution ...

    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问,设计模式于己于他人于系统都是多赢的;设计模式使代码编制真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。

    借用并改编一下鲁迅老师《故乡》中的一句话,一句话概括设计模式: 希望本无所谓有,无所谓无.这正如coding的设计模式,其实coding本没有设计模式,用的人多了,也便成了设计模式

    六大原则

    设计模式(面向对象)有六大原则:

    开闭原则(Open Closed Principle,OCP)

    里氏代换原则(Liskov Substitution Principle,LSP)

    依赖倒转原则(Dependency Inversion Principle,DIP)

    接口隔离原则(Interface Segregation Principle,ISP)

    合成/聚合复用原则(Composite/Aggregate Reuse Principle,CARP)

    最小知识原则(Principle of Least Knowledge,PLK,也叫迪米特法则)

    开闭原则具有理想主义的色彩,它是面向对象设计的终极目标。其他几条,则可以看做是开闭原则的实现方法。 设计模式就是实现了这些原则,从而达到了代码复用、增加可维护性的目的。

    C# 开闭原则

    1.概念:

    一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。模块应尽量在不修改原(是“原”,指原来的代码)代码的情况下进行扩展。

    2.模拟场景:

    在软件的生命周期内,因为变化、升级和维护等原因需要对软件原有代码进行修改时,可能会给旧代码中引入错误,也可能会使我们不得不对整个功能进行重构,并且需要原有代码经过重新测试。

    3.Solution:

    当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化。

    4.注意事项:

    通过接口或者抽象类约束扩展,对扩展进行边界限定,不允许出现在接口或抽象类中不存在的public方法

    参数类型、引用对象尽量使用接口或者抽象类,而不是实现类

    抽象层尽量保持稳定,一旦确定即不允许修改

    5.开闭原则的优点:

    可复用性

    可维护性

    6.开闭原则图解:

    C# 里氏代换原则

    1.概述: 派生类(子类)对象能够替换其基类(父类)对象被调用

    2.概念:

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

    3.子类为什么可以替换父类的位置?:

    当满足继承的时候,父类肯定存在非私有成员,子类肯定是得到了父类的这些非私有成员(假设,父类的的成员全部是私有的,那么子类没办法从父类继承任何成员,也就不存在继承的概念了)。既然子类继承了父类的这些非私有成员,那么父类对象也就可以在子类对象中调用这些非私有成员。所以,子类对象可以替换父类对象的位置。

    4.C# 里氏代换原则优点:

    需求变化时,只须继承,而别的东西不会改变。由于里氏代换原则才使得开放封闭成为可能。这样使得子类在父类无需修改的话就可以扩展。

    5.C# 里氏代换原则Demo:

    代码正文:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    namespaceTestApp

    {

    using System;

    classProgram

    {

    staticvoidMain(string[] args)

    {

    Transportation transportation =newTransportation();

    transportation.Say();

    Transportation sedan =newSedan();

    sedan.Say();

    Console.ReadKey();

    }

    }

    classTransportation

    {

    publicTransportation()

    {

    Console.WriteLine("Transportation?");

    }

    publicvirtualvoidSay()

    {

    Console.WriteLine("121");

    }

    }

    classSedan:Transportation

    {

    publicSedan()

    {

    Console.WriteLine("Transportation:Sedan");

    }

    publicoverridevoidSay()

    {

    Console.WriteLine("Sedan");

    }

    }

    classBicycles : Transportation

    {

    publicBicycles()

    {

    Console.WriteLine("Transportation:Bicycles");

    }

    publicoverridevoidSay()

    {

    Console.WriteLine("Bicycles");

    }

    }

    }

    代码效果:

    6.里氏代换原则图解:

    C# 依赖倒转原则

    1.概念:

    依赖倒置原则(Dependence Inversion Principle)是程序要依赖于抽象接口,不要依赖于具体实现。简单的说就是要求对抽象进行编程,不要对实现进行编程,这样就降低了客户与实现模块间的耦合。

    2.C# 依赖倒转原则用处:

    有些时候为了代码复用,一般会把常用的代码写成函数或类库。这样开发新项目时,直接用就行了。比如做项目时大多要访问数据库,所以我们就把访问数据库的代码写成了函数。每次做项目去调用这些函数。那么我们的问题来了。我们要做新项目时,发现业务逻辑的高层模块都是一样的,但客户却希望使用不同的数据库或存储住处方式,这时就出现麻烦了。我们希望能再次利用这些高层模块,但高层模块都是与低层的访问数据库绑定在一起,没办法复用这些高层模块。所以不管是高层模块和低层模块都应该依赖于抽象,具体一点就是接口或抽象类,只要接口是稳定的,那么任何一个更改都不用担心了。

    3.注意事项:

    高层模块不应该依赖低层模块。两个都应该依赖抽象。

    抽象不应该依赖结节。细节应该依赖抽象。

    4.模拟场景:

    场景:

    假设现在需要一个Monitor工具,去运行一些已有的APP,自动化来完成我们的工作。Monitor工具需要启动这些已有的APP,并且写下Log。

    代码实现1:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    namespaceTestLibrary.ExtensionsClass

    {

    usingSystem;

    publicclassAppOne

    {

    publicboolStart()

    {

    Console.WriteLine("1号APP开始启动");

    returntrue;

    }

    publicboolExportLog()

    {

    Console.WriteLine("1号APP输出日志");

    returntrue;

    }

    }

    publicclassAppTwo

    {

    publicboolStart()

    {

    Console.WriteLine("2号APP开始启动");

    returntrue;

    }

    publicboolExportLog()

    {

    Console.WriteLine("2号APP输出日志");

    returntrue;

    }

    }

    publicclassMonitor

    {

    publicenumAppNumber

    {

    AppOne=1,

    AppTwo=2

    }

    privateAppOne appOne =newAppOne();

    privateAppTwo appTwo =newAppTwo();

    privateAppNumber number;

    publicMonitor(AppNumber number)

    {

    this.number = number;

    }

    publicboolStartApp()

    {

    returnnumber == AppNumber.AppOne ? appOne.Start() : appTwo.Start();

    }

    publicboolExportAppLog()

    {

    returnnumber == AppNumber.AppOne ? appOne.ExportLog() : appTwo.ExportLog();

    }

    }

    }

    代码解析1:

    在代码实现1中我们已经轻松实现了Monitor去运行已有APP并且写下LOG的需求。并且代码已经上线了.

    春…夏…秋…冬…

    春…夏…秋…冬…

    春…夏…秋…冬…

    就这样,三年过去了。

    一天客户找上门了,公司业务扩展了,现在需要新加3个APP用Monitor自动化。这样我们就必须得改Monitor。

    代码实现2:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66

    67

    68

    69

    70

    71

    72

    73

    74

    75

    76

    77

    78

    79

    80

    81

    82

    83

    84

    85

    namespaceTestLibrary.ExtensionsClass

    {

    usingSystem;

    usingSystem.Collections.Generic;

    usingSystem.Linq;

    usingSystem.Text;

    usingSystem.Threading.Tasks;

    publicclassMonitor

    {

    publicenumAppNumber

    {

    AppOne = 1,

    AppTwo = 2,

    AppThree = 3,

    AppFour = 4,

    AppFive = 5

    }

    privateAppOne appOne =newAppOne();

    privateAppTwo appTwo =newAppTwo();

    privateAppThree appThree =newAppThree();

    privateAppFour appFour =newAppFour();

    privateAppFive appFive =newAppFive();

    privateAppNumber number;

    publicMonitor(AppNumber number)

    {

    this.number = number;

    }

    publicboolStartApp()

    {

    boolresult =false;

    if(number == AppNumber.AppOne)

    {

    result = appOne.Start();

    }

    elseif(number == AppNumber.AppTwo)

    {

    result = appTwo.Start();

    }

    elseif(number == AppNumber.AppThree)

    {

    result = appThree.Start();

    }

    elseif(number == AppNumber.AppFour)

    {

    result = appFour.Start();

    }

    elseif(number == AppNumber.AppFive)

    {

    result = appFive.Start();

    }

    returnresult;

    }

    publicboolExportAppLog()

    {

    boolresult =false;

    if(number == AppNumber.AppOne)

    {

    result = appOne.ExportLog();

    }

    elseif(number == AppNumber.AppTwo)

    {

    result = appTwo.ExportLog();

    }

    elseif(number == AppNumber.AppThree)

    {

    result = appThree.ExportLog();

    }

    elseif(number == AppNumber.AppFour)

    {

    result = appFour.ExportLog();

    }

    elseif(number == AppNumber.AppFive)

    {

    result = appFive.ExportLog();

    }

    returnresult;

    }

    }

    }

    代码解析2:

    这样会给系统添加新的相互依赖。并且随着时间和需求的推移,会有更多的APP需要用Monitor来监测,这个Monitor工具也会被越来越对的if…else撑爆炸,而且代码随着APP越多,越难维护。最终会导致Monitor走向灭亡(下线)。

    介于这种情况,可以用Monitor这个模块来生成其它的程序,使得系统能够用在需要的APP上。OOD给我们提供了一种机制来实现这种“依赖倒置”。

    代码实现3:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    namespaceTestLibrary.ExtensionsClass

    {

    usingSystem;

    publicinterfaceIApp

    {

    boolStart();

    boolExportLog();

    }

    publicclassAppOne : IApp

    {

    publicboolStart()

    {

    Console.WriteLine("1号APP开始启动");

    returntrue;

    }

    publicboolExportLog()

    {

    Console.WriteLine("1号APP输出日志");

    returntrue;

    }

    }

    publicclassAppTwo : IApp

    {

    publicboolStart()

    {

    Console.WriteLine("2号APP开始启动");

    returntrue;

    }

    publicboolExportLog()

    {

    Console.WriteLine("2号APP输出日志");

    returntrue;

    }

    }

    publicclassMonitor

    {

    privateIApp iapp;

    publicMonitor(IApp iapp)

    {

    this.iapp = iapp;

    }

    publicboolStartApp()

    {

    returniapp.Start();

    }

    publicboolExportAppLog()

    {

    returniapp.ExportLog();

    }

    }

    }

    代码解析3:

    现在Monitor依赖于IApp这个接口,而与具体实现的APP类没有关系,所以无论再怎么添加APP都不会影响到Monitor本身,只需要去添加一个实现IApp接口的APP类就可以了。

    C# 接口隔离原则

    1.概念:

    客户端不应该依赖它不需要的接口,类间的依赖关系应该建立在最小的接口上

    2.含义:

    接口隔离原则的核心定义,不出现臃肿的接口(Fat Interface),但是“小”是有限度的,首先就是不能违反单一职责原则。

    3.模拟场景:

    一个OA系统,外部只负责提交和撤回工作流,内部负责审核和驳回工作流。

    4.代码演示:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    namespaceTestLibrary.ExtensionsClass

    {

    usingSystem;

    usingSystem.Collections.Generic;

    usingSystem.Linq;

    usingSystem.Text;

    usingSystem.Threading.Tasks;

    publicinterfaceIReview

    {

    voidReviewWorkFlow();

    voidRejectWorkFlow();

    }

    publicclassReview : IReview

    {

    publicvoidReviewWorkFlow()

    {

    Console.WriteLine("开始审核工作流");

    }

    publicvoidRejectWorkFlow()

    {

    Console.WriteLine("已经驳回工作流");

    }

    }

    publicinterfaceISubmit

    {

    voidSubmitWorkFlow();

    voidCancelWorkFlow();

    }

    publicclassSubmit : ISubmit

    {

    publicvoidSubmitWorkFlow()

    {

    Console.WriteLine("开始提交工作流");

    }

    publicvoidCancelWorkFlow()

    {

    Console.WriteLine("已经撤销工作流");

    }

    }

    }

    5.代码解析:

    其实接口隔离原则很好理解,在上面的例子里可以看出来,如果把OA的外部和内部都定义一个接口的话,那这个接口会很大,而且实现接口的类也会变得臃肿。

    C# 合成/聚合复用原则

    1.概念:

    合成/聚合复用原则(Composite/Aggregate Reuse Principle,CARP)经常又叫做合成复用原则。合成/聚合复用原则就是在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分;新的对象通过向这些对象的委派达到复用已有功能的目的。它的设计原则是:要尽量使用合成/聚合,尽量不要使用继承。

    2.合成/聚合解析:

    聚合概念:

    聚合用来表示“拥有”关系或者整体与部分的关系。代表部分的对象有可能会被多个代表整体的对象所共享,而且不一定会随着某个代表整体的对象被销毁或破坏而被销毁或破坏,部分的生命周期可以超越整体。例如,Iphone5和IOS,当Iphone5删除后,IOS还能存在,IOS可以被Iphone6引用。

    聚合关系UML类图:

    C# 合成/聚合复用原则

    代码演示:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    namespaceTestLibrary.ExtensionsClass

    {

    classIOS

    {

    }

    classIphone5

    {

    privateIOS ios;

    publicIphone5(IOS ios)

    {

    this.ios = ios;

    }

    }

    }

    合成概念:

    合成用来表示一种强得多的“拥有”关系。在一个合成关系里,部分和整体的生命周期是一样的。一个合成的新对象完全拥有对其组成部分的支配权,包括它们的创建和湮灭等。使用程序语言的术语来说,合成而成的新对象对组成部分的内存分配、内存释放有绝对的责任。一个合成关系中的成分对象是不能与另一个合成关系共享的。一个成分对象在同一个时间内只能属于一个合成关系。如果一个合成关系湮灭了,那么所有的成分对象要么自己湮灭所有的成分对象(这种情况较为普遍)要么就得将这一责任交给别人(较为罕见)。例如:水和鱼的关系,当水没了,鱼也不可能独立存在。

    合成关系UML类图:

    代码演示:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    namespaceTestLibrary.ExtensionsClass

    {

    usingSystem;

    classFish

    {

    publicFish CreateFish()

    {

    Console.WriteLine("一条小鱼儿");

    returnnewFish();

    }

    }

    classWater

    {

    privateFish fish;

    publicWater()

    {

    fish =newFish();

    }

    publicvoidCreateWater()

    {

    // 当创建了一个水的地方,那这个地方也得放点鱼进去

    fish.CreateFish();

    }

    }

    }

    3.模拟场景:

    比如说我们先摇到号(这个比较困难)了,需要为自己买一辆车,如果4S店里的车默认的配置都是一样的。那么我们只要买车就会有这些配置,这时使用了继承关系:

    不可能所有汽车的配置都是一样的,所以就有SUV和小轿车两种(只列举两种比较热门的车型),并且使用机动车对它们进行聚合使用。这时采用了合成/聚合的原则:

    C# 迪米特法则

    1.概念:

    一个软件实体应当尽可能少的与其他实体发生相互作用。每一个软件单位对其他的单位都只有最少的知识,而且局限于那些与本单位密切相关的软件单位。迪米特法则的初衷在于降低类之间的耦合。由于每个类尽量减少对其他类的依赖,因此,很容易使得系统的功能模块功能独立,相互之间不存在(或很少有)依赖关系。迪米特法则不希望类之间建立直接的联系。如果真的有需要建立联系,也希望能通过它的友元类来转达。因此,应用迪米特法则有可能造成的一个后果就是:系统中存在大量的中介类,这些类之所以存在完全是为了传递类之间的相互调用关系——这在一定程度上增加了系统的复杂度。

    2.模拟场景:

    场景:公司财务总监发出指令,让财务部门的人去统计公司已发公司的人数。

    一个常态的编程:(肯定是不符LoD的反例)

    UML类图:

    代码演示:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    namespaceTestLibrary.ExtensionsClass

    {

    usingSystem;

    usingSystem.Collections.Generic;

    ///

    /// 财务总监

    ///

    publicclassCFO

    {

    ///

    /// 财务总监发出指令,让财务部门统计已发工资人数

    ///

    publicvoidDirective(Finance finance)

    {

    List employeeList =newList();

    // 初始化已发工资人数

    for(inti = 0; i < 500; i++)

    {

    employeeList.Add(newEmployee());

    }

    // 转告财务部门开始统计已结算公司的员工

    finance.SettlementSalary(employeeList);

    }

    }

    ///

    /// 财务部

    ///

    publicclassFinance

    {

    ///

    /// 统计已结算公司的员工

    ///

    publicvoidSettlementSalary(List employeeList)

    {

    Console.WriteLine(string.Format("已结算工资人数:{0}", employeeList.Count));

    }

    }

    ///

    /// 员工

    ///

    publicclassEmployee

    {

    }

    ///

    /// 主程序

    ///

    publicclassRunner

    {

    publicstaticvoidmain(String[] args)

    {

    CFO cfo =newCFO();

    // 财务总监发出指令

    cfo.Directive(newFinance());

    }

    }

    }

    根据模拟的场景:财务总监让财务部门总结已发工资的人数。 财务总监和员工是陌生关系(即总监不需要对员工执行任何操作)。根据上述UML图和代码解决办法显然可以看出,上述做法违背了LoD法则。

    依据LoD法则解耦:(符合LoD的例子)

    UML类图:

    代码演示:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66

    67

    68

    69

    70

    71

    72

    namespaceTestLibrary.ExtensionsClass

    {

    usingSystem;

    usingSystem.Collections.Generic;

    ///

    /// 财务总监

    ///

    publicclassCFO

    {

    ///

    /// 财务总监发出指令,让财务部门统计已发工资人数

    ///

    publicvoidDirective(Finance finance)

    {

    // 通知财务部门开始统计已结算公司的员工

    finance.SettlementSalary();

    }

    }

    ///

    /// 财务部

    ///

    publicclassFinance

    {

    privateList employeeList;

    //传递公司已工资的人

    publicFinance(List _employeeList)

    {

    this.employeeList = _employeeList;

    }

    ///

    /// 统计已结算公司的员工

    ///

    publicvoidSettlementSalary()

    {

    Console.WriteLine(string.Format("已结算工资人数:{0}", employeeList.Count));

    }

    }

    ///

    /// 员工

    ///

    publicclassEmployee

    {

    }

    ///

    /// 主程序

    ///

    publicclassRunner

    {

    publicstaticvoidmain(String[] args)

    {

    List employeeList =newList();

    // 初始化已发工资人数

    for(inti = 0; i < 500; i++)

    {

    employeeList.Add(newEmployee());

    }

    CFO cfo =newCFO();

    // 财务总监发出指令

    cfo.Directive(newFinance(employeeList));

    }

    }

    }

    根据LoD原则我们需要让财务总监和员工之间没有之间的联系。这样才是遵守了迪米特法则。

    博客总结

    想搞懂设计模式,必须先知道设计模式遵循的六大原则,无论是哪种设计模式都会遵循一种或者多种原则。这是面向对象不变的法则。本文针对的是设计模式(面向对象)主要的六大原则展开的讲解,并尽量做到结合实例和UML类图,帮助大家理解。在后续的博文中还会跟进一些设计模式的实例

    展开全文
  • 1.面向对象三大特性六大原则

    千次阅读 2018-04-04 12:48:17
    JAVA是一门面向对象的语言,那么其面向对象主要有以下几个特性和原则:面向对象三大特性六大原则面向对象的三大特性是"封装、"多态"、"继承",五大原则是"单一职责原则"、"...

    JAVA是一门面向对象的语言,那么其面向对象主要有以下几个特性和原则:

    面向对象三大特性大原则

    面向对象的三大特性是"封装、"多态""继承",五大原则是"单一职责原则""开放封闭原则""里氏替换原则""依赖倒置原则""接口分离原则""迪米特原则(高内聚低耦合)"

     

    什么是面向对象

    面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

    面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术[1] 发展到一定阶段后的产物。

    这里拿 PHP OOP 举个编程实例。

    三大基本特性:封装,继承,多态

    封装

    封装,就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部,某些代码或某些数据可以是私有的,不能被外界访问。通过这种方式,对象对内部数据提供了不同级别的保护,以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

    继承

    继承,指可以让某个类型的对象获得另一个类型的对象的属性和方法。它支持按级分类的概念。继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为子类派生类,被继承的类称为基类父类超类。继承的过程,就是从一般到特殊的过程。要实现继承,可以通过继承Inheritance)和组合Composition)来实现。继承概念的实现方式有二类:实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力;接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力。

    多态

    多态,是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着,虽然针对不同对象的具体操作不同,但通过一个公共的类,它们(那些操作)可以通过相同的方式予以调用。(比如输入的形参可以不同等去实现同一个方法从而得到不同的表现形式)

    六大基本原则:SPR, OCP, LSP, DIP, ISP,LoD

    单一职责原则SRP(Single Responsibility Principle)

    指一个类的功能要单一,不能包罗万象。如同一个人一样,分配的工作不能太多,否则一天到晚虽然忙忙碌碌的,但效率却高不起来。

    开放封闭原则OCP(OpenClose Principle)

    一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。比如:一个网络模块,原来只服务端功能,而现在要加入客户端功能,那么应当在不用修改服务端功能代码的前提下,就能够增加客户端功能的实现代码,这要求在设计之初,就应当将服务端和客户端分开,公共部分抽象出来。

    里式替换原则LSP(the Liskov Substitution Principle LSP)

    子类应当可以替换父类并出现在父类能够出现的任何地方。(比如父类public,子类一定是public)比如:公司搞年度晚会,所有员工可以参加抽奖,那么不管是老员工还是新员工,也不管是总部员工还是外派员工,都应当可以参加抽奖,否则这公司就不和谐了。

    依赖倒置原则DIP(the Dependency Inversion Principle DIP)

    A.高层次的模块不应该依赖于低层次的模块他们都应该依赖于抽象。

    B.抽象不应该依赖于具体实现,具体实现应该依赖于抽象

    具体依赖抽象,上层依赖下层。高层模块就是调用端,底层模块就是具体实现类。(应该让底层模块定义抽象接口并且实现,让高层模块调用抽象接口,而不是直接调用实现类。)

    通俗来讲:依赖倒置原则的本质就是通过抽象(接口或抽象类)使个各类或模块的实现彼此独立,互不影响,实现模块间的松耦合。

    问题描述:类A直接依赖类B,假如要将类A改为依赖类C,则必须通过修改类A的代码来达成。这种场景下,类A一般是高层模块,负责复杂的业务逻辑;类B和类C是低层模块,负责基本的原子操作;假如修改类A,会给程序带来不必要的风险。

    解决方案:将类A修改为依赖接口interface,类B和类C各自实现接口interfaceA通过接口interface间接与类B或者类C发生联系,则会大大降低修改类A的几率。(比如A依赖于车的轮胎,速度,牌子等接口,然后让BC直接实现这些接口的方法,A间接通过接口与BC发生联系。)

    好处:依赖倒置的好处在小型项目中很难体现出来。但在大中型项目中可以减少需求变化引起的工作量。使并行开发更友好。

    接口分离原则ISP(the Interface Segregation Principle ISP)

    模块间要通过抽象接口隔离开,而不是通过具体的类强耦合起来,即面向接口编程。(提供接口,给其他模块调用)

    核心思想:类间的依赖关系应该建立在最小的接口上通俗来讲:建立单一接口,不要建立庞大臃肿的接口,尽量细化接口,接口中的方法尽量少。

    也就是说,我们要为各个类建立专用的接口,而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。

    问题描述:类A通过接口interface依赖类B,类C通过接口interface依赖类D,如果接口interface对于类A和类C来说不是最小接口,则类B和类D必须去实现他们不需要的方法。

    需注意:接口尽量小,但是要有限度。对接口进行细化可以提高程序设计灵活性,但是如果过小,则会造成接口数量过多,使设计复杂化。所以一定要适度提高内聚,减少对外交互。使接口用最少的方法去完成最多的事情为依赖接口的类定制服务。只暴露给调用的类它需要的方法,它不需要的方法则隐藏起来。只有专注地为一个模块提供定制服务,才能建立最小的依赖关系。

    迪米特法则(Law of Demeter,简称LoD

    核心思想:类间解耦。

    通俗来讲:一个类对自己依赖的类知道的越少越好。自从我们接触编程开始,就知道了软件编程的总的原则:低耦合,高内聚。无论是面向过程编程还是面向对象编程,只有使各个模块之间的耦合尽量的低,才能提高代码的复用率。

    耦合是:

    简单地说,软件工程中对象之间的耦合度就是对象之间的依赖性。指导使用和维护对象的主要问题是对象之间的多重依赖性。对象之间的耦合越高,维护成本越高。因此对象的设计应使类和构件之间的耦合最小。

    有软硬件之间的耦合,还有软件各模块之间的耦合。
    耦合性是程序结构中各个模块之间相互关联的度量。它取决于各个模块之间的接口的复杂程度、调用模块的方式以及哪些信息通过接口。

    耦合可以分为以下几种,它们之间的耦合度由高到低排列如下:

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

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

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

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

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

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

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

    总结
    耦合是影响软件复杂程度和设计质量的一个重要因素,在设计上我们应采用以下原则:如果模块间必须存在耦合,就尽量使用数据耦合,少用控制耦合,限制公共耦合的范围,尽量避免使用内容耦合。

    同一个模块内的各个元素之间要高度紧密,但是各个模块之间的相互依存度却要不那么紧密。


    展开全文
  • 如果模块A使用或者调用了模块B,我们称A依赖B。 低层模块:在程序设计中,一些类实现了最基本、基础的操作。我们称呼为低层模块。 高层次模块:一些类实现了复杂的逻辑封装,并且依赖低层次模块。 指导方针:1、...
  • MySQL | 数据库基础理论、六大设计范式详解

    千次阅读 多人点赞 2019-05-09 04:16:34
    MySQL基础 、关系型数据库与非关系型数据库 、从技术层面了解MySQL 、数据库的范式设计
  • OOP的六大原则+一法则

    2021-03-28 20:43:47
    主要焦距在抽象、接口、实体的关系间。面向对象编程的三特性:封装、继承、多态。具有这样特性的oop语言,在进行项目显实现是就容易达到重用性、灵活性和扩展性。 [外链图片转存失败,源站可能有防盗链机制,建议将...
  • 面向对象的六大原则

    2021-01-28 14:51:59
    而面向对象的六大原则主要的目的,就是我们如何设计类,更能很好的利用面向对象的特性。 1)单一职责原则 一个类永远只有一个职责。 一套软件就像是一个团队,每个类就是团队中的一个成员。团队如果想稳定的发展。...
  • 设计模式六大原则及其定义 单一职责原则 定义:就一个类而言应该只有一个能让他变化的原因 通俗点理解就是我们不能让一个类承担过多的职责。如果这个类承担过多的职责就大大真强其耦合度,其耦合度的增强着...
  • 亲爱的伙伴欢迎加入苏宁家庭!致南昌苏宁置业的萌新当您入职手续办理成功后,为便于您尽快融入公司,我们为您制作了《新员工入职指南》,为您介绍入司后的基本须知,望给您今后在公司的工作、生活带来帮助。1第一...
  • 又有一种说法: http://www.cnblogs.com/yuanhailiang/p/9432198.html ———————————————————————————— ...目录 设计模式六大原则(1):单一职责原则 设计模式六大...
  • 下面来总结下自己所学习的设计模式,首先我们看下各个模式之间的关系图,下面这张图是网上比较典型的一个类图关系: ​ 从上面的类图之间可以看出,学习设计模式或者说学懂完全理解所有的设计模式还是挺难的,只能...
  • 本文来说下面向对象六大原则 文章目录概述 概述
  • 六大设计原则SOLID

    2021-03-12 23:48:13
    六大设计原则SOLID一、SOLID设计模式的六大原则二、单一职责原则 (Single Responsibility Principle)1. 单一职责原则定义2.单一职责原则适用于类、接口、方法3. 单一职责原则的好处三、 开闭原则(Open Closed ...
  • 目录六大设计原则之`迪米特法则`迪米特法则总结REFRENCES更多 六大设计原则之迪米特法则 定义 迪米特法则(Law of Demeter)又叫作最少知识原则(Least Knowledge Principle 简写LKP),就是说一个对象应当对其他...
  • 六大设计原则 一、单一职责原则 1、概念描述 对类来说的,即一个类应该只负责一项职责。如果一个类负责两个职责,可能存在职责1变化,引起职责2变化的情况。可以基于抽象逻辑,或者业务逻辑对类进行细化 2、案例演示...
  • 现在编程的主流语言基本上都是面向对象的。如C#,C++,JAVA。...而面向对象的六大原则主要的目的,就是我们如何设计类,更能很好的利用面向对象的特性。单一职责原则一个类永远只有一个职责。一套软件就像...
  • 到这里,设计模式的六大原则就写完了。主要参考书籍有《设计模式》《设计模式之禅》《大话设计模式》以及网上一些零散的文章,但主要内容主要还是原文作者对这六个原则的感悟。写出来的目的一方面是对这六项原则系统...
  • 就像管理学中的一句话,如果一个职责由每个员工负责,那么这个职责就没有员工在负责。 这个原则的概念非常简单,也是非常基础的。很多人尽管没有学习过面向对象的思想,但是经常写代码之后也会不自觉的遵守这个原则...
  • android之设计模式六大原则

    千次阅读 2015-04-17 09:34:44
    设计模式六大原则1单一职责原则设计模式六大原则2里氏替换原则设计模式六大原则3依赖倒置原则设计模式六大原则4接口隔离原则设计模式六大原则5迪米特法则设计模式六大原则6开闭原则 本文转自:...
  • 设计模式六大原则详解

    千次阅读 2016-04-18 02:37:11
     需要说明的一点是单一职责原则不只是面向对象编程思想所特有的,只要是模块化的程序设计,都需要遵循这一重要原则。   二、里氏替换原则(Liskov Substitution Principle)  肯定有不少人跟我刚看到...
  • CRM、ERP、OMS、WMS、SCM、BRP,电商企业需知的六大管理系统 OA 比如典型的OA系统,模板如:OA(点击可直接使用) 框架是这样的: CRM CRM(Customer Relationship Management)即客户关系管理。 CRM即客户...
  • 59、解释对象/关系映射集成模块。 60、解释 WEB 模块。 61、Spring 配置文件 62、什么是 Spring IOC 容器?. 63、IOC 的优点是什么? 64、ApplicationContext 通常的实现是什么? 65、Bean 工厂和 Application ...
  • SAS(二)SAS基本数据类型及SAS基本模块的介绍 SAS基本介绍 SAS 是英文Statistical Analysis System的缩写,翻译成汉语是统计分析系统,最初由美国北卡罗来纳州立大学两名研究生研制,1976 年创立SAS公司, 2006年...
  • 1) 类(Class)封装了数据和行为,是面向对象的重要组成部分,它是具有相同属性、操作、关系的对象集合的总称。 2) 在系统中,每个类具有一定的职责,职责指的是类所担任的任务,即类要完成什么样的功能,要承担什么...
  • OO六大设计原则最全分析总结篇

    千次阅读 2018-04-20 09:06:14
    面向对象(OO)的基本特征: 抽象,先不考虑细节 封装,隐藏内部实现 ... OO六大设计原则: 单一职责 开闭原则 里氏替换 依赖倒置 接口隔离 迪米特法则 1. 单一职责原则(SRP) 定义...
  • 现在编程的主流语言基本上都是面向对象的。如C#,C++,JAVA。...而面向对象的六大原则 主要的目的,就是我们如何设计类,更能很好的利用面向对象的特性单一职责原则一个类永远只有一个职责。一套软件就...
  • 解析 接口设计不能太小(定义一个员工类,一级证件,二级证件,三级证件,虽然灵活性上去了,但是有的员工没有一级证件,所以要拆分这个类中的接口),不能太(灵活性太差,过于于臃肿),与单一职责类似,单一职责是...
  • 设计模式六大原则

    千次阅读 2017-05-15 16:30:19
    设计模式六大原则(1):单一职责原则 设计模式六大原则(2):里氏替换原则 设计模式六大原则(3):依赖倒置原则 设计模式六大原则(4):接口隔离原则 设计模式六大原则(5):迪米特法则 设计模式六大原则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,530
精华内容 5,412
关键字:

员工关系六大模块