下载文档原格式
⾯向对象知识点总结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 权限修饰符可以用来修饰成员变量和成员方法，对于类的权限修饰只可以用public和缺省default。
被public修饰的类可以在任意地方被访问；default类只可以被同一个包内部的类访问。
权限由大到小：public protected default(不写) private被private修饰的成员只能在本类中访问，外界不能访问2 set()/get()方法（1）this关键字a.可以用来调用变量，方法，构造方法；b.this.xx 理解为调用当前类的xx。
（2）成员变量和局部变量1）在类中的位置不同a:成员变量:在类中,方法外b:局部变量:在方法声明上（形式参数）,或者是在方法定义中2）在内存中的位置不同a:成员变量:在堆内存b:局部变量:在栈内存3）生命周期不同a:成员变量:随着对象的创建而存在,随着对象的消失而消失b:局部变量:随着方法调用而存在,随着方法的调用结束而消失4）初始化值不同a:成员变量:有默认值b:局部变量:必须初始化值,否则报错!(在使用它之前,没有初始化) （3）set()/get()方法当成员变量被private修饰时，不在本类中无法直接访问，便需要set()/get()方法来解决这个问题3 封装性封装：是面向对象的第一大特性，所谓封装，就是值对外部不可见（一般而言被private修饰），外部只能通过对象提供的接口（如set()/get()方法）来访问。
封装的好处：a.良好的封装能够减少耦合；b.类内部的结构可以自己修改，对外部影响不大；c.可以对成员进行更精准的控制（防止出现与事实不符的情况）；d.影藏实现细节。
注意：在开发中，类的成员变量全部要进行封装，封装之后通过set()/get()方法访问。
二丶继承extends1 实现：通过 class Zi extends Fu{} 实现类的继承（1）子类继承父类，父类中声明的属性，方法，子类都可以获取到；当父类中有私有的属性方法时，子类同样可以获取到，由于封装性的设计，使得子类不能直接调用访问。
⾯向对象设计的三个基本特征
1.抽象与封装:
抽象是把系统中需要处理的数据和在这些数据上的操作结合在⼀起，根据功能、性质和⽤途等因素抽象成不同的抽象数据类型。
每个抽象数据类型既包含了数据，⼜包含了针对这些数据的授权操作。
在⾯向对象的程序设计中，抽象数据类型是⽤“类”这种结构来实现的，每个类⾥都封装了相关的数据和操作。
封装是指利⽤抽象数据类型和基于数据的操作结合在⼀起，数据被保护在抽象数据类型的内部，系统的其他部分只有通过包裹在数据之外被授权的操作，才能与这个抽象数据类型进⾏交互。
2. 继承：
它是与传统⽅法不同的⼀个最有特⾊的⽅法。
它是⾯向对象的程序中两个类之间的⼀种关系，即⼀个类可以从另⼀个类（即它的⽗类）继承状态和⾏为。
继承⽗类的类称为⼦类。
继承的优越性：通过使⽤继承，程序员可以在不同的⼦类中多次重新使⽤⽗类中的代码，使程序结构清晰，易于维护和修改，⽽⼦类⼜可以提供⼀些特殊的⾏为，这些特殊的⾏为在⽗类中是没有的 。
3.多态：
是指⼀个程序中同名的⽅法共存的情况，调⽤者只需使⽤同⼀个⽅法名，系统会根据不同情况，调⽤相应的不同⽅法，从⽽实现不同的功能。
多态性⼜被称为“⼀个名字，多个⽅法”。
简述面向对象程序设计的三大基本特点面向对象程序设计（Object-Oriented Programming，简称OOP）是一种常用的编程范式，它具有三大基本特点：封装、继承和多态。
封装是面向对象程序设计的第一个基本特点。
它指的是将数据和对数据的操作封装在一个类中，通过类的接口来隐藏数据的实现细节。
封装使得数据和操作数据的方法被组织在一个单独的逻辑单元中，提高了代码的可维护性和可重用性。
通过封装，我们可以将数据和相关的操作绑定在一起，形成一个独立的实体，从而实现了数据的保护和安全性。
对外部用户来说，只需要通过类的公共接口来访问数据和操作，不需要关心内部的具体实现细节。
这种封装的特性可以有效地隐藏对象的内部信息，提高了代码的可读性和可理解性。
继承是面向对象程序设计的第二个基本特点。
继承是指一个类（称为子类或派生类）可以继承另一个类（称为父类或基类）的属性和方法。
通过继承，子类可以拥有父类的属性和方法，同时可以在此基础上进行扩展和定制。
继承可以有效地实现代码的重用，避免了重复编写相同的代码。
另外，继承还可以建立类之间的层次关系，使得代码的组织结构更加清晰和直观。
继承的特性使得面向对象程序设计具有了更强的灵活性，可以在不破坏原有代码的基础上进行功能扩展和修改。
多态是面向对象程序设计的第三个基本特点。
多态是指同一个方法在不同的对象上可以有不同的行为。
具体来说，是通过父类的引用指向子类的对象，以实现同一个方法在不同对象上表现出不同的行为。
多态可以提高代码的灵活性和可拓展性，使得程序更加易于扩展和维护。
通过多态，可以处理同一类对象的不同实现方式，提高了代码的可读性和可维护性。
多态还可以实现接口的统一，使得不同的对象可以以相同的方式调用方法。
面向对象程序设计的三大基本特点相互依赖、相互联系，共同构成了面向对象编程的核心思想和基本原则。
封装保护了对象的内部数据和操作，提供了对外的公共接口；继承实现了代码的重用和扩展，建立了类之间的层次关系；多态实现了同一方法在不同对象上的不同行为，提高了代码的灵活性和可拓展性。
面向对象编程的特点和优势面向对象编程（Object-Oriented Programming, OOP）是计算机编程中的一种主要的范型，它在现代软件开发中占据着重要的地位。
与传统的过程式编程相比，面向对象编程有着明显的特点和优势。
在本文中，我们将针对这些特点和优势进行讨论。
特点一：封装面向对象编程中的一大特点是封装。
封装指的是将数据和行为都封装在一个类中，将数据和行为作为该类的属性和方法，通过接口（接口就是类的方法）来调用这些属性和方法。
这样，外部代码只能通过接口来与类内部进行交互，从而实现了数据和方法信息的隐藏。
通过封装和隐藏，面向对象编程就能够更好地抽象和模块化。
而封装在软件开发中也是一个极其重要的设计原则，它通过对数据和方法的限制，高效地保证了代码的安全性和可维护性。
特点二：继承继承是面向对象编程的另一个特点。
继承的本质是一种代码复用的方式。
它基于现有的类，创建一个新类，新类继承了现有类的所有属性和方法，并可通过新增和修改方法的方式，提供新的功能。
面向对象编程中，通过继承，我们可以将代码的重复程度降低到最低，提高了代码的重用性；还可以大大提高代码的可维护性和可扩展性，因为子类可以更加灵活地继承和覆盖父类的方法和属性，可以通过多态的方式对类进行扩展。
特点三：多态多态是面向对象编程中的最后一个特点，它使得程序的编写更加灵活和可变化。
多态即同一种操作，对于不同的对象，会有不同的行为响应。
通过多态，我们可以在不同的场景下，使用同一个方法名，但是得到不同的结果。
这个特点可以方便地实现程序的扩展性，支持代码的泛型设计和组合设计。
面向对象编程的优势面向对象编程相较于传统的过程式编程有着不少的优势。
这里我们列出了一些主要的优势：1. 更加容易维护和扩展面向对象编程将程序中的功能按照逻辑关系进行了封装，可以更加方便地对程序进行维护和扩展。
可以进行组件复用，减少代码的冗余程度。
2. 更加适合团队协作面向对象编程可以将程序员分成多个小组，按照职责来进行类别的设计和开发。
《面向对象程序设计》知识点《面向对象程序设计》是计算机科学中的重要概念，它是一种软件开发方法，将软件模型作为一个系统的集合来设计、分析和实现。
本文将重点介绍面向对象程序设计中的关键知识点，包括面向对象的基本概念、类与对象、继承与多态、封装和抽象等内容，以便读者全面了解和掌握面向对象程序设计的核心概念和方法。
一、面向对象的基本概念1. 面向对象编程的起源：面向对象编程（Object-Oriented Programming，简称OOP）起源于20世纪60年代，是一种基于对象的软件开发范式，它将数据和操作数据的方法组合到一个对象中，以及通过对象之间的交互来完成程序的设计。
2. 面向对象的特征：面向对象的程序设计具有封装、继承和多态的特征。
封装指的是将数据和处理数据的方法封装在对象中，继承指的是子类可以继承父类的属性和方法，多态指的是同一操作作用于不同对象上时可以有不同的行为。
3. 面向对象的优势：面向对象的程序设计具有代码复用性高、可维护性强、扩展性好、可靠性高等优势，可以提高程序的设计效率和质量。
二、类与对象1. 类的定义：类是一种抽象数据类型，用来描述具有相同属性和行为的对象的集合。
类用来创建对象的模板，包含数据成员和成员函数。
2. 对象的创建：对象是类的一个实例，是具体的数据和行为的封装体。
通过类实例化，可以创建多个对象来表示真实世界的实体。
3. 类的成员：类包含数据成员和成员函数。
数据成员表示对象的属性，成员函数表示对象的行为，可以进行数据的操作和处理。
三、继承与多态1. 继承：继承是指一个新类从现有类中派生出来，并且拥有现有类的属性和行为。
继承可以实现代码的复用，并且可以建立类之间的关系。
2. 多态：多态是指同一操作作用于不同对象上时可以有不同的行为。
多态通过虚函数和动态绑定实现，可以使程序具有更好的灵活性和扩展性。
四、封装和抽象1. 封装：封装是指将数据和数据的操作封装在类的内部，外部无法直接访问和修改类的数据。
面向对象编程中封装的作用封装在面向对象编程中的作用封装是面向对象编程的三大特性之一，它在软件开发中扮演着非常重要的角色。
封装的作用主要体现在以下几个方面：1. 数据隐藏和保护：封装可以将对象的数据和行为包装在一起，通过访问修饰符（如private、protected、public）来限制对对象内部数据的直接访问。
这样可以有效地隐藏对象的实现细节，防止外部直接修改对象的数据，增强了数据的安全性和稳定性。
只有通过对象提供的公共接口（方法）才能访问和操作对象的数据，提高了代码的可维护性。
2. 接口定义和规范：封装可以通过定义类的公共接口，来规范对象的使用方式。
对象的接口定义了外部与对象交互的方法和属性，使用者只需关注对象的接口而不需要关心内部实现细节。
这样可以降低代码的耦合度，提高代码的重用性和可扩展性。
3. 代码复用和模块化：封装可以将一些相关的属性和方法封装在一个对象中，形成一个独立的模块。
这样可以方便地复用代码，提高代码的可维护性和可读性。
通过封装，可以将一个复杂的系统分解成多个独立的模块，每个模块可独立开发、测试和维护，提高了开发效率。
4. 隐藏实现细节和减少代码冗余：封装可以将对象内部的实现细节隐藏起来，只对外部提供必要的接口。
这样可以减少外部代码对内部实现的依赖，降低了代码的耦合度。
在修改对象内部实现时，不会影响到外部代码的使用。
同时，封装还可以减少代码的冗余，将一些公共的操作封装成方法，提高了代码的重用性。
5. 提高代码的可维护性和可扩展性：封装可以将对象的属性和方法封装在一起，形成一个独立的对象。
这样可以方便地对对象进行维护和扩展。
当需要修改对象的实现时，只需修改对象内部的代码，而不会影响到外部代码的使用。
同时，通过继承和多态等机制，可以方便地对封装的对象进行扩展，提高了代码的灵活性和可扩展性。
封装是面向对象编程中非常重要的特性之一。
它通过将对象的数据和行为封装在一起，并通过访问修饰符来限制对对象内部数据的直接访问，实现了数据的隐藏和保护，规范了对象的使用方式，提高了代码的复用性和可维护性。
作者简介丁士锋 毕业于国防科技大学计算机学院。
有多年的大型软件系统开发经验，有近8年的.NET软件项目研发经验，擅长C#语言，对.NET框架及其底层机制有深入的理解。
曾经任职于三星电子、诺基亚等公司，从事软件项目开发。
对企业软件的设计与架构有深入的研究和大量经验，主导过多个大型的企业分布式项目的开发。
朱毅 毕业于上海交通大学，获信息工程、计算机科学双学士学位。
之后又获得了复旦大学软件工程硕士学位。
有6年多的.NET研发经验，涉及分布式系统、B/S体系结构系统、C/S体系结构系统的架构和开发。
曾任职于西门子移动通信有限公司，担任项目经理，致力于企业ERP系统的架构。
现任职于惠普有限公司ISEE项目组进行项目开发。
长期活跃于各大技术社区，曾著有《.NET程序员面试指南》一书。
业余时间喜欢阅读和旅游。
杨明羽 毕业于浙江大学计算机科学与技术专业，高级软件工程师。
多年来一直从事软件开发和项目管理类工作，有近10年的软件开发经验。
擅长C#语言，深入理解.NET框架底层机制，长期追踪.NET框架的最新技术。
曾任职于263在线、阿里巴巴等网络公司。
现任职于上海某大型网络科技公司，担任技术总监一职。
编辑推荐随书附赠微软Visual Studio 2008学习版安装光盘 6小时多媒体视频讲解 资深.NET程序员，全新视角，解读.NET 3.5框架的最新技术趋势 深入剖析.NET 3.5框架的四大开发技术及.NET 3.5框架的底层机制本书简介本丛书5种荣获“全国优秀畅销书奖”（科技类），本丛书累计销售超过100万册，本丛书先后被400余所培训机构选作参考书。
C#是微软推出的一种面向对象开发语言，其能让已有经验的开发人员轻松上手，并在很短的时间内就可以使用C#高效地进行工作。
这是读者选择C#的原因。
目前最新的C#版本就是.NET 3.5框架上的C# 3.0。
本书借助Visual Studio 2008开发工具，详细介绍了.NET框架中的4大开发利器：LINQ、WPF、WF和WCF。
C#2010 面向对象的特点面向对象程序设计是一种把面向对象的思想应用于软件开发过程中，指导开发活动的系统方法。
作为一种对人认识自然事物方式的模仿，面向对象的程序设计具有4种特性，如下所示。
1．封装性（Encapsulation）封装性是面向对象程序设计的基本特征。
具体到现实生活中，封装也是工业生产和日常生活中的一种常见现象。
例如日常使用的计算机主机，事实上就是将中央处理器、存储器、输入设备和输出设备封装为一体的一个对象，其结构如图4-4所示。
图4-4 计算机的构成在使用计算机时，用户无需了解计算机中各种组件的运行原理，也不需要掌握这些组件各自发挥的作用，只需要直接调用计算机中的操作系统，通过操作系统这个接口即可实现内外的交互。
以上实例充分体现了封装的原理，在面向对象的程序设计中，将所有进行对象处理和操作，以及表述对象特征的代码全部被封装到类中，通过类的各种对外接口实现内外的交互。
封装可以将程序运行的代码与实际调用过程完全隔离，开发者在使用程序时，只需要了解程序对外的接口，无需了解程序内部运行的原理，这样既保护程序代码的完整性和安全性，又方便了开发者使用这些程序。
封装还可以为类的各种成员定义外部的访问权限。
例如，通过对类的成员定义修饰符，可以禁止某些成员被类以外的代码访问，或进行这些成员被命名空间以外的内容访问。
封装保证了模块具有较好的独立性，使得程序维护修改较为容易。
对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。
封装的容器可以有许多种，例如包、类、方法，也可以是某个具体的对象。
在之前介绍函数的章节中，就多次提到使用函数封装代码，从而实现模块化的程序开发。
2．抽象性（Abstraction）抽象性也是面向对象的基本特点，其具体的表现就是在将多个实例归纳和总结为类时，需要对若干个实例的属性、方法、常量和事件进行分析，求出这些实例成员的交集，即可抽象为类的成员。
抽象是一个重要的过程，也是对实例的各种成员进行甄别和筛选的必要过程。
⾯向对象程序设计的特点、
、、期待与您交流！
1，封装性
⾯向对象程序设计的基本特征就是将现实世界的属性和⾏为封装，形成抽象的类。
⽤户直接基于类创建实例对象，即可调⽤对象中的⽅法。
不需要理会该⽅法是如何实现的。
2，继承性
继承性可以表⽰类之间层次的概念，通过继承可以从⼀个对象获得另⼀刻对象的⽅法。
例如：东北虎是虎的⼀种，虎⼜是哺乳动物的⼀种，哺乳动物⼜是动物的⼀种。
东北虎继承了虎的特性，同时还有⾃⼰特有的属性；虎是⼜继承了哺乳动物的特性，同时还有⾃⼰特的属性；以此类推。
动物是这个继承体系中的最⾼级。
同理，对象的继承性也是如此，⼦类继承⽗类之后，⼦类不仅可以为⾃⼰添加新的属性和⽅法，还可以使⽤⽗类所有的属性和⽅法。
3，多态性
多态性是指⽗类的属性和⽅法被⼦类继承后具有不同的表现⾏为。
多态性可以让⼦类中的同⼀属性或同⼀⽅法与⽗类具有不同的语义。
⽤户可以发送⼀个相同的信息，将对消息的处理细节分别安排到不同的对象中完成，因此同⼀个消息可以有不同的运⾏结果。
在⾯向对象的程序设计中利⽤⽅法重载（⽅法重载指⼀个类中有相同的⽅法，但因⽅法传⼊的参数不同，可以分别求出不同的结果）来实现多态性。
⾯向对象语⾔编程三⼤特点-封装，继承，多态⾯向对象的三个基本特征是：封装、继承、多态。
封装：可以隐藏实现细节，使得代码模块化；继承：可以扩展已存在的代码模块（类）；它们的⽬的都是为了——代码重⽤。
多态：则是为了实现另⼀个⽬的——接⼝重⽤！现在仔细讲⼀下什么是封装？封装可以隐藏实现细节，使得代码模块化；在⾯向对象编程上可理解为：把客观事物封装成抽象的类，并且类可以把⾃⼰的数据和⽅法只让可信的类或者对象操作，对不可信的进⾏信息隐藏。
封装的意义？封装的意义在于保护或者防⽌代码（数据）被我们⽆意中破坏。
在⾯向对象程序设计中数据被看作是⼀个中⼼的元素并且和使⽤它的函数结合的很密切，从⽽保护它不被其它的函数意外的修改。
1. 保护数据成员，不让类以外的程序直接访问或修改，只能通过提供的公共的接⼝访问==>数据封装；2. ⽅法的细节对⽤户是隐藏的，只要接⼝不变，内容的修改不会影响到外部的调⽤者==> ⽅法封装；3. 当对象含有完整的属性和与之对应的⽅法时称为封装；4. 从对象外⾯不能直接访问对象的属性，只能通过和该属性对应的⽅法访问；5. 对象的⽅法可以接收对象外⾯的消息；什么是继承？继承是指这样⼀种能⼒：它可以使⽤现有类的所有功能，并在⽆需重新编写原来的类的情况下对这些功能进⾏扩展。
其继承的过程，就是从⼀般到特殊的过程。
通过继承创建的新类称为“⼦类”或“派⽣类”。
被继承的类称为“基类”、“⽗类”或“超类”。
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
在某些 OOP 语⾔中，⼀个⼦类可以继承多个基类。
但是⼀般情况下，⼀个⼦类只能有⼀个基类，要实现多重继承，可以通过多级继承来实现。
继承的实现⽅式？继承概念的实现⽅式有三类：实现继承、接⼝继承和可视继承。
1. 实现继承是指使⽤基类的属性和⽅法⽽⽆需额外编码的能⼒；2. 接⼝继承是指仅使⽤属性和⽅法的名称、但是⼦类必须提供实现的能⼒；3. 可视继承是指⼦窗体（类）使⽤基窗体（类）的外观和实现代码的能⼒；什么是多态？“⼀个接⼝，多种⽅法”，同⼀操作作⽤于不同的对象，可以有不同的解释，产⽣不同的执⾏结果。
什么是面向对象方法面向对象方法（Object-oriented method，简称OO方法）是一种针对面向对象编程的设计和开发方法论。
它以对象作为程序设计的基本单位，通过封装、继承、多态等特性来处理问题。
面向对象方法是一种从现实世界抽象出的程序设计范式，它能更好地模拟现实世界的问题，并提供了灵活性和可重用性。
面向对象方法的核心思想是将复杂的问题分解成一系列小而独立的对象，这些对象具有自己的属性和行为。
通过将对象连接在一起，形成对象的协作关系，从而完成问题的解决。
面向对象方法具有以下几个重要特点：1. 封装（Encapsulation）：封装是指将数据和操作数据的方法绑定在一起，形成一个对象。
封装可以隐藏对象的内部细节，只暴露对外可见的接口，从而保证了对象的安全性和数据的一致性。
2. 继承（Inheritance）：继承是指通过定义一个新的类，来继承已有类的属性和方法。
继承可以减少代码的重复编写，提高代码的可复用性和维护性。
同时，通过继承，可以实现对象的层次结构，形成类的继承关系。
3. 多态（Polymorphism）：多态是指同一操作可以应用于不同的对象上，产生不同的结果。
它使得程序可以根据对象的实际类型来调用相应的方法，从而实现了动态绑定。
多态提高了代码的灵活性和可扩展性。
面向对象方法的开发过程可以概括为以下几个步骤：1. 需求分析：在需求分析阶段，通过与客户沟通和了解，确定问题的需求和约束条件。
将问题划分成一系列小的对象，并明确它们之间的关系。
2. 设计：设计阶段根据需求分析的结果，建立对象模型。
定义对象的属性和方法，描述对象之间的关系，确定系统的核心功能和模块。
3. 编码：在编码阶段，将设计的对象模型转换成可执行的代码。
通过选择合适的编程语言，实现对象和类的定义，以及对象之间的交互。
4. 测试：在测试阶段对代码进行测试，检查是否满足需求，排除潜在的错误。
通过单元测试、集成测试、系统测试等方法，确保程序的正确性和可靠性。
⾯向对象的三⼤特性⾯向对象的三⼤特性⽬录⼀、封装1.1 隐藏属性封装是⾯向对象三⼤核⼼中最核⼼的⼀个特性。
封装就是将类的某些属性隐藏起来，然后通过接⼝对外开放，但是在外部不能直接进⾏查找属性。
在类内部的变量属性或者函数属性名前加上两个下划线。
就实现了对该属性的隐藏，此时，通过外界就查不到该属性。
# 属性的隐藏class Student:__school = "清华"def __init__(self,name,age):self.__name = nameself.__age = agedef tell_info(self):print("学校：%s 姓名：%s 年龄：%s"%(self.__school,self.__name,self.__age))stu_1 = Student("tom",18)print(stu_1.__school) # 这种⽅法是查看不到该学校属性的。
print(stu_1._Student__school) # 采⽤_类__属性的⽅法就可以查看了。
stu_1.__handsome = "帅" # 定义完毕类之后在添加__属性，该属性是不会隐藏起来的。
通过上述的查看⽅式，就⼤概看出来，这个隐藏其实是⼀种变形，这个阶段主要发⽣在定义阶段，当执⾏类内部的代码时候，遇到__属性的⽅式就会将其变为_类__属性名的形式。
这样我们就可以在外界通过这种形式调⽤查看该属性。
由于是在定义阶段发⽣的变形，因此，在外界我们在重新指定对象的属性的时候，是不会在发⽣变形的。
这种隐藏的⽅式并不是完全的没办法访问，但是如果你还想调⽤查看的话，请⼀开始就不要搞这种隐藏，多此⼀举。
这种隐藏其内部是可以使⽤的，因为其内部在定义的时候都发⽣了转变，所以内部使⽤的⽅式也变成了_类__属性的⽅式。
那为什么要设置隐藏呢？1. 隐藏数据是为了限制外界对属性的直接修改。
面向对象程序设计课堂笔记一、什么是面向对象程序设计。
面向对象程序设计（Object-Oriented Programming，OOP）是一种编程范式，它将现实世界看作由各种对象组成，每个对象都具有不同的属性和行为，并且可以与其他对象进行交互。
二、面向对象程序设计的三大特征。
1. 封装（Encapsulation）。
封装是指将数据和操作数据的方法进行封装，构成一个类。
通过对外提供公共的方法和属性，类的内部实现可以隐藏起来，保证类的安全性和可维护性。
2. 继承（Inheritance）。
继承是指子类可以继承父类的属性和方法，并且可以在此基础上进行扩展。
这样可以提高代码的复用性和可维护性，同时也有助于层次化设计。
3. 多态（Polymorphism）。
多态是指同一个类的对象可以呈现不同的形态。
多态的实现是通过继承和接口实现的。
多态可以提高代码的灵活性和可扩展性。
三、面向对象程序设计的基本要素。
1. 类（Class）。
类是面向对象程序设计的基本组成单位，是一种抽象数据类型。
类的属性和方法决定了对象的特征和行为。
2. 对象（Object）。
对象是类的实例，每个对象都有自己的属性和方法，可以与其他对象进行交互。
3. 属性和方法（Property and Method）。
属性和方法是类的两个基本元素，属性是对象的特征或状态，方法是对象具有的行为或动作。
4. 继承（Inheritance）。
继承是一种代码复用的方式，子类可以继承父类的属性和方法，并且可以在此基础上进行扩展。
继承可以实现代码的层次化设计。
5. 重载（Overload）和重写（Override）。
重载是指在一个类中定义多个同名方法，但是参数类型、个数或顺序等不同，以提供更多的操作方式。
重写是指子类重写父类的方法，可以实现多态的功能。
6. 接口（Interface）。
接口是一种规范，规定了类必须实现的一组方法。
它可以实现多态和代码的松耦合。
四、面向对象程序设计的思想和技术。
面向对象开发方法的基本要求及评价标准面向对象是一种基于对象的软件开发方法，它主要基于面向对象的思想，采用封装、继承、多态等机制，将复杂的系统划分为相互独立的对象，并通过定义对象间的关系，实现系统的功能。
面向对象开发方法不仅具有灵活性、可维护性和可扩展性等优点，同时也有一系列基本要求和评价标准，以下将对其进行详细介绍。
一、基本要求1. 模块化：面向对象开发方法中，每个对象都应该属于某个类，每个类都应该属于某个模块。
通过将系统划分为多个模块，可以使系统具有更好的可维护性和可扩展性，同时也可以方便多人协同开发。
2. 封装：封装是对象的一种基本属性，它指的是将对象的状态和行为封装在一起，并对外部隐藏其具体实现细节。
这样可以保证对象在外部操作时，只能通过限定的接口进行访问，避免了对象被不合理修改的情况。
3. 继承：继承是面向对象开发中的一种基本机制，它可以使某个对象获得另一个对象的属性和方法。
通过继承，可以避免重复定义代码，减小了代码的冗余度，提高了代码的可维护性。
4. 多态：多态是面向对象开发中的另一种重要机制，它可以将不同的对象用相同的方式对待，从而提高了代码的可扩展性和可复用性。
二、评价标准1. 可读性：一个好的面向对象代码应该易于阅读和理解。
通过良好的命名规范、注释和风格统一等手段，可以使代码具有更好的可读性。
2. 可维护性：面向对象开发方法应该具有良好的可维护性，即当系统需要进行修改或添加新功能时，应该能够快速定位到问题所在，并进行修改。
这需要在设计时考虑良好的架构，遵循良好的设计原则，以及对系统进行充分的测试。
3. 可扩展性：面向对象开发方法应该具有良好的可扩展性，即能够方便地添加新的功能或特性。
这需要在设计时考虑到系统的未来发展，采用合适的设计模式，避免设计过于局限。
4. 可复用性：面向对象开发方法应当具有较高的可复用性，即在不同的系统中，可以重复使用相同的代码、类或组件。
这需要采用合适的设计模式、使用通用的接口和数据结构等手段，以便代码的复用。
