精华内容
下载资源
问答
  • 对象的特征和行为称为对象的
    千次阅读
    2020-03-26 20:11:33

    一、什么是面向对象

    1、面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术发展到一定阶段后的产物。
    面向对象是相对于面向过程来讲的,面向对象方法,把相关的数据和方法组织为一个整体来看待,从更高的层次来进行系统建模,更贴近事物的自然运行模式。

    二、面向对象的优势

    2.1、与人类解决问题的思维方式一致

    2.1.1传统的结构化方法

    传统的结构化方法是面向过程实现的 ,在实现的过程中以算法作为核心,数据和过程相分离,忽略了数据和操作之间的内在的联系,问题空间和解空间并不是一致的。

    2.1.2面向对象方法

    面向对象方法是在相对于面向过程的,面向对象的方法是以对象作为核心,将数据和方法作为一个整体看待。尽可能接近人类习惯的抽象思维方法,并尽量一致地描述问题空间和解空间,从而自然而然地解决问题。

    2.2 系统的稳定性好

    面向对象方法用对象模拟问题域中的实体,以对象间的联系刻画实体间联系。当系统的功能需求变化时,不会引起软件结构的整体变化,仅需做一些局部的修改。
    由于现实世界中的实体是相对稳定的,因此,以对象为中心构造的软件系统也会比较稳定。

    2.3 可重用性好

    面向对象方法具有的继承性和封装性支持软件复用。有两种方法可以重复使用一个对象类。一是创建类的实例,从而直接使用它;二是从它派生出一个满足需要的新类,子类可以重用其父类的数据结构和程序代码,并且可以在父类的基础上方便地修改和扩充,而且子类的修改并不影响父类的使用。

    2.4.可维护性好

    由于面向对象的软件稳定性比较好,容易修改、容易理解、易于测试和调试,因而软件的可维护性就会比较好。

    2.5信息的查找速度和传播速度

    因为面向对象方式是以对象为核心的。数据在内存中是无序存放的,当有许多数据时,需要找到某个数据可能需要找遍所有数据才能找到 ,而面向对象方法可以通过对象的”键”快速找到某个数据。当某个函数需要多个数据进行传参时,不再需要一个个传参,而是将这些数据放入一个对象中进行传参,这样就只相对于传了一个数据。

    三、面向对象的特点

    3.1 继承

    一种联结类的层次模型,并且允许和鼓励类的重用,提供一种明确表达共性的方法。对象的一个新类可以从现有的类中派生,这个过程称为类继承。新类继承了原始类的特性,新类称为原始类的派生类(子类),原始类称为新类的基类(父类)。派生类可以从它的父类哪里继承方法和实例变量,并且类可以修改或增加新的方法使之更适合特殊的需要。因此可以说,继承为了重用父类代码,同时为实现多态性作准备。

    3.2 封装

    封装是面向对象的特征之一,是对象和类概念的主要特性。封装就是把过程和数据包围起来,对数据的访问只能通过已定义的界面。隐藏复杂的特点,使交互变得更简单。
    封装保证了模块具有较好的独立性,使得程序维护修改较为容易。对应用程序的修改仅限于类的内部,因而可以将应用程序修改带来的影响减少到最低限度。

    3.3多态

    多态是指允许不同类的对象对同一消息做出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活/抽象/行为共享/代码共享的优势,使程序拥有更强的动态扩展能力

    更多相关内容
  • Python类和对象1

    2020-12-22 11:44:40
    面向对象中的对象(Object),通常指客观世界存在对象对象具有唯一性,对象之间各不相同,各有特点,每个对象有自己的运动规律内部状态。 对象对象之间相互联系,相互作用,对象也可以是一个抽象事物,时间万物皆...
  •  把数据影响这个数据的操作聚合成一个对象行为称为“封装”  封装隐藏对象的属性实现细节,公对公开接口,控制程序中属性的读修改的访问级别  从外视图看,在一个对象内封装的数据是隐藏的   封装
  • 我们通过描述属性(特征和行为来描述一个对象的。比如家里的小狗,它的颜色,大小,年龄,体重等是它的属性或特征。它会汪汪叫,会摇尾巴等是它的行为。 我们在描述一个真实对象(物体)时包括两个方面: 它可以做...
  • 对象是对世界的理解抽象,世界又代称为万物。理解世界是比较复杂的,但是世界又是由事物组成的。正是这样的一种关系,认识事物是极其重要的。那什么是事物呢?事物:由事物两个方面组成。事即事情,物即物体,那...
  • 继承(加上封装多态性)是面向对象的编程的三个主要特性(也称为“支柱”)之一。 继承用于创建可重用、扩展修改在其他类中定义的行为的新类。其成员被继承的类称为“基类”,继承这些成员的类称为“派生类”。...
  • java类与对象

    2020-12-21 21:06:40
    java类与对象 类与对象的概念类的定义格式对象的创建使用对象的创建对象访问类的变量与方法成员变量默认值成员变量的封装步骤# 封装中this关键字的使用成员方法的重载overload重载的意义重载的格式构造方法构造...
  • 第三阶段:面向对象

    2020-12-23 02:06:24
    1.3面向对象 ...其中特征称为属性,行为称为方法;简单来说,类就相当于制造飞机的图纸,是一个模版是负责创造对象的,类是抽象的是负责创建对象对象是由类创造出来的一个具体存在,可以直接使用
  • 面向对象三大特性

    2020-12-22 01:28:08
    编写类时,你定义一大类对象都有的通用行为,基于类创建对象时,每个对象都自动具备这种通用行为,然后可根据需要赋予每个对象独特的个性,使用面向对象编程可以模拟现实情境。根据类来创建对象称为实例化。 封装 ...
  • 面向对象概念基本特征

    千次阅读 2018-07-23 16:24:51
    所谓的面向对象就是基于对象概念,以对象为中心,以类继承为构造机制,来认识、理解刻画客观世界设计、构建相应的软件系统。 OO (Object Oriented, 面向对象)是当前计算机界关心的重点,它是90年代软件开发的...

    1 ,什么是面向对象?

    正如每个人心中都有一个哈姆雷特一样,每个人都有对面向对象的不一样的理解

    所谓的面向对象就是基于对象概念,以对象为中心,以类和继承为构造机制,来认识、理解刻画客观世界和设计、构建相应的软件系统。

    OO (Object Oriented, 面向对象)是当前计算机界关心的重点,它是90年代软件开发的主流。面向对象的概念和应用已经超越了程序设计和软件开发,扩展到很宽的范围。如数据库系统、交互式界面、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

    OO方法(Object-Oriented Method,面向对象方法)面向对象的方法是一种把面向对象的实现应用于软件开发过程中,指导开发活动的系统方法,简称OO(Object-Oriented)方法,Object Oriented是建立在“对象”概念基础上的方法学。对象是由数据和容许的操作组成的封装体,与客观实体有直接对应关系,一个对象类定义了具有相识性质的一组对象。而每继承性是具有层次关系的类的属性和操作进行共享的一种方式。所谓的面向对象就是基于对象概念,以对象为中心,以类和继承为构造机制,来认识、理解刻画客观世界和设计、构建相应的软件系统。

    (我会在介绍完js中对象的特征后面继续介绍面向对象方法,转的一句话说明什么事面向对象方法,让你对面向对象有一个更深入的了解!)

    2 ,JS中的面向对象的基本特征

    面向对象的三个基本特征是:封装、继承、多态。在js中面向对象只有封装和继承,没有多态。

    封装:通过将一个方法或者属性声明为私用的,可以让对象的实现细节对其他对象保密以降低对象之间的耦合程度,可以保持数据的完整性并对其修改方式加以约束这样可以使代码更可靠,更易于调试。封装是面向对象的设计的基石。

    JavaScript是一门面向对象的语言,可它并不具备将成员声明为公共或私用的任何内部机制,所以我们只能自己想办法实现这种特性。下面还是通过一台完整的代码去分析,介绍什么是私有属性和方法,什么是特权属性和方法,什么是公有属性和方法,什么是公有静态属性和方法。

    私有静态属性和方法: 函数有作用域,在函数内用var 关键字声明的变量在外部无法访问,私有属性和方法本质就是你希望在对象外部无法访问的变量。

    特权属性和方法:创建属性和方法时使用的this关键字,因为这些方法定义在构造器的作用域中,所以它们可以访问到私有属性和方法;只有那些需要直接访问私有成员的方法才应该被设计为特权方法。

    公有属性和方法:直接书写在原型prototype上的属性和方法,不可以访问构造器内的私有成员,可以访问特权成员,子类会继承所有的公有方法。

    公有静态属性和方法:最好理解的方式就是把它想象成一个命名空间,实际上相当于把构造器作为命名空间使用。

     /* -- 封装 -- */
        var _packaging =function(){
           //私有属性和方法
          var name ='Darren';
           var method1 =function(){
              //...
           }
           //特权属性和方法
           this.title ='JavaScript Design Patterns' ;
          this.getName =function(){
             return name;
          }
       }
       //公有静态属性和方法
       _packaging._name ='Darren code';
       _packaging.alertName =function(){
          alert(_packaging._name);
       }
       //公有属性和方法
       _packaging.prototype = {
          init:function(){
             //...
          }
       }

    继承:继承是指这样一种能力:他可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。

    通过继承创建的新类称为 “子类” 或 “派生类”。

    被继承的类称为“基类”、“父类”  或者  “超类”。

    ① 构造函数绑定

    这一种方法最简单,使用call 或者 apply 方法,将父对象的构造函数绑定在子对象上,既在子对象构造元素中加一行代码:

    父类构造函数名.apply(this, arguments);

    Person.prototype.getName = function(){
        returnthis.name;
    }
    function Programmer(name,sex) {
        Person.call(this,name);  //在这里添加
        this.sex = sex;
    }

    ② 原型式继承 让子类的prototype对象指向父类的实例,相当于完全删除了prototype对象的原来的值,但是我们需要在原型继承js语句后面加上段代码 : 子类. prototype.constructor = 子类  ,不然子类的原型对象的构造函数属性就会指向所继承的父类prototype上的constructor(直接继承父类的原型的时候),继承父类的实例的时候回丢失constructor属性,继承完成之后当前这个子类的实例也都可以继承父类的prototype上的方法

       //直接继承父类原型
        function Parent(name) {
     		this.name = name;
     	}
     	Parent.prototype.sayHello = function() {
     		console.log("hello");
     	}
     	function Son(name) {
     		this.name = name;
     	}
     	Son.prototype = Parent.prototype;
     	Son.prototype.constructor = Son;//不加这句话Son.prototype.constructor指向Parent
     	var s = new Son();
     	s.sayHello()//hello
    // 原型式继承改进 
     	function Parent(name) {
     		this.name = name;
     	}
     	Parent.prototype.sayHello = function() {
     		console.log("hello");
     	}
     	function Son(name, age) {
     		this.name = name;
     		this.age = age;
     	}
     	Son.prototype.sayHi = function() {
     		console.log("hi");
     	}
     	Son.prototype = new Parent(); //原型继承改进继承父类的实例
     	Son.prototype.constructor = Son;//不加这句话Son.prototype.constructor会丢失
     	var s = new Son();
     	var p = new Parent();
     	s.sayHello()//hello
     	console.log(Son.prototype)
     	p.sayHi()// Uncaught TypeError: p.sayHi is not a function,父类的实例不可以调用子类的方法了

    js中对象的组成

        方法——函数:过程、动态的
        属性——变量:状态、静态的

    下面列举一些别人描述面向对象的思想

    1 ,把一组数据结构和处理它们的方法组成对象(object),把相同的对象归纳为类(class),通过类的封装(encapsulation)隐藏内部细节,通过继承(inheritance)实现类的特化(specialization) / 泛化 (generalization),通过多态(polymorphism)实现基于对象类型的动态分派(dynamic dispatch)。

    2,一种尽量降低后续扩展代码引入 side-effect 可能的代码组织手段

    3,封装:把属性值、红蓝条、攻击、走位、放技能、清兵、游走等行为都塞在一个英雄里。

    ,继承:攻击+10 的装备可以升级到攻击+20,以后还可能升级到攻击+30 并带有吸血效果。不管升级成什么,都携带着攻击+10 这部分属性。

    多态:一个团队需要一个辅助,我们只需要一个辅助英雄,并不关心来的是哪个辅助英雄,能加血就行。

    具备这三种特性的编程思想,叫做面向对象。
     

    展开全文
  • 派生:子类在父类的基础上衍生出新的特征(属性和行为) 总结:其实他们是一回事,只是描述问题的侧重点不同(继承侧重相同点,派生侧重不同点) 可以简单理解 儿子 相对于父亲 可以对父亲的家产创新 也可以变卖 可以取...
  • 而对于一个普通的对象来说,如果它的所有property名均为正整数,同时也有相应的length属性,那么虽然该对象并不是由Array构造函数所创建的,它依然呈现出数组的行为,在这种情况下,这些对象称为“类数组对象”。...
  • 终于搞懂了面向对象概念,以及它的三个基本特征:封装、继承、多态!

    什么是面向对象思想?已经学完了java确不知道如何跟别人解释面向对象是什么意思这很常见。让我们一起来回顾下这个奇思妙想~


    一、面向对象与面向过程

    现在越来越多的高级语言流行起来了,如大家耳熟能详的c++,python,java等,这些都是基于面向对象的语言
    而最最基础的,学校必学的语言----c语言它是属于面向过程的语言。
    好了,现在让我们来讨论下这两类语言的区别

    1、什么是面向过程?

    面向过程:
    就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。

    举例来说,大象装进冰箱需要几步?
    在这里插入图片描述
    按照面向过程思想:
    第一步:工作人员去打开冰箱门
    第二步:把大象塞进冰箱
    第三步:工作人员把冰箱门关上
    诶,这里我们就看出来了,面向过程就是把一件事按步骤一步一步来实现
    用代码表示

        public void openDoor(){}  //开门
        public void putIn(){}       //装冰箱
        public void closeDoor(){}   //关门
    

    依次调用这些方法就完成了

    2、什么是面向对象?

    对象,就是对问题中的事物的抽象
    面向对象:
    就是把现实中的事物都抽象为“对象”。每个对象是唯一的,且都可以拥有它的属性与行为。我们就可以通过调用这些对象的方法、属性去解决问题。

    用面向对象思想解决大象装进冰箱

    大致的了解到了对象这个概念,可以说是对现实事物的一种抽象映射
    在这里插入图片描述
    例如在这个事件中:
    冰箱作为一个对象;
    大象作为一个对象。
    冰箱有这些功能:开门、装物体、关门

    class fridge{
        public void open(大象){}   //开门
        public void putIn(大象){}  //放进冰箱
        public void close(大象){}  //关门
    }
    class elephant{
    	public void eat(){}   //吃
    }
    

    看出来了什么?每个对象是独立的,有属于它自己的功能,只需要专心实现自己的功能就好。所以在建立对象模型阶段,仅仅关注对象有什么的功能,但不考虑如何实现这些功能。

    面向对象的好处,就包括有很好的延展性,比如我给大象赋予了一个吃的功能,它通过调用就可以在冰箱里去吃东西。面向对象就是把现实问题抽象为对象,通过调用每个对象的属性或功能去解决问题。

    如果我要修改我的需求,把大象换成兔子,我用面向过程是不是得把每个步骤中的大象改为兔子。而用面向对象解决,我甚至可以重新创一个兔子对象,仅仅在调用的时候选择兔子就行了。

    二、类与对象的关系

    很多人都会创建对象,不就是new嘛,调用对象方法不就是new.方法嘛。结果,有部分人在new类的时候,就下意识的把类当成了对象,那么类到底是不是对象呢?

    肯定不是,先给出他们的基本概念

    1、基本概念

    对象
    对象是由数据(描述事物的属性)和作用于数据的操作(体现事物的行为)组成的封装体,描述客观事物的一个实体,是构成系统的基本单元。


    类是对一组有相同数据和相同操作的对象的定义,是对象的模板,其包含的方法和数据描述一组对象的共同行为和属性。类是在对象之上的抽象,对象则是类的具体化,是类的实例。类可有其子类,也可有其他类,形成类层次结构。

    2、类与对象的区别

    1)类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,占用存储空间。

    2)类是一组具有相同属性和行为的对象的抽象。我们可以将类看做是创建对象蓝图,对象根据这个蓝图去具体实现某个东西。

    比如来说,给一张“伞”的蓝图,我们设计出了晴雨伞,剑伞等等,你会发现,这些伞都有相同的行为呀----遮雨
    在这里插入图片描述

    所以,类的实例化结果就是对象,而对一类对象的抽象就是类,类描述了一组有相同属性和相同方法的对象。

    三、基本特征:封装、继承、多态

    1、封装

    (一)基本概念
    封装(encapsulation)即信息隐蔽。它是指在确定系统的某一部分内容时,应考虑到其它部分的信息及联系都在这一部分的内部进行,外部各部分之间的信息联系应尽可能的少。

    (二)四种访问控制级别

    • public:对外公开,访问级别最高
    • protected:只对同一个包中的类或者子类公开
    • 默认:只对同一个包中的类公开
    • private:不对外公开,只能在对象内部访问,访问级别最低
      在这里插入图片描述

    (三)封装使用
    1、把尽可能多的东西藏起来,对外提高简洁的接口
    比如有半自动洗衣机和一个全自动洗衣机

    半自动洗衣机接口有以下方法
    ①开机
    ②关机
    ③放水
    ④定时
    ⑤洗涤
    ⑥排水
    ⑦脱水

    全自动洗衣机有以下方法
    ①开机
    ②关机
    ③设置洗衣机模式
    ④开始洗衣服,洗完自动关

    对比来看,我们就会发现,自动洗衣机把放水、定时、洗涤、排水、脱水等细节,封装到了③设置洗衣机模式里,这样为使用者提供了更加简单易用的接口,所以自动洗衣机会更加方便。

    2、把所有属性藏起来
    加入某种属性允许外界访问,那么提供访问该属性的公开方法。假如狗类有一个名字、年龄属性,不允许外界直接访问属性,但允许提供get和set方法来访问

    class Dogs{
        private String name;  //名字
        private String age;   //年龄
        
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    }
    

    那么我们把属性设为private私有,把对外界提供设置属性的方法设置为public。

    有些人会问,既然是对外公开的,为什么不直接把name,age属性设置为public呢,反而还要通过方法来设置,会不会多此一举?

    不会,有以下四个原因:

    (一)符合现实外因通过内因起作用的客观规律
    假设原来狗就有一个叫“旺财”的名字,是对象本身原主人取的,调用了setName()方法【内因】。好了,领养狗的主人打算给狗换个名字“大黄”,他是使用者,也是调用setName()方法【外因】。

    (二)灵活控制属性的读和修改的访问级别
    比如我只能让使用者知道这狗狗的名字,但却不允许修改他。那就吧setName()设为private私有,getName()设为public公有。

    (三)防止使用者错误修改属性
    直接调用类的属性,万一改错了怎么办。所以我们可以在公有方法setName()里面添加限制条件,防止使用者错误修改属性。例如,狗狗的年龄的范围要在0~20期间。

    public void setAge(int age) {
        if (age >20 || age < 0){
            throw new IllegalArgumentException("口令不合法");
        }
        else {
            this.age = age;
        }
    }
    

    (四)有助于对象封装实现细节
    如果上述判断年龄合法的过程我们不想对使用者公开,就把这个过程用private封装成一个“透明”的方法。这个判断年龄合法的过程对使用者是透明的。

    与封装具有相同含义的一个概念就是透明。对象封装实现细节,也就意味着对象的实现细节对使用者是透明的。透明在这里理解为“看不见”

    public void setAge(int age) {
            isLegal();   //判断是否合法
            this.age = age;
        }
    
    private void isLegal(){
        if (age >20 || age < 0){
            throw new IllegalArgumentException("口令不合法");
        }
        else return;
    }
    

    2、继承

    继承:让某个类型的对象获得另一个类型的对象的属性和方法。继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

    (一)语法

    class A extends B{}

    一共继承了哪些东西呢?这要分两种情况

    • 当A和B在同一包下,A继承了B中public、protected和默认访问级别的成员变量和成员方法
    • 当A和B不在同一包下,A继承了B中public、protected成员变量和成员方法

    (二)继承父类成员变量/方法
    hanqishi继承了父类Dog

    class Dog{
        public String name="小白";
        public void say(){
            System.out.println("汪汪汪");
        }
    }
    //哈奇士
    class haqishi extends Dog {
        public void test(){
            System.out.println(name);
            say();
        }
    }
    

    调用haqishi的test()方法,测试如下

    小白
    汪汪汪

    测试结果:子类haqishi继承了父类的成员变量和成员方法

    (三)重写父类方法
    子类haqishi重写父类Dog的say方法

    class Dog{
        public String name="小白";
        public void say(){
            System.out.println("汪汪汪");
        }
    }
    //哈奇士
    class haqishi extends Dog {
        @Override
        public void say() {
            //super.say();    继承父类原有方法
            System.out.println("哈哈哈");
        }
    }
    

    调用子类say方法,测试如下:

    哈哈哈

    (四)重载父类方法
    重载方法必须满足以下条件:
    1、方法名相同
    2、方法的参数类型、个数、顺序至少有一项不同
    3、方法的返回类型可以不同
    4、方法的修饰符可以不相同

    class Dog{
        public String name="小白";
        public void say(){
            System.out.println("汪汪汪");
        }
    }
    //哈奇士
    class haqishi extends Dog {
       //重载 改变参数
        public void say(String name) {
            System.out.println(name+"汪汪汪");
        }
    	//重载 改变参数+返回值
        public int say(int age) {
            System.out.println("汪汪汪"+age);
            return age;
        }
    }
    

    分别调用
    haqishi h = new haqishi();
    h.say();
    h.say(“哈奇士”);
    h.say(6);
    结果如下:

    汪汪汪
    哈奇士汪汪汪
    汪汪汪6

    3、多态

    多态:对于同一个行为,不同的子类对象具有不同的表现形式。多态存在的3个条件:
    1)继承 2)重写 3)父类引用指向子类对象。

    public class extend {
        public static void main(String[] args) {
            Animal a = new Dog();
            Animal b = new Cat();
            a.say();
            b.say();
        }
    }
    
    abstract class Animal {
        abstract void say();
    }
    //猫
    class Cat extends Animal{
        public String name="小黑";
        public void say(){
            System.out.println("喵喵喵");
        }
    }
    //狗
    class Dog extends Animal{
        public String name="小白";
        public void say(){
            System.out.println("汪汪汪");
        }
    }
    

    运行结果

    汪汪汪
    喵喵喵

    理解多态
    在这个运行环境中,引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定。Java虚拟机会根据引用变量指向的对象来调用该对象的指定方法,这种运行机制被称为动态绑定

    参考文献:《Java面向对象编程(第2版)》- 孙卫琴

    展开全文
  • 类图和对象

    千次阅读 2019-06-30 04:52:26
    类的定义:类是具有相似结构、行为和关系的一组对象的描述符。 2.类之间的关系 2.1 关联 关联(association)是模型元素简的一种语义联系,它是对具有共同的结构特征行为特性、关系语义的链的描述。 ...

    1.类的定义

    类的定义:类是具有相似结构、行为和关系的一组对象的描述符。
    在这里插入图片描述

    2.类之间的关系

    2.1 关联
            关联(association)是模型元素简的一种语义联系,它是对具有共同的结构特征、行为特性、关系和语义的链的描述。
            在上面的定义中,需要注意的是链这个概念,链是一个实例,就像对象是累的实例一样,而链表示的是对象与对象之间的关系。
    在类图中 ,关联用一条把类连接在一起的实现表示,如图:
    在这里插入图片描述        一个关联可以有两个或多个关联端,每个关联端连接到一个类。关联也可以有方向,可以是单向关联或双向关联。如下图表示的是双向关联,表示的是从类A到类B的单向关联。
    在这里插入图片描述
    2.1.1 关联名
            可以给关联加上关联名,来描述关联的作用。如图使用关联名的一个例子,其中Company类和Person类之间的关联如果不使用关联名,则可以有多种解释,如Person类可以表示是公司的客户、雇员或所有者等。但如果在关联上加上Employs这个关联名,则表示Company类和Person类之间是雇佣(Employs)关系,显然这样语义上更加明确。一般说来,关联名通常是动词或动词短语。
    在这里插入图片描述
    2.1.2 关联的角色
            关联两端的泪可以某种角色参与关联。如下图,Company类以employer的角色、Person类以employee的角色参与关联,employer和employee称为角色类。如果在关联上没有标出角色名,则隐含地用类的名称作为角色名。
    在这里插入图片描述2.2 聚集和组合
            聚集是一种特殊形式的关联。聚集表示类之间整体与部分的关系。在对系统进行分析和设计时,需求描述中的“包含”、“组成”、“分为……部分”等词常常意味着存在聚集关系。
            组合表示的也是类之间的整体与部分的关系,但组合关系中的整体与部分具有同样的生存期。也就是说,组合是一种特殊形式的聚集。
    如图分别是聚集关系和组合关系的例子
    在这里插入图片描述
    在这里插入图片描述
            Circle类和Style类之间是聚集关系。一个圆可以有颜色、是否填充这些样式方面的属性,可以用一个style对象表示这些属性,但同一个style对象也可以表示别的对象如三角形的一些样式方面的属性,也就是说,style对象可以用于不同的地方。如果circle这个对象不存了,不一定意味着style这个对象也不存在了。
    下面列出聚集和组合之间的一些区别:

    • 聚集关系也称为”has -a"关系,组合关系也称为“contains-a"关系。
    • 聚集关系表示事物的整体/部分关系的较弱的情况,组合关系表示事物的整体/部分关系的较强的情况。
    • 在聚集关系中,代表部分事物的对象可以属于多个聚集对象,可以为多个聚集对象所共享,而且可以随时改变它所从属的的聚集对象。代表部分事物的对象与代表聚集事物对象的生存期无关,一旦删除了它的一个聚集对象,不一定也就随即删除代表部分事物的对象。在组合关系中,代表整体事物的对象负责创建和删除代表部分事物的对象,代表部分事物的对象只属于一个组合对象。一旦删除了组合对象,也就随即删除了相应的代表部分事物的对象。
    • 2.3 泛化关系
      在这里插入图片描述
              泛化(generalization)定义了一般元素和特元素之间的分类关系,如果从面向对象程序设计语言的角度来说,类与类之间的泛化关系就是平常所说的类与类之间的继承关系。
              泛化关系也称为”a -kind -of"关系。
    • 2.4 依赖关系
      在这里插入图片描述
              假设有两个元素X、Y,如果修改元素X的定义可能会导致对另一个元素Y的定义的修改,则称元素Y依赖于元素X。
              对于类而言,依赖(dependency)关系可能由各种原因引起,如一个类想另一个类发送消息,或者一个类是另一个类的数据成员类型,或者一个类是另一个类的操作的参数型等。
              有时依赖关系和关联关系比较难区分。事实上,如果类A和类B之间有关联关系,那么类A和类B之间也就有依赖关系了。但如果两个类之间有关联关系,那么一般只要表示出关联关系即可,不用再表示这两个类之间还有依赖关系。而且,如果在一个类图中有过多的依赖关系,反而会使类图难以理解。
              与关联关系不一样的是,依赖关系本身不生成专门的实现代码。
    展开全文
  • C++_类和对象

    2012-03-30 11:22:23
    类的结构(也即类的组成)是用来确定一类对象行为的,而这些行为是通过类的内部数据结构相关的操作来确定的。这些行为是通过一种操作接口来描述的(也即平时我们所看到的类的成员函数),使用者只关心的是接口的功能...
  • 抽象只关注对象有哪些属性和行为, 并不关注这些行为的细节是什么。 - 继承:继承是从已有类得到继承信息创建新类的过程。 提供继承信息的类被称为父类(超类、基类); 得到继承信息的类被称为子类(派生类)。...
  • (1) 有一个名字:每一个对象必须有一个名字,称为对象名,以区别于其他对象; (2) 有一组属性:用属性来描述它的某些特征,一般可以用数据来表示,所有的属性都有值; (3) 有一组行为: 对象的行为或功能也称为方法,一般...
  • 什么是面向对象,以及什么是类和对象

    千次阅读 多人点赞 2019-08-11 19:04:04
    什么是面向对象,以及什么是类和对象 ​ 1.1面向过程与面向对象的区别 ​ 面向对象是一种现在最为流行的程序设计方法 。将面向过程与面向对象进行比较。 ​ 首先这两个种都是一种编程思维, 在一些简单的动作...
  • python 类的定义_类和对象的关系

    千次阅读 2021-02-10 22:19:10
    对象是类的具体实例,一般称为“类的实例”。类看做“饼干模具”,对象就是根据这个“模具”,制造出来的“饼干”。从一个类创建对象时,每个对象会共享这个类的行为(类中定义的方法),但会有自己的属性值(不共享...
  • go 面向对象编程-2

    2021-01-06 13:24:54
    定义一个结构体的时候,实际上就是把一类事物的共有的属性(字段)和行为(方法)提取出来,形成一个物理模型(结构体). 这种研究问题的方法称为抽象 package main import ( fmt ) type Account struct { AccountNo ...
  • 封装是面向对象特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据方法只让可信的类或者对象操作,对不可信的进行信息隐藏。 继承 面向对象编程 (OOP) 语言...
  • java中类和对象的概念

    千次阅读 2021-02-26 09:37:31
    1首先说说类和对象是怎么那回事。(这部分对于java来说是一个非常重要的知识)今天心情很好,来学习一下java中的类和对象!Java是什么?Java是一门面向对象的编程语言(OOP),想要理解Java,首先要理解类(Class)和对象...
  • python面向对象编程之类和对象的概念

    千次阅读 多人点赞 2022-04-27 11:50:19
    面向对象是把一组数据结构处理他们的方法组成对象,把具有相同行为对象归纳成类,通过封装隐藏类的内部细节,通过继承使类得到泛化,通过多态实现基于对象类型的动态分类。 类是什么 类表示一组(或一类)对象...
  • * 面向对象 -----类与对象 课程内容 定义类 创建对象 封装 $this的使用 一、定义类 在PHP中把具有相同属性和行为对象看成同一类,把属于某个类的实例称为某个类的对象。例如学生张三与李四是两个不同的对象,两者...
  • java 面向对象特征(详解):

    千次阅读 2019-09-21 15:27:18
    首先阐述面向对象思想概述 概述 ...向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征行为特征抽象出来,描述成计算 机事件的设计思想。 它区别于面向过程思想,强调的...
  • 面向对象简称 OO(Object Oriented),20 世纪 80 年代以后,有了面向对象分析(OOA)、 面向对象设计(OOD)、面向对象程序设计(OOP)等新的系统开发方式模型的研究。 对 Java 语言来说,一切皆是对象。把现实世界...
  • 1)抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。 2)继承:继承是从已有类得到继承信息创建新类的过程。...
  • 面向对象主要有四大特性· 抽象o 忽略一个主题中与当前目标无关的东西,专注的注意与当前目标有关的方面.(就是把现实世界中的某一类东西,提取出来,用程序代码表示,...表示世界中一类事物的特征,就是对象的属性.比...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 352,371
精华内容 140,948
热门标签
关键字:

对象的特征和行为称为对象的