第6讲面向对象特征解析
python面向对象教学课件
a = Account("Huang") print(a.balance) a.deposit(100) a.withdraw(10) print(a.balance)
b = Account("Li") c = Account("Li") b.balance = 100 c.balance = 80 print(b.balance =_是在对象消亡时由 python自动调用的函数， 一般用于完成对象的消亡 前处理操作
15
继承、重写、多态、访问限制
16
继承
• 类别可以存在层级关系 • 实现代码复用的重要方式
17
继承
• 例如： – 定义一个新类型的账户，具有取款手续费
class CheckingAccount: def __init__(self, account_holder): self.balance = 0 self.holder = account_holder def deposit(self, amount): self.balance += amount def withdraw_charge(self, amount): self.balance -= (amount + 1)
class CheckingAccount(Account): def __init__(self, acc_holder, balance): Account.__init__(self, acc_holder) self.balance = balance
super().__init__(acc_holder)
a = Account("Huang") a.deposit(100) print(a.deposit)
面向对象的三个基本特征和概念
面向对象的三个基本特征（讲解）面向对象的三个基本特征是：封装、继承、多态。
封装封装最好理解了。
封装是面向对象的特征之一，是对象和类概念的主要特性。
封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
继承面向对象编程 (OOP) 语言的一个主要功能就是“继承”。
继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”。
继承的过程，就是从一般到特殊的过程。
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
在某些 OOP 语言中，一个子类可以继承多个基类。
但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
继承概念的实现方式有三类：实现继承、接口继承和可视继承。
实现继承是指使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。
例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。
但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。
OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
多态多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。
面向对象分析方法
面向对象分析方法面向对象分析方法是以系统的用户和目的为出发点的一种分析技术，它主要用于分析系统中的物体（对象）之间的关系，以及这些物体所具有的通用性质，以便将它们组织为一个可使用的整体系统。
在软件开发中，面向对象分析方法用于发现和描述系统中的对象，以及它们之间的关系，并将这些对象组织为可重用的模块，以便用于系统的设计和实现。
面向对象分析方法包括四个主要步骤： 1、识别对象：根据系统的用户和目的，识别系统中的对象，并确定它们之间的关系。
2、分析对象：对系统中的对象进行进一步分析，以便更好地理解它们之间的关系。
3、确定对象的功能：确定系统中的对象应该具有的功能，以及它们之间的关系应该如何实现。
4、设计对象结构：考虑到对象之间的关系，设计系统的对象结构，以便将它们组织为可重用的模块。
面向对象分析方法有助于定义和分析系统中的对象以及它们之间的关系，从而准备进行软件设计和实现。
它能够帮助开发人员更好地理解系统的用户和目的，以及系统的功能和结构，从而有效地实现软件开发过程。
首先，面向对象分析可以帮助开发人员确定和识别系统中的对象，以及它们之间的关系。
通过分析用户和目的，开发人员可以确定用户可能会使用的对象，以及这些对象之间的关系。
在确定系统中的对象之后，开发人员可以分析这些对象，以便更好地理解它们之间的关系。
其次，面向对象分析可以帮助开发人员确定系统中的对象应该具有的功能，以及它们之间的关系应该如何实现。
通过分析用户和目的，开发人员可以确定每个对象应具有的功能，以及它们之间的关系应该如何实现。
最后，面向对象分析可以帮助开发人员设计系统的对象结构，以便将它们组织为可重用的模块。
在设计对象结构时，开发人员需要考虑到对象之间的关系，以及它们应该如何被组织和重用。
总之，面向对象分析方法是一种帮助开发人员确定和分析系统中的对象以及它们之间的关系的技术，从而为软件设计和实现提供依据。
它可以帮助开发人员确定系统中的对象，以及它们应该具有的功能和结构，从而有助于软件开发过程的有效实施。
面向对象知识点总结
⾯向对象知识点总结1、⾯向对象三⼤特征封装：封装就是隐藏对象的属性和实现细节，仅对外公开接⼝，控制在程序中属性的读和修改的访问级别，将抽象得到的数据和⾏为（或功能）相结合，形成⼀个有机的整体。
继承：继承就是⼦类继承⽗类的特征和⾏为，使得⼦类对象（实例）具有⽗类的实例域和⽅法，或⼦类从⽗类继承⽅法，使得⼦类具有⽗类相同的⾏为。
多态：多态指同⼀个⾏为具有多个不同表现形式或形态的能⼒，是指⼀个类实例（对象）的相同⽅法在不同情形有不同表现形式，使具有不同内部结构的对象可以共享相同的外部接⼝。
2、类与对象对象：对象是类的⼀个实例，有状态和⾏为。
类：类是⼀个模板，它描述⼀类对象的⾏为和状态。
⼀个类可以包含以下类型变量：（1）局部变量：在⽅法、构造⽅法或者语句块中定义的变量被称为局部变量。
变量声明和初始化都是在⽅法中，⽅法结束后，变量就会⾃动销毁。
（2）成员变量：成员变量是定义在类中，⽅法体之外的变量。
这种变量在创建对象的时候实例化。
成员变量可以被类中⽅法、构造⽅法和特定类的语句块访问。
（3）类变量：类变量也声明在类中，⽅法体之外，但必须声明为 static 类型。
3、构造⽅法每个类都有构造⽅法。
如果没有显式地为类定义构造⽅法，Java 编译器将会为该类提供⼀个默认构造⽅法。
在创建⼀个对象的时候，⾄少要调⽤⼀个构造⽅法。
构造⽅法的名称必须与类同名，⼀个类可以有多个构造⽅法。
4、封装封装是指⼀种将抽象性函式接⼝的实现细节部分包装、隐藏起来的⽅法。
封装可以被认为是⼀个保护屏障，防⽌该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接⼝控制。
修改属性的可见性来限制对属性的访问（⼀般限制为private），可通过getter和setter⽅法访问和操作类中私有成员变量。
如下代码：class BookClass{private String title;private int pageNum;BookClass(){};// 设置名称public void setTille(String title) {this.title = title;}public String getTitle() {return title;}// 设置页数public void setPageNum(int pageNum) {if (pageNum>=200) {this.pageNum = pageNum;} else {System.out.println("页数输⼊错误，图书页数不能⼩于200页，设置为默认值200");this.pageNum = 200;}}public int getPageNum() {return pageNum;}// 显⽰图书信息public void detail() {System.out.println("图书名称为："+title+"，页数为："+pageNum);}}5、继承在 Java 中通过 extends 关键字可以申明⼀个类是从另外⼀个类继承⽽来的。
简述对面向对象的三大特征的理解
简述对面向对象的三大特征的理解
面向对象有三大特点：封装、继承、多态。
1、继承性：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
对象的一个新类可以从现有的类中派生，这个过程称为类继承。
新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。
派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
2、封装性：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。
面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
3、多态性：
多态性是指允许不同类的对象对同一消息作出响应。
多态性包括参数化多态性和包含多态性。
多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
面向对象技术概述
1.1 知识要点1．面向对象技术的基本概念∙面向对象技术是以对象为基础、以事件或者消息来驱动对象执行处理的程序设计技术。
∙对象是包含客观事物特征的抽象实体，是属性和行为的封装体。
在程序设计领域，可以用“对象=数据+作用于这些数据上的操作”这一公式来表达。
∙类是对具有相同属性和行为的一组对象的抽象描述。
∙事件是系统产生的动作或是运行应用程序产生的动作。
事件通过消息描述，消息是描述事件发生的信息。
∙消息是对象间交互的手段，是要求某个对象执行某个操作的规格说明。
2．面向对象技术的基本特征∙抽象性是指忽略事物中与当前目标无关的非本质特征，而强调本质特征的特征。
∙封装性是指把对象的属性和行为封装在一起，并尽可能隐藏对象的内部细节的特征。
∙继承性是指特殊类的对象拥有其一般类的属性和行为的类与类之间层次关系的特征。
∙多态性是指不同对象收到相同消息时可以产生多种不同的行为方式的特征。
【重点】∙面向对象技术的概念。
∙类与对象的概念及关系。
∙面向对象与面向过程程序设计的区别。
∙面向对象技术的基本特征。
面向对象技术与Visual C++学习指导2【难点】∙类与对象的概念。
∙面向对象与面向过程程序设计的区别。
∙面向对象技术的基本特征。
1.2 习题解答1．什么是面向对象技术？【问题解答】面向对象技术是一种以对象为基础，以事件或消息来驱动对象执行处理的程序设计技术。
它具有抽象性、封装性、继承性及多态性。
2．面向对象与面向过程程序设计有什么不同?【问题解答】面向对象与面向过程程序设计有如下不同：（1）面向过程程序设计方法采用函数（或过程）来描述对数据的操作，但又将函数与其操作的数据分离开来；面向对象程序设计方法将数据和对数据的操作封装在一起，作为一个整体来处理。
（2）面向过程程序设计方法以功能为中心来设计功能模块，难于维护；而面向对象程序设计方法以数据为中心来描述系统，数据相对于功能而言具有较强的稳定性，因此更易于维护。
（3）面向过程程序的控制流程由程序中预定顺序来决定；面向对象程序的控制流程由运行时各种事件的实际发生来触发，而不再由预定顺序来决定，更符合实际需要。
面向对象分析
面向对象分析：是确定需求或者业务的角度，按照面向对象的思想来分析业务。
例如：OOA只是对需求中描述的问题，进行模块化的处理，描述问题的本质，区别每个问题的不同点相同点，确定问题中的对象。
OOA与结构化分析有较大的区别。
OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。
基本步骤：
在用OOA具体地分析一个事物时，大致上遵循如下五个基本步骤：
第一步，确定对象和类。
这里所说的对象是对数据及其处理方式的抽象，它反映了系统保存和处理现实世界中某些事物的信息的能力。
类是多个对象的共同属性和方法集合的描述，它包括如何在一个类中建立一个新对象的描述。
第二步，确定结构（structure）。
结构是指问题域的复杂性和连接关系。
类成员结构反映了泛化-特化关系，整体-部分结构反映整体和局部之间的关系。
第三步，确定主题（subject）。
主题是指事物的总体概貌和总体分析模型。
第四步，确定属性（attribute）。
属性就是数据元素，可用来描述对象或分类结构的实例，可在图中给出，并在对象的存储中指定。
第五步，确定方法（method）。
方法是在收到消息后必须进行的一些处理方法：方法要在图中定义，并在对象的存储中指定。
对于每个对象和结构来说，那些用来增加、修改、删除和选择一个方法本身都是隐含的（虽然它们是要在对象的存储中定义的，但并不在图上给出），而有些则是显示的。
面向对象的四个基本特征
面向对象的四个基本特征面向对象编程（Object-Oriented Programming，简称OOP）是一种广泛使用的编程范式，它将数据和对数据的操作封装在一起，形成一个对象。
面向对象的编程主要有以下四个基本特征：1. 封装（Encapsulation）：封装是指将数据和对数据的操作封装在一起形成对象。
对象通过暴露一组公共接口来与外部进行交互，隐藏了内部的实现细节。
这样可以提高代码的模块化程度，减少了代码的耦合度，同时也增加了代码的可重用性和维护性。
通过封装，我们可以将复杂的问题分解为简单的对象，每个对象都负责完成自己的任务。
2. 继承（Inheritance）：继承是指在已有类的基础上创建新的类，新的类继承了已有类的属性和方法。
子类可以继承父类的特性，同时还可以重新定义或扩展父类的行为。
继承可以提高代码的重用性，减少了代码的重复量，同时也使得代码更加易于扩展和维护。
3. 多态（Polymorphism）：多态是指在继承关系中，一个方法可以有不同的实现方式。
具有多态性的方法在不同的对象上可以有不同的行为，这使得代码更具灵活性和可扩展性。
多态性可以通过方法的重写和方法的重载来实现。
方法的重写指的是子类重新定义父类中的方法，而方法的重载则指的是在同一个类中定义多个同名但参数列表不同的方法。
4. 抽象（Abstraction）：抽象是指从具体事物中提取出其核心的特征和行为，忽略其具体的实现细节。
在面向对象编程中，抽象的主要方式是通过抽象类和接口来定义。
抽象类指的是只包含抽象方法（没有具体实现的方法）的类，它只提供了一种规范或接口，具体的实现由其子类完成。
接口则是一种特殊的抽象类，它只包含抽象方法和常量，不包含任何具体实现。
抽象类和接口能够帮助我们实现代码的层次化组织和规范化管理。
总结：面向对象的编程主要有封装、继承、多态和抽象四个基本特征。
这四个特征使得代码更具有模块化、重用性、可扩展性和可维护性，提高了代码的灵活性和可靠性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1
接口与抽象类 2 异常类 3 类与类型 4 基础数据结构
1接口与抽象类 1.1接口语法
[public] {//接口体; //常量域声明 interface 接口名 [extends 父接口名列表]
[public]
[static]
[final]
域类型
域名=常量值;
2.4 异常处理总结
对Error类或其子类的对象，程序中不必进行处理 对RuntimeException类或其子类，程序中可以不必进行处 理 除此之外的异常，程序员都应该在程序中进行处理。要 么用try-catch-finally进行捕获处理，要么明确表示不处理 从而声明抛出异常，要么先捕获处理然后再次抛出。 Java的异常处理机制（try-catch-finally语句、throws 子句、 throw 语句）带来Java程序代码结构上的改变 不能滥用异常机制。简单的出错判断建议用if语句 不要过分细分异常
2 异常类
异常：正常程序所不能处理或者无法
处理的情况。 原因：1、避免程序繁琐与复杂 2、当前层次处理不恰当 引入异常机制的目的： 1、使异常处理简化、统一 2、保留异常处理的灵活性
2.1异常类
通常用类Exception及其子类来描述异常的
特征。 按照编译时是否能够监测，分为: Checked Exception Unchecked Exception两种，其中非监测异 常又分为RuntimeException、Error。通常 Error是致命性的，无法由程序来处理,例如 VirtualMachineError.
自定义异常类
本例中，当a的值小于10或大于100时，将产生异常。
class MyException1 extends Exception { int num; MyException1(int a) { num=a;} public String toString() { return num+"<10!\r\n值必须大于10"，打印出其机内码。注意不是UNICODE码。若按了 a键，则立即抛出异常。
import java.io.*; public class Ex_Exception3 { public static void main(String[] args) { int c; try { while ( ( c = System.in.read())!=-1 ) { if( c=='a' ) throw new Exception("键a坏了！"); System.out.println(c); } } catch(IOException e) { System.out.println(e); } catch(Exception e) { System.out.println(e); } } }
//抽象方法声明 [public] 异常列表];} [abstract] [native]返回值 方法名(参数列表) [throw
从上面的语法规定可以看出，定义接口与定义类非常相似，实际上完全可以把接口理 解成为一种特殊的类，接口是由常量和抽象方法组成的特殊类。
1.2接口声明
（1）接口中的属性都是用 final修饰的常量，在 这个类中，所有的成员函数都是抽象的，也就 是说它们都只有说明没有定义； （ 2 ）接口中的方法都是用 abstract 修饰的抽象方 法，在接口中只能给出这些抽象方法的方法名、 返回值和参数列表，而不能定义方法体，即仅 仅规定了一组信息交换、传输和处理的“接 口”。
1.3接口实现
• 在类的声明部分，用implements关键字声明该类将要实现哪些接口 • 如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须实 现指定接口的所有抽象方法，即为所有抽象方法定义方法体，而且方 法头部分应该与接口中的定义完全一致，即有完全相同的返回值和参 数列表 • 如果实现某接口的类是abstract的抽象类，则它可以不实现该接口所有 的方法 • 一个类在实现某接口的抽象方法时，必须使用完全相同的方法头 • 接口的抽象方法，其访问限制符都已指定是public，所以类在实现方法 时，必须显式地使用public修饰符
class MyException2 extends Exception { int num; MyException2(int a) { num=a;} public String toString() { return num+">100!\r\n值必须小于100";}
2.2异常产生与声明
声明抛出异常是一个子句，只能加在方法头部的后边。 语法格式如下： throws <用逗号分隔的异常列表> 如：public int read() throws IOException { ... 真正抛出异常的动作是由抛出异常语句来完成的。 格式如下: throw <异常对象>； 其中：<异常对象>必须是Throwable类或其子类的对象。 如：throw new Exception("这是一个异常"); 下面的语句在编译时将会产生语法错误： throw new String("能抛出吗？")； 这是因为String类不是Throwable类的子类。
//可能会产生异常的程序代码
2.3异常捕获与处理
当产生异常时，程序从上往下依次判该异常是不是 catch(Exception_x e)块中Exception_x类或其子类的对象。 try-catch-finally语句的嵌套。 try-catch-finally语句的 try 块、catch块、 finally块中的程 序代码都可以嵌套另外的 try-catch-finally语句，且嵌套层次数 任意。
2.3异常捕获与处理
Java 中 使 用 try-catch-finally 语 句 来 捕 获 并 处 理 异 常 ， trycatch-finally语句的语法格式如下： try { } catch(Exception_1 e1) { //处理异常Exception_1的代码 } catch(Exception_2 e2) { //处理异常Exception_2的代码 } ... catch(Exception_n en) { //处理异常Exception_n的代码 } [ finally{//通常是释放资源的程序代码 } ] 整个语句由try块、catch块和可以缺省finally块三部分组成。