面向对象的三个基本特征和概念
什么是面向对象、对象是什么、什么是类、如何使用对象、类和对象的关系
什么是⾯向对象、对象是什么、什么是类、如何使⽤对象、类和对象的关系⾯向对象⼀、⾯向对象 概念：⾯向对象是⼀种编程思想，使⽤编程语⾔解决现实问题的⼀种思路。
分类： ⾯向过程: C 语⾔ ⾯向对象: Java ⾯向对象的思想： ⾯向对象的思想： ⾯向过程的思想：⾃顶向下 逐步执⾏。
---> 当解决⼀件事情的时候，⾸先想到的是我该怎么去做⾯向对象思想：以对象为中⼼，使⽤对象调⽤其功能。
---> 当解决⼀件事情的时候，⾸先想到的是我该让谁帮我做。
想到的谁 ---> 对象 对象：现实⽣活中存在的真实的事物都是对象，Java 中有⼀句名⾔： 万物皆对象，⼤到宇宙、⼩到夸克在Java 的世界中都可以看成对象。
提起对象，就需要提起另⼀个概念——类。
类是对象的模板，对象是类的实例。
⼆、类 概念： 将具有相同特征的⼀类事物的共性进⾏抽取(抽取的过程叫做抽象)，形成的⼀个概念叫做类。
类的抽象： 1. 怎么去描述⼀个事物，从哪些维度进⾏描述？ 这个事物具有什么 ---> 属性 这个事物会做什么 ---> ⾏为 2. 怎么去描述⼀类事物的共性？ 这些事物具有什么 ---> 属性 这些事物会做什么 ---> ⾏为 类和对象的关系： 类是对象的模板 对象是类的实例 类的定义： 概述： 属性 ： 使⽤成员变量来进⾏描述 ⾏为 ： 使⽤成员⽅法进⾏描述 语法：关键词：class语法：public class 类名｛｝ 成员变量 定义位置：类中⽅法外 语法： 数据类型 变量名； / 数据类型 变量名 = 初始值；作⽤域：⾄少在本类 默认值： 和数组元素的默认值是⼀样的 基本数据类型 整数类型 0 ⼩数类型 0.0 字符类型空字符 布尔类型 false 引⽤数据类型 null 定义的注意事项 1. 在同⼀个类中不能定义两个同名的成员变量 2. 在同⼀个类中成员变量可以和局部变量可以重名，但是在访问的时候，局部变量优先。
java面向对象的三个特征
使用java面向对象编程的三大特征大多数新人，在才开始学习java面对对象编程的过程中对于这一块的三大特征一直比较模糊，基本都是刚开始学习接触编程，一个人跌跌撞撞摸索着往前走，初学的时候很多东西理解的也懵懵懂懂，后来实践的多了，有些东西才慢慢清楚；二是经过一定的实践之后，反过头来再去学习一些基础东西才能够理解的更透彻；三是有些东西基础但是确很重要，是值得好好搞一搞的。
1、面向对象面向对象（Object Oriented）是一种新兴的程序设计方法，或者是一种新的程序设计规范(paradigm)，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。
从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。
2、对象对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。
一个对象由一组属性和对这组属性进行操作的一组服务组成。
3、类类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。
在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。
Java中的类实现包括两个部分：类声明和类体。
类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。
当不存在对一个对象的引用时，该对象成为一个无用对象。
Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。
当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。
向对象的三个基本特征是：封装、继承、多态。
4、封装封装性就是尽可能的隐藏对象内部细节，对外形成一道边界，只保留有限的接口和方法与外界进行交互。
封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外界对对象内部属性的破坏。
可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。
第四章_面向对象技术
4. 具有良好的可重用性
由于对象所具有的封装性和信息隐蔽，具有很强的 独立性。
4.1.2 面向对象的概念
理解面向对象的基本概念对于学习和掌握面向 对象的开发方法是十分重要的。 对象(Object)
类（Class）
继承（Inheritance） 消息(Information) 多态性(Polymorphism) 永久对象(Persistent object)
4.3 面向对象的分析
面向对象分析OOA(Object-Oriented Analysis)的 目标是完成对所求解问题的分析，确定系统“作什 么”，并建立系统的模型。 基本概念: 问题域(problem domain) — 被开发系统的应用领域。 系统责任(system responsibilities) — 所开发的系统应 具备的职能。 OOA的基本任务 运用面向对象的方法,对问题域和系统责任进行 分析和理解，找出描述它们的类和对象，定义其属 性和操作，及其结构、静态联系和动态联系。
4.3.1 OOA的分析过程
获取用户基本需求 标识类和对象
定义类的结构和层次 表示类(对象)间的关系
为对象行为建模
图4.7 OOA分析过程
4.3.2 OOA模型
基本模型 （类图）
交 对象层 主
互 特征层
图 关系层 详 细 说 明 图4.8 OOA模型与详细说明 基本模型是一个类图(class diagram)， 是以直观的方式表达系统最重要的 信息。OOA基本模型的三个层次分 别描述了：系统中应设哪几类对象， 每类对象的内部构成，对象与外部 的关系。
4.4.1 OOD基本任务
1. 系统设计 将分析模型划分为若干子系统，子系统应该具有 良好的接口，子系统内的类相互协作。标识问题本身 的并发性，为子系统分配处理器。
浅析面向对象的三大特征
）
｝ １ ｂ ｃ ｔｎ ｅ ａ ｅ ｐ ｌ ｒ ｇｇｔ ｍ ０ ｕ ｉＳ ｉ Ｎ
图 １ 类 ：
可 以看 出 ． 体 在 面 向 对 象程 序 设 计 中体 现 在 ： 具
ｌ成 员 方 法 的 设 计 。 １ ２成 员 权 限 的 使 用 。 １ 这 样 就 达 到 了对 成员 访 问 权 限 的 合 理 控 制 ．使 不 同类 之 间
形 象 的语 言 描 述 这 些 概 念 ．帮 助 学 生 更好 的理 解 面 向对 象 的 本 的 相 互 影 响 减少 到最 低 限度 ．进 而 增 强 数据 的 安 全 性 和 简 化程 序 的 编 写 工 作 。 这 里 ， 提 出 的 是 许 多教 材 往 往 只 关 注 封 装方 在 要 质。 法 的实 现 ．而忽 略 了封 装 的本 质功 能是 对成 员 访 问 权 限 的 合理 ２ 面 向对 象 的基 本 概 念 、 以一 个 人 的 出 生 年月 为 例 ． 特征 表 现 在 出 生 年 月 只 有一 其 程 序 设 计 语 言经 历 了机 器 语 言 一 级 语 言一 级 语 言 的 过 控 制 ． 中 高 并 在 并且 程 ． 面 向 对 象 语 言称 之 为高 级 语 言 ， 时也 意 味 着 面 向对 象 语 个 ． 且 不 可 更 改 ， 程 序 设 计 中表 现 为 只 可 初 始 化 一 次 ， 而 同 因 言更 接 近 于 人 的思 维 ， 因此 ． 常说 ， 习面 向对 象 编 程 最 直 接 只 能 读 不 能 写 ． 此 正 确 的设 计 为 ： 我 学
面向对象的名词解释是什么
面向对象的名词解释是什么在计算机科学中，面向对象（Object-Oriented）是一种编程范式，它将系统的组织和设计建立在对象的概念上。
面向对象编程的核心理念是将问题分解成不同的对象，每个对象都有自己的状态和行为，并且能够与其他对象进行交互。
面向对象编程的基本概念是“类”和“对象”。
类是一种抽象的概念，描述了一组具有相同属性和行为的对象。
通过类的定义，我们可以创建一些具体的实例，即对象。
对象是类的具体实例化，它拥有类定义的属性和行为。
在面向对象的编程中，我们通过创建对象来解决问题，每个对象都具有自己的数据和可执行的代码。
面向对象编程具有许多特性，其中最重要的是封装、继承和多态。
封装是面向对象编程的基本原则之一。
它指的是将数据和相关操作封装在单个对象中，同时隐藏对象内部的细节。
通过封装，我们可以将对象的数据和行为组织在一起，使其成为一个独立的实体。
封装有助于减少代码的耦合性，提高代码的可维护性和复用性。
继承是面向对象编程的另一个重要概念。
继承允许我们创建一个新的类，该类继承现有类的属性和行为。
新类称为子类或派生类，而被继承的类称为父类或基类。
通过继承，子类可以重用父类的代码，并且可以在其基础上进行扩展或修改。
继承可以提高代码的可读性和可维护性，同时也促进了代码的重用。
多态是面向对象编程的第三个重要特性。
多态允许不同的对象对相同的消息作出不同的响应。
具体来说，多态使我们可以使用一个通用的接口来处理不同类型的对象，而不需要关心对象的具体类型。
这种特性使得代码更加灵活和可扩展，使得程序具有更好的适应性和可复用性。
除了封装、继承和多态，面向对象编程还有其他一些重要的概念，如抽象、接口和消息传递等。
抽象指的是将问题的共同特征提取出来，形成类或接口的过程。
接口定义了类所提供的方法和属性，它为类提供了一种协议，规定了类和外部世界之间的交互方式。
消息传递是面向对象编程中对象之间通信的方式，对象通过发送消息来请求其他对象执行某个操作。
面向对象编程的基本概念
面向对象编程的基本概念面向对象编程的基本概念随着计算机技术的不断发展和应用的深入，编程语言也不断演化，出现了各种面向对象编程语言，如Java、C++、Python等。
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它将计算机程序模块化，以对象作为程序设计的基本单元进行组织和设计。
本文将从面向对象编程的概念、特点、实现方式、应用等方面进行详细介绍。
一、面向对象编程的概念面向对象编程是一种编程思想和方法，它将现实世界的事物抽象为“对象”，以及对象之间的交互，来进行程序设计和模块化。
对象是指具有属性和方法的实体，它既可以是现实世界中的事物，也可以是抽象的概念，如字符串、整数、函数等。
而方法则是对象的行为，用于操作对象的属性，实现某种功能。
面向对象编程的核心思想就是封装、继承和多态。
二、面向对象编程的特点1、抽象化和封装化面向对象编程通过抽象化和封装化，将复杂的现实世界事物抽象为简单的对象，并将对象的内部细节隐藏起来，使得外部只能通过对象的接口来访问对象，从而实现了信息的隐藏和保护。
2、继承性继承性是面向对象编程的一个重要特点，它允许创建一个新的类，并从一个或多个现有类中继承属性和方法，从而减少了代码的冗余，提高了代码的重用性和灵活性。
3、多态性多态性是面向对象编程的另一个重要特点，它允许不同类型的对象调用同一个方法，不同对象按照自己的方式去实现这个方法，从而增强了程序的灵活性和可扩展性。
三、面向对象编程的实现方式1、类和对象类是具有相同属性和方法的对象的集合，它是面向对象编程的基本概念。
对象是类的实例，包含了类的所有属性和方法，可以通过对象来访问类的属性和方法。
2、封装封装是面向对象编程的特有功能，它可以将属性和方法隐藏起来，只留下外界可以访问的接口，从而达到保护数据的目的。
3、继承和多态继承是面向对象编程中的另一个重要概念，它可以复用已有的代码，减少代码冗余，提高代码的可重用性。
《面向对象程度设计基础》(第2版)李师贤 05 第五章 类与对象(32页)
■ set_mode
■set_val(u)e() ■
■ increment()代码
■ (■)set_value()
■ get_value
■ decrement()代码
■ get_value
■increme(n)t ■
■ (■)increment
■ d e c r e m e n(t)( )
(■)decrement(
// 设置循环计数器的上下限和当前值 …… };
程序5.4.2 …… // 设置循环计数器的上下限和当前值 CIRCULAR_NUMBERS::CIRCULAR_NUMBERS(int min, int max, int value) {
min_val = (min <= max) ? min : max; max_val = (min <= max) ? max : min; if (value < min_val) current = min_val; else {
■类
■ 对象angle ■min_val ■0
■CIRCULAR_NUMBER
■ 对象 mo■n1th ■min_val
■max_val ■359
■ set_mode()代码
■12 ■max_val
■current ■250
■ set_value()代码
■11 ■current
■ set_mode
■ get_value()代码
类的外面，因此必须用类名和作用域运算符::来修饰函 数名。一般形式为: ■ 成员函数类型类名::成员函数名(形参表) ■ { 函数体 ■} ■ 例: // 循环计数器加一 ■ void CIRCULAR_NUMBERS::increment()
第5章 面向对象的程序设计
5.2.6 修饰符2-1
包中类B 本类D 包中子 类E 所有子类C 所有类A
public protected
类、变量、方法 A B+C 变量、方法
default 类、变量、方法 B private D 变量、方法 private protected 变量、方法 C
14
5.2.6 修饰符2-2
用来说明类、方法或变量的类型。
5.5.1 接口的定义
说明：
[修饰符] interface 接口名称{
[public] [static] [final] 变量名＝初值； // 静态常量 （1）通常接口的名字以able或ible结尾；
[public] [abstract] [native]返回值 方法名（[参数 （2）可以使用 extends 来继承接口的常量和抽象方法，
12
5.2.5 构造方法
• • • • 构造函数名称与类名称相同 构造函数没有返回类型 其任务是在创建对象时初始化其内部状态 若无定义系统默认有一个无参构造方法
class Fruit { boolean seedLess; boolean seasonal; float price; Fruit(boolean seed, boolean season, float p) { seedLess = seed; seasonal = season; price = p; } } 13
所以类在实现时，必须显示的使用public修饰符，否
则被警告缩小了接口中定义的方法的访问控制范围。
27
实例：接口的定义和实现
class InterfaceTest interface A { { public static void main(String args[ ]) double g=9.8; { void show( ); B b=new B( ); b.show( ); } } class B implements A } { public void show( ) {System.out.println(“g=“+g);} }
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
面向对象的三个基本特征（讲解）面向对象的三个基本特征是：封装、继承、多态。
封装封装最好理解了。
封装是面向对象的特征之一，是对象和类概念的主要特性。
封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
继承面向对象编程 (OOP) 语言的一个主要功能就是“继承”。
继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”。
继承的过程，就是从一般到特殊的过程。
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
在某些 OOP 语言中，一个子类可以继承多个基类。
但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
继承概念的实现方式有三类：实现继承、接口继承和可视继承。
➢实现继承是指使用基类的属性和方法而无需额外编码的能力；➢接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；➢可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。
例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。
但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。
OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
多态多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。
简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
实现多态，有二种方式，覆盖，重载。
覆盖，是指子类重新定义父类的虚函数的做法。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。
如，有两个同名函数：function func(p:integer):integer;和functionfunc(p:string):integer;。
那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。
对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。
也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。
当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。
因此，这样的函数地址是在运行期绑定的（晚邦定）。
结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。
”那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。
而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
概念讲解泛化（Generalization）图表 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的功能和属性。
聚合（组合）图表 2 组合若在逻辑上A是B的“一部分”（a part of），则不允许B从A派生，而是要用A和其它东西组合出B。
例如，眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，不是派生（继承）而成。
聚合的类型分为无、共享(聚合)、复合(组合)三类。
聚合（aggregation）图表 3 共享上面图中，有一个菱形（空心）表示聚合（aggregation）（聚合类型为共享），聚合的意义表示has-a关系。
聚合是一种相对松散的关系，聚合类B不需要对被聚合的类A负责。
组合（composition）图表 4 复合这幅图与上面的唯一区别是菱形为实心的，它代表了一种更为坚固的关系——组合（composition）（聚合类型为复合）。
组合表示的关系也是has-a，不过在这里，A的生命期受B控制。
即A会随着B的创建而创建，随B的消亡而消亡。
依赖(Dependency)图表 5 依赖这里B与A的关系只是一种依赖(Dependency)关系，这种关系表明，如果类被修改，那么类B会受到影响。
什么是面向对象，和面向过程的区别是什么最佳答案面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。
把上面每个步骤用分别的函数来实现，问题就解决了。
而面向对象的设计则是从另外的思路来解决问题。
整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。
第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的i变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。
可以明显地看出，面向对象是以功能来划分问题，而不是步骤。
同样是绘制棋局，这样的行为在面向过程的设计中分散在了总多步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。
而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。
功能上的统一保证了面向对象设计的可扩展性。
比如我要加入悔棋的功能，如果要改动面向过程的设计，那么从输入到判断到显示这一连串的步骤都要改动，甚至步骤之间的循序都要进行大规模调整。
如果是面向对象的话，只用改动棋盘对象就行了，棋盘系统保存了黑白双方的棋谱，简单回溯就可以了，而显示和规则判断则不用顾及，同时整个对对象功能的调用顺序都没有变化，改动只是局部的。
再比如我要把这个五子棋游戏改为围棋游戏，如果你是面向过程设计，那么五子棋的规则就分布在了你的程序的每一个角落，要改动还不如重写。
但是如果你当初就是面向对象的设计，那么你只用改动规则对象就可以了，五子棋和围棋的区别不就是规则吗？（当然棋盘大小好像也不一样，但是你会觉得这是一个难题吗？直接在棋盘对象中进行一番小改动就可以了。
）而下棋的大致步骤从面向对象的角度来看没有任何变化。
当然，要达到改动只是局部的需要设计的人有足够的经验，使用对象不能保证你的程序就是面向对象，初学者或者很蹩脚的程序员很可能以面向对象之虚而行面向过程之实，这样设计出来的所谓面向对象的程序很难有良好的可移植性和可扩展性。
111111111111111111111111111111111111111111111111111111111111111111111111111111 一、什么是递归很多数据结构的定义都是根据递归性质来进行定义的，是因为这些结构固有的性质。
递归是指某个函数直接或间接的调用自身。
问题的求解过程就是划分成许多相同性质的子问题的求解，而小问题的求解过程可以很容易的求出，这些子问题的解就构成里原问题的解了。
二、递归的几个特点1.递归式，就是如何将原问题划分成子问题。
2.递归出口，递归终止的条件，即最小子问题的求解，可以允许多个出口。
3.界函数，问题规模变化的函数，它保证递归的规模向出口条件靠拢三、递归的运做机制很明显，很多问题本身固有的性质就决定此类问题是递归定义，所以递归程序很直接算法程序结构清晰、思路明了。
但是递归的执行过程却很让人费解，这也是让很多人难理解递归的原因之一。
由于递归调用是对函数自身的调用，在一次调用没有结束之前又开始了另外一次调用，按照作用域的规定，函数在执行终止之前是不能收回所占用的空间，必须保存下来，这也就意味着每一次的调用都要把分配的相应空间保存起来。
为了更好管理这些空间，系统内部设置一个栈，用于存放每次函数调用与返回所需的各种数据，其中主要包括函数的调用结束的返回地址，返回值，参数和局部变量等。
其过程大致如下：1.计算当前函数的实参的值2.分配空间，并将首地址压栈，保护现场3.转到函数体，执行各语句，此前部分会重复发生（递归调用）4.直到出口，从栈顶取出相应数据，包括，返回地址，返回值等等，收回空间，恢复现场，转到上一层的调用位置继续执行本次调用未完成的语句。
四、引入非递归从用户使用角度来说，递归真的很简便，对程序宏观上容易理解。
递归程序的时间复杂度虽然可以根据T(n)=T(n-1)*f(n)递归求出，其中f(n)是递归式的执行时间复杂度，一般来说，时间复杂度和对应的非递归差不多，但是递归的效率是相当低的它主要发费在反复的进栈出栈，各种中断等机制上（具体的可以参考操作系统）更有甚者，在递归求解过程中，某些解会重复的求好几次，这是不能容忍的，这些也是引入非递归机制的原因之一。
五、递归转非递归的两种方法1.一般根据是否需要回朔可以把递归分成简单递归和复杂递归，简单递归一般就是根据递归式来找出递推公式（这也就引申出分治思想和动态规划）。