面向对象的三大特性

面向对象的编程语言特点
1.封装性：将对象的数据与函数封装在一起，只对外部提供必要的接口，隐藏内部实现细节，提高安全性和可靠性。

2. 继承性：允许从现有类派生出新的类，新类可以继承原类的属性和方法，并可以添加新的属性和方法，提高代码复用性和可维护性。

3. 多态性：同一操作可以针对不同的对象产生不同的行为，提高代码的灵活性和可扩展性。

4. 抽象性：将对象的共性抽象出来形成类，通过类来实例化对象，避免重复编写代码，提高代码的可读性和可维护性。

5. 消息传递：对象之间通过消息传递来进行通信，而不是直接对数据进行操作，降低了对象之间的耦合度，提高了代码的可移植性和可扩展性。

6. 动态绑定：在运行时根据对象的类型来确定实际调用的方法，实现了动态多态，提高代码的灵活性和可扩展性。

7. 内存管理：面向对象的语言通常采用自动内存管理机制，避免了程序员手动管理内存的繁琐和容易出错。

- 1 -。

使用java面向对象编程的三大特征大多数新人，在才开始学习java面对对象编程的过程中对于这一块的三大特征一直比较模糊，基本都是刚开始学习接触编程，一个人跌跌撞撞摸索着往前走，初学的时候很多东西理解的也懵懵懂懂，后来实践的多了，有些东西才慢慢清楚；二是经过一定的实践之后，反过头来再去学习一些基础东西才能够理解的更透彻；三是有些东西基础但是确很重要，是值得好好搞一搞的。

1、面向对象面向对象（Object Oriented）是一种新兴的程序设计方法，或者是一种新的程序设计规范(paradigm)，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。

从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。

2、对象对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。

一个对象由一组属性和对这组属性进行操作的一组服务组成。

3、类类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。

在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。

Java中的类实现包括两个部分：类声明和类体。

类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。

当不存在对一个对象的引用时，该对象成为一个无用对象。

Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。

当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。

向对象的三个基本特征是：封装、继承、多态。

4、封装封装性就是尽可能的隐藏对象内部细节，对外形成一道边界，只保留有限的接口和方法与外界进行交互。

封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外界对对象内部属性的破坏。

可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

简述对面向对象的三大特征的理解
面向对象有三大特点：封装、继承、多态。

1、继承性：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。

对象的一个新类可以从现有的类中派生，这个过程称为类继承。

新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。

派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

2、封装性：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。

面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

3、多态性：
多态性是指允许不同类的对象对同一消息作出响应。

多态性包括参数化多态性和包含多态性。

多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

一丶封装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.多态。

封装
⼀个不可分割的独⽴实体；
隐藏内部细节；
保留对外接⼝。

封装的好处：
1. 保证数据的安全性；
2. 提供清晰的对外接⼝；
3. 类内部实现可任意修改，不影响其他类。

继承
继承可以使⼦类具有⽗类的属性和⽅法，或者重新定义、追加属性和⽅法等。

对象的继承代表了⼀种‘is-a’的关系，如果两个对象A和B，可以描述为‘B是A’，则表明B可以继承A；例如⼈是动物，猫是动物，狗是动物等等......
实际上，继承者还可以理解为是对被继承者的特殊化，因为它除了具备被继承者的特性外，还具备⾃⼰独有的个性。

例如猫块可以爬树，⽽并不是所有动物都会爬树。

这也就说明量对象之间是不能颠倒顺序的。

继承定义了类如何相互联系，共享特性，继承的⼯作⽅式是，定义⽗类和⼦类，或叫做基类和派⽣类，其中⼦类继承⽗类的所有特性，⼦类不仅继承了⽗类的所有特性，还可以定义新的特性。

继承提⾼了代码复⽤性
多态
同⼀操作作⽤于不同的对象，可以有不同的解释，产⽣不同的执⾏结果，这就是多态性
简单来说就是⼀类事物有多种形态，例如动物有多态：猫、狗、⼈...
多态的特点：
1. 多态前提是必须有继承；
2. ⽗类引⽤变量指向⼦类；
3. ⽗类引⽤变量调⽤⽅法时，会调⽤⼦类重写后的⽅法。

简述面向对象的特点
面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序中的数据和操作数据的方法组合成一个对象，以此来描述现实世界中的事物和概念。

