精华内容
下载资源
问答
  • 面向对象程序设计的基本概念

    千次阅读 2016-07-04 15:31:41
    概述概念面向对象 = 对象 + 类 + 继承 + 消息对象对象(Object):具有责任的实体。用来描述客观事物的实体,是构成系统的一个基本单位,由一组属性以及作用在这组属性的操作构成。特性:标识符(区别其他对象)、属性...

    概述

    概念

    面向对象 = 对象 + 类 + 继承 + 消息

    对象

    对象(Object):具有责任的实体。用来描述客观事物的实体,是构成系统的一个基本单位,由一组属性以及作用在这组属性的操作构成。

    特性:标识符(区别其他对象)、属性(状态)和操作(行为)。

    属性(Attribute):与对象关联的数据,描述对象静态特性;

    操作(Operation):与对象关联的程序,描述对象动态特性;

    类(Class):

    概念

    具有相同属性和操作的一组对象的抽象,它为属于该类的全部对象提供了统一的抽象描述。

    区别

    类是静态的,类的存在、语义和关系在程序执行前就已经定义好了。

    对象是动态的,对象在程序执行时可以被创建和删除。

    层次
    这里写图片描述


    属性
    这里写图片描述


    方法
    这里写图片描述


    消息

    这里写图片描述


    封装

    这里写图片描述

    封装的作用

    使对象形成两个部分:接口(可见)和实现(不可见),将对象所声明的功能(行为)与内部实现(细节)分离

    “封装”的作用是什么?

    • 数据的安全性:保护对象,避免用户误用。
    • 模块的独立性:保护客户端(调用程序),其实现过程的改变不会影响到相应客户端的改变。
    • 易开发、易维护性:隐藏复杂性,降低了软件系统开发难度;各模块独立组件修改方便,重用性好。

    泛化与继承

    泛化(generalization)/继承(Inheritance) 关系是类元的一般描述和具体描述之间的关系,具体描述建立在一般描述的基础之上,并对其进行了扩展。

    继承(Inheritance):子类( Subclass)可自动拥有父类/超类(SuperClass)的全部属性和操作。

    • 表示两个类之间是“is a”关系。
    • 继承使两个以上的类共享相同的属性和/或相同方法。
    • 继承的各个类间形成层次结构。
    • 继承提高了复用性,使多态成为了可能。

    多态性(Polymorphism)

    多态性(Polymorphism):在父类中定义的属性或服务被子类继承后,可以具有不同的数据类型或表现出不同的行为。

    java中有重写(静态),重载(动态)

    抽象类(abstract class)与接口(Interface)

    抽象类

    • 抽象类中至少有一个方法被定义为“abstract”类型的。
    • “abstract”类型的方法:只有方法定义,没有方法的具体实现。
    • 抽象类的类名在模型中一般为“斜体”,或

    接口

    接口(Interface):描述了一个类的一组外部可用的操作(方法)集合

    体现了“接口与实现的分离”的思想,即“信息隐藏”。

    对象之间的联系

    继承、实现、依赖、关联、聚合、组合的联系与区别

    分别介绍这几种关系:

    继承
    指的是一个类(称为子类、子接口)继承另外的一个类(称为父类、父接口)的功能,并可以增加它自己的新功能的能力,继承是类与类或者接口与接口之间最常见的关系;在Java中此类关系通过关键字extends明确标识

    空心箭头-实线
    这里写图片描述

    实现

    指的是一个class类实现interface接口(可以是多个)的功能;实现是类与接口之间最常见的关系;在Java中此类关系通过关键字implements明确标识

    空心箭头-虚线
    这里写图片描述

    依赖

    可以简单的理解,就是一个类A的方法中使用到了另一个类B,而这种使用关系是具有偶然性的、、临时性的、非常弱的,但是B类的变化会影响到A;比如某人要过河,需要借用一条船,此时人与船之间的关系就是依赖;表现在代码层面,为类B作为参数被类A在某个method方法中使用;

    箭头-虚线
    这里写图片描述

    关联

    他体现的是两个类、或者类与接口之间语义级别的一种强依赖关系,比如我和我的朋友;这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的,一般是长期性的,而且双方的关系一般是平等的、关联可以是单向、双向的;表现在代码层面,为被关联类B以类属性的形式出现在关联类A中,也可能是关联类A引用了一个类型为被关联类B的全局变量;

    箭头-实线
    这里写图片描述

    聚合

    聚合是关联关系的一种特例,他体现的是整体与部分、拥有的关系,即has-a的关系,此时整体与部分之间是可分离的,他们可以具有各自的生命周期,部分可以属于多个整体对象,也可以为多个整体对象共享;比如计算机与CPU、公司与员工的关系等;表现在代码层面,和关联关系是一致的,只能从语义级别来区分;

    空心菱形-实线-箭头
    这里写图片描述

    组合

    组合也是关联关系的一种特例,他体现的是一种contains-a的关系,这种关系比聚合更强,也称为强聚合;他同样体现整体与部分间的关系,但此时整体与部分是不可分的,整体的生命周期结束也就意味着部分的生命周期结束(大脑的实例化在person对象中创建,与person对象生命周期相同);比如你和你的大脑;表现在代码层面,和关联关系是一致的,只能从语义级别来区分;

    实心菱形-实线-箭头
    这里写图片描述

    对于继承、实现这两种关系没多少疑问,他们体现的是一种类与类、或者类与接口间的纵向关系;其他的四者关系则体现的是类与类、或者类与接口间的引用、横向关系,是比较难区分的,有很多事物间的关系要想准备定位是很难的,前面也提到,这几种关系都是语义级别的,所以从代码层面并不能完全区分各种关系;

    但总的来说,后几种关系所表现的强弱程度依次为:组合>聚合>关联>依赖;

    面向对象分析和设计

    面向对象分析(Object Oriented Analysis, OOA)
    分析:强调的是对问题和需求的调查研究,而不是解决方案

    面向对象分析过程中,强调的是在问题领域内发现和描述对象

    面向对象设计(Object Oriented Design, OOD)
    设计:强调的是满足需求的概念上的解决方案(在软件方面和硬件方面),而不是其实现。

    面向对象设计过程中,强调的是定义软件对象以及它们如何协作以实现需求。

    区别
    有价值的分析和设计可以概括为:做正确的事(分析)和正确地做事(设计)

    展开全文
  • 类与对象概念

    千次阅读 2008-04-27 19:29:00
    第4章 类 与 象4.1类与对象概念4.2封装机制4.3数据成员4.4成员方法第4章 类 与 象4.1类与对象概念程序设计所面对的问题域——客观世界,是由许多事物构成的,这些事物既可以是有形的(比如一辆汽车),也...
    第4章 类 与 对 象
    
    4.1
    类与对象的概念
    4.2
    封装机制
    4.3
    数据成员
    4.4
    成员方法
    第4章 类 与 对 象
    4.1
    类与对象的概念
    程序设计所面对的问题域——客观世界,是由许多事物构
    成的,这些事物既可以是有形的(比如一辆汽车),也可以是无形
    的(比如一次会议)。把客观世界中的事物映射到面向对象的程序
    设计中就是对象。对象是面向对象程序设计中用来描述客观事
    物的程序单位。客观世界中的许多对象,无论其属性还是其行
    为常常有许多共同性,抽象出这些对象的共同性便可以构成类。
    所以,类是对象的抽象和归纳,对象是类的实例。
    第4章 类 与 对 象
    4.1.1
    抽象原则
    所谓抽象(abstraction),就是从被研究对象中舍弃个别的、
    非本质的、或与研究主旨无关的次要特征,而抽取与研究工作
    有关的实质性内容加以考察,形成对所研究问题正确的、简明
    扼要的认识。例如,“马”就是一个抽象的概念,实际上没有任
    何两匹马是完全相同的,但是我们舍弃了每匹马个体之间的差
    异,抽取其共同的、本质性的特征,就形成了“马”这个概念。
    抽象是科学研究中经常使用的一种方法,是形成概念的必
    要手段。在计算机软件开发领域,抽象原则的运用非常广泛,
    概括起来,可分为过程抽象和数据抽象两类。
    第4章 类 与 对 象
    1.
    过程抽象
    过程抽象是指:软件开发者可以把任何一个完成确定功能
    的操作序列都看作是一个单一的实体,尽管它实际上可能是由
    一系列更低级的操作完成的。运用过程抽象,软件开发者可以
    把一个复杂的功能分解为一些子功能(模块),如果子功能仍比较
    复杂,则可以进一步分解。这使得开发者可以在不同的抽象层
    次上考虑问题,在较高层次上思考时可以不关心较低层次的实
    现细节。面向过程的程序设计采用的是过程抽象方法。
    使用过程抽象有利于控制、降低整个程序的复杂度,但
    是,这种方法允许在全系统的范围内进行功能的描述,本身自
    由度大,难于规范化和标准化,不易保证软件的质量,而且操
    作起来也有一定难度。
    第4章 类 与 对 象
    2.
    数据抽象
    数据抽象把系统中需要处理的数据和施加于这些数据之上
    的操作结合在一起,根据功能、性质、作用等因素抽象成不同
    的抽象数据类型。每个抽象数据类型既包含了数据,也包含了
    针对这些数据的授权操作,并限定数据的值只能由这些操作来
    观察和修改。因此,数据抽象是相对于过程抽象更为严格、更
    为合理的抽象方法。
    面向对象的程序设计就是采用数据抽象这一方法来构建程
    序中的类和对象的。它强调把数据和操作结合为一个不可分的
    系统单位——对象,对象的外部只需要知道这个对象能做什
    么,而不必知道它是如何做的。
    第4章 类 与 对 象
    4.1.2
    对象
    只要仔细研究程序设计所面对的问题域——客观世界,我
    们就可以看到:客观世界是由一些具体的事物构成的,每个事
    物都具有自己的一组静态特征(属性)和一组动态特征(行为)。例
    如,一辆汽车有颜色、型号、马力、生产厂家等静态特征,又
    具有行驶、转弯、停车等动态特征。把客观世界的这一事实映
    射到面向对象的程序设计中,则把问题域中的事物抽象成了对
    象(Object),事物的静态特征(属性)用一组数据来描述,事物的
    动态特征(行为)则用一组方法来刻画。因此,对象具有下述特
    征:
    第4章 类 与 对 象
    (1) 对象标识:即对象的名字,是用户和系统识别它的唯一
    标志。例如,汽车的牌照可作为每一辆汽车对象的标识。对象
    标识有“外部标识”和“内部标识”之分。外部标识供对象的定义
    者或使用者用,内部标识供系统内部唯一地识别每一个对象。
    在计算机世界中,我们可以把对象看成计算机存储器中一块可
    标识的区域,它能保存固定或可变数目的数据(或数据的集合)。
    (2) 属性:即一组数据,用来描述对象的静态特征。例如,
    汽车的颜色、型号、马力、生产厂家等。在Java程序中,把这
    一组数据称为数据成员。
    第4章 类 与 对 象
    (3) 方法:也称为服务或操作,它是对象动态特征(行为)的
    描述。每一个方法确定对象的一种行为或功能。例如,汽车的
    行驶、转弯、停车等动作可分别用move( )、rotate( )、stop( )等
    方法来描述。为避免混淆,本书中把方法称为成员方法。
    在Java程序中,类是创建对象的模板,对象是类的实例,任
    何一个对象都是隶属于某个类的。Java程序设计是从类的设计开
    始的,所以,在进一步讲述对象的知识之前,必须先掌握类的
    概念。
    第4章 类 与 对 象
    4.1.3

    对象是对事物的抽象,而类是对对象的抽象和归纳。人类在
    认识客观世界时经常采用的思维方法就是把众多的事物归纳成一
    些类。分类所依据的原则是抽象,即抽象出与当前目标有关的本
    质特征,而忽略那些与当前目标无关的非本质特征,从而找出事
    物的共性,把具有共同性质的事物归结为一类,得出一个抽象的
    概念——类。
    在面向对象的编程语言中,类是一个独立的程序单位,是具
    有相同属性和方法的一组对象的集合。类的概念使我们能对属于
    该类的全部对象进行统一的描述。例如,“树具有树根、树干、
    树枝和树叶,它能进行光合作用”。这个描述适合于所有的树,
    从而不必对每棵具体的树都进行一次这样的描述。因此,在定义
    对象之前应先定义类。描述一个类需要指明下述三个方面内容:
    第4章 类 与 对 象
    (1)
    类标识:类的一个有别于其他类的名字,这是必不可少的。
    (2)
    属性说明:用来描述相同对象的静态特征。
    (3)
    方法说明:用来描述相同对象的动态特征。
    第4章 类 与 对 象
    例如,下面是对dog类进行的描述:
    class dog // class指出这是一个类,dog是类标识
    {
    String name;
    int AverageWeight; 类的属性(静态特征)
    int AverageHeight;
    public void move( )
    { …… } 类的方法(动态特征)
    public void ShowDog( )
    { …… }
    }
    dog类
    第4章 类 与 对 象
    4.1.4
    类与对象的关系
    类给出了属于该类的全部对象的抽象定义,而对象则是符
    合这种定义的一个实体。类与对象之间的关系就如同一个模具
    与用这个模具铸造出来的铸件之间的关系一样。也就是说,我
    们可以把类与对象之间的关系看成是抽象与具体的关系。在面
    向对象的程序设计中,对象被称作类的一个实例(instance),而
    类是对象的模板(temp1ate)。类是多个实例的综合抽象,而实例
    又是类的个体实物。如图4.1所示为类与对象的关系。
    第4章 类 与 对 象
    图4.1 类与对象的关系
    抽象
    实例化
    对象:刘丽
    静态特征:刘丽

    讲师
    890.00
    动态特征:授课
    评职称
    调工资
    数据值
    执行的
    操作
    方法名数据结构
    类:教师
    属性:姓名
    性别
    职称
    工资
    服务:授课
    评职称
    调工资
    第4章 类 与 对 象
    4.1.5
    定义类的一般格式
    (1) 系统定义的类,即Java
    类库,它是系统定义好的类。类
    库是Java语言的重要组成部分。Java语言由语法规则和类库两部
    分组成,语法规则确定Java程序的书写规范;类库则提供了Java
    程序与运行它的系统软件(Java虚拟机)之间的接口。Java类库是
    一组由它的发明者SUN公司以及其他软件开发商编写好的Java程
    序模块,每个模块通常对应一种特定的基本功能和任务,且这
    些模块都是经过严格测试的,因而也总是正确有效的。当自己
    编写的Java程序需要完成其中某一功能的时候,就可以直接利用
    这些现成的类库,而不需要一切从头编写,这样不仅可以提高
    编程效率,也可以保证软件的质量。
    第4章 类 与 对 象
    (2) 用户自己定义的类。系统定义的类虽然实现了许多常见
    的功能,但是用户程序仍然需要针对特定问题的特定逻辑来定义
    自己的类。用户按照Java的语法规则,把所研究的问题描述成
    Java程序中的类,以解决特定问题。进行Java程序设计,首先应
    学会怎样定义类。
    在Java程序中,用户自己定义类的一般格式如下:
    class 类名
    {
    数据成员
    成员方法
    }
    第4章 类 与 对 象
    图4.2
    类的图形表示
    类名
    数据成员
    成员方法
    第4章 类 与 对 象
    可以看出,类的结构是由类说明和类体两部分组成的。类
    的说明部分由关键字class与类名组成,类名的命名遵循Java标
    识符的定义规则;类体是类声明中花括号所包括的全部内容,
    它又由数据成员(属性)和成员方法(方法)两部分组成。数据成员
    描述对象的属性;成员方法刻画对象的行为或动作,每一个成
    员方法确定一个功能或操作。图4.2为类的图形表示。
    第4章 类 与 对 象
    【示例程序c4_1.java】
    import java.awt.*; //引用系统类库中的awt包
    import java.applet.*; //引用系统类库中的applet包
    public class c4_1 extends Applet // 由applet类派生的c4_1类
    { int a=5; //数据成员a
    double b=23.4; //数据成员b
    public void paint(Graphics g) //成员方法paint
    { //以下使用g对象的drawString方法
    g.drawString("a="+a,25,25);
    g.drawString("b="+b,25,35);
    }
    }
    第4章 类 与 对 象
    图4.3 程序c4_1的运行结果
    第4章 类 与 对 象
    4.1.6 Java
    类库
    要想掌握好Java的面向对象编程技术,编写出高质量的程
    序,必须对Java的类库有足够的了解。Java的类库是系统提供的
    已实现的标准类的集合,是Java编程的API(Application Program
    Interface),它可以帮助开发者方便、快捷地开发Java程序。Java
    类库的主要部分是由它的发明者SUN公司提供的,这些类库称为
    基础类库(JFC),也有少量则是由其他软件开发商以商品形式提供
    的。有了类库中的系统类,编写Java程序时就不必一切从头做
    起,避免了代码的重复和可能的错误,也提高了编程的效率。一
    个用户程序中系统标准类使用得越多、越全面、越准确,这个程
    序的质量就越高;相反,离开了系统标准类和类库,Java程序几
    乎寸步难行。
    第4章 类 与 对 象
    所以,学习Java语言程序设计,一是要学习其语法规则,
    即第2~3章中的基本数据类型、基本运算和基本语句等,这是
    编写Java程序的基本功;二是要学习使用类库,这是提高编程
    效率和质量的必由之路,甚至从一定程度上来说,能否熟练自
    如地掌握尽可能多的Java类库,决定了一个Java程序员编程能力
    的高低。我从第7章起主要讲述类库的使用。
    第4章 类 与 对 象
    在Java系统中,系统定义好的类根据实现的功能不同,可
    以划分成不同的集合。每个集合称为一个包,所有包合称为类
    库。根据功能的不同,Java类库的每个包中都有若干个具有特
    定功能和相互关系的类和接口。例如,java.lang
    包中包含了运
    行Java
    程序必不可少的系统类,它们包括基本数据类型、基本
    数学方法、字符串处理、线程、异常处理等类;java.awt
    包中
    包括了Java
    语言用来构建图形用户界面(GUI)
    的类库。
    第4章 类 与 对 象
    使用类库中系统定义好的类有三种方式:一种是直接使用
    系统类,例如在字符界面向系统标准输出设备输出字符串时使
    用的方法System.out.println( ),就是系统类System的动态属性
    out的方法;另一种方式是继承系统类,在用户程序里创建系统
    类的子类,例如每个Java Applet的主类都是java.applet包中的
    applet类的子类;最后一种方式是创建系统类的对象,例如图
    形界面的程序中要接受用户的输入时,就可以创建一个系统类
    TextField类的对象来完成这个任务。
    第4章 类 与 对 象
    无论采用哪种方式,使用系统类的前提条件是这个系统类
    应该是用户程序可见的类。为此用户程序需要用import
    语句引
    入它所用到的系统类或系统类所在的包。例如使用图形用户界
    面的程序,应该用语句:
    import java.awt.*;
    import java.awt.event.*;
    引入java.awt包和java.awt.event包。
    第4章 类 与 对 象
    类库包中的程序都是字节码形式的程序,利用import语句
    将一个包引入到程序里,就相当于在编译过程中将该包中所有
    系统类的字节码加入到用户的Java程序中,这样用户的Java程
    序就可以使用这些系统类及其中的各种功能了。
    第4章 类 与 对 象
    下面列出一些在Java程序设计中经常使用的包。
    1
    .java.lang

    java.1ang包是Java语言的核心类库,包含了运行Java程序
    必不可少的系统类,如基本数据类型、基本数学函数、字符串
    处理、线程、异常处理类等。每个Java程序运行时,系统都会
    自动地引入java.1ang包,所以这个包的加载是缺省的。
    第4章 类 与 对 象
    2
    .java.io

    java.io包中包含了实现Java程序与操作系统、用户界面以
    及其他Java程序之间进行数据交换所使用的类,如基本输入/输
    出流、文件输入/输出流、过滤输入/输出流、管道输入/输出流、
    随机输入/输出流等。凡是需要完成与操作系统有关的较底层的
    输入输出操作的Java程序,都要用到java.io包。
    第4章 类 与 对 象
    3
    .java.awt

    java.awt包是Java语言用来构建图形用户界面(GUl)的类
    库,它包括了许多界面元素和资源。利用java.awt包,开发人员
    可以很方便地编写出美观、方便、标准化的应用程序界面。
    java.awt包主要在三个方面提供界面设计支持:①低级绘图操
    作, 如Graphics 类等; ② 图形界面组件和布局管理, 如
    Checkbox类、Container类、LayoutManager接口等;③界面用户
    交互控制和事件响应,如Event类。
    第4章 类 与 对 象
    4
    .java.awt.event

    java.awt.event包是对JDK1.0版本中原有的Event类的一个扩
    充,它使得程序可以用不同的方式来处理不同类型的事件,并
    使每个图形界面的元素本身可以拥有处理它上面事件的能力。
    5
    .java.awt.image

    java.awt.image包是用来处理和操纵来自于网上的图片的Java
    工具类库。
    6
    .java.applet

    java.applet包是用来实现运行于Internet浏览器中的Java
    Applet的工具类库,它仅包含少量几个接口和一个非常有用的类
    Java.applet.Applet。
    第4章 类 与 对 象
    7
    .java.net

    java.net包是Java语言用来实现网络功能的类库。由于Java
    语言还在不停地发展和扩充,它的功能,尤其是网络功能,也
    在不断地扩充。目前已经实现的Java网络功能主要有:底层的
    网络通信,如实现套接字通信的Socket类、ServerSocket类;编
    写用户自己的Telnet、FTP、邮件服务等实现网上通信的类;用
    于访问Internet上资源和进行CGl网关调用的类,如URL等。利
    用java.net包中的类,开发者可以编写自己的具有网络功能的程
    序。
    第4章 类 与 对 象
    8
    .java.rmi
    包、java.rmi.registry
    包和java.rmi.server

    这三个包用来实现RMI(Remote Method Invocation,远程方
    法调用)功能。利用RMI功能,用户程序可以在远程计算机(服务
    器)上创建对象,并在本地计算机(客户机)上使用这个对象。
    9
    .java.util

    java.util包中包括了Java语言中的一些低级的实用工具,如
    处理时间的Date类,处理变长数组的Vector类,实现栈的Stack
    类和实现哈希(散列)表的HashTable类等,使用它们开发者可以
    更方便快捷地编程。
    第4章 类 与 对 象
    10
    .java.sql

    java.sql包是实现JDBC(Java Database Connection)的类库。
    利用这个包可以使Java程序具有访问不同种类的数据库(如
    Oracle,Sybase,DB2,SQLServer等)的功能。只要安装了合适
    的驱动程序,同一个Java程序不需修改就可以存取、修改这些
    不同的数据库中的数据。JDBC的这种功能,再加上Java程序本
    身具有的平台无关性,大大拓宽了Java程序的应用范围,尤其
    是商业应用的适用领域。
    第4章 类 与 对 象
    11.java.security
    ijtscerayuva.
    包、java.security.acl
    iljtscerayu.包和java.security.interfaces
    ifjtsceraynu.包
    这三个包提供了更完善的Java程序安全性控制和管理,利
    用它们可以对Java程序加密,也可以把特定的Java Applet标记
    为“可信赖的”,使它能够具有与Java Application相近的安全权
    限。
    12
    .java.awt.peer

    java.awt.peer包是实现Java语言跨平台特性的手段之一。这
    个包虽然在程序中很少直接用到,但它的作用是将不同的平台
    包裹、隐藏起来,使这些平台在用户程序面前呈现基本相同的
    面貌。
    第4章 类 与 对 象
    14
    .java.awt.datatransfer

    java.awt.datatransfer包提供了处理数据传输的工具类,包括
    剪贴板、字符串发送器等。
    15
    .java.lang.reflect

    java.lang.reflect包提供了用于反射对象的工具,反射允许
    程序监视一个正在运行的对象并获得它的构造函数、方法和属
    性。
    第4章 类 与 对 象
    16
    .java.corba
    包和java.corba.orb

    这两个包将CORBA(Common Object Request Broker
    Architecture,是一种标准化接口体系)嵌入到Java环境中,使得
    Java程序可以存取、调用CORBA对象,并与CORBA对象共同
    工作。这样,Java程序就可以方便、动态地使用已经存在的由
    Java或其他面向对象语言开发的部件,简化软件的开发。
    第4章 类 与 对 象
    4.1.7
    创建对象
    创建对象通常包括声明对象、建立对象和初始化对象三步。
    1
    .声明对象
    声明对象就是确定对象的名称,并指明该对象所属的类。声
    明对象的格式如下:
    类名
    对象名表;
    第4章 类 与 对 象
    其中:类名是指对象所属类的名字,它是在声明类时定义
    的;对象名表是指一个或多个对象名,若为多个对象名时,用
    逗号进行分隔。声明对象的作用是为将来的编译过程提供必要
    的信息。例如:
    class_name object_one,object_two;
    这个语句声明了两个对象object_one,object_two,它们都
    是class_name类的对象。
    第4章 类 与 对 象
    2
    .建立对象
    所谓建立对象,实际上就是用Java提供的new
    关键字为对象
    分配存储空间。在声明对象时,只确定了对象的名称和它所属
    的类,并没有为对象分配存储空间,此时对象还不是类的实例。
    只有通过建立对象这一步,才为对象分配内存,使该对象成为
    类的实例。建立对象的格式如下:
    对象名=new
    构造方法( )
    例如:object_one=new class_name( );
    object_two=new class_name( );
    第4章 类 与 对 象
    也可以在声明对象的同时建立对象,这称为创建一个对象。
    创建对象的格式如下:
    类名
    对象名=new
    构造方法( )
    例如:class_name object_one=new class_name( );
    class_name object_two=new class_name( );
    其中:new是Java的关键字,也可将其称为运算符,因为
    new的作用是建立对象,为对象分配存储空间。执行new
    class_name( )将产生一个class_name( )类的实例(对象)。
    第4章 类 与 对 象
    3.
    初始化对象
    初始化对象是指由一个类生成一个对象时,为这个对象确定
    初始状态,即为它的数据成员赋初始值的过程,当然,它主要由
    一些赋值语句组成。由于初始化操作是最常用的操作之一,为简
    化这一过程,Java还提供了专用的方法来完成它,这个方法被称
    为构造方法。关于构造方法的详细内容请参阅4.1.9节。
    第4章 类 与 对 象
    4.1.8
    使用对象
    一个对象可以有许多属性和多个方法。在面向对象的系统
    中,一个对象的属性和方法被紧密地结合成一个整体,二者是
    不可分割的,并且限定一个对象的属性值只能由这个对象或它
    的方法来读取和修改。这便是封装和信息隐藏的一个方面。
    当一个对象被创建后,这个对象就拥有了自己的数据成员
    和成员方法,我们可以通过引用对象的成员来使用对象,对象
    的数据成员的引用方式如下:
    对象名.
    数据成员名
    对象的成员方法的引用方式如下:
    对象名.
    成员方法名(
    参数表)
    第4章 类 与 对 象
    【示例程序c4_2.java】 定义一个dogs类,使其包括Name、
    Weight和Height三个数据成员和一个名为ShowDog的成员方法。
    为dogs类创建Dane和Setter两个对象,确定两个对象的属性后
    引用ShowDog方法显示这两个对象。
    import java.awt.*;
    import java.applet. *;
    class dogs //定义dogs类
    {
    //以下三行定义dogs类的数据成员
    public String Name;
    public int Weight;
    public int Height;
    第4章 类 与 对 象
    //以下六行是dogs类的成员方法ShowDog( )的定义
    public void ShowDog(Graphics g,int x,int y)
    {
    g.drawString("Name:"+Name,x,y);
    g.drawString("Weight:"+Weight,x,y+20);
    g.drawString("Height:"+Height,x,y+40);
    } //成员方法ShowDog( )定义完成
    }// dogs类定义毕
    第4章 类 与 对 象
    public class c4_2 extends Applet
    {
    public void paint(Graphics g)
    {
    //以下为创建对象
    dogs Dane; //声明了一个名为Dane的对象,它属于dogs类
    Dane=new dogs( ); //建立Dane对象,为它分配存储空间
    dogs Setter=new dogs( );//声明Setter对象的同时建立该对象
    //以下六行引用对象的数据成员,将一组值赋给对象的数据成员
    Dane.Name="Gread Dane";
    Dane.Weight=100;
    第4章 类 与 对 象
    Dane.Height=23;
    Setter.Name="Irish Setter";
    Setter.Weight=20;
    Setter.Height=30;
    //以下两行引用对象的成员方法
    Dane.ShowDog(g,25,25);
    Setter.ShowDog(g,25,120);
    }
    }
    第4章 类 与 对 象
    图4.4 c4_2的运行结果
    第4章 类 与 对 象
    4.1.9
    对象的初始化与构造方法
    创建对象时,通常首先要为对象的数据成员赋初始值(如上
    例中的Dane.Name="Gread Dane";等6条语句),这被称为对象的初
    始化。初始化是最常用的操作之一,为简化这一操作,Java系统
    提供了专用的方法——构造方法来完成这一操作。
    构造方法是一个类的方法中方法名与类名相同的类方法。每
    当使用new关键字创建一个对象,为新建对象开辟了内存空间之
    后,Java系统将自动调用构造方法初始化这个新建对象。构造方
    法是类的一种特殊方法,它的特殊性主要体现在以下几个方面:
    第4章 类 与 对 象
    (1) 构造方法的方法名与类名相同。
    (2) 构造方法是类的方法,它能够简化对象数据成员的初
    始化操作。
    (3) 不能对构造方法指定类型,它有隐含的返回值,该值
    由系统内部使用。
    (4) 构造方法一般不能由编程人员显式地直接调用,在创
    建一个类的对象的同时,系统会自动调用该类的构造方法将新
    对象初始化。
    (5) 构造方法可以重载,即可定义多个具有不同参数的构
    造方法。
    第4章 类 与 对 象
    (6) 构造方法可以继承,即子类可以继承父类的构造方法。
    (7) 如果用户在一个自定义类中未定义该类的构造方法,
    系统将为这个类定义一个缺省的空构造方法。这个空构造方法
    没有形式参数,也没有任何具体语句,不能完成任何操作。但
    在创建一个类的新对象时,系统要调用该类的构造方法将新对
    象初始化。
    第4章 类 与 对 象
    【示例程序c4_3.java】 将示例程序c4_2改写为定义了构造方法的程序。
    import java.awt.*;
    import java.applet.*;
    class dogs //定义 dogs类
    {
    public String Name;
    public int Weight;
    public int Height;
    public dogs(String CName, int CWeight, int CHeight) //构造方法
    第4章 类 与 对 象
    { Name=CName;
    Weight=CWeight;
    Height=CHeight;
    }//构造方法定义毕
    public void ShowDog(Graphics g,int x,int y)
    { g.drawString("Name:"+Name,x,y);
    g.drawString("Weight:"+Weight,x,y+20);
    g.drawString("Height:"+Height,x,y+40);
    }
    } // dogs类定义毕
    第4章 类 与 对 象
    public class c4_3 extends Applet
    {
    public void paint(Graphics g)
    { dogs Dane=new dogs("Gread Dane",100,23);
    dogs Setter=new dogs("Irish Setter",20,30);
    Dane.ShowDog(g,25,25);
    Setter.ShowDog(g,25,120);
    }
    }
    第4章 类 与 对 象
    该程序的执行结果与示例程序c4_2.java相同。
    特殊情况下,构造方法中的参数名可能与数据成员名相
    同,此时,在构造方法中可用下面两种形式之一来区分数据成
    员名与参数名。
    (1)默认法。当构造方法的参数名与数据成员名相同时,
    将赋值号左边的标识符默认为对象的数据成员名,则赋值号右
    边的标识符为参数。
    public dogs(String Name, int Weight, int Height)
    { Name=Name;// 左边的标识符为数据成员名,右边的标识符为参数。下同
    Weight=Weight;
    Height=Height;
    }
    第4章 类 与 对 象
    (2) 使用代表本类对象的关键字this
    指出数据成员名之所在。
    关于this,将在5.4.4节讲述。
    public dogs(String Name, int Weight, int Height)
    {
    this.Name=Name; //用this指出数据成员名。下同
    this.Weight=Weight;
    this.Height=Height;
    }
    展开全文
  • 面向对象分析和设计基本概念

    千次阅读 2014-10-12 11:54:31
     面向对象分析和设计基本概念  面向对象是基于一种哲学思想,它认为:客观实体和实体之间的联系构成了现实世界的所有问题,而每一个实体都可以抽象为对象。这种思想尽可能地按照人类认识世界的方法和思维方式来...

    转载:http://www.cnblogs.com/mywolrd/archive/2008/04/03/1930735.html

      面向对象分析和设计基本概念

            面向对象是基于一种哲学思想,它认为:客观实体和实体之间的联系构成了现实世界的所有问题,而每一个实体都可以抽象为对象。这种思想尽可能地按照人类认识世界的方法和思维方式来分析和解决问题,使人们分析、设计一个系统的方法尽可能接近认识一个系统的方法。面向对象的基本观点可以概括如。( 1 )客观世界由对象组成,任何客观实体都是对象,复杂对象可以由简单对象组成。( 2 )具有相同数据和操作的对象可归纳成类,对象只是类的一个实例。( 3 )类可以派生出子类,子类除了继承父类的全部特性外还可以有自己的特性。( 4 )对象之间的联系通过消息传递来维系。由于类的封装性,它具有某些对外界不可见的数据,这些数据只能通过消息请求调用可见方法来访问。简单的来说,面向对象=对象+类+继承+消息。
              面向对象分析( OOA )是指利用面向对象的概念和方法为软件需求建造模型,以使用户需求逐步精确化、一致化、完全化的分析过程。分析的过程也是提取需求的过程,主要包括理解、表达和验证。由于现实世界中的问题通常较为复杂,分析过程中的交流又具有随意性和非形式化等特点,软件需求规格说明的正确性、完整性和有效性就需要进一步验证,以便及时加以修正。面向对象分析中建造的模型主要有对象模型、动态模型和功能模型。其关键是识别出问题域中的对象,在分析它们之间相互关系之后建立起问题域的简洁、精确和可理解的模型。对象模型通常由五个层次组成:类与对象层、属性层、服务层、结构层和主题层,此五个层次对应着在面向对象分析过程中建立对象模型的五项主要活动:发现对象、定义类、定义属性、定义服务、设别结构。面向对象的分析过程如图 1 所示。

    面向对象分析过程模型
            
            分析是提取和整理用户需求,并建立问题域精确模型的过程。面向对象设计( OOD )则是把分析阶段得到的需求转变成符合成本和质量要求的、抽象的系统实现方案的过程。从面向对象分析( OOA )到面向对象设计( OOD )是一个逐渐扩充模型的过程,也可以说面向对象设计是用面向对象观点建立求解域模型的过程。面向对象分析主要是模拟问题域和系统任务,而面向对象设计是面向对象分析的扩充,主要增加各种组成部分。面向对象设计的模型又五层组成,在设计期间主要扩充四个组成部分:人机交互部分、问题域、任务管理和数据管理。人机交互部分包括有效的人机交互所必须的实际显示和输入。问题域部分放置面向对象分析结果并管理面向对象分析的某些类和对象、结构、属性和方法。任务管理部分包括任务定义、通信和协调、硬件分配及外部系统。数据管理部分包括对永久性数据的访问和管理。面向对象设计模型如图 2 所示。

             为了方便、高效地进行面向对象分析和设计, UML Unified Modeling Language )被创造出来。 UML 是一种功能强大的、面向对象分析的可视化系统分析的建模语言,它采用一整套成熟的建模技术,广泛地适用于各个应用领域。运用 UML 进行面向对象分析设计,通常都要经过下述三个步骤。( 1 )识别系统的用例和角色。首先要对项目进行需求调研,分析项目的业务流程图和数据流程图,以及项目中涉及的各级操作人员,识别出系统中的所有用例和角色;接着分析系统中各角色和用例见的联系,使用 UML 建模工具画出系统的用例图;最后,勾画系统的概念层次模型,借助 UML 建模工具描述概念层的类和活动图。( 2 )进行系统分析并抽象出类。系统分析的任务是找出系统的所有要求并加以描述,同时建立特定领域模型。从实际需求抽象出类,并描述各个类之间的关系。( 3 )设计系统,并设计系统中的类及其行为。设计阶段由结构设计和详细设计组成。结构设计是高层设计,其任务是定义包(子系统)、包间的依赖关系和主要的通信机制。包有利于描述系统的逻辑组成以及各个部分之间的依赖关系。详细设计主要用来细化包的内容,清晰描述所有的类,同时使用 UML 的动态模型描述在特定环境下这些类的实例的行为。

    展开全文
  • 面向对象的一些概念

    千次阅读 2011-10-24 00:23:48
    1.面向对象的三个基本特征是:...封装是面向对象的特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,不可信的进行信息隐藏

    参考文献:http://www.cppblog.com/snowball/archive/2011/10/05/55051.html

    1.面向对象的三个基本特征是:封装、继承、多态。

    o_OOBase.gif

    1.1封装

    封装最好理解了。封装是面向对象的特征之一,是对象和类概念的主要特性。

    封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

    1.2继承

    面向对象编程 (OOP) 语言的一个主要功能就是 “ 继承 ” 。继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。

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

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

    继承的过程,就是从一般到特殊的过程。

    要实现继承,可以通过 “ 继承 ” ( Inheritance )和 “ 组合 ” ( Composition )来实现。

    在某些 OOP 语言中,一个子类可以继承多个基类。但是一般情况下,一个子类只能有一个基类,要实现多重继承,可以通过多级继承来实现。

     

    继承概念的实现方式有三类:实现继承、接口继承和可视继承。

    Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力;

    Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力;

    Ø         可视继承是指子窗体(类)使用基窗体(类)的外观和实现代码的能力。

    在考虑使用继承时,有一点需要注意,那就是两个类之间的关系应该是 “ 属于 ” 关系。例如, Employee 是一个人, Manager 也是一个人,因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类,因为腿并不是一个人。

    抽象类仅定义将由子类创建的一般属性和方法,创建抽象类时,请使用关键字 Interface 而不是 Class 。

    OO 开发范式大致为:划分对象 → 抽象类 → 将类组织成为层次化结构 ( 继承和合成 ) → 用类与实例进行设计和实现几个阶段。

    1.3多态

    多态性( polymorphisn )是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。

    实现多态,有二种方式,覆盖,重载。

    覆盖,是指子类重新定义父类的虚函数的做法。

    重载,是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。

    其实,重载的概念并不属于 “ 面向对象编程 ” ,重载的实现是:编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(至少对于编译器来说是这样的)。如,有两个同名函数: function func(p:integer):integer; 和 function func(p:string):integer; 。那么编译器做过修饰后的函数名称可能是这样的: int_func 、 str_func 。对于这两个函数的调用,在编译器间就已经确定了,是静态的(记住:是静态)。也就是说,它们的地址在编译期就绑定了(早绑定),因此,重载和多态无关!真正和多态相关的是 “ 覆盖 ” 。当子类重新定义了父类的虚函数后,父类指针根据赋给它的不同的子类指针,动态(记住:是动态!)的调用属于子类的该函数,这样的函数调用在编译期间是无法确定的(调用的子类的虚函数的地址无法给出)。因此,这样的函数地址是在运行期绑定的(晚邦定)。结论就是:重载只是一种语言特性,与多态无关,与面向对象也无关!引用一句 Bruce Eckel 的话: “ 不要犯傻,如果它不是晚邦定,它就不是多态。 ”

    那么,多态的作用是什么呢?我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了 —— 代码重用。而多态则是为了实现另一个目的 —— 接口重用!多态的作用,就是为了类在继承和派生的时候,保证使用 “ 家谱 ” 中任一类的实例的某一属性时的正确调用。

    2.泛化、聚合、组合和依赖的概念解析

    2.1泛化( Generalization )

    o_Generalization.gif

    图表 泛化

    在上图中,空心的三角表示继承关系(类继承),在 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 的功能和属性。

    2.2聚合(组合)

    o_aggregationBase.gif

    图表 组合

    若在逻辑上 A 是 B 的“一部分”( a part of ),则不允许 B 从 A 派生,而是要用 A 和其它东西组合出 B 。

    例如,眼( Eye )、鼻( Nose )、口( Mouth )、耳( Ear )是头( Head )的一部分,所以类 Head 应该由类 Eye 、 Nose 、 Mouth 、 Ear 组合而成,不是派生(继承)而成。

    聚合的类型分为无、共享 ( 聚合 ) 、复合 ( 组合 ) 三类。

    2.3聚合( aggregation )

     

    o_aggregation.gif

    图表 共享

    上面图中,有一个菱形(空心)表示聚合( aggregation )(聚合类型为共享),聚合的意义表示 has-a 关系。聚合是一种相对松散的关系,聚合类 B 不需要对被聚合的类 A负责。

    2.4组合( composition )

    o_composition.gif

    图表 复合

    这幅图与上面的唯一区别是菱形为实心的,它代表了一种更为坚固的关系 —— 组合( composition )(聚合类型为复合)。组合表示的关系也是 has-a ,不过在这里, A 的生命期受 B 控制。即 A 会随着 B 的创建而创建,随 B 的消亡而消亡。

    2.5依赖 (Dependency)

    o_Dependency.gif

    图表 依赖

    这里 B 与 A 的关系只是一种依赖 (Dependency) 关系,这种关系表明,如果类 A 被修改,那么类 B 会受到影响。

    3接口与抽象类有什么区别

    abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析,试图给开发者提供一个在二者之间进行选择的依据。

    3.1理解抽象类

    abstract class和interface在Java语言中都是用来进行抽象类(本文中的抽象类并非从abstract class翻译而来,它表示的是一个抽象体,而abstract class为Java语言中用于定义抽象类的一种方法,请读者注意区分)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢?

    在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样。并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形这样一些具体概念,它们是不同的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能够实例化的。

    在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这个抽象体派生,也可扩展此模块的行为功能。熟悉OCP的读者一定知道,为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle),抽象类是其中的关键所在。

    3.2从语法定义层面看abstract class和interface

    在语法层面,Java语言对于abstract class和interface给出了不同的定义方式,下面以定义一个名为Demo的抽象类为例来说明这种不同。

    使用abstract class的方式定义Demo抽象类的方式如下:

    abstract class Demo { 
    abstract void method1(); 
    abstract void method2(); 
    … 

    使用interface的方式定义Demo抽象类的方式如下:

    interface Demo { 
    void method1(); 
    void method2(); 
    … 
    }

    在abstract class方式中,Demo可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface方式的实现中,Demo只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。从某种意义上说,interface是一种特殊形式的abstract class。

    从编程的角度来看,abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。

    首先,abstract class在Java语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。也许,这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。

    其次,在abstract class的定义中,我们可以赋予方法的默认行为。但是在interface的定义中,方法却不能拥有默认行为,为了绕过这个限制,必须使用委托,但是这会 增加一些复杂性,有时会造成很大的麻烦。

    在抽象类中不能定义默认行为还存在另一个比较严重的问题,那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面(一般通过abstract class或者interface来表示)以适应新的情况(比如,添加新的方法或者给已用的方法中添加新的参数)时,就会非常的麻烦,可能要花费很多的时间(对于派生类很多的情况,尤为如此)。但是如果界面是通过abstract class来实现的,那么可能就只需要修改定义在abstract class中的默认行为就可以了。

    同样,如果不能在抽象类中定义默认行为,就会导致同样的方法实现出现在该抽象类的每一个派生类中,违反了"one rule,one place"原则,造成代码重复,同样不利于以后的维护。因此,在abstract class和interface间进行选择时要非常的小心。

    3.3从设计理念层面看abstract class和interface

    上面主要从语法定义和编程的角度论述了abstract class和interface的区别,这些层面的区别是比较低层次的、非本质的。本小节将从另一个层面:abstract class和interface所反映出的设计理念,来分析一下二者的区别。作者认为,从这个层面进行分析才能理解二者概念的本质所在。

    前面已经提到过,abstarct class在Java语言中体现了一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在"is a"关系,即父类和派生类在概念本质上应该是相同的(参考文献〔3〕中有关于"is a"关系的大篇幅深入的论述,有兴趣的读者可以参考)。对于interface 来说则不然,并不要求interface的实现者和interface定义在概念本质上是一致的,仅仅是实现了interface定义的契约而已。为了使论述便于理解,下面将通过一个简单的实例进行说明。

    考虑这样一个例子,假设在我们的问题领域中有一个关于Door的抽象概念,该Door具有执行两个动作open和close,此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型,定义方式分别如下所示:

    使用abstract class方式定义Door:

    abstract class Door { 
    abstract void open(); 
    abstract void close(); 
    }

    使用interface方式定义Door:

    interface Door { 
    void open(); 
    void close(); 
    }

    其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

    如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢(在本例中,主要是为了展示abstract class和interface反映在设计理念上的区别,其他方面无关的问题都做了简化或者忽略)?下面将罗列出可能的解决方案,并从设计理念层面对这些不同的方案进行分析。

    解决方案一:

    简单的在Door的定义中增加一个alarm方法,如下:

    abstract class Door { 
    abstract void open(); 
    abstract void close(); 
    abstract void alarm(); 
    }

    或者

    interface Door { 
    void open(); 
    void close(); 
    void alarm(); 
    }

    那么具有报警功能的AlarmDoor的定义方式如下:

    class AlarmDoor extends Door { 
    void open() { … } 
    void close() { … } 
    void alarm() { … } 
    }

    或者

    class AlarmDoor implements Door { 
    void open() { … } 
    void close() { … } 
    void alarm() { … } 

    这种方法违反了面向对象设计中的一个核心原则ISP(Interface Segregation Priciple),在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变(比如:修改alarm方法的参数)而改变,反之依然。

    解决方案二:

    既然open、close和alarm属于两个不同的概念,根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有:这两个概念都使用abstract class方式定义;两个概念都使用interface方式定义;一个概念使用abstract class方式定义,另一个概念使用interface方式定义。

    显然,由于Java语言不支持多重继承,所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的,但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

    如果两个概念都使用interface方式来定义,那么就反映出两个问题:1、我们可能没有理解清楚问题领域,AlarmDoor在概念本质上到底是Door还是报警器?2、如果我们对于问题领域的理解没有问题,比如:我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的,那么我们在实现时就没有能够正确的揭示我们的设计意图,因为在这两个概念的定义上(均使用interface方式定义)反映不出上述含义。

    如果我们对于问题领域的理解是:AlarmDoor在概念本质上是Door,同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢?前面已经说过,abstract class在Java语言中表示一种继承关系,而继承关系在本质上是"is a"关系。所以对于Door这个概念,我们应该使用abstarct class方式来定义。另外,AlarmDoor又具有报警功能,说明它又能够完成报警概念中定义的行为,所以报警概念可以通过interface方式定义。如下所示:

    abstract class Door { 
    abstract void open(); 
    abstract void close(); 

    interface Alarm { 
    void alarm(); 

    class AlarmDoor extends Door implements Alarm { 
    void open() { … } 
    void close() { … } 
    void alarm() { … } 
    }

    这种实现方式基本上能够明确的反映出我们对于问题领域的理解,正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系,interface表示的是"like a"关系,大家在选择时可以作为一个依据,当然这是建立在对问题领域的理解上的,比如:如果我们认为AlarmDoor在概念本质上是报警器,同时又具有Door的功能,那么上述的定义方式就要反过来了。

    小结

    1. abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。
    2. 在abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在 interface中一般不定义数据成员),所有的成员方法都是abstract的。
    3. abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系,interface表示的是"like-a"关系。 
    4. 实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。
    5. 接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值。
    6. 抽象类中的变量默认是 friendly 型,其值可以在子类中重新定义,也可以重新赋值。 
    7. 接口中的方法默认都是 public,abstract 类型的。

    结论

      abstract class 和 interface 是 Java语言中的两种定义抽象类的方式,它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概 念本质的理解、对于设计意图的反映是否正确、合理,因为它们表现了概念间的不同的关系(虽然都能够实现需求的功能)。这其实也是语言的一种的惯用法,希望读者朋友能够细细体会。

    展开全文
  • c++面向对象和c面向过程的一些概念

    千次阅读 2017-01-18 14:02:46
    1.面向对象和面向过程的概念 面向过程是分析解决问题的步骤,然后用函数把这些步骤一步一步的实现,然后在使用的时候一一调用则可。 面向对象是把构成问题的事务分解成各个对象,而建立对象的目的也不是为了完成一...
  • 第四讲:面向对象程序设计方法及类、对象概念  掌握:面向对象程序设计的方法及特点;类的声明的对象的定义理解:对象的封装、抽象、继承与多态性四个特快性的概念;类和对象的作用;面向对象和面向过程的程序...
  • 什么是类?对象?类与对象的关系是什么

    万次阅读 多人点赞 2019-06-02 14:56:30
    什么对象?          万物皆对象。它包括现实中客观存在的事物,也包括抽象的时间、规则、思维。简单点说,对象具有状态、行为和标识。 类 什么是类?   ...
  • 1、对象和类概念对象:任何一个对象都应该具备两个要素:属性、行为。在C++中每个对象都有数据(体现了‘属性’)和函数(用来数据进行操作,以实现某些功能)两部分组成。类:具有共性的实体的抽象。类是对象的...
  • 面向对象概念及术语总结

    千次阅读 2005-11-21 12:56:00
    名称 注解 范型(paradigm) 做事情的整体策略和观点,范型是一套特定的思想集. 类(class) 对象创建
  • java面试题32:Java网络程序设计中,下列正确描述是() A:Java网络编程API建立在Socket基础之上 B:Java网络接口只支持tcP以及其上层协议 C:Java网络接口只支持UDP以及其上层协议 D:Java网络接口支持IP...
  • 如何正确的创建和销毁Java对象

    万次阅读 2017-06-15 18:24:16
    Java是一门强大的高级语言。在学习了其基础知识后,我们仍需要理解其深刻的内涵。接下来,我们会以《Effective Java》一书做为Java进阶学习的载体,Java进行一个系统的、全新的认识。 第一章:创建和销毁对象
  • 什么是面向对象

    千次阅读 2018-12-30 09:41:44
    面向对象是一种编程风格,Python一切皆对象,把一切东西看成是一个个对象,比如人、耳机、鼠标、水杯等,他们各自都有属性,比如:耳机是白色的,鼠标是黑色的,水杯是圆柱形的等等,把这些对象拥有的属性变量和操作...
  • 几个描述逻辑中的概念

    千次阅读 2008-12-12 02:59:00
    描述逻辑(DescriptionLogic)是基于对象的知识表示的形式化,它吸取了KL-ONE的主要思想,是一阶谓词逻辑的一个可判定子集。它与一阶谓词逻辑不同的是,描述逻辑系统能提供可判定的推理服务。除了知识表示以外,描述...
  • 正确地理解Window窗口概念

    千次阅读 2017-03-12 22:46:21
    正确的Window窗口概念应该是:通过图像的形式响应用于操作的界面。 因此,理解Window窗口就需要解答两个问题: 1、Window窗口获取用户输入的流程是怎样的? 2、Window窗口绘制图像的流程是怎样的? 首先...
  • 第一章 对象概念 “我们没有意识到惯用语言的结构有多大的力量。可以毫不夸张地说,它通过语义反应机制奴役我们。语言表现出来并在无意识中给我们留下深刻印象的结构会自动投射到我们周围的世界。” – Alfred ...
  • 这里有面向对象开发的几个核心的思想和概念 1、问题领域、对象、属性、状态、行为、方法、实现 问题领域: 指软件系统所模拟的真实世界中的系统,在现实生活中,比较常见的比如,税收、社保、银行、商场...
  • 一、 名词解释抽象 封装 消息【问题解答】面向对象方法中的 抽象是指 具体问题(对象)进 行概括,抽出一类对象的公共性质并加以描述的过 程。面向对象方法中的 封装就是 把抽象出来的对象的 属性和行为结合成一个...
  • 面向对象方法,OO方法所具有的模块化、信息封装与隐蔽、抽象性、继承性、多样性等独特之处,这些优异特性为研制大型软件、提高软件可靠性、可重用性、可扩充性和可维护性提供了有效的手段和途径。Java主要特征:封装性...
  • 概念模型(1)用途与基本要求(2) 信息世界中的基本概念(3)两个实体型之间的联系① 一一联系(1:1)② 一多联系(1:n)③ 多多联系(m:n)(4)两个以上实体型之间的联系① 一多联系(1:m||1:n)② 一一联系...
  • java面向对象

    万次阅读 多人点赞 2018-08-21 16:51:59
    包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是...
  • 深入理解Python中的面向对象

    万次阅读 多人点赞 2017-06-12 06:42:41
    1、面向过程与面向对象的对比面向过程的程序设计的核心是过程(流水线式思维),过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西。 优点是:极大的降低了程序的
  • 对象与引用对象

    千次阅读 2014-06-03 22:16:43
    概念介绍 对象对象引用
  • 下面关于抽象概念描述中,不正确的是 A 计算机软件开发使用的抽象有过程抽象和数据抽象两种 B 过程抽象强调功能完成的过程和步骤 C 过程抽象按照功能将整个系统的不同部分抽象成不同的类 D 数据抽象的每个抽象...
  • 深入理解Java类型信息(Class对象)与反射机制

    万次阅读 多人点赞 2017-05-01 23:19:19
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ...深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
  • Spring核心概念的理解

    千次阅读 2019-05-16 18:13:26
    那么什么是IOC呢,有反转就会有正转,正转就是你需要用到这个类对象时,自己手动new出来。而反转就是你设计编写好的类不是由你自己创建,而是把创建的权力交予spring框架的IOC容器。 1.1 IOC是啥 所谓IOC,对于...
  • Qt 之对象树与所有权

    千次阅读 2016-09-02 17:53:32
    简述QObjects在一个对象树中组织他们自己。当创建一个QObject时,如果使用了其他对象作为其父对象,那么,它就会被添加到父对象的children()列表中。这样一来,当父对象被销毁时,这个QObject也会被销毁。事实表明,...
  • 标准参考 根据 DOM (Core) Level 1 规范中的描述,getAttribute 与 setAttribute 为 Element 接口下的方法,其功能分别是通过 "name" 获取和设置一个元素的属性(attribute)值。getAttribute 方法会以...
  • 多态,大概每个人都知道。但是,又有几个人真的理解什么是多态、多态有哪些细节呢?如果你看到这篇文章的名字,脑海中多态没有一个清晰的概念,不妨点进来看看,也许会有收获。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 211,362
精华内容 84,544
关键字:

对对象概念描述正确的是什么