精华内容
下载资源
问答
  • 面向对象三要素

    2015-05-01 20:20:53
    面向对象三要素是:封装 继承 多态 封装  封装就是事物抽象为类,把对外接口暴露,将实现和内部数据隐藏。 继承 面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力:它可以使用...

    面向对象三要素是:封装 继承 多态

    o_OOBase.gif

    封装

     封装就是事物抽象为类,把对外接口暴露,将实现和内部数据隐藏。

    继承
    面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。
    通过继承创建的新类称为“子类”或“派生类”。
    被继承的类称为“基类”、“父类”或“超类”。
    继承的过程,就是从一般到特殊的过程。
    要实现继承,可以通过“继承”(Inheritance)和“组合”(Composition)来实现。
    在某些 OOP 语言中,一个子类可以继承多个基类。但是一般情况下,一个子类只能有一个基类,要实现多重继承,可以通过多级继承来实现。
     
    继承概念的实现方式有三类:实现继承、接口继承和可视继承。
    Ø          实现继承是指使用基类的属性和方法而无需额外编码的能力;
    Ø          接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力;
    Ø          可视继承是指子窗体(类)使用基窗体(类)的外观和实现代码的能力。
    在考虑使用继承时,有一点需要注意,那就是两个类之间的关系应该是“属于”关系。例如,Employee 是一个人,Manager 也是一个人,因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类,因为腿并不是一个人。
    抽象类仅定义将由子类创建的一般属性和方法,创建抽象类时,请使用关键字 Interface 而不是 Class。
    OO开发范式大致为:划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
     
    多态
    多态性(polymorphisn)是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。
    实现多态,有二种方式,覆盖,重载。
    覆盖,是指子类重新定义父类的虚函数的做法。
    重载,是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。
    其实,重载的概念并不属于“面向对象编程”,重载的实现是:编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(至少对于编译器来说是这样的)。如,有两个同名函数:function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的:int_func、str_func。对于这两个函数的调用,在编译器间就已经确定了,是静态的(记住:是静态)。也就是说,它们的地址在编译期就绑定了(早绑定),因此,重载和多态无关!真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后,父类指针根据赋给它的不同的子类指针,动态(记住:是动态!)的调用属于子类的该函数,这样的函数调用在编译期间是无法确定的(调用的子类的虚函数的地址无法给出)。因此,这样的函数地址是在运行期绑定的(晚邦定)。结论就是:重载只是一种语言特性,与多态无关,与面向对象也无关!引用一句Bruce Eckel的话:“不要犯傻,如果它不是晚邦定,它就不是多态。”
    那么,多态的作用是什么呢?我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用!多态的作用,就是为了类在继承和派生的时候,保证使用“家谱”中任一类的实例的某一属性时的正确调用。
     
    概念讲解
    泛化( Generalization
    o_Generalization.gif
    图表 1 泛化
    在上图中,空心的三角表示继承关系(类继承),在 UML 的术语中,这种关系被称为泛化( Generalization )。 Person( ) 是基类, Teacher( 教师 ) Student( 学生 ) Guest( 来宾 ) 是子类。
    若在逻辑上B是A的“一种”,并且A的所有功能和属性对B而言都有意义,则允许B继承A的功能和属性。
    例如, 教师是人, Teacher  Person 的“一种”( a kind of  )。那么类 Teacher可以从类 Person派生(继承)。
    如果A是基类,B是A的派生类,那么B将继承A的数据和函数。
    如果类A和类B毫不相关,不可以为了使B的功能更多些而让B继承A的功能和属性。
    若在逻辑上B是A的“一种”(a kind of ),则允许B继承A的功能和属性。
     
    聚合(组合)
    o_aggregationBase.gif
    图表 2 组合
    若在逻辑上A是B的“一部分”(a part of),则不允许B从A派生,而是要用A和其它东西组合出B。
    例如,眼(Eye)、鼻(Nose)、口(Mouth)、耳(Ear)是头(Head)的一部分,所以类Head应该由类Eye、Nose、Mouth、Ear组合而成,不是派生(继承)而成。
     
    聚合的类型分为无、共享( 聚合)、复合( 组合)三类。
     
    聚合( aggregation
     
    o_aggregation.gif
    图表 3 共享
    上面图中,有一个菱形(空心)表示聚合( aggregation )(聚合类型为共享),聚合的意义表示 has-a 关系。聚合是一种相对松散的关系,聚合类 B 不需要对被聚合的类 A 负责。
     
    组合( composition
    o_composition.gif
    图表 4 复合
    这幅图与上面的唯一区别是菱形为实心的,它代表了一种更为坚固的关系 —— 组合( composition )(聚合类型为复合)。组合表示的关系也是 has-a ,不过在这里, A 的生命期受 B 控制。即 A 会随着 B 的创建而创建,随 B 的消亡而消亡。
     
    依赖 (Dependency)
    o_Dependency.gif
    图表 5 依赖
    这里 B A 的关系只是一种依赖 (Dependency) 关系,这种关系表明,如果类 A 被修改,那么类 B 会受到影响。
    展开全文
  • 在开始面向对象设计模式之前,我们必须了解一下什么是面向对象,什么是面向对象三要素面向对象面向对象编程(Object Oriented Programming),所以也叫做OOP,这与我们早期的面向过程很不一样。早期计算机处理...

    在开始面向对象设计模式之前,我们必须了解一下什么是面向对象,什么是面向对象三要素。

    面向对象:面向对象编程(Object Oriented Programming),所以也叫做OOP,这与我们早期的面向过程很不一样。早期计算机处理的问题都不是很复杂,所以一个算法,一个数据结构就能够很好的解决当时的问题。但是随着计算机技术的发展,要处理的计算机问题越来越复杂。为了更好的解决这样的问题,就出现了一切皆对象的面向对象编程,把计算机中的东西比喻成现实生活中的一样事物,一个对象。那现实生活中的对象都会有属性和行为,这就对应着计算机中的属性和方法(函数)。简答的说,就是一些属性和方法的集合,可以通过new 方法来生成对象实例。

    下面我们介绍面向对象的三要素,并且结合JS(有可能是TS)来解释三种特性。

    1:继承

    所谓继承就是在无需修改原有类的情况下,对该类进行属性和功能上面的扩展。通过继承创建的类称为子类或者派生类,被继承的类被称为父类或者超类。

    JS实现继承的方式有很多,比如原型继承,组合继承,寄生组合等(这不是重点),我们这里直接使用es6的语法糖extends.

    class Person {
        constructor(name, age) {
            this.name = name;
            this.age = age;
        }
        speak() {
            console.log(`I am ${this.name}, ${this.age} years old.`)
        }
    }
    
    
    class Student extends Person {
        constructor(name, age, grade) {
            super(name, age);
            this.grade = grade;
        }
        doHomework() {
            console.log(`I am a student and need to do homework.`)
        }
    }
    
    const xiaozhang = new Student("xiaozhang", 21, "A-3");
    
    xiaozhang.speak();
    xiaozhang.doHomework();

    这里我们先写了一个父类(人类,里面有一些基本属性,姓名和年龄,一个基本方法speak),还写了一个子类(继承于人类)里面额外有一个属性grade和一个方法doHomework()。我们调用speak和grade方法,都成功的打印了。

    为什么可以使用name,age speak了?这都需要归功于继承这个功能,student在不需要额外扩展下就继承了父类的方法。

    我们可以通过继承把公共的方法抽离出来,需要使用的类只需要继承它,那么就减少了代码的冗余和复杂度,提高了利用率。

    2:封装

    封装:就是把事物(属性和操作属性的方法)封装分成类,并且根据需要可以规定那些类可以访问那些属性或者方法。简答的说一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部,某些代码或某些数据可以是私有的,不能被外界访问,某个是可以给外界访问的,是共用的,而有一些只能给子类使用。

    这里涉及的主要是三个修饰符,private(私有的),public(共有的),protected(受保护的)

    因为原生JS没有提供这样类似的修饰符,所以我们就使用typescript来测试一下

    http://www.typescriptlang.org/play/    (测试ts的位置)

    我们看一下如下代码

     class Person {
        name //共用
        age
        protected weight
        constructor(name, age) {
            this.name = name;
            this.age = age;
            this.weight = 120;
        }
        speak() {
            console.log(`I am ${this.name}, ${this.age} years old.`)
        }
    }
    
    
    class Student extends Person {
        private grade
        constructor(name, age, grade) {
            super(name, age);
            this.grade = grade;
        }
        doHomework() {
            console.log(`I am a student and need to do homework.`)
        }
        getWeight() {
            console.log(`${this.weight}`)
        }
    }
    
    const xiaozhang = new Student("xiaozhang", 21, "A-3");
    xiaozhang.getWeight();
    console.log(xiaozhang.grade);

    我们定义了俩个public属性name age 一个protected weight  在子类Student中 我们定义了一个私有属性privategrade,然后生成了一个实例xiaozhang  访问getWeight是可以正常访问,但是访问grade时就出现错误了,错误也很明显了。

    我们在外面访问weight了?同样出错。这很正常因为修饰符的原因。

    使用这些修饰符,我们可以减少耦合,因为我们可以控制暴露率,一些不想暴露的就不暴露(这些在js一般是规定_开头的)

    而且也利于管理。

    3:多态

    通俗易懂的讲,就是同一操作当操作对象不一样时,那么执行的操作也就不同。简答的说就是把做什么和谁来做,怎么做解耦。

    看如下例子

    class Person {
        constructor(name, age) {
            this.name = name;
            this.age = age;
        }
        speak() {
            console.log(`I am ${this.name}, ${this.age} years old.`)
        }
    }
    
    
    class Student extends Person {
        constructor(name, age, grade) {
            super(name, age);
            this.grade = grade;
        }
        speak() {
            console.log(`I am a student.`)
        }
    }
    
    const xiaozhang = new Student("xiaozhang", 21, "A-3");
    const p = new Person("p", 26);
    xiaozhang.speak();
    p.speak();
    

    我们生成了俩个实例,分别调用speak方法,就分别调用了自己的speak方法。

    多态分为编译时多态和运行时多态。其中编辑时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来区分不同的函数,通过编辑之后会变成两个不同的函数,在运行时谈不上多态。而运行时多态是动态的,它是通过动态绑定来实现的,也就是我们所说的多态性。但是JS语言比较特殊,并不存在方法重载,并且在继承方面也与传统的接口/类不同,所以在JavaScript中大多是通过子类重写父类方法的方式实现多态,就像上面这段代码一样。

    比如我还可以换一种写法。

    class Person {
        constructor(name, age) {
            this.name = name;
            this.age = age;
        }
    }
    class Student extends Person {
        constructor(name, age, grade) {
            super(name, age);
            this.grade = grade;
        }
    }
    
    function speak(object) {
        if (object instanceof Student) {
            console.log(`Student`)
        } else if (object instanceof Person) {
            console.log(`Person`)
        }
    }
    
    const xiaozhang = new Student("xiaozhang", 21, "A-3");
    const p = new Person("p", 26);
    speak(xiaozhang);
    speak(p);
    

    通过if else判断来进行(但是我这里必须要强调一点  ,speak里面通过if else来进行 ,这是一个很low的代码,学了后面的设计模式就明白了,因为这样很不利于扩展,不满足面向对象设计原则)

    上面的面向对象的三要素是很基础的内容,也是学习设计模式的基础知识。

     

    最后我们谈一下为什么要使用面向对象。

    我们知道一般程序执行是三种,判断,顺序,循环,非常简单,我们平时写的大部分代码都逃不开这三种(有一种goto但是不推荐使用)。这三种执行方式满足了我平时开发的所有需求,以至于不需要第四种,我可以称着三种方式结构化。

    那么我们使用面向对象的原因是想实现数据结构化。

    你假象一下,如果我们没有使用面向对象,那么假设有一个人,那么他可以有姓名,性别,年龄,身份证号,男女朋友,同学,朋友,父母,亲戚,老师,同事,爱好等 还有一些行为例如吃饭 睡觉 工作 学习 看电影 听音乐等。假如我们没有实现数据结构化,这些数据随便存放,那么一个人可能你还觉得还ok,假设有1千万个人了,那么这些数据处理起来,就可麻烦大了。

    使用面向对象,我们将这些属性和对象封装起来实现数据结构化,那么处理起来就简单多了。

    编程我们追求的就是简单和抽象。

    简单的前提是抽象,抽象是为了简单。

    大家可以看左边个人分类的目录,跟着一起学习。

     

    展开全文
  • 面向对象三要素五原则六视点 一、面向对象三要素 1、封装; 2、继承; 3、多态。 二、面向对象五原则 1、单一职责原则; 2、开放-封闭原则(对扩展开放;对修改关闭); 3、Liskov替换原则(子类型必须能够...

    面向对象三要素五原则六视点

    一、面向对象三要素

    1、封装;

    2、继承;

    3、多态。

    二、面向对象五原则

    1、单一职责原则;

    2、开放-封闭原则(对扩展开放;对修改关闭);

    3、Liskov替换原则(子类型必须能够完全替换其父类型(继承);关注行为的替换(多态));

    4、依赖倒置原则(依赖抽象;面向接口编程等);

    5、接口隔离原则(接口尽量小;接口要稳定,职责要单一;多个小接口比一个大的通用接口要好等)。

    三、面向对象六视点

    1、复用(代理、原型模式);

    2、扩展(代理、访问者模式);

    3、分离(桥接模式);

    4、变化(策略模式);

    5、简约(单例、外观模式);

    6、一致(适配、组合模式)。

    展开全文
  • 面向对象三要素  封装(Encapsulation) 继承(Inheritance)  多态(Polymorphism) 面向对象五原则 单一职责原则(SRP) 开放-封闭原则(OCP) Liskov替换原则(LSP)依赖倒置原则(DIP)接口隔离原则(ISP) 面向...
    面向对象
    三要素 
    

     封装(Encapsulation)
    继承(Inheritance)
     多态(Polymorphism)
    面向对象五原则
    单一职责原则(SRP)
    开放-封闭原则(OCP)
    Liskov替换原则(LSP)
    依赖倒置原则(DIP)
    接口隔离原则(ISP)
    面向对象六视点
     复用(Reusibility)
    扩展(Extensibility)
    分离(Separability)
    变化(Change)
    简约(Simplicity)
    一致(Coherance)
    展开全文
  • Python面向对象3要素-多态  作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任。 转载于:https://www.cnblogs.com/yinzhengjie/p/11179289.html...
  • ZT :面向对象三要素

    千次阅读 2008-04-20 14:21:00
    面向对象三要素是封装 继承 多态 封装 封装就是事物抽象为类,把对外接口暴露,将实现和内部数据隐藏。继承面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力:它可以使用现有类的所有功能...
  • ** 对象的属性是对象的特征, 事件是对象发生了什么事情, 方法就是这个事情的活动。 事件有很多,比如你扎气球这个事件,对象是气球,属性是易爆炸,方法是扎。这就构成了一个完整的事件。在编程中通过对对象的属性...
  • 面向对象三要素--初窥

    千次阅读 2012-09-20 21:21:01
    由于明天要做软工的作业,老师让我们写一写面向对象三要素是怎样体现的 首先是封装,其实在最开始学习的时候,我一直没有弄明白所谓的类到底是什么东西,先前只是在课本上看到面向对象个特征封装,继承,多态...
  • 面向对象三要素的作用

    千次阅读 2012-07-22 19:00:53
    封装可以隐藏实现细节,使得代码模块化。 继承可以扩展已存在的代码模块(类);...通俗说,多态的本质就是将子类类型的指针赋值给父类类型的指针,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作
  • 面向对象个基本特征是:封装、继承、多态。 一 封装  封装就是将数据与操作数据的源代码进行有机的结合,形成类,其中数据和函数都是类的成员。隐藏了类的实现,类的使用者只需知道公共的接口,就可以...
  • 面向对象三要素 封装(Encapsulation) 继承(Inheritance) 多态(Polymorphism) 面向对象六视点 复用(Reusibility) 扩展(Extensibility) 分离(Separability) 面向对象五原则 单一职责原则(SRP) ...
  • C#之面向对象三要素

    千次阅读 热门讨论 2018-04-29 21:24:50
    一、面向对象1、什么是面向对象面向对象是一种思想,面向对象是将功能等通过对象来实现,将功能封装进对象之中,让对象去实现具体的细节,在面向对象中,将数据作为第一位,而方法或者说是算法作为其次,这是对...
  • 学习面向对象面向对象的基本概念:对象和其他基本要素
  • 面向对象个基本要素: 封装、继承、多态 面向对象的五个基本原则: 单一职责原则、开放封闭原则、Liskov替换原则、依赖倒置原则、接口抽象原则
  • VB面向对象三要素理解。

    千次阅读 热门讨论 2019-10-13 11:02:20
    面向对象比较通俗的解释:对象使人们要进行研究的任何事物,从最简单的整数到复杂的飞机等均可以看做对象,他不仅能表示具体的事物,还能表示抽象的规则,计划或事件。 VB就是使用了面向对象程序设计(OOP)方法,从...
  • VB中面向对象三要素及实例

    千次阅读 2019-10-13 10:44:05
    面向对象的程序设计(Object Oriented Programming,OOP)是一种全新的程序设计方法,它从根本上改变了传统的“面向过程的程序设计”模式。现实世界是由各种动作主体组成。一个复杂的动作主体又是由若干简单的动作体...
  • 面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。 2. 继承: 继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一...
  • 面向对象三要素五大原则

    千次阅读 2013-09-03 20:57:55
    要素:封装、继承、多态 参考文章: http://blog.csdn.net/wangjunkg/article/details/3762132   一、单一职责原则: 全称:“Single-Responsibility Principle” 说明:就一个类而言...
  • 面向对象三要素(即面向对象三大特性)  封装(Encapsulation)  继承(Inheritance)  多态(Polymorphism) 面向对象五原则  单一职责原则(SRP)  开放-封闭原则(OCP)  Liskov替换原则(LSP)  依赖倒置...
  • 面向对象三要素,五原则 笔记

    千次阅读 2012-09-27 00:27:13
    三要素:封装、继承、多态 五原则: 单一职责原则(Single Resposibility Principle) 开放封闭原则(Open-Close Principle):对扩展开放,对修改封闭 Liskov 替换原则: 参考...
  • 面向对象实践编程

    2018-06-25 15:37:47
    第一节:面向对象三要素 第二节:面向对象设计的步骤 第节:需求分析 第四节:设计 第五节:编码和测试

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,961
精华内容 17,984
关键字:

面向对象三要素