面向对象编程具有以下特点：
1. 封装性：封装是指将数据和方法封装在一个对象中，对外部隐藏对象的内部实现细节，只暴露必要的接口。

这样可以保证数据的安全性和一致性，同时也方便了代码的维护和重用。

2. 继承性：继承是指一个类可以继承另一个类的属性和方法，从而减少代码的重复性。

子类可以重写父类的方法，也可以添加自己的方法和属性，从而实现更加灵活的功能。

3. 多态性：多态是指同一个方法可以根据不同的对象调用出不同的行为。

多态可以提高代码的可扩展性和可维护性，同时也可以提高代码的可读性和可理解性。

4. 抽象性：抽象是指将具有相似特征的对象抽象成一个类，从而减少代码的重复性。

抽象类和接口是面向对象编程中的重要概念，它们可以定义一些方法和属性，但是不能被实例化，只能被子类继承或实现。

面向对象编程的特点使得它在软件开发中得到了广泛的应用。

它可以提高代码的可重用性、可扩展性和可维护性，同时也可以提高代码的可读性和可理解性。

面向对象编程可以应用于各种领域，如游
戏开发、Web开发、桌面应用程序开发等。

随着计算机技术的不断发展，面向对象编程也在不断地演化和发展，如面向方面编程（Aspect-Oriented Programming，AOP）、面向服务编程（Service-Oriented Programming，SOP）等。

【⾯向对象设计的3个基本特征】JAVA中⾯向对象的三⼤特征：⾯向对象具有继承性（Inheritance）⾯向对象具有多态性（Polymorphism）⾯向对象具有封装性（Encapsulation）⼀、继承多个类具有共同的属性（成员变量）与⾏为（成员⽅法）的时候，将这些共同的部分抽取出来定义到⼀个公共的类中，其他及各类可以与这个公共的类形成继承关系，从⽽在多个类中不需要重复定义公共部分!这个公共的类就是⽗类，也称为超类或者基类，其他的类就是⼦类。

⼦类可以直接访问⽗类的⾮私有化成员变量，访问⽗类的私有化成员变量可以使⽤super.get()⽅法。

