面向对象的基本思想
3面向对象的基本思想
对象的进一步研究
Person per=new Person(); A.申明对象：Person per，栈内存中申明的，与数组一样，数组名称就 是保存在栈内存中，只开辟了栈内存的对象是无法使用的，必须有其堆 内存的引用才可以使用； B.实例化对象：new Person（），在堆内存中开辟空间，所有的内容都 是默认值； --String是一个字符串，本身是一个类，就是一个引用数据类型，则 此时默认值就是null; --int 是一个数字，本身是一个数，所以是基本数据类型，则此时的 默认值是0； 如果进一步划分以上代码，可以表示如下： Person per=null;//申明对象 Per=new Person()//实例化对象 开发中，数据最好赋一个初值，了解了其分配的关系，就可以为属性赋 值，并调用类中的方法。使用格式： 调用属性：对象.属性；
类图：
在程序的开发中都是以类图的形式进行说明的，对于一个类来说，形式 如下：
分为三个层次： 第一个层次：表示类名，类的名称要求首字母大写 第二个层次：表述属性的定义，按照"访问权限 属性名称:属性类型"的 格式定义；
第三个层次：表示类中的方法的定义，按照"访问权限 方法名称():方法 返回值"的格式定义。
一些问题：
a. 对象是保存在栈内存中，属性是保存在堆内存中，那么方法保存在 哪里的呢?方法是保存在全局代码区之中的，此区中的内容是所有 对象共享的。 b. 在使用对象的时候，对象必须被实例化之后才可以使用（实例化对 象，并不是单单指通过new关键字实现的，只要其有堆内存的空间 指向，则表示实例化成功） c. 如果不实例化会出现：ng.NullPointerException（空间指向异 常）的错误，这是在以后程序开发中会经常遇到的问题，应注意。 通常是在引用操作中，如果一个对象没有堆内存的引用，而调用了 类中的属性和方法，就会出现这种问题。 d. 可以产生多个对象，只要按照一定的格式即可。
java面向对象的三个特征
使用java面向对象编程的三大特征大多数新人，在才开始学习java面对对象编程的过程中对于这一块的三大特征一直比较模糊，基本都是刚开始学习接触编程，一个人跌跌撞撞摸索着往前走，初学的时候很多东西理解的也懵懵懂懂，后来实践的多了，有些东西才慢慢清楚；二是经过一定的实践之后，反过头来再去学习一些基础东西才能够理解的更透彻；三是有些东西基础但是确很重要，是值得好好搞一搞的。
1、面向对象面向对象（Object Oriented）是一种新兴的程序设计方法，或者是一种新的程序设计规范(paradigm)，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。
从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。
2、对象对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。
一个对象由一组属性和对这组属性进行操作的一组服务组成。
3、类类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。
在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。
Java中的类实现包括两个部分：类声明和类体。
类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。
当不存在对一个对象的引用时，该对象成为一个无用对象。
Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。
当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。
向对象的三个基本特征是：封装、继承、多态。
4、封装封装性就是尽可能的隐藏对象内部细节，对外形成一道边界，只保留有限的接口和方法与外界进行交互。
封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外界对对象内部属性的破坏。
可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。
面向对象的名词解释是什么
面向对象的名词解释是什么在计算机科学中，面向对象（Object-Oriented）是一种编程范式，它将系统的组织和设计建立在对象的概念上。
面向对象编程的核心理念是将问题分解成不同的对象，每个对象都有自己的状态和行为，并且能够与其他对象进行交互。
面向对象编程的基本概念是“类”和“对象”。
类是一种抽象的概念，描述了一组具有相同属性和行为的对象。
通过类的定义，我们可以创建一些具体的实例，即对象。
对象是类的具体实例化，它拥有类定义的属性和行为。
在面向对象的编程中，我们通过创建对象来解决问题，每个对象都具有自己的数据和可执行的代码。
面向对象编程具有许多特性，其中最重要的是封装、继承和多态。
封装是面向对象编程的基本原则之一。
它指的是将数据和相关操作封装在单个对象中，同时隐藏对象内部的细节。
通过封装，我们可以将对象的数据和行为组织在一起，使其成为一个独立的实体。
封装有助于减少代码的耦合性，提高代码的可维护性和复用性。
继承是面向对象编程的另一个重要概念。
继承允许我们创建一个新的类，该类继承现有类的属性和行为。
新类称为子类或派生类，而被继承的类称为父类或基类。
通过继承，子类可以重用父类的代码，并且可以在其基础上进行扩展或修改。
继承可以提高代码的可读性和可维护性，同时也促进了代码的重用。
多态是面向对象编程的第三个重要特性。
多态允许不同的对象对相同的消息作出不同的响应。
具体来说，多态使我们可以使用一个通用的接口来处理不同类型的对象，而不需要关心对象的具体类型。
这种特性使得代码更加灵活和可扩展，使得程序具有更好的适应性和可复用性。
除了封装、继承和多态，面向对象编程还有其他一些重要的概念，如抽象、接口和消息传递等。
抽象指的是将问题的共同特征提取出来，形成类或接口的过程。
接口定义了类所提供的方法和属性，它为类提供了一种协议，规定了类和外部世界之间的交互方式。
消息传递是面向对象编程中对象之间通信的方式，对象通过发送消息来请求其他对象执行某个操作。
面向对象编程思想
面向对象编程思想面向对象是一种新兴的程序设计方法，或者说它是一种新的程序设计范型，其基本思想是使用对象，类，继承，封装，消息等基本概念来进行程序设计。
它是从现实世界中客观存在的事物（即对象）出发来构造软件系统，并在系统构造中尽可能运用人类的自然思维方式，强调直接以问题域（现实世界）中的事物为中心来思考问题，认识问题，并根据这些事物的本质特点，把它们抽象地表示为系统中的对象，作为系统的基本构成单位（而不是用一些与现实世界中的事物相关比较远，并且没有对应关系的其它概念来构造系统）。
这可以使系统直接地映射问题域，保持问题域中事物及其相互关系的本来面貌。
它可以有不同层次的理解：从世界观的角度可以认为：面向对象的基本哲学是认为世界是由各种各样具有自己的运动规律和内部状态的对象所组成的；不同对象之间的相互作用和通讯构成了完整的现实世界。
因此，人们应当按照现实世界这个本来面貌来理解世界，直接通过对象及其相互关系来反映世界。
这样建立起来的系统才能符合现实世界的本来面目。
从方法学的角度可以认为：面向对象的方法是面向对象的世界观在开发方法中的直接运用。
它强调系统的结构应该直接与现实世界的结构相对应，应该围绕现实世界中的对象来构造系统，而不是围绕功能来构造系统。
从程序设计的角度来看，面向对象的程序设计语言必须有描述对象及其相互之间关系的语言成分。
这些程序设计语言可以归纳为以下几类：系统中一切皆为对象；对象是属性及其操作的封装体；对象可按其性质划分为类，对象成为类的实例；实例关系和继承关系是对象之间的静态关系；消息传递是对象之间动态联系的唯一形式，也是计算的唯一形式；方法是消息的序列。
面向对象面向对象(Object Oriented,OO)是当前计算机界关心的重点，它是90年代软件开发方法的主流。
面向对象的概念和应用已超越了程序设计和软件开发，扩展到很宽的范围。
如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。
面向对象的基本思想
面向对象的基础思想1 类与对象（重点）1.1类与对象的基本关系类与对象是整个面向对象概念之中的最为重要的组成部分。
类：类是对整个现实世界的一种合理的抽象，是一种共性的产物，在类之中主要有两个组成部分：属性（变量）、行为（方法）；对象：是一个具体的，可以使用的产物，是一种个性的表示。
实际上类中规定了一个对象的具体行为，而对象是一个类的具体表现。
类只有通过对象才可以使用，所以在开发之中一定要先有类之后再定义对象。
但是一个类产生之后就好比汽车的设计图纸那样，本身并不能直接使用，必须按照图纸生产出具体的汽车之后才可以开，所以需要对象，而对象定义格式如下：格式一：声明并实例化对象格式二：分步完成通过以上的格式可以发现，依然存在了关键字new，所以这一操作也一定表示要开辟堆内存空间，同时需要注意的是，当一个对象开辟空间之后可以按照如下的两个方式来操作类中的内容：·操作类中的属性：对象.属性；·操作类中的方法：对象.方法()；范例：声明并实例化对象但是类本身属于引用数据类型，所以以上的程序依然要牵扯到内存的划分，同样使用两块内存：·堆内存：保存的是每一个对象所具备的属性；·栈内存：保存的是一块堆内存的使用地址，可以简单理解为对象名称。
1.2浅深入引用传递清楚了以上的内存关系之后，下面再来对另外一个类似的程序进行观察。
如果说现在同时产生了两个只要发现了关键字new，那么一定表示要开辟的是一块新的内存空间，每一块堆内存空间都有一个栈内存指向它。
范例：观察如下程序发现现在一个per对象没有进行实例化的操作，这个时候程序编译没有任何的语法错误，但是程序执行的时候出现了以下的错误提示：现在给出的是“NullPointerException”，表示空指向异常。
此异常肯定会伴随你的开发人生走完的那一刻，此异常只有在引用数据类型操作的时候才会出现。
NullPointerException更准确的讲法是指使用只声明而未开辟空间的引用类型所造成的问题，所以为了区分此概念，以后对于对象而言，在操作上就会给出两个不同的名词：·声明对象：只开辟了栈内存空间的对象，无法直接使用；·实例化对象：有了对应的堆内存空间指向，可以使用；以上的分析流程和数组是完全一样的，因为数组也属于引用数据类型，在数组学习的时候强调过，所谓的引用传递实际上指的就是一块堆内存空间可以同时被多个栈内存所指向的操作，那么对于类也是一样的，引用传递指的是一块堆内存同时被不同的对象（不同的栈）所指向。
OO思想
多态机制
类关系与类图
类之间的四种基本关系（约束）
关联（association） 泛化（generalization） 实现（realization） 依赖（dependence）
类图(Class diagram)是最常用的UML图，显示出类、接口以及它们之间的 静态结构和关系；它用于描述系统的结构化设计。 类图以一种更一般的方式指定了系统的任何合法状态都必须满足的特性 对象图是类图的一个实例，对象图中的链接满足类图中定义的各种约束 对象图是对象与链接的集合，显示系统的一个特定状态
2
OO的基本概念
类 对象 封装 继承 重载 多态
3
类
是对具有相同数据和相同操作的一组相似对象的 抽象定义 理解
是对具有相同属性（不同值）和行为的一组对象的描述 是支持继承的抽象数据类型，是对象实例化的模版 一个对象就是类的一个实例 类定义了对象的特征，分为属性和操作 属性，定义类实例存储的数据，是对客观实体所具 有共同性质的抽象，类实例化的每个对象都有自己 特有的属性值 操作：也称方法，定义类实例的动态行为（算法）
两种重载
public
重载机制
提高OO程序灵活性和可读性
12
多态（Polymorphism）
描述：
通过重写(override)父类的同名操作，使子类对象和父类 对象接受同一消息，却提供不同服务 不同层次的类共享一个行为（函数名、参数和返回值类型 都相同），但行为实现却不同
动态联编(dynamic binding)，也称滞后联编(late binging) 运行时，消息发送对象不知道谁将接收消息，依赖接 收对象以一种恰当的方式解释消息，根据消息接收对象所 属的类，决定实现什么样的行为，享受什么样的服务 增强OO系统的灵活性，减少信息冗余，提高软件的可重 用性和可扩充性
面向对象方法与结构化方法的比较
结构化方法和面向对象方法的比较结构化方法是结构化分析，结构化设计和结构化编程的总称，是最早最传统的软件开发方法，也是迄今为止信息系统中应用最普遍、最成熟的一种，它引入了工程思想和结构化思想，使大型软件的开发和编程都得到了极大的改善。
面向对象方法它不仅仅是一些具体的软件开发技术与策略，而且是一整套关于如何看待软件系统与现实世界的关系，用什么观点来研究问题并进行问题求解，以及如何进行软件系统构造的软件方法学。
人们普遍认为面向对象方法是一种运用对象、类、继承、封装、聚合、关联、消息和多态性等概念和原则来构造系统的软件开发方法。
结构化方法和面向对象方法二者的比较如下。
一、基本思想的比较结构化方法的基本思想主要体现在三个方面。
一、自顶向下，逐步求精：把程序看成是一个逐步演化的过程。
把一个系统与程序看成是一层一层的。
例如：户籍管理系统可以划分为：户籍迁入迁出，人员迁入迁出，户籍注销，人员注销等几个子系统，而每个子系统又划分为接收用户信息，实施处理，提供返回信息等等部分。
二、模块化：即将几个系统分成几个模块，每个模块实现特定的功能，最终整个系统由这些模块组成。
模块跟模块之间通过接口传递信息，模块最重要的特点就是独立性，模块之间还有上下层的关系，上层模块调用下层模块来实现一些功能。
三、语句结构化：顺序结构、分支结构、循环结构，都是常用的语句结构。
面向对象方法的基本思想主要有：一、客观世界中的事物都是对象，对象之间存在一定的关系，并且复杂对象由简单对象构成。
二、具有相同属性和操作的对象属于一个类，对象是类的一个实例。
三、类之间可以有层次结构，即类可以有子类，其中，子类继承父类的全部属性和操作，而且子类有自己的属性和操作。
四、类具有封装性，把类内部的属性和一些操作隐藏起来，只有公共的操作对外是可见的，对象只可通过消息来请求其他对象的操作或自己的操作。
五、强调充分运用人在日常逻辑思维中经常采用的思想方法与原则。
例如：抽象，分类，继承，聚合，封装，关联等。
什么是面向对象思想
什么是⾯向对象思想⾯向对象是⼀种思想，是基于⾯向过程⽽⾔的，就是说⾯向对象是将功能等通过对象来实现，将功能封装进对象之中，让对象去实现具体的细节；这种思想是将数据作为第⼀位，⽽⽅法或者说是算法作为其次，这是对数据⼀种优化，操作起来更加的⽅便，简化了过程。
⾯向对象有三⼤特征：封装性、继承性、多态性，其中封装性指的是隐藏了对象的属性和实现细节，仅对外提供公共的访问⽅式，这样就隔离了具体的变化，便于使⽤，提⾼了复⽤性和安全性。
对于继承性，就是两种事物间存在着⼀定的所属关系，那么继承的类就可以从被继承的类中获得⼀些属性和⽅法；这就提⾼了代码的复⽤性。
继承是作为多态的前提的。
多态是说⽗类或接⼝的引⽤指向了⼦类对象，这就提⾼了程序的扩展性，也就是说只要实现或继承了同⼀个接⼝或类，那么就可以使⽤⽗类中相应的⽅法，提⾼程序扩展性，但是多态有⼀点不好之处在于：⽗类引⽤不能访问⼦类中的成员。
举例来说：就是：⽐如说你要去饭店吃饭，你只需要饭店，找到饭店的服务员，跟她说你要吃什么，然后就会给你做出来让你吃，你并不需要知道这个饭是怎么错做的，你只需要⾯向这个服务员，告诉他你要吃什么，然后他也只需要⾯向你吃完收到钱就好，不需要知道你怎么对这个饭进⾏吃。
1、特点：1：将复杂的事情简单化。
2：⾯向对象将以前的过程中的执⾏者，变成了指挥者。
3：⾯向对象这种思想是符合现在⼈们思考习惯的⼀种思想。
2、⾯向对象的三⼤特征：封装，继承、多态1.封装：只隐藏对象的属性和实现细节，仅对外提供公共访问⽅式好处：将变化隔离、便于使⽤、提⾼复⽤性、提⾼安全性原则：将不需要对外提供的内容隐藏起来；把属性隐藏，提供公共⽅法对其访问2.继承：提⾼代码复⽤性；继承是多态的前提注：①⼦类中所有的构造函数都会默认访问⽗类中的空参数的构造函数，默认第⼀⾏有super()；若⽆空参数构造函数，⼦类中需指定；另外，⼦类构造函数中可⾃⼰⽤this指定⾃⾝的其他构造函数。
面向对象数据模型
§2.6 空间数据模型四、面向对象数据模型面向对象的基本概念是在本世纪70年代萌发出来的，它的基本做法是把系统工程中的某个模块和构件视为问题空间的一个或一类对象。
到了80年代，面向对象的方法得到很快发展，在系统工程、计算机、人工智能等领域获得了广泛应用。
但是，在更高级的层次上和更广泛的领域内对面向对象的方法进行研究还是90年代的事。
（一）基本思想和基本概念面向对象的基本思想是通过对问题领域进行自然的分割，用更接近人类通常思维的方式建立问题领域的模型，并进行结构模拟和行为模拟，从而使设计出的软件能尽可能地直接表现出问题的求解过程。
因此，面向对象的方法就是以接近人类通常思维方式的思想，将客观世界的一切实体模型化为对象。
每一种对象都有各自的内部状态和运动规律，不同对象之间的相互联系和相互作用就构成了各种不同的系统。
在面向对象的方法中，对象、类、方法和消息是基本的概念（图6-6-7）。
（二）面向对象的特性面向对象方法具有抽象性、封装性、多态性等特性。
（三）面向对象数据模型的四种核心技术1、分类：是把一组具有相同属性结构和操作方法的对象归纳或映射为一个公共类的过程。
如城镇建筑可分为行政区、商业区、住宅区、文化区等若干个类。
2、概括：将相同特征和操作的类再抽象为一个更高层次、更具一般性的超类的过程。
子类是超类的一个特例。
一个类可能是超类的子类，也可是几个子类的超类。
所以，概括可能有任意多层次。
概括技术避免了说明和存储上的大量冗余。
这需要一种能自动地从超类的属性和操作中获取子类对象的属性和操作的机制，即继承机制。
3、聚集：聚集是把几个不同性质类的对象组合成一个更高级的复合对象的过程。
4、联合：相似对象抽象组合为集合对象。
其操作是成员对象的操作集合。
四种核心技术的进一步说明。
（四）面向对象数据模型的核心工具1、继承一类对象可继承另一类对象的特性和能力，子类继承父类的共性，继承不仅可以把父类的特征传给中间子类，还可以向下传给中间子类的子类。
面向对象程序设计思想
面向对象程序设计思想面向对象程序设计（Object-Oriented Programming，简称OOP）是一种以对象为中心的编程范式，它将现实世界中的事物抽象为对象，并通过对象之间的交互来实现程序的运行。
面向对象程序设计的核心思想包括封装、继承和多态。
封装封装是面向对象程序设计中最基本的概念之一。
它指的是将数据（属性）和操作数据的方法（行为）组合在一起，形成一个对象。
封装的目的是隐藏对象的内部细节，只暴露出一个可以被外界访问的接口。
这样，对象的使用者不需要了解对象内部的实现细节，只需要通过接口与对象进行交互。
例如，在一个银行系统中，我们可以创建一个`Account`类，该类封装了账户的基本信息（如账号、余额）和对账户的操作（如存款、取款）。
用户在使用`Account`类时，只需要调用相应的方法，而不需要关心这些方法是如何实现的。
继承继承是面向对象程序设计中另一个重要的概念。
它允许一个类（子类）继承另一个类（父类）的属性和方法。
通过继承，子类可以扩展或修改父类的行为，而不需要重新编写代码。
继承支持代码的复用，使得程序设计更加简洁和高效。
例如，假设我们有一个`Animal`类，它定义了所有动物共有的属性和方法。
我们可以创建一个`Dog`类，它继承自`Animal`类。
`Dog`类将继承`Animal`类的所有属性和方法，并且可以添加一些特有的属性和方法，如`bark`。
多态多态是面向对象程序设计中的一个重要特性，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。
多态性使得程序设计更加灵活和可扩展。
多态性通常通过抽象类和接口来实现。
抽象类定义了一个或多个抽象方法，而具体的子类则提供了这些抽象方法的实现。
接口则定义了一组方法规范，不同的类可以实现同一个接口，但提供不同的实现。
例如，假设我们有一个`Shape`接口，它定义了一个`draw`方法。
我们可以创建`Circle`、`Square`等类，它们都实现了`Shape`接口。
面向对象的5个基本设计原则
面向对象的5个基本设计原则：单一职责原则（Single-Resposibility Principle）其核心思想为：一个类，最好只做一件事，只有一个引起它的变化。
单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。
职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而大大损伤其内聚性和耦合度。
通常意义下的单一职责，就是指只有一种单一功能，不要为类实现过多的功能点，以保证实体只有一个引起它变化的原因。
专注，是一个人优良的品质；同样的，单一也是一个类的优良设计。
交杂不清的职责将使得代码看起来特别别扭牵一发而动全身，有失美感和必然导致丑陋的系统错误风险。
开放封闭原则（Open-Closed principle）其核心思想是：软件实体应该是可扩展的，而不可修改的。
也就是，对扩展开放，对修改封闭的。
开放封闭原则主要体现在两个方面1、对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。
2、对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对其进行任何尝试的修改。
实现开开放封闭原则的核心思想就是对抽象编程，而不对具体编程，因为抽象相对稳定。
让类依赖于固定的抽象，所以修改就是封闭的；而通过面向对象的继承和多态机制，又可以实现对抽象类的继承，通过覆写其方法来改变固有行为，实现新的拓展方法，所以就是开放的。
“需求总是变化”没有不变的软件，所以就需要用封闭开放原则来封闭变化满足需求，同时还能保持软件内部的封装体系稳定，不被需求的变化影响。
Liskov替换原则（Liskov-Substituion Principle）其核心思想是：子类必须能够替换其基类。
这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。
在父类和子类的具体行为中，必须严格把握继承层次中的关系和特征，将基类替换为子类，程序的行为不会发生任何变化。
面向对象分析与设计习题及部分答案
⾯向对象分析与设计习题及部分答案《⾯向对象分析与设计》习题及部分答案第⼀章概论1.什么是⾯向对象⽅法？⾯向对象的基本原则主要有哪些？答：⾯向对象⽅法是⼀种运⽤对象、类、继承、封装、聚合、关联、消息、多态性等概念来构造系统的软件开发⽅法。
⾯向对象⽅法的解决问题的思路是从现实世界中的客观对象（如⼈和事物）⼊⼿，尽量运⽤⼈类的⾃然思维⽅式来构造软件系统，这与传统的结构化⽅法从功能⼊⼿和信息⼯程化⽅法从信息⼊⼿是不⼀样的。
⾯向对象的基本思想主要有：1)从现实世界中客观存在的事物出发来建⽴软件系统，强调直接以问题域（现实世界）中的事物为中⼼来思考问题、认识问题，并根据这些事物的本质特征，把它们抽象地表⽰为系统中的对象，作为系统的基本构成单位。
这可以使系统直接映射问题域，保持问题域中事物及其相互关系的本来⾯貌(对象)2)⽤对象的属性表⽰事物的性质；⽤对象的操作表⽰事物的⾏为。
（属性与操作）3)对象的属性与操作结合为⼀体，成为⼀个独⽴的、不可分的实体，对外屏蔽其内部细节。
（对象的封装）4)对事物进⾏分类。
把具有相同属性和相同操作的对象归为⼀类，类是这些对象的抽象描述，每个对象是它的类的⼀个实例。
（分类）5)复杂的对象可以⽤简单的对象作为其构成部分。
（聚合）6)通过在不同程度上运⽤抽象的原则,可以得到较⼀般的类和较特殊的类。
特殊类继承⼀般类的属性与操作，从⽽简化系统的构造过程及其⽂档。
（继承）7)对象之间通过消息进⾏通讯，以实现对象之间的动态联系。
（消息）8)通过关联表⽰类(⼀组对象)之间的静态关系。
（关联）2.与传统开发⽅法⽐，⾯向对象⽅法有什么优点？答：⾯向对象⽅法的解决问题的思路是从现实世界中的客观对象（如⼈和事物）⼊⼿，尽量运⽤⼈类的⾃然思维⽅式来构造软件系统，这与传统的结构化⽅法从功能⼊⼿和信息⼯程化⽅法从信息⼊⼿是不⼀样的。
与传统⽅法相⽐，⾯向对象的⽅法主要优点有：1)从认识论的⾓度可以看出，⾯向对象⽅法改变了⼈们认识世界的⽅式；2)语⾔的发展——鸿沟变窄；3)⾯向对象⽅法使得从问题域到计算机间的鸿沟变窄；4)⾯向对象⽅法有助于软件的维护与复⽤；（1）把易变的数据结构和部分功能封装在对象内并加以隐藏，⼀是保证了对象⾏为的可靠性；⼆是对它们的修改并不会影响其他的对象，有利于维护，对需求变化有较强的适应性。
面向对象的三个基本要素和五个基本设计原则
⾯向对象的三个基本要素和五个基本设计原则⼀、⾯向对象的三个基本要素：继承、封装、多态。
⼆、五个基本原则：1.单⼀职责原则（Single-Resposibility Principle）⼀个类，最好只做⼀件事。
只有⼀个⽅向引起它的变化；个⼈经验：具体做法就是分模块进⾏封装，不要写⼀个功能复杂的类。
2.开放封闭原则（Open-Closed principle）对扩展开放，对修改封闭的。
1）、对扩展开放，意味着有新的需求或变化时，可以对现有代码进⾏扩展，以适应新的情况。
2）、对修改封闭，意味着类⼀旦设计完成，就可以独⽴完成其⼯作，⽽不要对其进⾏任何尝试的修改。
个⼈经验：如果⼀个类要修改最好采⽤属性或⽅法注⼊的⽅式(采⽤接⼝)，即依赖注⼊；或者采⽤继承的⽅式；3.Liskov替换原则（Liskov-Substituion Principle）⼦类必须能够替换其基类个⼈经验：基类是个超级类（抽象类或⼀个接⼝），⼦类实现时要实现⼀些必要⽅法；4.依赖倒置原则（Dependecy-Inversion Principle）依赖于抽象。
具体⽽⾔就是⾼层模块不依赖于底层模块，⼆者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。
依赖于抽象，就是对接⼝编程，不要对实现编程。
个⼈经验：将具体被调⽤类的实现封装起来（使⽤接⼝或抽象类），提供接⼝给具体调⽤的类；5.迪⽶特法则（Law of Demeter）⼜叫最少知识原则（Least Knowledge Principle LKP），就是说⼀个对象应当对其他对象有尽可能少的了解，不和陌⽣⼈说话。
个⼈经验：尽量少暴露类的⽅法和属性。
接⼝隔离，使⽤多个⼩的专门的接⼝，⽽不要使⽤⼀个⼤的总接⼝。
面向对象的理解并举例
面向对象的理解并举例面向对象（Object-oriented)是程序设计方法论的一种流派，从抽象的角度考虑处理和解决问题，让程序可以表示真实世界和模拟真实世界的分析和模拟操作，它被认为是程序开发方面的一种思想。
一、定义：面向对象是程序设计方法论的一种流派，它从抽象的角度考虑处理和解决问题，使程序可以实现对真实世界和模拟真实世界的分析和模拟操作，是程序开发方面的一种思想。
它强调的是开发者的思维由概念对象转变为对对象类的抽象，在创建任何软件时，在任何情况下都要先从物理过程和具体事物出发，将它们抽象为可封装、可复用的对象，而不是从易操作的、可运行的程序出发。
二、特点：1、面向对象就是以“对象”为中心，将程序中每一个部分都要以“对象”的形式表示。
2、面向对象有自己的一套编程思想，重在“对象”和“类”的概念，以及对象和类之间的联系，也就是“继承”的概念。
3、面向对象把程序分为两个部分：逻辑部分和数据部分，它能让程序拥有更强的可维护性和可扩展性。
4、面向对象的思想是以属性和行为来描述对象，对象之间存在着关系，关系由多态（polymorphism）实现。
三、优点：1、易扩展性：由于面向对象程序设计得到了实现，比传统的程序设计模式更容易扩展及共享，减少代码的重复，可以把基本功能编写在一个类中，然后在不同的子类上添加不同的行为，对对象和对象之间的关系可以以多种方式实现，比如继承和关联等。
2、重用性：面向对象程序设计可以利用现有的类，通过继承获得类的信息，这样可以节省时间和提高可重用性。
3、可维护性：面向对象程序设计能够使程序员及早地探测和解决程序可能出现的重大问题，降低模块之间的耦合，减少非利期间的变更，以便在修改部分代码时能够尽量减少影响的范围，从而增加程序的可维护性。
四、应用：1、面向对象的主要应用就是软件开发，比如游戏、系统程序和应用软件等等，此外，面向对象程序设计也广泛应用于数据库开发。
2、计算机可视化图形，如OpenGL、DirectX、RenderWare等，用于图形缓冲以及对象渲染，也都是建立在面向对象技术之上的，从而实现视觉效果。
面向过程程序设计和面向对象程序设计的理解
面向过程程序设计和面向对象程序设计的理解面向过程程序设计和面向对象程序设计是两种不同的程序设计范式，它们有不同的思想和方法。
本文将从以下几个方面来谈论这两种程序设计的理解。
一、定义面向过程程序设计是指通过对一系列步骤的组合来解决问题的一种程序设计方法，它主要关注的是程序的执行流程。
而面向对象程序设计则是一种以对象为中心的程序设计方法，它关注的是对象之间的互动。
二、基本思想面向过程程序设计的基本思想是将一个问题分解成一个个子问题，然后用函数将子问题解决掉，最后将所有函数组成一个完整的程序。
面向对象程序设计的基本思想是将一个问题抽象成一个个对象，每个对象都有自己的属性和方法，对象之间通过方法来交互和完成任务。
三、特点面向过程程序设计的特点是简单、直接，容易理解和实现，而且执行效率比较高；但是程序复杂度增加时，结构容易混乱，代码维护困难。
面向对象程序设计的特点则是高度的模块化、可重用性强，具有很好的扩展性和维护性；但是编写相应的代码比较繁琐，运行效率相对较低。
四、适用范围面向过程程序设计适用于需要直接操作数据的简单问题，如简单的计算、统计和排序等。
而面向对象程序设计则适用于复杂的、需要多种方法进行交互和处理的问题，如图形界面程序、网络应用程序等。
五、发展趋势随着应用程序的不断增加和需求的不断变化，面向过程程序设计已经不能满足人们的需求，面向对象程序设计因其具有更高的灵活性和可扩展性正逐渐成为主流的程序设计范式。
综上所述，面向过程程序设计和面向对象程序设计各具有自己的特点和适用范围，但随着编程需求的不断变化，面向对象程序设计已经成为未来的发展方向。
简述面向对象的基本概念
简述面向对象的基本概念一、引言面向对象编程是当前主流的编程范式之一，它的出现使得程序设计更加灵活、易于维护和扩展。
本文将从面向对象的基本概念入手，详细阐述面向对象编程的核心思想和基本特征。
二、什么是面向对象编程1. 面向对象编程（Object Oriented Programming，简称OOP）是一种计算机编程范式，它以“对象”为基本单位，通过封装、继承和多态等特性来组织代码。
2. 面向对象编程强调数据和操作数据的方法是一个整体，即数据类型和方法组成了一个“类”，而每个类都可以看做一个独立的“世界”。
3. 面向对象编程具有高内聚、低耦合等优点，可以提高代码重用性、可读性和可维护性。
三、面向对象的基本概念1. 类（Class）类是面向对象编程中最基本的概念之一。
一个类定义了一组属性（成员变量）和方法（成员函数），描述了某个具有相同属性和行为特征的事物。
2. 对象（Object）一个类实例化后就成为了一个对象。
每个对象都拥有该类所定义的属性和方法，并且可以通过方法来访问和修改属性。
3. 封装（Encapsulation）封装是面向对象编程的核心思想之一，它将数据和操作数据的方法封装在一个类中，对外部程序隐藏了具体实现细节。
这样可以保证数据的安全性和完整性，同时也提高了代码的可读性和可维护性。
4. 继承（Inheritance）继承是一种从已有类派生出新类的机制，新类将自动拥有已有类的所有属性和方法。
通过继承可以减少代码重复，提高代码复用性和可扩展性。
5. 多态（Polymorphism）多态是指同一个方法名可以被不同的对象调用，并且可以根据不同的对象类型产生不同的行为结果。
多态通过接口实现，使得程序更加灵活、易于扩展。
四、面向对象编程语言1. JavaJava是一种面向对象编程语言，它具有强类型、静态类型检查等特点。
Java中所有东西都是对象，支持封装、继承和多态等特性。
2. C++C++也是一种面向对象编程语言，它除了支持封装、继承和多态等特性外，还支持运算符重载、模板等高级特性。
举例说明面向对象和面向过程的区别
举例说明面向对象和面向过程的区别-CAL-FENGHAI.-(YICAI)-Company One1举例说明面向对象和面向过程的区别两种方法都是编程中的比较常用的方法，从理论上来说，都能达到用计算机程序来解决实际问题的目的，只不过是其中所体现出来的思想不一样而已。
面向过程：面向过程的思想是把一个项目、一件事情按照一定的顺序，从头到尾一步一步地做下去，先做什么，后做什么，一直到结束。
这种思想比较好理解，其实这也是一个人做事的方法。
面向对象：面向对象的思想是把一个项目、一件事情分成更小的项目，或者说分成一个个更小的部分，每一部分负责什么方面的功能，最后再由这些部分组合而成为一个整体。
这种思想比较适合多人的分工合作，就像一个大的机关，分成各个部门，每个部门分别负责某样职能，各个部门可以充分发挥自己的特色，只要符合一定前提就行了。
举例说明1：比如刚才说的一个大的机关，要做某一个项目，从面向过程的思想来说，应该是这样分析的，先怎么样，再怎么样，最后怎么样。
第一样应该如何完成，第二样应该如何完成等等。
等到每一步骤都完成，项目也就完成了。
而面向对象的思想则应该是这样想的，这个项目是由几个部分组成的，我们就做好分工，成立一个部门来做一个部分的功能，另一个部门来做另一个部分。
各个部门可以不用理解其他部门的事，只要完成自己那一部分的事情就OK 了。
举例说明2：又比如我们有一台演出，为简单起见，假设有如下流程：主持人开场——演员一表演——演员二表演——主持人总结。
用面向过程的思想来分析，就是先完成主持人开场，再完成演员一的表演，再完成演员二的表演，最后完成主持人的总结。
而如果用面向对象的思想来分析，就应该是这样的。
这个演出由两大部分组成：主持人、演员。
与主持人相关的：开场、总结。
与演员相关的：演员编号、所演的节目。
然后这台演出就可以这样策划：需要一个主持人a，需要两个演员b、c。
演出的事情可以表示为：a的开场——> b、c的编号和节目——> a的总结。
面向对象程序设计的基本思想与方法
面向对象程序设计的基本思想与方法随着计算机技术的不断发展，面向对象程序设计逐渐成为了一种广泛应用的编程思想。
在此编程方法中，程序的基本单位便是对象。
它是一种数据类型，不仅包含数据项，还包含可执行的操作。
这种编程思想以其良好的可维护性、可扩展性、可重用性以及高效性被广泛应用。
本文将介绍面向对象程序设计的基本思想与方法以及相应的面向对象设计原则。
一、面向对象程序设计的基本思想面向对象程序设计的基本思想是将一个大的程序拆分成一个个小的、可重用的对象，通过这些对象间的交互来实现程序的功能。
面向对象程序设计的三大要素：封装、继承和多态。
“封装”是指在对象中封装着其数据和操作，让其能够被控制和访问。
通过封装，对象的数据和行为可以被隐藏和保护，从而在一定程度上实现了程序的安全与简洁。
“继承”是指在一个对象的基础上新建一个对象。
新建的对象可以获得原对象的所有属性，也可以重新定义、增加或删除一些属性，从而实现了对象的复用与扩展。
“多态”是指不同的对象在执行同一个操作时可以出现不同的效果。
这种机制使得对象之间的交互更加灵活，能够在一定程度上提高程序的效率。
二、面向对象程序设计的基本方法面向对象程序设计的基本方法是类的设计。
类是一种对现实生活中的一些物体或概念进行抽象的数据类型。
在类的设计时，需要考虑以下问题：1. 类的属性：类的属性是指它所具有的数据。
这些数据的种类和数量确定了类所拥有的状态。
2. 类的行为：类的行为是指它的操作，也就是类所会的各种方法。
这些方法定义了类所能够执行的动作。
3. 类的关系：类与类之间有多重关系。
常见的关系有继承、组合、关联、聚合等。
三、面向对象程序设计的设计原则面向对象程序设计的设计原则是指在设计过程中遵循的一些指导性原则。
这些原则以确保代码的可维护性、可扩展性、可重用性为目标，具体包括以下几个方面。
1. 开闭原则：对于扩展开放，对于修改关闭。
2. 单一职责原则：一个类只负责一项职责，从而提高其可维护性。
什么是面向对象
①什么是面向对象？个人理解，面向对象是一种思想。
所谓科学的世界观--马克思主义哲学在开篇就定义：“世界是物质的，物质是运动的”。
前半句话就是面向对象的体现，把世界万物都作为对象来考虑。
面向对象的思想已经涉及到软件开发的各个方面。
如，面向对象的分析（OOA，Object Oriented Analysis），面向对象的设计（OOD，Object Oriented Design）、以及我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）。
②面向对象的基本概念(1)对象。
对象是人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。
(2)对象的状态和行为。
对象具有状态，一个对象用数据值来描述它的状态。
对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。
对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中(3)类。
具有相同或相似性质的对象的抽象就是类。
因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象。
类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。
类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。
(4)类的结构。
在客观世界中有若干类，这些类之间有一定的结构关系。
通常有两种主要的结构关系，即一般--具体结构关系，整体--部分结构关系。
一般——具体结构称为分类结构，也可以说是“或”关系，或者是“is a”关系。
整体——部分结构称为组装结构，它们之间的关系是一种“与”关系，或者是“has a”关系。
(5)消息和方法。
对象之间进行通信的结构叫做消息。
在对象的操作中，当一个消息发送给某个对象时，消息包含接收对象去执行某种操作的信息。
发送一条消息至少要包括说明接受消息的对象名、发送给该对象的消息名（即对象名、方法名）。
一般还要对参数加以说明，参数可以是认识该消息的对象所知道的变量名，或者是所有对象都知道的全局变量名。
面向对象程序设计思想
面向对象程序设计思想面向对象程序设计（Object-Oriented Programming，简称OOP）是一种软件开发方法，它以对象为基本单位，将数据和对数据的操作封装在一起，实现模块化的软件系统开发。
本文将介绍面向对象程序设计的基本原则和思想。
1. 封装（Encapsulation）封装是面向对象程序设计中最基础的思想之一。
它通过将数据和对数据的操作封装在一起，形成对象的特性和行为。
对象内部的数据只能通过对象自身的方法来访问，外部无法直接修改对象的内部状态，可以有效避免意外修改和数据泄露的问题。
2. 继承（Inheritance）继承是面向对象程序设计中的另一个重要原则，它通过定义一个基类，然后派生出不同的子类，实现代码的复用和拓展性。
子类将继承基类的属性和方法，可以在此基础上进行更多的功能扩展。
继承关系可以建立类之间的层次关系，形成类的继承链。
3. 多态（Polymorphism）多态是面向对象程序设计中的关键概念，它允许不同类的对象对同一消息作出响应，实现灵活的代码编写和代码的重用。
多态可以通过继承和接口实现。
通过多态，我们可以在不了解对象具体类型的情况下，调用相同的方法，实现不同的行为。
4. 类和对象面向对象程序设计中的核心是类和对象的概念。
类是抽象的描述，定义了对象的属性和方法。
对象是由类实例化而来，每个对象都有各自的属性和方法。
通过创建对象，我们可以实现对数据的封装和模块化的设计思想。
5. 类的设计原则在面向对象程序设计中，我们需要遵循一些设计原则，以保证代码的可读性、可维护性和扩展性。
其中一些重要的原则包括单一职责原则、开放封闭原则、里氏替换原则等。
这些原则帮助我们设计出高内聚、低耦合的类，使得代码更易于理解和维护。
6. 设计模式设计模式是面向对象程序设计中的经典解决方案，它提供了在特定情境下处理问题的一种标准方法。
常用的设计模式包括工厂模式、单例模式、观察者模式等。
通过使用设计模式，我们可以提高代码的复用性和可扩展性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
面向对象的基础思想1 类与对象（重点）1.1类与对象的基本关系类与对象是整个面向对象概念之中的最为重要的组成部分。
类：类是对整个现实世界的一种合理的抽象，是一种共性的产物，在类之中主要有两个组成部分：属性（变量）、行为（方法）；对象：是一个具体的，可以使用的产物，是一种个性的表示。
实际上类中规定了一个对象的具体行为，而对象是一个类的具体表现。
类只有通过对象才可以使用，所以在开发之中一定要先有类之后再定义对象。
但是一个类产生之后就好比汽车的设计图纸那样，本身并不能直接使用，必须按照图纸生产出具体的汽车之后才可以开，所以需要对象，而对象定义格式如下：格式一：声明并实例化对象格式二：分步完成通过以上的格式可以发现，依然存在了关键字new，所以这一操作也一定表示要开辟堆内存空间，同时需要注意的是，当一个对象开辟空间之后可以按照如下的两个方式来操作类中的内容：·操作类中的属性：对象.属性；·操作类中的方法：对象.方法()；范例：声明并实例化对象但是类本身属于引用数据类型，所以以上的程序依然要牵扯到内存的划分，同样使用两块内存：·堆内存：保存的是每一个对象所具备的属性；·栈内存：保存的是一块堆内存的使用地址，可以简单理解为对象名称。
1.2浅深入引用传递清楚了以上的内存关系之后，下面再来对另外一个类似的程序进行观察。
如果说现在同时产生了两个只要发现了关键字new，那么一定表示要开辟的是一块新的内存空间，每一块堆内存空间都有一个栈内存指向它。
范例：观察如下程序发现现在一个per对象没有进行实例化的操作，这个时候程序编译没有任何的语法错误，但是程序执行的时候出现了以下的错误提示：现在给出的是“NullPointerException”，表示空指向异常。
此异常肯定会伴随你的开发人生走完的那一刻，此异常只有在引用数据类型操作的时候才会出现。
NullPointerException更准确的讲法是指使用只声明而未开辟空间的引用类型所造成的问题，所以为了区分此概念，以后对于对象而言，在操作上就会给出两个不同的名词：·声明对象：只开辟了栈内存空间的对象，无法直接使用；·实例化对象：有了对应的堆内存空间指向，可以使用；以上的分析流程和数组是完全一样的，因为数组也属于引用数据类型，在数组学习的时候强调过，所谓的引用传递实际上指的就是一块堆内存空间可以同时被多个栈内存所指向的操作，那么对于类也是一样的，引用传递指的是一块堆内存同时被不同的对象（不同的栈）所指向。
范例：观察引用传递}范例：分析以下的程序运行}所谓的垃圾空间实际上就是指的没有任何的栈内存指向的堆内存空间，所有的垃圾空间要等待JVM不定期的进行垃圾回收（GC），以释放内存空间，不过虽然有了所谓的垃圾回收机制，从实际的开发来讲，应该尽量的去避免垃圾的产生。
2 封装性的基本实现（重点）封装性是作为面向对象第一大特征，但是需要提醒的是，本次所讲解的封装性只是针对于一种基本的实现，而Java之中的封装性是与权限有关的。
在真正的去研究封装操作之前，首先来观察这样的一个程序：这个时候程序依然可以执行，因为在int的数据范围之中本身就包含了负数，所以从技术上来讲，本程序没有任何的问题，但是从实际生活这样也完全不靠谱，所以这个时候按照开发的术语来讲是业务上有问题了。
而造成这一问题的本质在于属性没有经过任何的检查，并且可以在类的外部直接操作，所以要想解决问题，就必须让属性对外部不可见，可以使用private进行属性的定义。
现在给出的提示是name和age两个属性在Person类之中是属于私有的访问，所以类的外部无法使用，即：使用private定义的内容只能在当前类中起作用。
而当属性使用了private封装之后，按照Java EE的标准来讲，此时就必须使用如下的方法格式进行属性的操作，以name属性为例，现在已经使用了private封装：·设置属性内容（setter）：public void set N ame(String n)； setter要检查以后只要是类中的属性都必须使用private封装，封装之后的属性一定要使用setter、getter设置和取得。
3 构造方法（重点）现在可以对以上的格式分析一下：“类名称对象名称”，这个操作意味着声明一个指定类型的对象。
而后new表示要开辟一个新的堆内存空间，但是在最后有一个“类名称()”，一旦操作后面有“()”表示的是一个方法，那这个就是构造方法，所以对于构造方法在之前一直在使用。
范例：观察构造在一个类之中，构造方法的定义要求如下：·构造方法的名称和类的名称要求完全一样，如果class Person，则构造：Person()；每当使用关键字new实例化新的对象时，构造方法都要被调用，但是这个时候也出现一个问题了，在之前貌似没有编写过构造方法，那么为什么之前没有错呢？为了保证每一个类操作的方便，所以如果在一个类之中没有明确的定义一个构造方法的话，则会在编译的时候自动的生成一个无参的，什么都不做的构造方法：结论：在一个类之中至少存在一个构造方法，如果一个类之中已经明确定义一个构造的话，则无参的什么都不做的构造方法将不会再自动生成了。
构造方法的基本概念介绍完了，但是构造方法有什么用呢？在之前所进行的操作可以发现是按照如下的流程：·实例化对象：Person per = new Person() ;；·调用类的setter方法设置内容：per.setName("张三") ;、per.setAge(20) ;；很明显，当一个对象实例化之后就特别希望类中的属性就有内容了，这样分别调用setter方法设置实在是不方便，所以可以使用构造方法进行属性内容的传递。
构造方法的主要作用：是进行对象中属性的初始化操作。
简单点理解：就是一个类对象实例化的时候可以自动的完成一些操作。
但是在这里面还有一个小说明，既然现在在构造方法之中所调用的方法是本类中的方法，所以很多时候（在开发之中必须使用）都会使用一个this来强调一下是本类中的方法：既然构造方法本身属于方法，那么只要是方法就可以进行方法的重载，但是构造方法重载的时候根本就不用考虑方法名称（因为都跟类名称一样），只需要考虑参数的类型及个数的不同即可。
提示（以后解释）：在每一个对象的构造过程（实例化过程），构造方法是整个构造过程的最后一步，所以如果现在在类中的一个属性定义时存在了默认值，那么这个默认值也只有在构造完成之后才会真正的赋值给这个属性，其他的时候这个属性的值都是其对应数据类型的默认值，例如：从理论上讲，本类之中的name属性的默认值“无名氏”，只能构造完成之后才可以真正的给name，其他的时候name的内容就是null，但是这一特征如果要想通过代码来验证，需要点时间。
学习完构造方法之后，发现在类之中就存在了三样东西：属性、普通方法、构造方法，所以这三样东西的编写流程：1、定义属性；2、编写构造：如果有多个构造方法，则一定要按照参数的顺序编写（按照参数的个数升序或降序）3、普通方法：也需要考虑到参数的个数；4 匿名对象（重点）匿名就是指没有名字的对象，对于对象的内存划分，很明显现在是有两块内存，一块是堆内存，另外一块是栈内存空间，但是堆内存是真正要使用的内容，而栈只是保留了一块堆内存地址而已，就是一个表示堆内存的名字，所以所谓的匿名对象指的就是没有名字的堆内存对象。
但是由于匿名对象本身没有名字，所以使用一次之后就称为垃圾了，就要等待被回收。
何种情况下需要匿名对象：一个对象只用一次，就匿名对象。
5 对象的比较和排序如果是简单的对象之间是否相同的比较则直接重写Object提供的equals()方法和hashCode()；如果想进行一组对象的比较，那么必须存在比较器的支持，而Java之中的比较器有两种：Comparable、Comparator，下面分别说明。
5.1、重写equals()方法和hashCode()方法范例：在String类之中如果要想判断两个字符串的内容是否相等，使用equals()方法，那么如果说现在有一个自定义类的两个对象，要想判断是否相等，这个时候肯定要将类之中的所有属性依次进行比较判断。
如果从实际来讲肯定是自己来处理省事，因为如果把所有的比较操作交给了第三方去完成，那么就意味着，第三方必须清楚每一个操作的细节，这样做根本就不现实，而一个好的设计客户端不应该参与更多的细节方面的内容，关心的只是一个结果，而主方法就是一个客户端，所以在这个客户端之中不应该牵扯到细节。
为了解决这样的问题，那么肯定要由类提供这一操作，所以应该在Person类之中提供一个比较的操作方法。
而对象的比较操作在日后课程讲解以及开发之中，是一个极其重要的概念，一定要记住，对象比较是一个类自己提供的功能。
5.2 常用的比较器：Comparable（核心）首先来看一下Comparable接口的定义格式：在之前学习String的时候也学习过compareTo()方法，因为String也是Comparable接口的子类，所以String类中的compareTo()方法也是覆写而来，而如果是一个用户自己定义的compareTo()方法可以返回三种值：-1、1、0；可以发现Comparable接口是在一个类定义的时候就默认实现好了的，所以是一个类本身自己的功能。
6.2、挽救的比较器（了解）如果说现在定义了一个类，但是在定义类的时候并没有考虑到排序问题。
但是现在有一个新的要求出现了，突然希望可以对一组这样类的对象进行排序，而现在Person类无法修改，而又要同时满足排序要求的话，只能使用另外一种比较器：Comparator，此接口定义如下：如果希望使用Comparator的话，就必须准备出一个专门用于实现具体比较操作的规则类。
现在这是一个专门用于定义的比较规则，而这个比较规则在使用的时候直接向sort()方法上传递对象即可。
观察Arrays类的一个方法：public static <T> void sort(T[] a, Comparator<? super T> c)面试题：请解释一下两种比较器的区别？·Comparable：parable是在一个类定义时直接实现的接口，属于一个类本身的功能存在，里面只有一个compareTo()方法；·Comparator：parator是一个挽救的比较器接口，需要单独定义一个比较规则，里面有两个方法：compare()、equals()；·但是从使用上来讲肯定使用Comparable完成。