精华内容
下载资源
问答
  • 本文实例讲述了Javascript面向对象程序设计组合模式。分享给大家供大家参考,具体如下: 概述 关于组合模式的定义:组合模式(Composite Pattern)有时候又叫做部分-整体模式,它使我们树型结构的问题中,模糊了简单...
  • 看了侯捷老师一节课的视频,做一个记录和小结,在OOP语言中,面向对象编程,类和类之间有3种关系: 1)Inheritance(继承) 2)Composition(复合) 3)Delegation(委托) 先从Compositon开始讲起,其实在C语言中也见到...

    看了侯捷老师一节课的视频,做一个记录和小结,在OOP语言中,面向对象编程,类和类之间有3种关系:

    1)Inheritance(继承)

    2)Composition(复合)

    3)Delegation(委托)

    先从Compositon开始讲起,其实在C语言中也见到过,一个结构体里面包含另外一个结构体,在C++中复合也是一样的,侯捷老师以标准库来形象的说明了这种情况,在queue类中包含了deque类

    2个类的关系如图表示

    实心表示真的包含。那么复合关系下,这2个对象怎么产生,先后顺序是什么


    我们就像打地基一样,从底开始,我们需要component再去生成container,所以我们要在构造container之前先构造component,可以在container的初始化列表中构造,如果采用的是缺省的构造函数,编译器会自动填充(上述红色字体),但是如果不满意缺省构造函数,我们就得按自己想的写构造函数,在component()的位置上,同样的析构我们也是先从外一步一步拆到里面,所以在析构函数最后调用里面部分的析构函数。

    接下来再谈谈委托关系,委托是利用指针包含另一个类,左边有一个右边,但是这个有只是一个指针,有点虚,所以是空心的

    有这么一个指针以后,在任何时间我想要你帮忙做事情,就可以委托给你,这也是为什么复合的生命周期是一致的,而委托的生命周期是不一样的(需要时才创建)。


    string类只是对外的接口,真正的实现都在stringrep类里,当左边需要动作的时候,就去调用右边,被称为Pimpl(pointer to implementation),有一个指针去指向为我实现所有功能的类,这种手法的好处在于,这个指针还可以去指向不同的实现类,去实现不同的功能,右边不管怎么变动都不影响string类也就不影响客户端,string类也永远不用再编译。

    上述代码的实现如左下图所示,abc3个string指向一个指针,称为引用计数(共享特性)有多个字符串指向同一个hello,这时候abc互相不知道大家都在用同一个内存,如果改变a就会影响其他,怎么做到不影响呢,当a想改变时,整个系统就copy一份给a,让a改,然后降低count,称为copy and write。

    下一个关系叫做Inheritance(继承)

    public 继承表示is a,派生类是一种基类的东西,同样的继承了基类的数据。子类包含了父类,所以在构造子类之前要先构造父类,在子类的初始化列表上,同样的在析构子类的时候,也是先析构子类,再析构父类,和复合非常相似。

    继承中非常重要的是虚函数,将在下一讲中讲到

    展开全文
  • C++基础---面向对象程序设计

    千次阅读 2015-09-13 16:12:40
    面向对象编程:Object Oriented Programming(简称OOP),面向对象程序设计。 面向对象程序设计: (1)面向对象程序设计是一种计算机编程架构。面向对象程序设计的一条基本原则是计算机程序是由单个能够起到子程序...

    1. 面向对象的程序设计

    1.1 面向对象程序设计的定义

    • 面向对象编程:Object Oriented Programming(简称OOP),面向对象程序设计。
    • 面向对象程序设计:
      (1)面向对象程序设计是一种计算机编程架构,其中一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。
      (2)面向对象程序设计是一种程序设计范型,同时也是一种程序开发的方法。对象指的是类的实例。它将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性、灵活性和扩展性。
      (3)可以看作一种在程序中包含各种独立而又互相调用的对象的思想,这与传统的思想刚好相反,传统的程序设计主张将程序看作一系列函数的集合,或者直接就是一系列对电脑下达的指令。面向对象程序设计中的每一个对象都应该能够接受数据、处理数据并将数据传达给其它对象,因此它们都可以被看作一个小型的“机器”,即对象。
    • 面向对象程序设计的作用:
      (1)面向对象程序设计达到了软件工程的三个主要目标:重用性、灵活性和扩展性。为了实现整体运算,每个对象都能够接收信息、处理数据和向其它对象发送信息。
      (2)面向对象程序设计推广了程序的灵活性和可维护性,并且在大型项目设计中广为应用。
      (3)面向对象程序设计要比以往的做法更加便于学习,因为它能够让人们更简单地设计并维护程序,使得程序更加便于分析、设计、理解。
    • 面向对象程序设计中的概念:主要包括对象、类、数据抽象、继承、动态绑定、数据封装、多态性、消息传递。通过这些概念面向对象的思想得到了具体的体现。
      注:当我们提到面向对象的时候,它不仅指一种程序设计方法。它更多意义上是一种程序开发方式。在这一方面,我们必须了解更多关于面向对象系统分析和面向对象设计(Object Oriented Design,简称OOD)方面的知识。

    1.2 面对对象程序设计的步骤

    • 第一步:首先是分析需求,先不要思考怎么用程序实现它,先分析需求中稳定不变的客体都是些什么,这些客体之间的关系是什么。
    • 第二步:把第一步分析出来的需求,通过进一步扩充模型,变成可实现的、符合成本的、模块化的、低耦合高内聚的模型。
    • 第三步:使用面向对象的实现模型。
    • 具体可划分为以下步骤:
      (1)分析确定在问题空间和解空间出现的全部对象及其属性;
      (2)确定应施加于每个对象的操作,即对象固有的处理能力;
      (3)分析对象间的联系,确定对象彼此间传递的消息;
      (4)设计对象的消息模式,消息模式和处理能力共同构成对象的外部特性;
      (5)分析各个对象的外部特性,将具有相同外部特性的对象归为一类,从而确定所需要的类;
      (6)确定类间的继承关系,将各对象的公共性质放在较上层的类中描述,通过继承来共享对公共性质的描述;
      (7)设计每个类关于对象外部特性的描述;
      (8)设计每个类的内部实现(数据结构和方法);
      (9)创建所需的对象(类的实例),实现对象间应有的联系(发消息)。
      注: 面向对象是一种思想,他让我们在分析和解决问题时,把思维和重点转向现实中的客体中来,然后通过UML工具理清这些客体之间的联系,最后用面向对象的语言实现这种客体以及客体之间的联系。它分为面向对象的分析(OOA),面向对象的设计(OOD),面向对象的编程实现(OOP)三个大的步骤。面向对象技术中的“技术”泛指根据生产实践经验和自然科学原理。

    1.3 面向对象程序设计的建议

    • 你不必严格遵守这些原则,违背它们也不会被处以宗教刑罚。但你应当把这些原则看成警铃,若违背了其中的一条,那么警铃就会响起。
      —–Arthur J.Riel
      (1)所有数据都应该隐藏在所在的类的内部。
      (2)类的使用者必须依赖类的共有接口,但类不能依赖它的使用者。
      (3)尽量减少类的协议中的消息。
      (4)实现所有类都理解的最基本公有接口,例如,拷贝操作(深拷贝和浅拷贝)、相等性判断、正确输出内容、从ASCII描述解析等等。
      (5)不要把实现细节(例如放置共用代码的私有函数)放到类的公有接口中。如果类的两个方法有一段公共代码,那么就可以创建一个防止这些公共代码的私有函数。
      (6)不要以用户无法使用或不感兴趣的东西扰乱类的公有接口。
      (7)类之间应该零耦合,或者只有导出耦合关系。也即,一个类要么同另一个类毫无关系,要么只使用另一个类的公有接口中的操作。
      (8)类应该只表示一个关键抽象。包中的所有类对于同一类性质的变化应该是共同封闭的。一个变化若对一个包影响,则将对包中的所有类产生影响,而对其他的包不造成任何影响。
      (9)把相关的数据和行为集中放置。 设计者应当留意那些通过get之类操作从别的对象中获取数据的对象。这种类型的行为暗示着这条经验原则被违反了。
      (10)把不相关的信息放在另一个类中(也即:互不沟通的行为)。朝着稳定的方向进行依赖。
      (11)确保你为之建模的抽象概念是类,而不只是对象扮演的角色。
      (12)在水平方向上尽可能统一地分布系统功能,也即:按照设计,顶层类应当统一地共享工作。
      (13)在你的系统中不要创建全能类/对象。对名字包含Driver、Manager、System、Susystem的类要特别多加小心。规划一个接口而不是实现一个接口。
      (14)对公共接口中定义了大量访问方法的类多加小心。大量访问方法意味着相关数据和行为没有集中存放。
      (15)对包含太多互不沟通的行为的类多加小心。这个问题的另一表现是在你的应用程序中的类的公有接口中创建了很多的get和set函数。
      (16)在由同用户界面交互的面向对象模型构成的应用程序中,模型不应该依赖于界面,界面则应当依赖于模型。
      (17)尽可能地按照现实世界建模(我们常常为了遵守系统功能分布原则、避免全能类原则以及集中放置相关数据和行为的原则而违背这条原则) 。
      (18)从你的设计中去除不需要的类。一般来说,我们会把这个类降级成一个属性。
      (19)去除系统外的类。系统外的类的特点是,抽象地看它们只往系统领域发送消息但并不接受系统领域内其他类发出的消息。
      (20)不要把操作变成类。质疑任何名字是动词或者派生自动词的类,特别是只有一个有意义行为的类。考虑一下那个有意义的行为是否应当迁移到已经存在或者尚未发现的某个类中。
      (21)我们在创建应用程序的分析模型时常常引入代理类。在设计阶段,我们常会发现很多代理没有用的,应当去除。
      (22)尽量减少类的协作者的数量。一个类用到的其他类的数目应当尽量少。
      (23)尽量减少类和协作者之间传递的消息的数量。
      (24)尽量减少类和协作者之间的协作量,也即:减少类和协作者之间传递的不同消息的数量。
      (25)尽量减少类的扇出,也即:减少类定义的消息数和发送的消息数的乘积。
      (26)如果类包含另一个类的对象,那么包含类应当给被包含的对象发送消息。也即:包含关系总是意味着使用关系。
      (27)类中定义的大多数方法都应当在大多数时间里使用大多数数据成员。
      (28)类包含的对象数目不应当超过开发者短期记忆的容量。这个数目常常是6。当类包含多于6个数据成员时,可以把逻辑相关的数据成员划分为一组,然后用一个新的包含类去包含这一组成员。
      (29)让系统功能在窄而深的继承体系中垂直分布。
      (30)在实现语义约束时,最好根据类定义来实现。这常常会导致类泛滥成灾,在这种情况下,约束应当在类的行为中实现,通常是在构造函数中实现,但不是必须如此。
      (31)在类的构造函数中实现语义约束时,把约束测试放在构造函数领域所允许的尽量深的包含层次中。
      (32)约束所依赖的语义信息如果经常改变,那么最好放在一个集中式的第3方对象中。
      (33)约束所依赖的语义信息如果很少改变,那么最好分布在约束所涉及的各个类中。
      (34)类必须知道它包含什么,但是不能知道谁包含它。
      (35)共享字面范围(也就是被同一个类所包含)的对象相互之间不应当有使用关系。
      (36)继承只应被用来为特化层次结构建模。
      (37)派生类必须知道基类,基类不应该知道关于它们的派生类的任何信息。
      (38)基类中的所有数据都应当是私有的,不要使用保护数据。类的设计者永远都不应该把类的使用者不需要的东西放在公有接口中。
      (39)在理论上,继承层次体系应当深一点,越深越好。
      (40)在实践中,继承层次体系的深度不应当超出一个普通人的短期记忆能力。一个广为接受的深度值是6 。
      (41)所有的抽象类都应当是基类。
      (42)所有的基类都应当是抽象类。
      (43)把数据、行为和/或接口的共性尽可能地放到继承层次体系的高端。
      (44)如果两个或更多个类共享公共数据(但没有公共行为),那么应当把公共数据放在一个类中,每个共享这个数据的类都包含这个类。
      (45)如果两个或更多个类有共同的数据和行为(就是方法),那么这些类的每一个都应当从一个表示了这些数据和方法的公共基类继承。
      (46)如果两个或更多个类共享公共接口(指的是消息,而不是方法),那么只有他们需要被多态地使用时,他们才应当从一个公共基类继承。 (47)对对象类型的显示的分情况分析一般是错误的。在大多数这样的情况下,设计者应当使用多态。
      (48)对属性值的显示的分情况分析常常是错误的。类应当解耦合成一个继承层次结构,每个属性值都被变换成一个派生类。
      (49)不要通过继承关系来为类的动态语义建模。试图用静态语义关系来为动态语义建模会导致在运行时切换类型。
      (50)不要把类的对象变成派生类。对任何只有一个实例的派生类都要多加小心。
      (51)如果你觉得需要在运行时刻创建新的类,那么退后一步以认清你要创建的是对象。现在,把这些对象概括成一个类。
      (52)在派生类中用空方法(也就是什么也不做的方法)来覆写基类中的方法应当是非法的。
      (53)不要把可选包含同对继承的需要相混淆。把可选包含建模成继承会带来泛滥成灾的类。
      (54)在创建继承层次时,试着创建可复用的框架,而不是可复用的组件。
      (55)如果你在设计中使用了多重继承,先假设你犯了错误。如果没犯错误,你需要设法证明。
      (56)只要在面向对象设计中用到了继承,问自己两个问题:(1)派生类是否是它继承的那个东西的一个特殊类型?(2)基类是不是派生类的一部分?
      (57)如果你在一个面向对象设计中发现了多重继承关系,确保没有哪个基类实际上是另一个基类的派生类。
      (58)在面向对象设计中如果你需要在包含关系和关联关系间作出选择,请选择包含关系。
      (59)不要把全局数据或全局函数用于类的对象的薄记工作。应当使用类变量或类方法。
      (60)面向对象设计者不应当让物理设计准则来破坏他们的逻辑设计。但是,在对逻辑设计作出决策的过程中我们经常用到物理设计准则。
      (61)不要绕开公共接口去修改对象的状态。

    参考文献:
    [1] 百度搜索关键字:面向对象程序设计

    展开全文
  • JavaScript面向对象程序设计——对象前言 JaveScript虽然说是支持面向对象编程方法,但是JavaScript的面向对象在其他的强类型的面向对象语言(如Java,C#)甚至在其他弱类型的脚本语言(如Python)其面向对象的...

    JavaScript面向对象程序设计——对象

    前言

     JaveScript虽然说是支持面向对象的编程方法,但是JavaScript的面向对象在其他的强类型的面向对象语言(如Java,C#)甚至在其他弱类型的脚本语言(如Python)其面向对象的特性可以用捉襟见肘来形容,需要通过一定的技巧才能勉强实现其他面向对象语言的特性。通过这一系列文章来介绍一下JavaScript面向对象的编程方法,也供我复习一下原生JavaScript的特性。

    简介

     说到面向对象编程肯定少不了对象这一概念,对象作为一系列属性和方法的封装,体现了面向对象编程的封装性。JavaScript中所有对象都继承于Object,z最基础的创建对象以及添加属性和方法的方式就是

    var o=new Object();
    o.value1="1";
    o.value2="2";
    o.getValue1=function(){
        return this.value1;
    };
    

    但这种方式并没有体现出封装性的特点,添加属性和方法的场合很零散,不容易管理。所以接下来会介绍JavaScript创建具有封装性的对象的几种方法。
    如果只是想了解创建对象的最实用方法可以直接跳到组合使用构造函数模式和原型模式

    具有封装性对象的构造

     具有封装性对象的构造的常用模式主要包括:

    • 工厂模式
    • 构造函数模式
    • 原型模式
    • 组合使用构造函数模式和原型模式
    • 动态原型模式
    • 寄生构造函数模式
    • 稳妥构造函数模式(安全性)

    工厂模式

     工厂模式是属于最简单的一种构造对象的模式。其思想很简单,就是使用一个函数,在函数内部创建一个Object对象,然后将属性和方法赋予这个对象,接着返回这个对象的引用,具体如下:

    function Person(name,age,job){
        var o=new Object();
        o.name=name;
        o.age=age;
        o.job=job;
        o.sayName=function(){
            return this.name;
        }
    }
    var person1=function("John",18,"Police");
    

    这种方法很轻地解决了对象封装性的问题,但没有起到识别对象的作用。什么是识别对象呢?就是在这个额例子中你并不知道这是一个Peron对象,它只会反应出它是一个Object对象。详细见下面截图。为了解决这个问题就出现了构造函数模式。

    工厂模式不能识别对象

    构造函数模式

     JavaScript中的构造函数跟传统面向对象语言的构造函数不是同一个概念。

    任何函数只要使用new操作符来调用,那它就可以作为构造函数。

    ——《JavaScript高级程序设计》

    我们知道Function也是一种特殊的Object,所以我们也可以给Function对象添加相应的属性,然后再加上封装性的要求,然后就可以通过一下代码使用构造函数模式重写Person对象的代码

    function Person(name,age,job){
        this.name=name;
        this.age=age;
        this.job=job;
        this.sayName=function(){
            return this.name;
        }
    }
    var person1=new Person("John",18,"Police");
    

    这样就能解决对象识别的问题,从下图我们可以看到person1Person对象的实例。

    构造函数模式识别对象

    那么构造函数模式是不是完美了呢,并不是。构造函数模式虽然能够完美的解决对象识别和封装性的问题,但是它并没有解决共有属性的统一引用的问题。例如我创建两个Person对象的实例person1person2,他们两个都有方法sayName()的引用但它们两个不是同一个引用,而是分别创建的两个方法。

    构造函数模式统一引用问题

    为了解决统一引用的问题有人想了一种方法,如下

    function sayName(){
        return this.name;
    }
    function Person(name,age,job){
        this.name=name;
        this.age=age;
        this.job=jobl
        this.sayName=sayName;
    }
    var person1=new Person("John",18,"Police");
    var person2=new Person("Jerry",18,"Doctor");
    

    解决统一引用

    这种方法虽然解决了统一引用的问题,但破坏了对象的封装性。为了解决统一引用问题,就出现了原型模式

    原型模式

     原型prototype是一个指向一个对象的指针,每一个函数都有这么一个指针。prototype对象是按照特定的规则产生的。在这里我们只需要了解一点,对象实例可以访问对象原型中的值,但不可以重写原型中的值。通过以下代码可以验证

    function Person(){}
    Person.prototype.name="Jerry";
    person1=new Person();
    person2=new Person();
    console.log(person1.name);//Jerry
    console.log(person2.name);//Jerry
    person2.name="John";
    console.log(person1.name);//Jerry
    console.log(person2.name);//John
    

    当你修改person2实例的name属性时并不会修改对象原型的值,只会给对象实例新增加一个属性并为他赋予新值。

    原型可读不可写

    原型模式创建对象就像上面的代码一样就行,但单纯的原型模式创建出的对象实例并没有自己私有的属性,所有属性都是共有的,这就和构造函数模式构成了两个极端了,一个是完全共享,一个是完全私有。为了权衡这两者之间的关系我们就将这两者混合起来出现了组合使用构造函数模式和原型模式。

    组合使用构造函数模式和原型模式

     这种模式是创建自定义对象最常见的模式。构造函数模式用于定义实例属性,而原型模式用于定义方法和共有属性。
    首先通过构造函数模式定义实例属性

    function Person(name,age,job){
        this.name=name;
        this.age=age;
        this.job=job;
    }
    

    然后通过原型模式定义方法和共有属性以及定义构造函数

    Person.prototype={
        constructor:Person,
        sayName:function(){
            return this.name;
        }
    }
    

    然后就可以创建实例了

    var person1=new Person("John",18,"Police");
    var person2=new Perons("Jerry",19,"Doctor");
    

    最终的效果如下

    完美的对象构造

    这种构造函数与原型混成的模式,是目前ECMAScript中使用最广泛,认同度最高的一种创建自定义类型的方法。可以说,这是用来定义引用类型的一种默认模式

    ——《JavaScript高级程序设计》

    既然我们已经有了接近完美的方法,那么接下来的几种方式,就是在特定情况下使用的方式。

    动态原型模式

     动态原型模式是对组合使用构造函数模式和原型模式的改良,虽然上述的模式很好,但是对象的构造函数和原型是独立存在的,对于传统的面向对象语言来说还是不足。所以有人就想办法在构造函数中初始化原型。这种模式的合兴是通过检查某个应该存在的方法或这共有属性判断原型是否需要初始化。通过这种模式重写Person对象

    function Person(name,age,job){
        this.name=name;
        this.age=age;
        this.job=job;
    
        if(typeof this.sayName!="function"){
            Person.prototype.sayName=function(){
                return this.name;
            };
        }
    }
    

    这样就有更好的封装性,并且保持了同时使用构造函数和原型的优点。

    寄生构造函数模式

     寄生构造函数模式是比较特殊的模式,存在的问题和工厂模式存在的问题一样,但却有着跟构造函数模式一样的写法。这种模式在可以使用其他模式的情况下不使用用。使用的场景一般只用在为原生的对象添加其它自定义方法时使用,如我们创建一个特殊的Array对象

    function SpecialArray(){
        var values=new Array();
    
        values.push.apply(values,arguments);
    
        values.toPipedString=function(){
            return this.join("|");
        }
    
        return values;
    }
    
    var colors=new SpecialArray("red","blue","green");
    console.log(colors.toPipedString());//"red|blue|green"
    

    这里我们就创建了SpecialArray对象,比普通的Array对象多了toPipedString()方法。

    稳妥构造函数模式

     稳团构造函数模式主要是用来构造稳妥对象的,

    所谓的稳妥对象,指的是没有公共属性,而且其方法也不引用this对象。

    ——《JavaScript高级程序设计》

    稳妥构造函数模式与寄生构造函数模式类似,不同点是:创建对象的实例方法不引用this,不适用new操作符调用构造函数。
    代码如下

    function Person(name,age,job){
        var o=new Object();
    
        o.sayName=function(){
            return name;
        }
    
        return o
    }
    

    在这里除了实例的sayName()方法外,没有其他任何的方法访问到对象的name属性。这个模式保证了即使有其他的代码给这个对象添加方法或者成员,但也不可能有别的方法访问传入到构造函数中的原始数据。所以稳妥构造函数模式能够提供一定的安全性。

    总结

     通过这篇博客我们浏览了JavaScript中面向对象设计中关于创建具有封装性对象的一般模式。也了解了接近最优的创建方法,以及一些创建特殊用途对象的方法。看完之后可能会有人说ES6已经支持class关键字了不必要再死抠ES5的历史问题了,其实class关键字只是一个语法糖

    ES2015 classes are a simple sugar over the prototype-based OO pattern. ——Learn ES2015·Babel

    所以对JS构造对象的理解对于理解ES6还是是有一点用处的。

    参考资料《JavaScript高级程序设计》
    展开全文
  • 看了侯捷老师一节课的视频,做一个记录和小结,在OOP语言中,面向对象编程,类和类之间有3种关系: 1)Inheritance(继承) 2)Composition(复合、组合) 3)Delegation(委托、聚合) 先从Compositon开始讲起,其实在...

    看了侯捷老师一节课的视频,做一个记录和小结,在OOP语言中,面向对象编程,类和类之间有3种关系:

    1)Inheritance(继承)

    2)Composition(复合、组合)

    3)Delegation(委托、聚合)

    先从Compositon开始讲起,其实在C语言中也见到过,一个结构体里面包含另外一个结构体,在C++中复合也是一样的,侯捷老师以标准库来形象的说明了这种情况,在queue类中包含了deque类

    2个类的关系如图表示

    菱形所在一端为A,箭头一端为B,A has B。

    实心表示真的包含。那么复合关系下,这2个对象怎么产生,先后顺序是什么

    我们就像打地基一样,从底开始,我们需要component再去生成container,所以我们要在构造container之前先构造component,可以在container的初始化列表中构造,如果采用的是缺省的构造函数,编译器会自动填充(上述红色字体),但是如果不满意缺省构造函数,我们就得按自己想的写构造函数,在component()的位置上,同样的析构我们也是先从外一步一步拆到里面,所以在析构函数最后调用里面部分的析构函数。

    接下来再谈谈委托关系,委托是利用指针包含另一个类,左边有一个右边,但是这个有只是一个指针,有点虚,所以是空心的

    在很多UML图中直接使用箭头,没有空心菱形,但也代表委托(聚合),这也是最常见的UML符号

    有这么一个指针以后,在任何时间我想要你帮忙做事情,就可以委托给你,这也是为什么复合的生命周期是一致的,而委托的生命周期是不一样的(需要时才创建)。

    string类只是对外的接口,真正的实现都在stringrep类里,当左边需要动作的时候,就去调用右边,被称为Pimpl(pointer to implementation),有一个指针去指向为我实现所有功能的类,这种手法的好处在于,这个指针还可以去指向不同的实现类,去实现不同的功能,右边不管怎么变动都不影响string类也就不影响客户端,string类也永远不用再编译。

    上述代码的实现如左下图所示,abc3个string指向一个指针,称为引用计数(共享特性)有多个字符串指向同一个hello,这时候abc互相不知道大家都在用同一个内存,如果改变a就会影响其他,怎么做到不影响呢,当a想改变时,整个系统就copy一份给a,让a改,然后降低count,称为copy and write。

    下一个关系叫做Inheritance(继承)

    public 继承表示is a,派生类是一种基类的东西,同样的继承了基类的数据。子类包含了父类,所以在构造子类之前要先构造父类,在子类的初始化列表上,同样的在析构子类的时候,也是先析构子类,再析构父类,和复合非常相似。

    继承中非常重要的是虚函数,将在下一讲中讲到
     

    展开全文
  • Go:面向对象编程

    万次阅读 2020-06-01 09:49:21
    Go语言面向对象编程
  • 面向对象程序设计

    千次阅读 2020-12-09 15:37:28
    一、面向对象程序设计的基本概念 1.面向对象的基本思想 (1)客观事物是由对象组成的,对象是在原事物基础上抽象的结果。 (2)对象是由属性和操作组成的,其属性反映了对象的数据信息特征,而操作则用来定义改变对象...
  • 1.Java面向对象编程的特点 9 2.继承 10 2.1继承 10 2.2.Super关键字: 10 2.3.this关键字: 10 2.4.子类对象的构造和初始化: 11 2.5.方法的覆盖: 11 2.6.各种数据类型之间的相互转换: 12 3.静态...
  • OOP 面向对象编程

    千次阅读 2019-12-09 11:34:20
    //实际编码实现阶段则是面向对象编程[OOP] 在面向对象设计这一环节中,我们将需求描述转化为具体的类的设计。 这个环节的工作可以拆分为下面四个部分。 1. 划分职责进而识别出有...
  • 在学习面向对象设计对象关系时,依赖、关联、聚合和组合这四种关系之间区别比较容易混淆。特别是后三种,仅仅是在语义上有所区别,所谓语义就是指上下文环境、特定情景等。他们在编程语言中的体现却是基本相同的,...
  • 面向对象程序设计步骤

    千次阅读 2017-08-21 10:03:09
    面向对象程序设计的第一步,就是在问题领域中识别出有效的对象,然后从识别出的对象中抽象出类来。面对纷繁复杂的现实问题,往往存在多种对象划分的方式,而不同的划分会带来类的设计以至于程序结构的各种不同。对象...
  • 面向对象编程

    千次阅读 2020-12-23 17:17:18
    面向对象编程的核心就是对象二字, 对象是特征与技能的集合体 也可以说对象是一个容器, 用来盛放 数据(特征) 和 功能(技能) 优点 : 提高程序的解耦合性, 进而提高程序的可扩展性, 对某一个对象单独修改, 会立刻反
  • 目录 目录 前言 组合 派生 ...我们定义一个类是希望能够把类当成模块来...组合: 就是将不同的类混合并加入到其他类中, 来 增加类的功能 / 提高代码的重用性 / 易于维护(对类的修改会直接反应到整个应用中) . 我们可以
  • 一、结构化程序设计 传统的程序设计方法可以归结为“程序=算法+数据结构”,将程序定义为处理数据的一系列过程。这种设计方法的着眼点是面向过程的,特点是数据与程序分离,即数据与数据处理分离。 结构化程序设计...
  • 面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标:...
  • 面向对象编程思想

    千次阅读 2018-05-17 23:30:50
    面向对象的基本概念: 面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。 OOP是一种...
  • 一、什么是面向对象程序设计? 1、所有的东西都是对象;对象保存着数据,且可对它自身进行操作; 2、可从要解决的问题上提出概念性的组件,然后再程序中将其表达为一个对象,(头、身体、手、腿组成一个人); 3...
  • OOP面向对象:类与类之间的关系,分为三种:Inheritance(继承)、Composition(组合)、Delegation(委托) **基于对象:单一类的封装Composition组合,表示has-a关系看一个栗子,如图此class里有(has-a)deque,...
  • 面向对象编程(OOP)

    2019-09-15 22:13:37
    面向对象程序设计(Object Oriented Programming,OOP)是一种计算机编程架构。OOP的一条基本原则是计算机程序由单个能够起到子程序作用的单元或对象组合而成。OOP达到了软件工程的三个主要目标:重用性、灵活性和...
  • <一> 面向对象程序设计语言的三大原则 <br /> 一个面向对象的语言在处理对象时,必须遵循的三个原则是:封装、继承和多态。 (1)封装  所谓“封装”,就是用一个框架把数据和代码组合在一起...
  • 面向对象又是这其中最主流的,现在大部分编程语言都是面向对象编程语言。大部分项目也是基于面向对象风格开发的。面向对象拥有丰富的特性(封装、抽象、继承、多态),可以实现很多复杂的设计思路,是很多设计原则、...
  • Java面向对象编程的特征 Java重要的特性之一是它完全面向对象的编程语言,其核心是用人类解决问题的抽象方法对复杂的客观问题进行分析、组织和解答。面向对象的编程语言是利用类和对象将问题的数据和操作封装起来,...
  • 面向对象程序设计思想的魅力

    千次阅读 2014-09-13 00:30:21
    说说面向对象程序设计 在学习面向程序之前,我先学了C语言,也就是面向过程的程序设计。学完C后的第一个感觉只能编写一些及其简单的题目,什么判断大小,或者利用一些循环语句,用批量判断大小。最起码我那时还不懂...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 125,884
精华内容 50,353
关键字:

组合关系面向对象编程