1、 Java继承的特点：A、Java只存在单个继承不存在多个继承，即：⼀个类只能有⼀个⽗类B、Java可以多层继承，多重继承2、Java继承的优点A、继承是基于存在多个重复代码的时候提出的，那么继承能很好的提⾼复⽤率！B、使类与类之间存在继承关系，是实现多态操作的前提！C、继承关键字：extends3、Java继承的缺点继承使得多个类之间具有了⼦⽗类关系，当⼀个类存在多个⼦类的时候，如果⽗类发⽣变化，那么这些⼦类会跟着⼀同变化，造成类与类之间的“强耦合”关系！4、Java继承注意点A、不要仅仅为了获取某个类的某个功能⽽去继承这个类B、类与类之间要存在所属关系，不能够随意继承例：⼈与狗都具有吃饭的动作，狗为了实现吃饭的动作，⽽继承⼈，这是不合适的！所谓的所属关系是is--a的关系，也就是说AAA is BB 的....学⽣是⼈的某⼀个群体，可以同时具有吃饭的动作5、何时使⽤继承A、具有公共的属性与⾏为操作的时候，提⾼复⽤性B、具有is--a的所属关系的类与类之间6、类的主要组成部分的⼦⽗类继承关系中的特点！A、成员变量a、继承关系中同名的⼦类成员变量、局部变量、⽗类的成员变量这三者之间使⽤顺序：在具有相同变量名的这种情况下，不使⽤this、super等关键字进⾏调⽤时，即成员变量前什么都不写,调⽤顺序按照由局部变量位置---当前类成员变量位置---⽗类成员变量位置依次进⾏查找变量，什么位置先有值，就会使⽤这个值！调⽤⽅式：this，superB、成员⽅法a、继承中的成员⽅法使⽤顺序：当⼦类具有与⽗类同名成员⽅法时，进⾏调⽤过程中不使⽤this、super等关键字，即成员⽅法前什么都不写,⽅法的有效顺序：当前类的成员⽅法---⽗类的成员⽅法⼦类中有⽅法实现，则按照⼦类的实现进⾏，若在⼦类中使⽤super调⽤了⽗类的⽅法，那么⽗类⽅法也要执⾏！但是默认成员⽅法内是没有super调⽤的！！！b、重写概念：⼦类中出现与⽗类⼀模⼀样的⽅法时，会出现⼦类⽅法将⽗类⽅法覆盖的情况，这种情况成为重写或者复写c、重写注意事项- ⽗类中的私有⽅法不可以被重写，覆盖！- ⼦类重写⽗类⽅法后，继续使⽤⽗类的⽅法时候，可以使⽤super调⽤- 重写时，⼦类的⽅法的访问权限要⼤于或者等于⽗类成员⽅法的访问权限- 静态⽅法只能被静态⽅法覆盖- ⼦类对于⽗类的功能有增强需求的时候，可以重写⽗类的⽅法以增强其功能！d、重写与重载的区别重写：⼦⽗类之间，⽅法完全相同（返回值、⽅法名、参数列表），但是⼦⽗类之间的⽅法体必须不同，否则没有意义！重载：同⼀个类中，⽅法名相同，参数列表不同，与返回值⽆关！（参数列表：包括两项：参数个数，对应参数的数据类型）重载何时使⽤：当⼀个类中需要完成某个相同功能，但是⽅法的参数不同需要分别进⾏操作时！C、构造⽅法a、⼦类中所有的构造⽅法默认都访问⽗类中⽆参构造b、每个构造⽅法的第⼀⾏是super();super(参数列表);如果把这两⾏代码放在⾮第⼀⾏位置会报错c、根据构造⽅法的特性，在⼿动给出任意⼀个构造⽅法的时候，之前默认的⽆参构造会被覆盖，此时具有继承关系的时候，⼦类之前默认存在的每个构造都调⽤⽆参构造super()失效，此时必须在每个构造⽅中⼿动给出super(参数列表)的⽅式直接或间接调⽤之前⼿动在⽗类中给出的构造！d、构造⽅法执⾏了⼀定会创建相应对象吗？不⼀定，当具有继承关系的类时，⼦类创建对象的时候会调⽤⽗类的构造⽅法，⽤来初始化⽗类的成员变量，这个时候⽗类的构造执⾏了，但是内存中并没有⽗类的对象！e、构造⽅法是否可以被重写或者继承？不可以，因为构造⽅法名需要与类名相同，假如出现继承或者重写关系，就会有⼦类中有⼀个与⽗类的类名相同的构造⽅法，但是⼜由于构造⽅法需要与类名相同，此时⼦类类名需要与构造相同，这个时候就会出现⽗类与⼦类的类名相同，⽗类类名==构造⽅法名==⼦类类名，不能存在同名的类！⼆、多态java程序中定义的引⽤变量所指向的具体类型和通过该引⽤类型发出的⽅法在调⽤时不确定，该引⽤变量发出的⽅法到底调⽤哪个类的实现的⽅法，必须在程序运⾏期间才能决定，这就是多态。

Java面向对象的三大特性Java面向对象的三大特性Java面向对象的三大特性分别为：封装、继承、多态，下面我们一起来详细了解一下!1.封装：说得通俗一点，就是把细节隐藏起来，把该公开的公开，把该私有的私有。

那如何封装一个类?类中含属性和方法，属性可有可无，并且应该设置为private.方法可有可无，对外的方法的应该公开，对内的方法应该私有.一个类的方法，大致有：构造方法 -> 可以生成存/取属性值的方法，也就是 getter/setter 属性方法. -> 可以生成业务方法，实现此类对象的真正业务功能，是程序员真正需要花心思考虑的。

针对类中的方法，有以下两种封装策略:1).把存/取属性方法、构造方法、业务方法全部封装到同个类中。

2).把业务方法单独独立出来，形成一个业务类，这个类用来操作与它所相关的实体对象。

