精华内容
下载资源
问答
  • 2019-12-07 21:10:29

    面向对象方法学与结构化方法学的异同

    面向对象方法与结构化方法都是软件开发过程中的方法。在传统的软件开发过程中多采用结构化技术完成软件开发的一系列工作,但这种方法并不适应发型软件产品的开发,而随着硬件发展,对于大型软件产品的需求又逐步提高,于是面向对象方法就应运而生。面向对象方法在上世纪八十年代中期开始被人们所关注的,而到了九十年代,面向对象方法学已经成为开发大型软件的首选范型。面向对象方法学的极大推广在目前并没有完全取代传统方法学说明了面向对象方法学目前也有缺陷需要进一步提高。那么面向对象方法学和结构化方法学之间的异同点有哪些呢,笔者认为二者不同点主要有以下几个方面:

    一、开发思想方面

    结构化方法开发的背景是在上世纪六十年代末提出软件危机之后,为了应对软件危机,软件开发的先辈们模仿当时比较成熟的工程化生产而提出一种方法。而这种方法也确实减轻或者说缓解了软件危机。结构化方法学的思想是面向过程,自上而下、逐步地分解问题,把一个大问题分解成多个小问题,小问题再分解成多个更小的问题,直到保证底层的问题足够简单,容易解决。

    面向对象方法学在开始,是编程语言而被引入的。而把对象作为编程的实体最早是上世纪六十年代由Simula 67语言引入思维。在结构化方法学提出几年之后,上世纪八十年代面向对象方法学逐渐走上历史的舞台,并在之后乃至现在大放异彩。面向对象方法学的思想是面向对象,以对象为中心,把数据封装在对象内部成为对象的属性,把面向过程的函数转为对象的行为方法,把对象抽象成为类,用以描述和设计、开发软件系统。

    二、基本概念方面

    结构化方法学又被称生命周期方法学或传统方法学。软件从设计者诞生开发想法起始,到没有人用、被废弃结束,称为软件的生命周期。传统的软件开发方法中,软件的生存周期分为三个大的阶段,即软件定义阶段,开发阶段,维护阶段。详细又可以分为问题定义、可行性分析、需求分析、系统设计、系统实现、后期维护等阶段。

    面向对象方法学是一种把面向对象程序设计语言的思想应用于软件开发过程,指导开发过程的方法。面向对象方法学由以下三部分面向对象分析、面向对象设计、面向对象程序设计组成。面向对象开发是按照人的逻辑概念,思维方式去解决问题,使软件开发时的代码重用性和可靠性大大提高。也使软件更容易被人理解,从而提高软件后期运行易维护性。

    三、开发过程方面

    结构化开发分为以下五个阶段

    1、系统规划阶段

    系统规划阶段的内容主要为明确软件的发展规划,确定用户对软件需求,并制定软件开发的计划。

    2、系统分析阶段

    系统分析阶段的内容有解析软件所对应的工作任务,工作任务中的数据和数据流图,软件的功能所需要的技术支持和选择。

    3、系统设计阶段

    系统设计阶段的工作有设计系统总体的结构,相关硬件设施的建设,相关环境的建立与进一步确定和数据库、数据结构设计等。

    4、系统实施阶段

    系统实施阶段的内容为按照上衣阶段的成果,协调技术人员开始编程同时对软件编程开发人员展开培训,测试等相关任务。

    5、系统运行阶段

    系统运行阶段的工作包括以下三个部分即对软件的运行管理,用户评价反馈,后台数据监省察。在软件运行时,一定会出现一些问题,这是也一定需要对软件进行修改,维护和调整,又时甚至会出现影响比较大的问题,如用户需求发生重大改变,相关技术革新,例如网络系统的更新换代,平台的升级更新,虽然这些问题可能出现的时间会比较晚,但也要即使监管并进行相关软件功能或者模块的升级。

    面相对象开发分为以下四个阶段

    1、面向对象分析阶段(OOA)

    这一阶段的工作主要有需求分析以及建立相关需求模型。具体来说就是建立软件中需要的相关的完整的对象,包括这些对象应具有的属性和相关行为。

    2、面向对象设计阶段(OOD)

    这个阶段的主要任务就是将上一阶段得到的需求转化为有技术能力实现的,成本符合预算的并且能够达到用户需求的软件实现方案。具体呢就是确定软件的高层架构,确定需要的类以及对外接口和实现算法等。

    3、面向对象编程阶段(OOP)

    此阶段的工作内容就是实现上一阶段的设计结果,并在编程的过程中修正出现的设计不到位的部分,实现预计的各项功能。

    4、面向对象测试阶段(OOT)

    面向对象测试阶段的主要工作任务就是测试软件各项功能是否存在问题,各项性能如容错性,稳定性,安全性等各项性能,以让软件不断完善。

    四、优劣对比的方面

    结构化方法开发

    优点

    1、传统方法学吧软件的大生命周期分成了许多小的阶段,每一个小阶段又可以分为其他多个不同的阶段,知道每个阶段的任务足够简单,实现相对独立,这样在开发时的分工合作就会比较简单,这样面对一些相同软件便可以流水线式快速高效开发。

    2、在传统方法学软件生命周期每一个阶段都会细细划分,这样也便于科学的管理开发进度使开发工作可以科学条理的开展,而且由于传统方法学中有着非常严格的审查制度,只有审查合格之后才可以进行下一阶段的开发工作。这可以在一定程度上保证软件的质量及其可维护性。而且值得肯定的是这种开发方法由于使用时间较长使其管理层面和技术层面都比较成熟,所以在一些简单的软件开发中,它的效率很高,甚至在当代一些软件开发仍然或多或少地使用传统方法学进行开发。

    缺点

    1、由于传统方法学的开发只能串行开发,前面的工作如果没有做好,就会给后面的工作带来非常大的麻烦,所以它的生产效率总体来说会比较低。

    2、由于其面向过程的局限性,软件的重用性非常差,程序冗余比较严重

    3、因为软件代码冗余比较多,这就会给后期的开发带来许多困难,这就使得软件的可维护性很低,由此带来的软件容错性、稳定性也比较低。

    4.开发出的软件无法很好地满足用户需求。由于用户一般是非专业人员,其所使用的语言逻辑,描述都可能有误差,这就导致呢软件在满足用户需求上效果不佳。

    面向对象方法开发

    优点

    1、面向对象方法学的开发逻辑和人的逻辑思维方法相近。开发大型软件难度相对降低,易被人所理解,同时也可以更好的满足客户需求。
    2、可以灵活的修改软件,软件稳定性高,这就使的后期可维护性有了很大的提高。而后期的软件升级也相对更加容易,更加稳定。

    3、面向对象的程序可重用性有了很大的提高,减少了程序冗余,代码重复,这在一定程度上也降低了开发难度,同时便于维护。

    缺点

    1、面向对象开发也存在着许多弊端,由于面向对象对环境的依赖,虽然大部分拥有了不错的跨平台性能,但需要依赖环境的支持,而相关的开发软件并不全面充分。

    2、面向对象开发不大适合比较大型的信息管理系统开发,而如果从整体设计划分不合理的情况下,会导致系统结构有较大缺陷,关系无法正常分配。

    3、由于其开发逻辑思维与人相似,所以无法从科学的角度管理和优化开发。

    五、对以上总结如下:

    传统方法学编程是以过程为中心的,尽量把大的程序划分为许多个相对独立、功能尽可能简单的小的程序模块,其强调重视过程,重视功能的结构化,和简单化。最终实现功能是通过一系列过程的调用和处理来完成。虽然经过时间累积开发人员们的不断完善,传统开发方法一直都有新的成果,模式出现,但无可避免的被面向对象开发方法所冲击。

    面向对象编程是将对象作为中心的,其功能的实现是对一系列相关对象的操作,给对象发送消息,再由对象来执行相对应的一系列操作并返回结果,重在强调对象。而在理论上,面向对象的程序设计方法可以生产更良好的模块内聚和耦合特性,更好得实现软件开发的逻辑原则,这也使得面向对开发的软件更易于重用与维护,也相对更加稳定,质量也相对更高。

    更多相关内容
  • 主要介绍了JavaScript面向对象三个基本特征,结合实例形式详细分析了JavaScript面向对象三个基本特征封装、继承与多态的概念、原理、用法与操作注意事项,需要的朋友可以参考下
  • js面向对象入门

    2021-01-21 11:55:36
    面向对象特点 封装 对于一些功能相同或者相似的代码,我们可以放到一个函数去,多次用到此功能时,我们只需要调用即可,无需多次重写。 这里我们可以理解为创造对象的几种模式:单例模式,工厂模式,构造函数...
  • #面向对象程序设计可以看作一种程序包含各种独立而又互相调用的对象的思想,这与传统的思想刚好相反: #传统的程序设计主张将程序看作一系列函数的集合,或者直接就是一系列对电脑下达的指令。 #面向对象程序设计...
  • 从某种意义上来说,多态是面向对象中重要的一部分,也是实施继承的主要目的。 一个实例可以拥有多个类型,它既可以是这种类型,也可以是那种类型,这种多种状态被称为类的多态。 多态的表现形式很多,其中继承和重载...
  • 如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征头脑里头形成一个基本面向对象的概念,这样有助于你更容易的学习Python的面向对象编程。 接下来我们就来了解关于...
  • 面向对象方法基本概念1)对象在面向对象程序设计方法中,对象是系统用来描述客观事物的一个实体,是构成系统的一个基本单位,它由一组表示其静态特征的属性和它执行的一组操作组成。对象的基本特点:(1)标识的...

    d32e19939d4e11d26c68d428ef8fde5f.png

    6365232312401906159791679.JPG

    面向对象方法的基本概念

    1)对象

    在面向对象程序设计方法中,对象是系统中用来描述客观事物的一个实体,是构成系统的一个基本单位,它由一组表示其静态特征的属性和它执行的一组操作组成。

    对象的基本特点:

    (1)标识的唯一性

    对象是可区分的,并且由对象的内在本质来区分,而不是通过描述来区分。

    (2)分类性

    指可以将具有相同属性和操作的对象抽象成类。

    (3)多态性

    指同一个操作可以是不同对象的行为。

    (4)封装性

    从外面看只能看到对象的外部特征,即只需知道数据的取值范围和可以对该数据施加的操作,根本无需知道数据的具体结构以及实现操作的算法。

    (5)模块独立性好

    从模块的独立性考虑,对象内容各种元素彼此相结合得很紧密,内聚性强。

    2)类和实例

    将属性、操作相似的对象归为类。具有共同的属性、共同的方法的对象的集合,即是类。

    3)消息

    消息是一个实例与另一个实例之间传递的信息,它请求对象执行某一处理或回答某一个要求的信息,它统一了数据流和控制流。

    消息只包含传递者的要求,它告诉接受者需要做哪些处理,并不指示接受者怎样去完成这些处理。

    4)继承

    继承是使用已有的类定义作为基础建立新类的定义技术。已有的类可当作基类来引用,则新类相应地可作为派生类来引用。

    继承即是指能够直接获得已有的性质和特征,而不必重复定义它们。

    5)多态性

    对象根据所接受的消息而做出动作,同样的消息被不同的对象接受时可导致完全不同的行动,该现象称为多态性。

    在面向对象技术中,多态性是指子类对象可以像父类对象那样使用,同样的消息可以发送给父类对象也可以发送给子类对象。

    多态性机制增加了面向对象软件系统的灵活性,减少了信息冗余,而且显著提高了软件的可重用性可扩充性。

    考无忧小编推荐:

    更多计算机等级考试真题及答案>>>点击查看

    想知道更多关于计算机等级报考指南、考试时间和考试信息的最新资讯在这里>>>

    本文网址:http://www.k51.com.cn/info/jsjdjks/1801/2323098.html

    展开全文
  • 二、面向对象有什么特征? 三、什么是构造函数和析构函数? 四、面向对象的作用域范围有哪几种? 五、PHP 魔术方法有哪些? 六、什么是对象克隆? 七、this、self和parent的区别是什么? 八、抽象类与接口...
  • 面向对象

    2021-01-07 10:58:00
    面向对象的分析 ooa 面向对象的设计 ood 面向对象的编程 oop 什么是类? -类是现实实际不存在,是一个模版,一个概念 -类代表一类事物 -对象a和对象b之间具有共同特征,进行抽象总结出一个模版,这个模版称为类 什么...
  • 面向对象设计的方法,设计一个圆的类,包括计算圆的直径、圆的周长和圆的面积的方法。 【问题描述】 用面向对象设计的方法,设计一个圆的类,包括计算圆的直径、圆的周长和圆的面积的方法。 【基本要求】 采用...
  • 面向对象编程

    2021-07-13 22:54:56
    1. 面向对象概念 ...识别真实对象的状态和行为是开始思考面向对象编程一种良好的方法。 软件对象概念上与真实对象相似:它们也由状态和行为组成。对象将其状态存储字段,并通过方法公开其行为。方法对对象的

    1. 面向对象概念

    1.1 什么是对象

    对象是相关状态和行为的包装,软件对象通常用于对日常生活中找到真实对象进行建模。

    对象是理解面向对象技术的关键。看看周围,你会发现有许多真实世界的对象的例子:你的狗狗、笔记本、桌子、显示器、自行车。

    显示世界的对象有两个特征:状态和行为。狗有状态(名称,颜色,品种)和行为(吠叫,跑,摇尾巴)。识别真实对象的状态和行为是开始思考面向对象编程一种良好的方法。

    软件对象在概念上与真实对象相似:它们也由状态和行为组成。对象将其状态存储在字段中,并通过方法公开其行为。方法对对象的内部状态进行操作,并充当对象和对象通信的主要机制。隐藏内部状态并要求通过对象的方法执行所有交互称为数据封装,这是面向对象编程的基本原则。

    在这里插入图片描述

    将代码捆绑到单个对象中提供了许多好处:

    1. 模块化:对象的源代码可以独立于其它对象的源代码编写和维护。创建后,可以在系统内轻松传递对象;
    2. 信息隐藏(封装):仅通过与对象的方法交互,其内部实现的详细信息仍然隐藏在对象内部;
    3. 代码可重用:如果一个对象已经存在,你可以在程序中使用该对象。这允许你实现/测试/调试复杂的任务的特定对象,然后可以信任这些对象在自己的代码中运行;
    4. 可插拔性和调试的易用性:如果特定对象出现问题,只需要将其从程序中删除,然后插入其它对象作为替换对象即可。这类似于在现实世界中修复机械问题,如果螺栓断裂,则更换螺栓而不是更换整台机器。

    在 Java 的编程世界中,一切皆对象。

    1.2 类

    类是创建对象的蓝图或原型。

    在现实世界中,有许多同一种个体。比如成千上万辆自行车具有相同的品牌和型号。每辆自行车都是根据相同的设计图制造的,因此包含相同的组件。用面向对象的术语来说,你的自行车是称为自行车的一个类对象的实例。类是从中创建单个对象的蓝图。

    自行车类的实现可能为:

    class Bicycle {
        int cadence = 0;
        int speed = 0;
        int gear = 1;
        
        void changeCadence(int newValue) {
            cadence = newValue;
        }
        
        void changeGear(int newValue) {
            gear = newValue;
        }
        
        void speedUp(int increment) {
            speedUp = speed + increment;
        }
        
        void applyBrakes(int decrement) {
            speed = speed - decrement;
        }
        
        void printStates() {
            System.out.println("cadence:" + cadence + " speed:" + speed + " gear:" + gear);
        }
    }
    

    此类是基于上文对自行车对象的讨论。字段 cadence,speed,gear 表示该对象的状态,并且通过 changeCadence(int), changeGear(int), speedUp(int) 方法与外部进行交互(这些方法可以修改其状态)。

    2. 面向对象三大特征

    2.1 面向对象 – 封装

       封装是指把一个对象的状态信息(也就是属性或成员变量)隐藏在对象内部,不允许外部对象直接访问对象的内部信息。但是对象自己可以提供一些可以被外界访问的方法来操作属性。如果属性不想被外界访问,我们可以不提供方法给外界访问。但是如果一个类没有提供任何外界访问的方法,那么这个类也就没有任何的意义了。封装增加了代码的安全性和可维护性。

    public class Person {
    	// id 属性私有化
    	private int id;
    	// name 属性私有化
    	private String name;
    	
      // 设置私有化id的方法
    	public void setId(int id) {
    		this.id = id;
    	}
    	// 获取私有化id的方法
    	public int getId() {
    		return id;
    	}
    	
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	public String getName() {
    		return name;
    	}
    }
    

    2.2 面向对象 - 继承

    不同类的对象之间有一些共同点。例如,山地自行车、公路自行车和双人自行车都具有自行车的特征(当前速度、踏板节奏、当前档位)。然而,每个自行车还定义了一些特有的功能:双人自行车有两个座位和两个车把;公路自行车有下降的车把;一些山地自行车有一个附加的链环,使他们的齿轮比更低。

    面向对象的编程允许类从其他类继承常用的状态和行为。在这个例子中,Bicycle 现在变成了MountainBike、RoadBike、TandemBike的父类。在 Java 编程语言中,每个类都可以有一个直接的超类,并且每个超类都有无限数量的子类的可能。增加代码的复用性。

    class MountainBike extends Bicycle {
        //......
    }
    

    在这里插入图片描述

    判断继承关系的简单规则:is-a

    “is-a” 规则,例如,每个经理是一个员工,主管是一个员工;

    “is-a” 规则的另一中表述法是置换法则。它表明程序中出现超类对象的任何地方都可以用子类对象置换,例如:

    Employee e; // 雇员
    e = new Employee(); // 普通雇员是一个雇员
    e = new Manager();  // 主管雇员是一个雇员
    

    注意:

    1. 子类拥有父类对象所有的属性和方法(包括私有属性和私有方法),但是子类无法访问父类中的私有属性和私有方法,只是拥有;
    2. 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展;
    3. 子类可以用自己的方式实现父类的方法(重写)

    2.2.2 重写

    重写就是子类对父类方法的重新改造,子类返回值、方法名称和参数列表必须相同,访问修饰符不低于父类(public, protected, defalt),抛出异常范围必须小于等于父类抛出的异常,内部实现逻辑可以改变。

    重写小结:

    1. 只有继承才会发生重写;
    2. 重写发生在运行期,是子类对父类方法进行重新编写和实现;
    3. 重写方法返回值、方法名、参数列表必须相同,否则就不构成重写;
    4. 抛出异常范围小于等于父类抛出异常的范围;
    5. 访问修饰符范围大于或等于父类访问修饰符范围;
    6. final 修饰的类不能被继承(因为 final 修饰的类是不可被修改的),所以其方法不能被重写;
    7. 父类方法访问修饰符为 private/final/staic 时,子类不能重写该方法,但 static 方法可以被在此声明(因为static方法属于类);
    8. 构造方法无法被重写;

    2.3 面向对象 - 多态

    多态在是继承的情况下对象的一种表现形式。

    “is-a” 置换法则中,Employee 可以引用一个 Employee 对象,也可以引用一个 Employee 类的子类对象 Manager 等,这种员工的表现形式(普通员工,主管)称为多态。简单的说就是一个对象具有多种形态,具体表现就是父类的引用指向子类的实例。

    Employee e; // 雇员
    e = new Employee(); // 普通雇员是一个雇员
    e = new Manager();  // 主管雇员是一个雇员
    

    小结:

    • 多态条件:继承、重写、父类指向子类对象;
    • 对象类型和引用类型之间具有继承/实现关系;
    • 引用类型变量发出的方法调用到底是哪个类中的方法,必须在程序运行期间才能确定;
    • 多态不能调用只在子类存在但在父类不存在的方法;
    • 如果子类重写了父类的方法,真正执行的是子类覆盖的方法,如果子类没有覆盖父类的方法,执行的是父类的方法。

    3. 面向对象设计的七大原则

    3.1 开闭原则 - Open Close Principle(OCP)

    3.1.1 定义

    一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。

    3.1.2 基本概念

    • 开:对扩展开放,支持方便的扩展;
    • 闭:对修改关闭,严格限制对已有内容的修改;

    说明:一个软件产品只要在声明周期内,都会发生变化,既然变化是不可避免的,我们就应该在设计时尽量适应这些变化,以提高项目的稳定性和灵活性,真正实现”拥抱变化“。开闭原则告诉我们尽量通过扩展软件实体的行为来实现变化,而不是通过修改现有代码来完成变化,它是为软件实体的未来事件而定制的对现有开发设计进行约束的一个原则。

    注:任何对老接口的修改都会带来一定的风险。

    3.1.3 优点

    • 提高项目稳定性(任何对老接口的直接修改都有一定的风险);
    • 提高可复用性;
    • 提高可维护性;

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

    3.2.1 定义

    不要存在多于一个导致类变更的原因。

    3.2.2 基本概念

    • 单一职责是高内聚低耦合的一个体现;

    说明:通俗的讲就是一个类只能负责一个职责,就像流水线上的工人一样,每个人负责一件事情,修改一个类不能影响到别的功能,也就是说只有一个导致该类被修改的原因。

    3.2.3 优点

    • 高内聚,低耦合,代码修改时影响范围小;
    • 降低类的复杂度,职责分明,提高可读性;
    • 变更引起的风险低,利于维护;

    3.3 里氏替换原则 - Liskov Substitution Principle(LSP)

    3.3.1 定义

    所有引用基类的地方必须能透明地使用其子类对象。

    如果对每一个类型为 T1 的对象 o1,都有类型为 T2 的对象 o2,使得以 T1 定义的所有程序 P 在所有的对象 o1 都替换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 T1 的子类型。

    3.3.2 基本概念

    里氏替换原则强调的设计和实现要依赖于抽象而非具体;子类只能去扩展基类,而不是隐藏或者覆盖基类它包含以下 4 层含义:

    1. 子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法。
    2. 子类中可以增加自己特有的方法;
    3. 当子类的方法重载父类的方法时,方法的前置条件(即方法的形参)要比父类方法的输入参数更宽松;
    4. 当子类的方法实现父类的抽象方法时,方法的后置条件(即方法的返回值)要比父类更严格。

    3.3.3 优点

    • 开闭原则的体现,约束继承泛滥;
    • 提高系统的健壮性、扩展性和兼容性;

    3.4 依赖倒置原则 - Dependence Inversion Principle(DIP)

    3.4.1 定义

    高层模块应该依赖底层模块,二者都应该依赖其抽象;抽象不应该依赖细节,细节应该依赖抽象。

    3.4.2 基本概念

    • 依赖倒置原则的核心就是要我们面向接口编程,理解了面向接口编程,也就理解了依赖倒置;
    • 低层模块尽量都要有抽象类或接口,或者两者都有;
    • 变量的声明类型尽量是抽象类或接口;
    • 使用继承时遵循里氏替换原则;
    • 设计和实现要依赖于抽象而非具体实现。一方面抽象化更符合人的思维习惯;另一方面,根据里氏替换原则,可以很容易将原来的抽象替换为扩展后的具体实现,这样可以很好的支持开闭原则;

    3.4.3 优点

    • 减少类之间的耦合性,提高系统的稳定性;
    • 降低并行开发引发的风险;
    • 提高代码的可读性和可维护性;

    3.5 接口隔离原则 - Interface Segration Principle(ISP)

    3.5.1 定义

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

    3.5.2 基本概念

    • 一个类对另一个类的依赖应该建立在最小的接口上,通俗的讲就是需要什么就提供什么,不需要的就不提供;
    • 接口中的方法应该尽量少,不要使接口过于臃肿,不要有很多不相关的逻辑方法;

    3.5.3 优点

    • 高内聚,低耦合;
    • 可读性高,易于维护

    3.6 迪米特法则/最少知道原则 - Law of Demeter or Least Knowledge Principle(LoD or LKP)

    3.6.1 定义

    • 一个对象应该对其它对象保持最少的了解;
    • 这个原理的名称来源于希腊神话中的农业女神,孤独的德墨忒尔;

    3.6.2 基本概念

    • 每个单元对于其它单元只能拥有有限的知识:只是与当前单元紧密联系的单元;
    • 每个单元只能和它的朋友交谈:不能和陌生单元交谈;
    • 只和自己直接的朋友交谈;

    3.6.3 优点

    • 使得软件更好的可维护与适应性;
    • 对象较少依赖其它对象的内部结构,可以改变对象容器而不用改变它的调用者;

    3.7 合成/聚合复用原则 - Composite/Aggregate Reuse Principle(CARP/CRP)

    3.7.1 定义

    尽量采用组合、聚合的方式而不是继承的关系来达到软件的复用目的。

    3.7.2 基本概念

    如果新对象的某些功能在别的已经创建好的对象里面已经实现,那么应当尽量使用别的对象提供的功能,使之成为对象的一部分,而不要再从新创建。

    组合/聚合的优点:类之间的耦合比较低,一个类的变化对其它类造成的影响比较少;

    组合/聚合的缺点:类的数量增多实现起来比较麻烦;

    继承的优点:由于很多方法父类已经实现,子类的实现会相对比较简单;

    继承的缺点:将父类暴露给了子类,一定程度上破坏了封装性,父类的改变对子类影响比较大;

    3.7.3 优点

    • 可以降低类与类之间的耦合程度;
    • 提高了系统的灵活性;

    4. 面向接口编程

    4.1 什么是接口

    接口是类与外界之间的契约。当一个列类实现了一个接口时,它承若提供该接口发布的所有行为。

    对象通过其公开的方法定义了它们与外界的交互。方法形成对象与外界的接口;例如,电视机正面的按钮是你与塑料外壳另一侧的电线之间的接口。按下店员按钮可以打开或关闭电视。

    在常见的形式中,接口是一组具有空主体的相关方法。如果将自行车的行为指定为接口,则可能如下所示:

    interface Bicycle {
    	void changeCadence(int newValue);
    	void changeGear(int newValue);
    	void speedUp(int increment);
    	void applyBrakes(int decrement);
    }
    

    要实现此接口,你的类名称需要加上 implements 关键字,例如 ACMEBicycle:

    class ACMEBicycle implements Bicycle {
    	int cadence = 0;
    	int speed = 0;
    	int gear = 1;
    	
    	void changeCadence(int newValue) {
    		cadence = newValue;
    	}
    	
    	void speedUp(int increment) {
    		speed = speed + increment;
    	}
    	
    	void applyBrakes(int decrement) {
    		speed = speed - decrement;
    	}
    	
    	void printStates() {
    		System.out.println("cadence:" + cadence + " speed:" + speed + " gear:" + gear);
      }
    }
    

    实现接口可以使类对其承若提供的行为变得更加正式。接口在类和外部世界之间形成契约,并且该契约在编译时由编译器强制执行。如果你的类声明要实现一个接口,则在成功编译该类之前,该接口的所有方法必须出现在其源代码中。

    4.2 面向接口编程和面向对象编程是什么关系

    面向接口编程并不是独立于面向对象编程的更先进的编程思想,而是隶属于面向对象编程思想体系,换句话说,面向接口编程是面向对象编程体系中的思想精髓之一。

    4.3 接口的本质

    站在面向接口编程的角度来看。”接口“可以说是一种从软件架构的角度、从一个高度抽象的层面上指的是用于隐藏具体底层类和实现多态性的结构组件。

    站在面向对象编程语言角度来看。表面上接口由几个没有主体实现代码(Java8 default 可有主体)的方法定义组成的集合体,可以被类或其它接口所实现或继承。接口定义可能如下:

    interface Bicycle {
    	void changeCadence(int newValue);
    	void changeGear(int newValue);
    	void speedUp(int increment);
    	void applyBrakes(int decrement);
    }
    
    1. 接口是一组规则的集合,它规定了实现此接口的类或接口必须拥有的一组规则。体现了自然界“如果你是… … 则必须能… …”的理念

    例如,在自然界中,人都能吃饭,及“如果你是人,则必须能吃饭”。那么模拟到计算机程序中,就应该有一个 IPerson接口,并有一个方法叫 eat(),然后我们规定,每一个表示“人”的类,必须实现 IPerson接口,这就模拟了自然界“如果你是人,则必须能吃饭”这条规则。

    从这里,我想各位也能看到些许面向对象思想的东西。面向对象的思想的核心之一,就是模拟真是世界,把真是世界中的事物抽象成类,整个程序靠各个类的实例互相通信、互相协作完成系统功能,这非常符合真实世界的运行状况,也就是面向对象思想的精髓。

    1. 接口是在一定粒度视图上同类事物的抽象表示。注意这里强调了在一定粒度上,因为“同类事物”这个概念是相对的,它因为粒度视图不同而不同。

    例如,在我的眼里,我是一个人,和一头猪有本质区别,我可以接受我和我同学是同类这个说法,但决不能接受我和一头猪是同类。但是,如果在一个动物学家眼里,我和猪应该是同类,因为我们都是动物,他可以认为“人”和“猪”都是动物,而他在研究动物行为时,不会把人和猪分开对待,而是从“动物”这个较大的粒度上研究,但他会认为人和树有本质区别。

    现在换了一个遗传学家,情况又不同了,因为生物都能遗传,所以在他眼中,人不仅和猪没区别,和蚊子、细菌、树都没有区别,因为他会认为这些都是可遗传的,他不会分别研究这些对象,而会将所有生物作为同类进行研究,在他眼中没有人和其它生物之分,只有可遗传和不可以穿的物质。但至少,动物和石头还是有区别的。

    可不幸的事情发生了,某日,地球上出现了以为伟大的人,他叫列宁,他在熟读马克思、恩格斯的辩证唯物主义思想巨著后,颇有心得,于是他下了一个著名的定义:所谓物质,就是能被意识所反映的客观事物。至此,任何一块石头、空气、磁场等已经没有区别了,因为在列宁的眼中,我们都是可被意识所反映的客观事物。如果列宁是一名程序员,他会这样说:所谓物质,就是所有同事实现了 “IReflectabe”和“IEsse”两个接口所生成的实例。

    5. 参考:

    面向对象设计的七大原则 - 简书 (jianshu.com)

    面向接口编程详解(一)——思想基础 - T2噬菌体 - 博客园 (cnblogs.com)

    展开全文
  • 展开全部面向对象语言的三个基本特征:识认性、类别性、多态性;优势:继承性,在基本层次关系的不e69da5e6ba903231313335323631343130323136353331333433623130同类中共享数据和操作。识认性,系统基本构件可识...

    展开全部

    面向对象语言的三个基本特征:识认性、类别性、多态性;优势:继承性,在基本层次关系的不e69da5e6ba903231313335323631343130323136353331333433623130同类中共享数据和操作。

    识认性,系统中的基本构件可识认为一组可识别的离散对象;类别性,系统具有相同数据结构与行为的所有对象可组成一类;多态性,对象具有唯一的静态类型和多个可能的动态类型。

    较典型的面向对象语言有:

    simula 67,支持单继承和一定含义的多态和部分动态绑定;Smalltalk支持单继承、多态和动态绑定;EIFFEL,支持多继承、多态和动态绑定。

    C++,支持多继承、多态和部分动态绑定。Java,支持单继承、多态和部分动态绑定。五种语言涉及概念的含义虽然基本相同,但所用术语有别。

    扩展资料

    传统的基于类的面向对象语言的一个主要特点就是inheritance,subclassing和subtyping之间的密不可分的联系。很多的面向对象语言的语法,概念,就是从这三者而来的。

    比如说,通过subclassing,可以继承父类的一些方法,而同时又可以在子类中改写父类的方法。这个改写过的方法,通过subtyping、subsumption,又可以从一个类型是父类的对象去调用。

    但是,inheritance、subclassing、subtyping这三者并不是永远和睦相处的。在一些场合,这三者之间的纠缠不清会妨碍到通过继承或泛型得到的代码重用。

    因此,人们开始注意到把这三者分离开来的可能性。区分subclassing和subtyping已经很常见了。而其它的一些方法还处于研究的阶段。

    展开全文
  • 多态性:多态性指的是程序允许出现重名的现象,它指一个类定义的属性和方法被其它类继承后,他们可以具有不同的数据类型或表现出不同的行为,这使得同一个属性和方法在不同的类有不同的语义。 面向过程和...
  • 浅谈面向对象方法

    千次阅读 热门讨论 2020-05-15 18:00:32
    二、面向对象基本特征 封装、继承、多态 三、面向对象的建模 对象模型、动态模型、功能模型 四、面向对象设计 五、面向对象的实现 设计风格 测试策略 六、面向对象方法学的优点与缺点 优点 缺点 一、...
  • 面向对象的语言必须具备四个基本特征: 1.封装能力(即允许将基本数据类型的变量或函数放到一个类里,形成类的成员或方法) 2.聚合能力(即允许类里面再包含类,这样可以应付足够复杂的设计) 3.支持继承(父类可以派生出...
  • 面向对象基本特征

    2020-12-01 22:31:49
    面向对象方法具有三个基本特征:封装、继承、多态。 封装:指的是将对象的实现细节隐藏起来,然后通过一些公用的方法来暴露该对象的功能。 通俗的讲:就像电视遥控器一样,你不需要知道里面是怎么做的,你只需知道...
  • 将数据和算法捆绑成一个整体,这个整体就是对象,描述对象的数据被分装其内部 2,继承性 是指保留基类的部分特性创造新类的过程(派生:已有的基类增加自己的特性) 3,多态性 当多种事物继承同一事物,...
  • 面向对象的三个基本特征

    千次阅读 2018-10-28 13:51:42
    面向对象的三个基本特征是:封装、继承、多态。 封装 封装最好理解了。封装是面向对象特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类...
  • 工业控制系统的PLC程序也可以采用这种设计思想,虽然我们无法实现面向对象的很多特点如“继承”,甚至于它根本就不具备面向对象编程语言的特点,但面向对象编程的基本概念就是类和类的实例(即对象),我们只...
  • 面向对象的四大基本特征 首先,我们来聊一聊什么是Java语言的特征? 开源 跨平台的 JVM 面向对象 多线程 自动垃圾回收(这个也属于是JVM部分的) 支持网络 安全的 那么Java语言如何实现跨平台呢? Java语言的流行...
  • MATLAB 面向对象编程(OOP) MATLAB 设计用户类 设计 MATLAB 类时应包括一组标准的方法以使类的行为与 MATLAB 环境 协调一致并合乎逻辑根据所设计的类的特点你不一定要包含所有这些方法 并且你可能会包含一些...
  • 本文实例讲述了javascript面向对象三大特征之继承。分享给大家供大家参考,具体如下: 继承 JavaScript的继承的实质就是子代可以拥有父代公开的一些属性和方法js编程时,我们一般将相同的属性放到父类,...
  • 面向对象的优势和特点

    千次阅读 2020-03-26 20:11:33
    一、什么是面向对象 1、面向对象(Object Oriented)是软件开发方法面向对象的概念和应用已超越了程序设计和软件开发,扩展到...面向对象是相对于面向过程来讲的,面向对象方法,把相关的数据和方法组织为一个整体...
  • 为了适应面向对象设计发展,第2版保留第1版特点的同时,根据当前软件工程的发展趋势和教学特点,精心选择了最主要基本内容进行介绍。全书包括14章和3个附录,分别为UML导论,对象建模,软件开发过程,餐馆系统的...
  • 1、面向对象基本概念 ...2、面向对象的基本特征 抽象:从一个具体的对象提取提取一组数据,去除非本质和特性的属性,保留本质的、共性的。 比如学生,有很多的属性(学号、姓名、性别、身高、...
  • 1、 封装:a) 铺垫:Java把真实世界某些具有共同特征的实体抽象成Java的类,类的实例就是一个对象,而对象和真实世界的实体是一一对应的,所以说java是一门面向对象的语言。b)概念:每一个类中都会有...
  • 1.结构化方法:面向过程的方法 结构化分析(SA, Structured Analysis) 结构化设计(SD, Structured Design) 结构化编程(SP, Structured Programming) 2.模块的独立性:模块是高内聚,低耦合的 高内聚指的是一个函数...
  • 对象所具有的3个重要特征:封装、继承、多态

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 349,743
精华内容 139,897
关键字:

在面向对象的方法中对象的基本特点