面向对象的三大特性(封装-继承-多态)

面向对象是当前计算机界的重点，是当今软件开发方法的主流。

java面向对象具有三大基本特性:封装、继承、多态。

要想掌握面向对象思想，就得深入了解这三大基本特性。

一、封装性所谓封装，就是将对象具有的成员变量和成员函数包装和隐藏起来，让外界无法直接使用，被封装的成员只能通过某些特定的方式才能访问。

实现封装有两个步骤：1、将不能暴露的成员隐藏起来，我们就不能让其在类的外部被直接访问或赋值。

实现方法是将该成员定义为私有的，在成员定义前加上private访问权限修饰符。

2、用公共方法来暴露对该隐藏成员的访问，可以给成员加上public修饰符，将该成员定义为公共的。

具体请看如下实例：class Customer{String name;String sex;private int age;public void setAge(){if(age<0||age>100){System.out.println("age无法赋值")return;}this.age = age;}public int getAge(){return this.age;}}public class Test{public void main(String[] args){Customer zhangsan = new Customer();zhangsan.setAge(25); //使用特殊方法访问Customer类的age成员System.out.println("zhangsan.age="+zhangsan.getAge());}}二、继承性所谓继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。

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

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

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

精心整理《JavaSE》结课笔试注意：1、考试时间120分钟；2、请将答案填写到答题纸上；1、面向对象编程的三大特性是（）2、3、4、C)default D)protected5、以下哪种类成员修饰符可以在不同包的子类中访问（）A)static B)privateC)default D)protected6、Java语言中哪个包是被自动导入的（）A)java.util B)ngC)java.default D)java.io7、以下程序代码中，如何使属性foo可以在方法bar中被直接访问（）classTest{publicfloatfoo;8、9、publicstaticvoidmain(Stringargs[]){Strings1="Helloworld";Strings2="Hello";s2=s2+"world";}}A)true B)falseC)编译错误D)Helloworld10、在Java中，如果父类中的某些方法不包含任何逻辑，并且需要由子类重写，11、12、B)数组的元素可以是基本型、引用型或其它数组C)定义数组的同时必须分配内存空间D)一个数组中的所有值必须是相同类型13、下面关于接口说法不正确的是()A)接口的所有方法都是抽象的B)接口所有的方法一定都是public的C)用于定义接口的关键字是implements D)接口是一组行为的集合14、为了区分类中重载的同名不同方法，要求()A)参数的类型或个数不同B)使用不同的参数名C)修改访问权限D)方法返回值数据类型不同15、如果子类覆盖了父类的一个public方法，则此方法在子类中可以使用什么修16、17、}finally{System.exit(0);//程序中止}}}A)testB)finallyC)testfianlly18、C)ArithmeticExceptionD)ArithmeticException和ArrayIndexOutOfBoundsException19、关于异常，下列描述正确的是（）A)try代码段和其后跟随的catch代码段之间可以有间隔代码B)每个catch代码段声明其能处理的一种特定类型的异常C)finally代码段在异常出现的情况下不被执行D)finally代码段中不可以有try和catch代码段//X20、关于日期时间说法正确的是（）A)类无法表示1970年1月1日00:00:00之前的时间B)要得到日历类的实例，我们唯一的做法是newGregorianCalendar()21、22、23、B)对内容有序的List可以进行二分法查找C)调用indexOf方法查找D)无论是否有序都可以用二分法查找，比线性查找快很多24、如果要按照特定顺序保存元素，应当使用的容器是（）A)HashMap B)ArrayListC)JFrame D)TreeSet25、有一个名为myList的ArrayList实例，取得其最后一个元素的方法是（）A)myList.get(0); B)myList.get(st());C)myList.get(myList.size()); D)myList.get(myList.size()-1);26、有一个名为myList的ArrayList实例，调用mylist.get(0)的结果是()27、28、returna+2;}publicstaticvoidmain(String[]args){Bb=newB();}}A)编译错误B)运行错误C)1 D)229、当编译并运行下面程序时会出现什么结果（）publicclassMyAr{30、31、C)URL和URLConnection D)DNS和HTTPStream32、当编译并运行下面程序时会发生什么结果（）publicclassBgroundextendsThread{ publicstaticvoidmain(Stringargv[]){ Bgroundb=newBground();b.run();//start}publicvoidstart(){for(inti=0;i<10;i++){}}}33、ABC、a9897.098D、a98979834、将对象序列化，要实现哪个接口（）A)Cloneable B)RunnableC)Serializable D)Comparator35、有以下Java程序代码，运行结果是（）publicclassTest{publicstaticStringoutput="";//134publicstaticvoidfoo(inti){try{foo(0);foo(1);}}A)1342 B)123C)134234 D)1342336、在JAVA中，()接口位于集合框架的顶层A)Collection B)CollectionsC)Map D)Set37、启动一个线程，应调用什么方法（）38、39、ABCD40、C.JAVA可以多继承D.JAVA的单一继承避免了菱形继承的危险41、下面哪些接口直接继承自Collection接口（）（多选）A.ListB.MapC.SetD.Iterator42、研究下面的JAVA代码，输出结果将是（）publicclassTestException{publicstaticvoidmain(String[]args){ inta[]={0,1,2,3,4};intsum=0;C.数组下标越界程序结束D.程序结束43、研究下面的JAVA代码，输出结果将是（）publicclassTestException{publicstaticvoidmain(String[]args){try{System.exit(0);}finally{}}44、}A.s:cbathis.s:nbas:cbathis.s:nbaB.s:nbathis.s:nbas:nbathis.s:nbaC.s:cbathis.s:nbas:cbathis.s:cbaD.s:nbathis.s:cbas:cbathis.s:cba45、关于sleep和wait方法，下列说法不正确的是（）（多选）A.sleep必须使用在同步方法中B.使用wait方法后，线程需要被通知唤醒C.wait方法用于线程之间的通讯D.wait是Thread类的方法46、D47、}}A、用来调用类B中定义的super()方法B、用来调用类C中定义的super()方法C、用来调用类B中的无参构造方法D、用来调用类B中第一个出现的构造方法48、关于线程，以下说法正确的是（）(多选)A.sleep方法执行时会释放对象锁。

什么是面向对象编程请解释面向对象编程的三大特征面向对象编程（Object-oriented Programming，简称OOP）是一种计算机编程范式，它的设计思想基于现实世界中对象的概念。

面向对象编程将程序设计看作是一组相互作用的对象之间的消息传递和数据交互，致力于将复杂问题分解为更小、更易于理解和维护的对象，并通过封装、继承和多态等机制来实现程序的模块化和可重用性。

面向对象编程有三大主要特征，分别是封装、继承和多态。

1. 封装（Encapsulation）封装是指将对象的属性（数据）和方法（操作）封装在一起，形成一个独立的单位。

通过隐藏对象的内部细节，只公开必要的接口来操作对象，实现了信息的隐藏和保护，提高了程序的安全性和可维护性。

封装还允许对象内部的数据和实现细节发生变化，而对外部的其他对象保持透明。

这种机制使得多个对象可以并行开发，彼此之间相互独立，减少了代码的耦合性。

2. 继承（Inheritance）继承指的是一个对象（称为子类或派生类）可以从另一个对象（称为父类或基类）继承属性和方法，并可以对其进行扩展。

通过继承，子类可以继承父类的特性，包括数据和行为，而不需要重新编写相同的代码。

继承提供了代码的重用性，可以使得程序的设计更加灵活和可扩展。

同时，继承还建立了类与类之间的层次结构，使得对象之间的关系更加清晰，有助于代码的组织和理解。

3. 多态（Polymorphism）多态是指同一个消息可以被不同类的对象解释为不同的行为。

多态允许使用一个统一的接口来操作不同的对象，从而实现了程序的可扩展性和灵活性。

通过多态，可以在不改变原有代码的情况下，通过定义新的子类并实现特定的方法来满足不同的需求。

多态可以提高代码的可读性和可维护性，使得程序更容易扩展和修改，同时也减少了代码的重复性。

总结：面向对象编程的三大特征，即封装、继承和多态，共同构成了面向对象编程的基础。

封装提供了信息隐藏和保护的机制，继承支持了代码的重用和组织，而多态则提供了灵活性和可扩展性。

C++中的封装、继承、多态理解封装(encapsulation)：就是将抽象得到的数据和⾏为(或功能)相结合，形成⼀个有机的整体，也就是将数据与操作数据的源代码进⾏有机的结合，形成”类”，其中数据和函数都是类的成员。

封装的⽬的是增强安全性和简化编程，使⽤者不必了解具体的实现细节，⽽只是要通过外部接⼝，特定的访问权限来使⽤类的成员。

封装可以隐藏实现细节，使得代码模块化。

继承(inheritance)：C++通过类派⽣机制来⽀持继承。

被继承的类型称为基类或超类，新产⽣的类为派⽣类或⼦类。

保持已有类的特性⽽构造新类的过程称为继承。

在已有类的基础上新增⾃⼰的特性⽽产⽣新类的过程称为派⽣。

继承和派⽣的⽬的是保持已有类的特性并构造新类。

继承的⽬的：实现代码重⽤。

派⽣的⽬的：实现代码扩充。

三种继承⽅式：public、protected、private。

继承时的构造函数：(1)、基类的构造函数不能被继承，派⽣类中需要声明⾃⼰的构造函数；(2)、声明构造函数时，只需要对本类中新增成员进⾏初始化，对继承来的基类成员的初始化，⾃动调⽤基类构造函数完成；(3)、派⽣类的构造函数需要给基类的构造函数传递参数；(4)、单⼀继承时的构造函数：派⽣类名::派⽣类名(基类所需的形参，本类成员所需的形参):基类名(参数表) {本类成员初始化赋值语句；}；(5)、当基类中声明有默认形式的构造函数或未声明构造函数时，派⽣类构造函数可以不向基类构造函数传递参数；(6)、若基类中未声明构造函数，派⽣类中也可以不声明，全采⽤缺省形式构造函数；(7)、当基类声明有带形参的构造函数时，派⽣类也应声明带形参的构造函数，并将参数传递给基类构造函数；(8)、构造函数的调⽤次序：A、调⽤基类构造函数，调⽤顺序按照它们被继承时声明的顺序(从左向右)；B、调⽤成员对象的构造函数，调⽤顺序按照它们在类中的声明的顺序；C、派⽣类的构造函数体中的内容。

继承时的析构函数：(1)、析构函数也不被继承，派⽣类⾃⾏声明；(2)、声明⽅法与⼀般(⽆继承关系时)类的析构函数相同；(3)、不需要显⽰地调⽤基类的析构函数，系统会⾃动隐式调⽤；(4)、析构函数的调⽤次序与构造函数相反。

Lua⾯向对象（实现类的创建和实例化、封装、继承、多态）⽬录1、Lua⾯向对象基础⾯向对象三⼤特性包括：封装、继承、多态。

还有在Lua中如何创建类和实例化，这⾥⼀⼀介绍1.1、Lua类的创建和实例化Test1.lua--name，age就相当于字段。

eat就相当于⽅法person = {name = 'Ffly',age = 20}function person:eat()print( .. '该吃饭饭了，饿死了')end--这个⽅法⽤于实例化使⽤function person:new()local self = {}--使⽤元表，并把__index赋值为person类setmetatable(self,{__index = person})return selfendTest2.lua--加载模块Test1.lua（类似于C#中的using引⽤）--LuaStudio默认从软件根⽬录下加载require "Test1"--实例化person类person1 = person:new()person1:eat() --正常输出1.2、Lua封装--对age字段进⾏封装，使其只能⽤get⽅法访问function newPerson(initAge)local self = {age = initAge};--三个⽅法local addAge = function(num)self.age = self.age + num;endlocal reduceAge = function(num)self.age = self.age - num;endlocal getAge = function(num)return self.age;end--返回时只返回⽅法return {addAge = addAge,reduceAge = reduceAge,getAge = getAge,}endperson1 = newPerson(20)--没有使⽤额外的参数self，⽤的是那⾥⾯的self表--所以要⽤.进⾏访问person1.addAge(10)print(person1.age) --输出nilprint(person1.getAge()) --输出301.3、Lua继承--基类person，boy类继承于personperson = {name = "default",age = 0}function person:eat()print( .. '该吃饭饭了，饿死了')end--使⽤元表的 __index完成继承（当访问不存在的元素时，会调⽤）function person:new(o)--如果o为false或者o为nil，则让o为{}o = o or {}setmetatable(o,self)--设置上⾯self的__index为表personself.__index = selfreturn oend--相当于继承boy = person:new()--name在boy⾥找不到会去person⾥⾯找print() --输出default--修改了person⾥的值，并不会影响boy⾥⾯的值 = 'feifei'print() --输出defaultprint() --输出feifei1.4、Lua多态person = {name = "default",age = 0}--重载--简单⽅法：lua中会⾃动去适应传⼊参数的个数，所以我们可以写在⼀个⽅法⾥⾯function person:eat(food)if food == nil thenprint( .. '该吃饭饭了，饿死了')elseprint( .. '喜欢吃：' .. food)endendfunction person:addAge(num)if num == nil thenself.age = self.age + 1elseself.age = self.age + numendendprint(person:eat())print(person:eat("⼤西⽠"))person:addAge()print(person.age)person:addAge(5)print(person.age)--重写function person:new(o)--如果o为false或者o为nil，则让o为{}o = o or {}setmetatable(o,self)--设置上⾯self的__index为表personself.__index = selfreturn oendboy = person:new() = "Ffly"boy:eat() --调⽤基类eat⽅法--相当于重写eat⽅法function boy:eat()print('⼩男孩' .. .. '快要饿死了')endboy:eat() --调⽤派⽣类eat⽅法2、Lua⾯向对象进阶2.1、class.lua的实现class代码参考于的博客。

简述面向对象程序设计的三大基本特点面向对象程序设计（Object-Oriented Programming，简称OOP）是一种常用的编程范式，它具有三大基本特点：封装、继承和多态。

封装是面向对象程序设计的第一个基本特点。

它指的是将数据和对数据的操作封装在一个类中，通过类的接口来隐藏数据的实现细节。

封装使得数据和操作数据的方法被组织在一个单独的逻辑单元中，提高了代码的可维护性和可重用性。

通过封装，我们可以将数据和相关的操作绑定在一起，形成一个独立的实体，从而实现了数据的保护和安全性。

对外部用户来说，只需要通过类的公共接口来访问数据和操作，不需要关心内部的具体实现细节。

这种封装的特性可以有效地隐藏对象的内部信息，提高了代码的可读性和可理解性。

继承是面向对象程序设计的第二个基本特点。

继承是指一个类（称为子类或派生类）可以继承另一个类（称为父类或基类）的属性和方法。

通过继承，子类可以拥有父类的属性和方法，同时可以在此基础上进行扩展和定制。

继承可以有效地实现代码的重用，避免了重复编写相同的代码。

另外，继承还可以建立类之间的层次关系，使得代码的组织结构更加清晰和直观。

继承的特性使得面向对象程序设计具有了更强的灵活性，可以在不破坏原有代码的基础上进行功能扩展和修改。

多态是面向对象程序设计的第三个基本特点。

多态是指同一个方法在不同的对象上可以有不同的行为。

具体来说，是通过父类的引用指向子类的对象，以实现同一个方法在不同对象上表现出不同的行为。

多态可以提高代码的灵活性和可拓展性，使得程序更加易于扩展和维护。

通过多态，可以处理同一类对象的不同实现方式，提高了代码的可读性和可维护性。

多态还可以实现接口的统一，使得不同的对象可以以相同的方式调用方法。

面向对象程序设计的三大基本特点相互依赖、相互联系，共同构成了面向对象编程的核心思想和基本原则。

封装保护了对象的内部数据和操作，提供了对外的公共接口；继承实现了代码的重用和扩展，建立了类之间的层次关系；多态实现了同一方法在不同对象上的不同行为，提高了代码的灵活性和可拓展性。

简述面向对象技术的三大机制。

面向对象技术（Object-Oriented Technology）是一种常用的编程范式，它基于对象的概念来设计程序和系统。

面向对象技术的三大机制分别是封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。

封装是面向对象技术的基本原则之一，它将数据和操作封装在对象内部，对象对外部的数据和操作进行隐藏，只提供有限的接口供外部访问。

通过封装，对象可以控制对自身数据的访问，确保数据的安全性和完整性。

封装使得对象的实现细节对外部隐藏，提高了系统的可维护性和可扩展性。

同时，封装也使得对象之间的耦合度降低，各对象之间更加独立，提高了系统的灵活性。

继承是面向对象技术的另一个重要特性，它允许一个类（子类）继承另一个类（父类）的属性和方法。

通过继承，子类可以重用父类的代码，减少了重复编码的工作量，提高了代码的复用性和可维护性。

同时，继承也体现了类之间的层次关系，使得程序结构更加清晰和易于理解。

通过继承，可以实现代码的统一管理和扩展，提高了系统的可扩展性和可维护性。

多态是面向对象技术的另一重要机制，它允许不同的对象对同一消息作出不同的响应。

通过多态，可以实现接口的统一，提高了代码的灵活性和可重用性。

多态使得程序可以根据不同的对象类型调用不同的方法，实现了代码的动态绑定，提高了程序的可扩展性和可维护性。

多态是面向对象技术的一个重要特点，它使得程序更加灵活和易于扩展，提高了程序的可读性和可维护性。

封装、继承和多态是面向对象技术的三大机制，它们共同构成了面向对象技术的基本特性。

通过封装，可以保护对象的数据和实现细节；通过继承，可以实现代码的重用和扩展；通过多态，可以实现接口的统一和动态绑定。

这三大机制相互配合，共同构成了面向对象技术的核心思想，为软件开发提供了强大的支持和工具。

面向对象技术已成为现代软件开发的主流范式，它不仅提高了程序的可维护性和可扩展性，还提高了程序的质量和效率，是软件开发领域的一项重要技朧。

【⾯向对象设计的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程序中定义的引⽤变量所指向的具体类型和通过该引⽤类型发出的⽅法在调⽤时不确定，该引⽤变量发出的⽅法到底调⽤哪个类的实现的⽅法，必须在程序运⾏期间才能决定，这就是多态。

1-2-java语⾔的特点及运⾏机制
1、java语⾔的特点
特点⼀：⾯向对象
两个基本概念：类、对象
三⼤特性：封装、继承、多态
特点⼆：健壮性
吸收了C/C++语⾔的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与
释放等），提供了⼀个相对安全的内存管理和访问机制
特点三：跨平台性
跨平台性：通过Java语⾔编写的应⽤程序在不同的系统平台上都可以运⾏。

原理：只要在需要运⾏ java 应⽤程序的操作系统上，先安装⼀个Java虚拟机 (JVM Java
Virtual Machine) 即可。

由JVM来负责Java程序在该系统中的运⾏。

2、java核⼼机制
（1）java虚拟机(JVM)
JVM 是⼀个虚拟的计算机，具有指令集并使⽤不同的存储区域。

负责执⾏指令，管理数据、内存、寄存器。

实现⼀次编译，到处运⾏。

（2）垃圾回收机制
java提供⼀种系统级线程跟踪存储空间的分配情况，并在JVM空闲时，检查并释放那些可被释放的存储空间。

垃圾回收在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) { }}注：此处在真实的场景中应该由接口与实现类组成。