它一般由接口与实现类组成.实体(Entity)对象，就是指含业务属性和属性存/取方法的对象.如：封装策略一:public class Account {private long id;private String name;private double balance;private String pwd;....// getter/setter方法// 构造方法....// 业务方法public void withdraw(double money) {if(balance < money) {System.out.println("余额不足");return ;}balance -= money;}public void deposit(double money) { }}//采用封装策略二：首先是实体类public class Account {private long id;private String name;private double balance;private String pwd;....// getter/setter方法// 构造方法}//再定义一个业务类，操作Accountpublic class AccountService {// 业务方法public void withdraw(Account a,double money) { if(a.getBalance() < money) {System.out.println("余额不足");return ;}a.setBalance(a.getBalance - money);}public void deposit(Account a, double money) { }}注：此处在真实的场景中应该由接口与实现类组成。

面向对象三大特征的理解面向对象(Object-Oriented Programming,OOP)是计算机科学中的重要概念,是一种编程范式,强调将程序看作一系列对象,将程序开发过程中的代码组织成具有层次结构的类和对象,以及使用类和对象之间的交互来实现程序的功能。

OOP 的三大特征如下:1. 封装(封装):将程序中的敏感信息(如数据和方法)隐藏在类的内部,只向外部暴露一些公共接口供其他对象访问和使用。

封装使得类能够更好地保护数据和方法,避免不必要的修改和破坏,同时也使得类更加灵活,可以根据需要随时修改内部状态。

2. 继承(继承):类可以从其他类继承属性和方法,实现类之间的多态性。

继承使得类能够更好地模仿其他类的形态和行为,同时也增加了程序的灵活性和可扩展性。

3. 抽象(抽象):抽象类没有具体的实现,只声明了一些公共的接口,需要使用实例化的对象来调用接口方法。

抽象类可以减少代码的重复和冗余,同时也使得类更加灵活,可以根据需要随时取消抽象。

除了上述三大特征,OOP还有其他一些重要的特征,如多态性、接口、类层次结构、面向对象编程的原则等。

在实际编程中,我们可以根据具体的需求和场景选择合适的编程范式,以更好地组织和管理程序的代码和功能。

除了以上三大特征,面向对象编程还有一些常见的实现方法和技术,如继承、多态、接口、类层次结构、抽象类等。

在实际编程中,我们需要根据具体的需求和场景选择合适的实现方法和技术,以更好地组织和管理程序的代码和功能。

面向对象编程是一种重要的编程范式,具有强大的功能和灵活性。

在实际编程中,我们需要深入理解和掌握面向对象编程的三大特征和常见的实现方法和技术,以更好地组织和管理程序的代码和功能。

⾯向对象编程三⼤特性⾯向对象：以对象为中⼼的编程思想，通过指挥对象实现具体功能。

⾯对过程：以过程为中⼼的编程思想，实现具体功能都是⾃⼰实现。

类和对象的关系：类：类是对现实⽣活类中具有共同属性和⾏为的实物的抽象。

类是对象的数据类型，类是具有相同属性和⾏为的⼀组对象的集合。

类就是对现实事务的⼀种描述。

⽽对象则是以类为模板所创建的。

类的组成*属性：指事物的特征，也就是成员变量。

*⾏为：指事物能执⾏的操作，也就是成员⽅法。

*构造⽅法：⽅法名与类名⼀致，没有返回值类型，没有返回值。

⽤于创建对象，没创建⼀次对象，执⾏⼀次构造⽅法，不能⼿动调⽤构造⽅法。

系统默认为⽆参构造，如果定义了构造⽅法，⽆参构造不存在。

对象创建内存模型（1）当程序开始运⾏，⽅法区以加载好程序所需类的字节码⽂件。

（2）栈内存加载程序，当运⾏到需要创建对象时，会在堆内存中创建对象，此时对象的成员变量为初始值，成员⽅法为地址，指向⽅法区中的类成员⽅法。

（3）堆内存中所创建的对象指向栈内存中引⽤，然后赋值。

可以通过对象引⽤找到堆内存中的成员变量进⾏赋值，使⽤成员⽅法则是通过引⽤找到堆内存中的成员⽅法地址，然后在⽅法区中找到具体的成员⽅法。

成员变量和局部变量的区别：（1）位置不同：成员变量在⽅法外，局部变量在⽅法内部或⽅法声明上（2）内存位置不同：成员变量在堆内存中，局部变量在栈内存中（3）声明周期不同：成员变量随对象的存在⽽存在，局部变量随⽅法的调⽤⽽存在，⽅法调⽤结束就消失（4）初始化值不同：成员变量默认初始化值，局部变量没有默认初始值，必须⾃定义初始化赋值才能使⽤。

⾯向对象三⼤特性之⼀———封装将成员变量隐藏在对象内部，外界⽆法直接操作，通过该类提供的⽅法来实现对隐藏信息的操作和访问，封装通过get、set⽅法的⽅式来控制成员变量的操作，提⾼了代码的安全性和复⽤性。

封装的思想实现类⾼内聚、低耦合this关键字this修饰的变量⽤于代指成员变量，其主要作⽤是区分成员变量和局部变量的重名问题。

⾯向对象三⼤基本特性,五⼤基本原则透切理解⾯向对象三⼤基本特性是理解⾯向对象五⼤基本原则的基础.三⼤特性是：封装,继承,多态所谓封装，也就是把客观事物封装成抽象的类，并且类可以把⾃⼰的数据和⽅法只让可信的类或者对象操作，对不可信的进⾏信息隐藏。

封装是⾯向对象的特征之⼀，是对象和类概念的主要特性。

简单的说，⼀个类就是⼀个封装了数据以及操作这些数据的代码的逻辑实体。

在⼀个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。

通过这种⽅式，对象对内部数据提供了不同级别的保护，以防⽌程序中⽆关的部分意外的改变或错误的使⽤了对象的私有部分。

所谓继承是指可以让某个类型的对象获得另⼀个类型的对象的属性的⽅法。

它⽀持按级分类的概念。

继承是指这样⼀种能⼒：它可以使⽤现有类的所有功能，并在⽆需重新编写原来的类的情况下对这些功能进⾏扩展。

通过继承创建的新类称为“⼦类”或“派⽣类”，被继承的类称为“基类”、“⽗类”或“超类”。

继承的过程，就是从⼀般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

继承概念的实现⽅式有⼆类：实现继承与接⼝继承。

实现继承是指直接使⽤基类的属性和⽅法⽽⽆需额外编码的能⼒；接⼝继承是指仅使⽤属性和⽅法的名称、但是⼦类必须提供实现的能⼒；所谓多态就是指⼀个类实例的相同⽅法在不同情形有不同表现形式。

多态机制使具有不同内部结构的对象可以共享相同的外部接⼝。

这意味着，虽然针对不同对象的具体操作不同，但通过⼀个公共的类，它们（那些操作）可以通过相同的⽅式予以调⽤。

五⼤基本原则单⼀职责原则SRP(Single Responsibility Principle)是指⼀个类的功能要单⼀，不能包罗万象。

如同⼀个⼈⼀样，分配的⼯作不能太多，否则⼀天到晚虽然忙忙碌碌的，但效率却⾼不起来。

开放封闭原则OCP(Open－Close Principle)⼀个模块在扩展性⽅⾯应该是开放的⽽在更改性⽅⾯应该是封闭的。

面向对象方法特点
面向对象方法的特点有以下几点：
1. 封装性：面向对象方法将数据和操作数据的方法封装在一起，通过定义类来创建对象，对象可以调用类中定义的方法来操作数据。

封装性可以隐藏数据的具体实现方式，提高代码的可维护性和重用性。

2. 继承性：面向对象方法支持继承机制，可以通过继承一个已有的类来创建一个新的类，新类可以继承父类的属性和方法，并且可以在此基础上添加新的属性和方法。

继承能够提高代码的重用性，并且可以实现代码的层次化组织。

3. 多态性：面向对象方法支持多态机制，多态指的是同一操作可以作用在不同的对象上，并且可以产生不同的结果。

多态性可以提高代码的灵活性和可扩展性。

4. 抽象性：面向对象方法支持抽象机制，通过定义抽象类和接口来封装和规范对象的行为。

抽象性能够屏蔽实现细节，只关注对象的行为和功能。

5. 可维护性：面向对象方法的封装、继承和多态性等特点可以提高代码的可维护性。

封装性可以减少代码的耦合，继承性和多态性可以使得代码的修改对其他部分的影响最小化，提高代码的可扩展性和可重用性。

面向对象程序设计的基本特点包括封装性、继承性和多态性。

1. 封装性：封装性是指将对象相关的信息和行为状态捆绑成一个单元，即将对象封装为一个具体的类。

封装隐藏了对象的具体实现，当要操作对象时，只需调用其中的方法，而不用管方法的具体实现。

2. 继承性：继承性是指子类可以继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承之间是子父类的关系。

3. 多态性：多态性是指不同的对象对同一事物而做出的相同行为。

多态机制使具有不同内部结构的对象可以共享相同的外部接口。

总之，面向对象程序设计是一种以对象为基础，以事件或消息来驱动对象的执行的设计方法。

它具有封装性、继承性和多态性等特点，这些特点使得面向对象程序设计更加灵活、易于维护和扩展。

除了以上提到的基本特点，面向对象程序设计还具有以下一些特点：4. 抽象性：抽象性是指只展现对象的必要信息，而隐藏不必要的详细信息。

这使得程序员可以更加专注于编写程序的核心逻辑，而不是陷入实现的细节中。

5. 模块化：面向对象程序设计鼓励将代码组织成独立的、可重用的模块。

这有助于提高代码的可维护性和可重用性，同时也方便了团队协作和项目管理。

6. 灵活性：面向对象程序设计提供了强大的类和对象机制，使得程序员可以更加灵活地设计和实现各种复杂的应用程序。

例如，可以通过继承和多态实现代码的重用和扩展，或者通过封装和抽象隐藏实现细节。

7. 可扩展性：面向对象程序设计提供了良好的可扩展性。

当需要添加新的功能或修改现有的功能时，可以通过继承、多态或接口实现代码的扩展，而不需要修改现有的代码。

8. 可靠性：面向对象程序设计鼓励程序员编写高质量的代码，并通过测试和调试确保程序的正确性和可靠性。

此外，面向对象程序设计中的封装和抽象等机制也有助于减少代码的错误和漏洞。

总之，面向对象程序设计是一种非常强大和灵活的编程范式，它提供了许多有用的特性和机制，使得程序员可以更加高效、可靠地编写高质量的程序。

OOP面向对象三大特性五大原则面向对象编程（OOP）是一种常见的编程方法，它基于对象和类的概念，允许开发人员将代码组织成可重用和易于理解的结构。

OOP有三个主要特性，分别是封装、继承和多态。

此外，还有五个重要的原则，即单一责任原则、开放封闭原则、里式替换原则、依赖倒置原则和接口隔离原则。

下面将对这些特性和原则进行深入探讨。

面向对象编程的三大特性：1. 封装（Encapsulation）：封装是将相关数据和方法组合在一个单元（称为类）中的能力，以隐藏内部细节并使其对外部不可见。

通过封装可以确保数据的一致性和有效性，并维护代码的可维护性。

封装还提供了数据的访问控制，通过定义公共和私有成员，可以限制对数据和方法的访问权限。

2. 继承（Inheritance）：继承是一种通过现有类创建新类的方法。

新类（称为子类）可以继承现有类（称为父类）的属性和方法，同时还可以添加新的属性和方法。

通过继承，可以实现代码的重用，避免在不同的类中重复编写相同的代码。

继承还支持代码的灵活性和扩展性，通过添加、修改或删除父类的属性和方法，可以影响到所有的子类。

3. 多态（Polymorphism）：多态是指同一操作对于不同对象可以产生不同的行为。

通过多态，可以统一处理不同类的对象，并根据对象的类型选择正确的行为。

多态提高了代码的灵活性和可扩展性，可以通过替换对象的类型来实现不同的行为效果。

多态常用的实现方式有重写（Override）和重载（Overload）两种。

面向对象编程的五大原则：1. 单一责任原则（Single Responsibility Principle）：一个类应该只有一个引起变化的原因。

这意味着一个类应该只负责完成一个单一的功能或职责。

这样可以降低类的复杂度，增强代码的可读性和可维护性。

2. 开放封闭原则（Open-Closed Principle）：软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。

这意味着通过扩展现有的代码，而不是修改它，来适应新的需求。

⾯向对象的三⼤特性⾯向对象的三⼤特性⽬录⼀、封装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）。

接口是一种规范，规定了类必须实现的一组方法。

它可以实现多态和代码的松耦合。

四、面向对象程序设计的思想和技术。

⾯向对象3⼤特性1.⾯向对象的三⼤特点：封装、继承、多态。

2.字段：存储数据，访问修饰符设置为privae;属性：保护字段。

对字段的取值和赋值进⾏限定。

调⽤构造函数对每个属性赋值的过程称为对象初始化。

new 关键字：1.在堆中开辟内存空间，2.在开辟的内存空间中创建对象、3，调⽤对象的构造函数初始化对象。

字段保护的三种⽅法：1.通过属性中的get；set设置；在构造函数中先判断在给属性赋值来实现保护作⽤。

return的作⽤：1.⽴即结束本⽅法；2.在⽅法中返回要返回的值。

this的作⽤:1.代表当前对象2.在类中显⽰的调⽤构造函数。

继承：继承解决了代码冗余，实现多态，增强了代码的扩展性，便于维护。

继承的特点：1.单根性2.传递性⼦类中并没有继承⽗类的构造函数，⼦类在创建对象时，在⼦类对象中创建了⽗类的对象，故需要调⽤⽗类的构造函数来初始化对象，若⽗类中声明了有参数的构造函数，则⼦类创建对象时，不能创建成功，因为在创建过程中，不能调到⽗类中⽆参数的构造函数；解决办法：1.在⽗类中显⽰的声明⽆参数的构造函数。

2.在⼦类中调⽤⽗类的构造函数，是⽤base（）关键字。

如果⼀个⼦类继承了⼀个⽗类，那么这个⼦类除了可以使⽤⾃⼰的成员外，还可以使⽤从⽗类那⾥继承过来的成员，但是⽗类永远都只能使⽤⾃⼰的成员，⽽不能使⽤⼦类的成员，⼦类之间也不能相互使⽤对⽅的成员。

⾥⽒转换：1.⼦类可以赋值给⽗类2.⽗类中包含⼦类，则⽗类可以强制转换成⼦类。

bool b = A is B .若A能转换成B,则b= true;否则b = false;B b = A as B 若A能转换成B ，则返回B类型，否则转换不成功。

多态：实现多态的三种⽅法：1.虚⽅法如果⽗类知道如何实现，并且⽅法知道如何写。

此时⽤虚⽅法可以实现多态。

2.抽象类如果⽗类不知道如何实现，且⽅法不知道怎么写，则⽤抽象类来实现。

3.接⼝。

面向对象设计的三个基本要素面向对象的三个基本特征是：封装、继承、多态。

1·封装性封装性是一种信息隐蔽技术，他体现于类的说明，是对象重要的特性。

封装使得数据和操作数据的方法封装为一个整体，想成独立性很强的模块，使得用户只能看到对象的外部特性（对象可以接受拿些信息，可以进行何种处理），而对象的内部特性（内部私有属性和实现处理能力的算法）用户是看不到的。

简而言之就是说，封装使对象的设计者与对象的使用者分开，使用者只要知道对象可以做什么就可以了，无需知道具体是怎么实现的。

借助封装有助于提高类和系统的安全性。

2·继承性继承是一种由已有类创建子类的机制，利用继承，可以先创建一个共有属性的一般类，根据这个类再创建具有特殊属性的子类，被继承的类成为父类，当然子类也可以成为父类来继续向下扩展。

3·多态性同一个信息被不同的对象接收到时可能产生不同的行为，这就是多态性。

有继承（接口）有重写，父类引用指向子类对象，就会产生多态。

多态可以改善程序的组织架构，提高程序的可扩展性。

二、面向对象设计的五个基本设计原则面向对象设计的五个基本设计原则是：单一职责原则（SRP）、开放封闭原则（OCP）、Liskov替换原则（LSP）、依赖倒置原则（DIP）、接口隔离原则（ISP）1·单一职责原则（Single-Responsibility Principle）其核心思想为：一个类只做一件事情，只有一个引起他的变化。

单一职责原则可以看做是低耦合，高内聚在面向对象原则上的隐身，将职责定义为引起变化的原因，以提高内举行来减少引起变化的原因。

职责过多可能引起他变化的原因也就越多，这将导致职责依赖，相互之间产生影响，从而大大损伤内聚性和耦合度。

单一职责就是指，只有一种单一的功能，不要为类实现过多的功能点，有些功能可以定义为接口来实现，以保证只有一个引起他变化的原因。

专注是一个人优良的品质。

同样的，单一也是一个类的优良设计，杂交不清的职责将使得代码看起来特别别扭，牵一发动全身，有失没敢和必然导致丑陋的系统错误风险。