系列文章目录

Java面试题·解释题·JavaSE
Java面试题·解释题·框架
Java面试题·解释题·单例模式、工厂模式、代理模式

---

---

前言

本文介绍JavaSE阶段的解释题。
什么是解释题呢？
就是“请你介绍一下面向对象编程？”这种问题。

---

面向对象编程是什么？

面向对象编程（Object-Oriented Programming，简称OOP）是一种软件开发的编程范式，它将程序的设计和实现组成一组相互关联的对象，通过对象之间的交互来完成任务。
面向对象编程具有以下特征：
封装（Encapsulation）： 将数据（属性）和操作（方法）封装在一个类中，隐藏内部实现细节，只对外提供公共接口。通过封装，可以实现数据的安全性和代码的模块化。
继承（Inheritance）： 通过继承机制，子类可以继承父类的属性和方法，从而实现代码的重用和扩展。继承可以建立类与类之间的层次关系，提高代码的可维护性和可扩展性。
多态（Polymorphism）： 多态允许不同的对象对同一消息作出不同的响应。通过多态，可以编写通用的代码，处理不同类型的对象，提高代码的灵活性和可扩展性。
面向对象编程的优点包括：
可维护性： 封装和继承机制使得代码更加易于维护和修改。修改一个对象的实现不会对其他对象产生影响，通过继承可以重用代码，减少冗余。
可扩展性： 通过继承和多态，可以很方便地扩展现有的代码功能，添加新的类和方法，不影响原有的代码。
代码复用： 通过继承和组合，可以重用已有的代码，减少开发时间和代码量。
可读性： 使用面向对象的设计方法，可以更好地组织和结构化代码，使得代码更易读、易理解和易于维护。

Java的跨平台原理

Java具有一次编译，跨平台运行 的特点。就是说编译后形成的字节码文件可以跨平台运行，只要该平台具有相应的Java虚拟机。
Java虚拟机是可运行Java字节码文件的虚拟计算机。不同平台的虚拟机是不同的，但它们都提供了相同的接口。
字节码文件不面向任何具体平台，只面向虚拟机。 虚拟机先将字节码文件解释成机器码，在交给操作系统运行，从而实现了跨平台。

Java的安全性

语言层次的安全性体现在：
1、Java取消了强大但又危险的指针，而代之以引用：由于指针可进行移动运算，指针可随便指向一个内存区域，而不管这个区域是否可用，这样做是危险的，因为原来这个内存地址可能存储着重要数据或者是其他程序运行所占用的，并且使用指针也容易数组越界。
2)垃圾回收机制：不需要程序员直接控制内存回收，由垃圾回收器在后台自动回收不再使用的内存。避免程序忘记及时回收，导致内存泄露；或程序错误回收程序核心类库的内存，导致系统崩溃。
3)异常处理机制：Java异常机制主要依赖于try、catch、finally、throw、throws五个关键字。
4)强制类型转换（instanceOf）：只有在满足强制转换规则的情况下才能强转成功。
底层的安全性可以从以下方面来说明
Java在字节码的传输过程中使用了公开密钥加密机制(PKC)。
在运行环境提供了四级安全性保障机制：
字节码校验器–>类装载器–>运行时内存布局–>文件访问限制

Java的三大版本

Java2平台包括标准版（J2SE）、企业版（J2EE）和微缩版（J2ME）三个版本：
1、Standard Edition(标准版) J2SE 包含那些构成Java语言核心的类。
比如：数据库连接、接口定义、输入/输出、网络编程
2、Enterprise Edition(企业版) J2EE 包含J2SE 中的类，并且还包含用于开发企业级应用的类。
比如：EJB、servlet、JSP、XML、事务控制
3、Micro Edition(微缩版) J2ME 包含J2SE中一部分类，用于消费类电子产品的软件开发。
比如：呼机、智能卡、手机、PDA、机顶盒
4、他们的范围是：J2SE包含于J2EE中，J2ME包含了J2SE的核心类，但新添加了一些专有类
应用场合，API的覆盖范围各不相同。

Java开发运行过程

编写，编译，运行
1、可以用任何文本编辑器创建并编辑Java源程序，Java源程序用.java作为文件扩展名
2、编译Java源程序编译器，使用命令javac来编译java源程序文件名.java。最后编译成Java虚拟机能够明白的指令集合，且以字节码的形式保存在文件中。通常，字节码文件以.class作为扩展名。
3、执行java程序，使用“java”命令运行.class（字节码）文件java文件名，Java解释器会读取字节码，取出指令并且翻译成计算机能执行的机器码，完成运行过程。

什么是JVM？

JVM ：JVM是Java Virtual Machine（Java虚拟机）的缩写，它是整个java实现跨平台的最核心的部分，所有的java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行，也就是说class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行。
JVM是Java平台的基础，和实际的机器一样，它有自己的指令集，并且在运行时操作不同的内存区域。 JVM通过抽象操作系统和CPU结构，提供了一种与平台无关的代码执行方法，即与特殊的实现方法、主机硬件、主机操作系统无关。
JVM的主要工作是解释自己的指令集（即字节码）到CPU的指令集或对应的系统调用，保护用户免被恶意程序骚扰。 JVM对上层的Java源文件是不关心的，它关注的只是由源文件生成的类文件（.class文件）。

什么是JDK？

JDK是java development kit（java开发工具包）的缩写。每个学java的人都会先在机器上装一个JDK，那让我们看一下JDK的安装目录。在目录下面有六个文件夹、一个src类库源码压缩包、和其他几个声明文件。

什么是JRE？

JRE：JRE是java runtime environment（java运行环境）的缩写。光有JVM还不能让class文件执行，因为在解释class的时候JVM需要调用解释所需要的类库lib。
在JDK的安装目录里你可以找到jre目录，里面有两个文件夹bin和lib,在这里可以认为bin里的就是jvm，lib中则是jvm工作所需要的类库，而jvm和lib和起来就称为jre。
所以，在你写完java程序编译成.class之后，你可以把这个.class文件和jre一起打包发给朋友，这样你的朋友就可以运行你写程序了（jre里有运行.class的java.exe）。
JRE是Sun公司发布的一个更大的系统，它里面就有一个JVM。我们编写的Java程序也必须要JRE才能运行。

JDK,JRE,JVM三者关系概括

jdk是JAVA程序开发时用的开发工具包，其内部也有JRE运行环境。JRE是JAVA程序运行时需要的运行环境，就是说如果你光是运行JAVA程序而不是去搞开发的话，只安装JRE就能运行JAVA程序。JDK、JRE内部都包含JAVA虚拟机JVM，JAVA虚拟机内部包含许多应用程序的类的解释器和类加载器等等。

Java的数据类型？

1.整数类型： byte(1个字节)、short(2个字节)、int(4个字节)、long(8个字节)
2.浮点型： float(4个字节)、double(8个字节)
3.字符型： char(2个字节)
4.布尔型： boolean(1位)

Java中的四大存储区域是

方法区： 被称为元空间（Java 8及以后的版本）或永久代（Java 7及以前的版本），用于存储类的结构信息、静态变量、常量等。方法区在程序运行期间是不会被销毁的。
堆区： 用于存储对象实例和数组。在堆区分配的对象和数组由垃圾收集器负责回收。堆区是Java中最大的内存区域，也是唯一一个被所有线程共享的内存区域。字符串常量池在堆区中。
栈区： 用于存储方法的局部变量、方法参数、返回值等。每个方法在执行时都会创建一个栈帧，栈帧包含了方法的局部变量表、操作数栈、返回地址等。栈区中的数据随着方法的执行结束而自动销毁。
程序计数器： 用于记录当前线程执行的字节码指令的地址。每个线程都有自己的程序计数器，用于线程切换后能够恢复到正确的执行位置。

基本数据类型的类型转换规则

基本类型转换分为自动转换和强制转换。
自动转换规则： 容量小的数据类型可以自动转换成容量大的数据类型，也可以说低级自动向高级转换。这儿的容量指的是指类型表述的范围，而不是字节数。
强制转换规则： 容量大的变为容量小的需要强制转换。转换规则：（char、byte、short）<int<long<float<double（boolean不参与类型转换）
如何转换：
=右边的转换，先自动转换成表达式中级别最高的数据类型，再进行运算。
=两侧的转换，若左边级别>右边级别，会自动转换；若左边级别 == 右边级别，不用转换；若左边级别 < 右边级别，需强制转换。
以将整型常量直接赋值给byte, short, char等类型变量，而不需要进行强制类型转换，前提是不超出其表述范围，否则必须进行强制转换。

Java的三种流程控制结构

顺序结构： 从上到下，从左到右，逐行执行。
选择结构： if选择结构、switch选择结构
循环结构： do…while、while、for、增强for

break和continue的作用

break：结束当前循环并退出当前循环体或退出switch语句
continue：循环体中后续的语句不执行，但是循环没有结束，继续进行循环条件的判断（for循环还会执行改变条件）。continue只是结束循环中的。
可以通过标签给外层循环命名，来结束外层循环

递归的定义和优缺点

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。
递归算法解决问题的特点：
1、递归就是在过程或函数里调用自身。
2、在使用递归策略时，方法体中必须有一个明确的递归结束条件，称为递归出口。
3、递归算法解题通常显得很简洁，但运行效率较低。所以一般不提倡用递归算法设计程序。
4、在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出、执行效率低等。所以一般不提倡用递归算法设计程序。

数组的特性

1、数组是相同类型数据的有序
2、数组会在内存中开辟一块连续的空间，每个空间相当于一个变量，称为数组的元素element
3、元素的获取：数组名[下标]
4、下标从0开始，到数组长度-1
5、每个数组元素有默认值：浮点数0.0，布尔值false，整数型0
6、数组元素有序的，不是大小顺序，是索引的顺序
7、数组中可以存储基本数据类型，可以存储引用数据类型；但是对于一个数组而言，数组的类型是固定的
8、length：数组的长度
9、数组的长度是固定的，一经定义，不能再发生变化（可以定义一个新的更长的数组来存储原来的数据）
10、数组长度通过length属性获得，但是无法获得数组中真实的元素个数。

介绍冒泡排序

冒泡排序：用来对一组数字进行从小到大，或从大到小的有序排列。
冒泡排序使用双层循环嵌套的方式，
外层循环：控制数字比较的轮数，轮数为参数排序的数字个数 - 1；
内层循环：控制每轮数字比较的次数，次数为参与排序数字个数 - 1 - 轮数。每次进行顺序改变需要中间变量。
经过以上循环比较，每轮过后都会得到一个该轮中的最大数放在数组末尾。
所有循环结束后，就会得到从小到大依次排开的一组数字。这就是冒泡排序。
【但是冒泡排序排序的效率比较低，快速排序】

可变参数的作用和特点

1、可变参数的形式一般为Object… obj
2、可变参数只能是方法的形参
3、可变参数对应的实参可以0,1,2…个，也可以是一个数组
4、在可变参数的方法体中，将可变参数当做数组来处理
5、可变参数最多有一个，只能是最后一个
6、可变参数好处：方便、简单、减少重载方法的数量
7、如果定义了可变参数的方法，不允许同时定义相同类型数组参数的方法

类和对象的关系

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的模板，它是一个定义了包括在特定类型的对象应该具备的方法和属性的软件模板。

多态的技能点（前提条件，向上转型、向下转型）

多态的作用：使Java代码具有扩展性，可维护性
实现多态的三个条件
1、继承的存在；（继承是多态的基础，没有继承就没有多态）
2、子类重写父类的方法；（多态下会调用子类重写后的方法）
3、父类引用变量指向子类对象；（涉及子类到父类的类型转换）
向上转型 Student person = new Student()
1、将一个父类/接口的引用指向一个子类对象，成为向上转型，自动进行类型转换。
两种形态：
父类作参数： 代码的扩展性能达到极致
父类做返回值： 提高了扩展性，但还没有达到最好，需要创建多种不同的子类对象（if里）【简单工厂设计模式】
2、此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，而不是父类的方法
3、向上转型后，代码具有扩展性，此时通过父类引用变量无法调用子类特有的方法（如果想要调用子类特有的方法，可以使用instanceof运算符）
向下转型 Student stu = (Student)person
1、将一个指向子类对象的引用赋给一个子类的引用，成为向下转型，此时必须进行强制类型转换。
2、向下转型必须转换为父类引用指向的真实子类类型，，否则将出现ClassCastException，不是任意的强制转换
3、向下转型时可以结合使用instanceof运算符进行强制类型转换，比如出现转换异常。

this和super关键字的作用

this是对象内部指代自身的引用
1、this可以调用成员变量，通常用于解决成员变量和局部变量同名冲突
2、this可以调用成员方法
3、this可以在构造方法中调用重载的构造方法，且必须是构造方法的第一条语句，不能和super同时出现在同一个构造方法里。
super代表对当前对象的直接父类对象的引用
1、super可以调用直接父类的成员变量（注意权限修饰符的影响，比如不能访问private成员）
2、super可以调用直接父类的成员方法（注意权限修饰符的影响，比如不能访问private成员）
3、super可以调用直接父类的构造方法，只限构造方法中使用，且必须是第一条语句，不能和this同时出现在同一个构造方法里
4、super直接从父类开始找，不找本类下的

static关键字的作用（修饰变量、方法、代码块）

static可以修饰变量、方法、代码块和内部类
1、static修饰的属性属于这个类所有，即由该类创建的所有对象共享同一个static属性。可以对象创建后通过对象名.属性名和类名.属性名两种方式来访问。也可以在没有创建任何对象之前通过类名.属性名的方式来访问。
2、static变量和非static变量的区别(都是成员变量，不是局部变量)
3、在内存中份数不同
不管有多少个对象，static变量只有1份。对于每个对象，实例变量都会有单独的一份
static变量是属于整个类的，也称为类变量。而非静态变量是属于对象的，也称为实例变量
4、在内存中存放的位置不同
静态变量存在方法区中，实例变量存在堆内存中
5、访问的方式不同
实例变量： 对象名.变量名 stu1.name=“小明明”;
静态变量：对象名.变量名 stu1.schoolName=“西二旗小学”; 不推荐如此使用
类名.变量名 Student.schoolName=“东三旗小学”; 推荐使用
6、在内存中分配空间的时间不同
实例变量：创建对象的时候才分配了空间。静态变量：第一次使用类的时候
Student.schoolName=“东三旗小学”;或者Student stu1 = new Student(“小明”,“男”,20,98);
7、static方法也可以通过对象名.方法名和类名.方法名两种方式来访问
8、static代码块。当类被第一次使用时（可能是调用static属性和方法，或者创建其对象）执行静态代码块，且只被执行一次，主要作用是实现static属性的初始化。
9、static内部类：属于整个外部类，而不是属于外部类的每个对象。不能访问外部类的非静态成员（变量或者方法），.可以访问外部类的静态成员
10、static 修饰的资源，会在程序第一次访问类名的时候，就加载到内存里；并且只加载一份存储在特定区域里

final和abstract关键字的作用

final和abstract是功能相反的两个关键字，可以对比记忆
1、abstract可以用来修饰类和方法，不能用来修饰属性和构造方法；使用abstract修饰的类是抽象类，需要被继承，使用abstract修饰的方法是抽象方法，需要子类被重写。
2、final可以用来修饰类、方法和属性，不能修饰构造方法。使用final修饰的类不能被继承，使用final修饰的方法不能被重写，使用final修饰的变量的值不能被修改，所以就成了常量。
特别注意：final修饰基本类型变量，其值不能改变。但是final修饰引用类型变量，栈内存中的引用不能改变，但是所指向的堆内存中的对象的属性值仍旧可以改变

继承条件下构造方法的执行过程

继承条件下构造方法的调用规则如下：
如果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this显式调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，写不写“super();”语句，效果是一样的。
如果子类的构造方法中通过super显式调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法。
如果子类的构造方法中通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则。
特别注意的是，如果存在多级继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。
1、在子类构造器中，第一行是调用父类构造，所以会先执行父类构造，后执行子类构造。如果没写，程序会默认调用无参构造
2、如果父类也存在继承，那么继续找到更高级别的父类，直到Object类。
3、子类构造器中对父类构造器的调用有两种方式：使用super 进行父类的有参，无参显式调用
4、程序自动帮忙调用父类public 的无参构造。

简述Java的垃圾回收机制

1、Java语言不需要程序员直接控制内存回收，是由JRE在后台自动回收不再使用的内存，称为垃圾回收机制。目的在于去除程序中不再使用的对象对应的内存空间，当对象建立的时候，垃圾收集器就开始监控对象的动态情况，开始监控该对象的一切活动，在JVM的空闲时，检査并释放可被释放的存储器空间。
2、Java消除了程序员回收无用内存空间的职责，提供一种系统级线程跟踪存储空间的分配情况。相比c++,开发人员负责要自己收回无用内存。
3、垃圾收集在Java程序运行过程中自动进行，程序员无法精确控制和干预。
4、GC的自动回收，提高了内存空间的利用效率，也提高了编程人员的效率，很大程度上减少了因为没有释放空间而导致的内存泄露，和错误回收导致的系统崩溃

Java异常处理try-catch-finally的执行过程

try-catch-finally程序块的执行流程以及执行结果比较复杂。基本执行过程如下：
程序首先执行可能发生异常的try语句块。如果try语句没有出现异常则执行完后跳至finally语句块执行；如果try语句出现异常，则中断执行并根据发生的异常类型跳至相应的catch语句块执行处理catch语句块执行完后程序会继续执行finally语句块。
catch语句块可以有多个，捕获不同类型的异常。finally语句是可选的，如果有的话，则不管是否发生异常，finally语句都会被执行。
需要注意的是即使try和catch块中存在return语句，finally语句也会执行。是将return分为传输返回值和结束本方法：return传输返回值后，执行finally语句后，return结束本方法。

String s = new String(“xyz”);创建几个String Object?

两个，”xyz”对应一个对象，这个对象放在字符串常量池，常量”xyz”不管出现多少遍，都是常量池中的那一个。New String每写一遍，就创建一个新的对象，它依据那个常量”xyz”对象的内容来创建出一个新String对象。
如果以前就用过’xyz’，这句代表就不会在常量池创建”xyz”了，直接拿。

String s=“Hello”;s=s+“world!”;执行后，s内容是否改变？

（javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。）
原本的地址的值不会改变，引用指向的新的地址的值是变了的。原因是String类型是不可变的，每次改变他的值都会使他指向新的值。

String类为什么是final的

1、为了效率。若被允许继承，则其高度的使用率会降低程序的性能。
2、为了安全。JDK中提供的好多核心类比如String，这类的类的内部好多方法的实现都不是java编程语言本身编写的，好多方法都是调用的操作系统本地的API，这就是著名的“本地方法调用”，也只有这样才能做事，这种类是非常底层的，和操作系统交流频繁的，那么如果这种类可以被继承的话，如果我们再把它的方法重写了，会对操作系统产生攻击。
3、不希望别人改，这个类就像一个工具一样，类的提供者给我们提供了，就希望我们直接用就完了，不想让我们随便能改，其实说白了还是安全性，如果随便能改了，那么java编写的程序肯定就很不稳定，

八个基本数据类型的包装类

基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

为什么为基本数据类型引入包装类

基本数据类型有方便之处，简单、高效。
但是Java中的基本数据类型却是不面向对象的（没有属性、方法），这在实际使用时存在很多的不便（比如集合的元素只能是Object）。
为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行包装，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。
自动装箱和自动拆箱
JDK1.5提供了自动装箱（autoboxing）和自动拆箱（autounboxing）功能，从而实现了包装类和基本数据类型之间的自动转换

Java集合体系结构（List、Set、Collection、Map的区别和联系）

Collection 接口存储一组不唯一，无序的对象
List 接口存储一组不唯一，有序（输入顺序）的对象
Set 接口存储一组唯一，无序的对象
Map接口存储一组键值对，提供key到value的映射。Key无序，唯一。value不要求有序，允许重复。（如果只使用key存储，而不使用value，那就是Set）

HashSet的使用和原理（hashCode()和equals()）

1、向哈希表中添加数据的原理：当向集合Set中增加对象时，首先集合计算要增加对象的hashCode码，根据该值来得到一个位置用来存放当前对象，如在该位置没有一个对象存在的话，那么集合Set认为该对象在集合中不存在，直接增加进去。如果在该位置有一个对象存在的话，接着将准备增加到集合中的对象与该位置上的对象进行equals方法比较，如果该equals方法返回false,那么集合认为集合中不存在该对象，在进行一次散列，将该对象放到散列后计算出的新地址里。如果equals方法返回true，那么集合认为集合中已经存在该对象了，不会再将该对象增加到集合中了。
2、在哈希表中判断两个元素是否重复要使用到hashCode()和equals()。hashCode决定数据在表中的存储位置，而equals判断是否存在相同数据。

TreeSet的原理和使用（Comparable和comparator）

1、TreeSet中的元素不允许重复，但是有序
2、TreeSet采用树结构存储数据，存入元素时需要和树中元素进行对比，需要指定比较策略。可以通过Comparable内部和Comparator外部来指定比较策略。
3、实现了Comparable的系统类可以顺利存入TreeSet。自定义类可以实现Comparable接口来指定比较策略。
4、可创建Comparator接口实现类来指定比较策略，并通过TreeSet构造方法参数传入。这种方式尤其对系统类非常适用。

说明缓冲流的优点和原理

不带缓冲的流的工作原理：它读取到一个字节/字符，就向用户指定的路径写出去，读一个写一个，所以就慢了。带缓冲的流的工作原理：读取到一个字节/字符，先不输出，等凑足了缓冲的最大容量后一次性写出去，从而提高了工作效率
优点：减少对硬盘的读取次数，降低对硬盘的损耗。

创建线程的三种方式分别是什么,优缺点是什么？

第一种：继承Thread父类
线程类：只有线程类能开辟新的线程
main方法所在的线程为主线程
第二种：实现Runnable接口
启动线程对象效率低，没有占用父类位置，共享资源的能力强，不用加静态
第三种：实现Callable接口
run方法返回值为void，不能抛出异常，Callable接口能解决

线程的生命周期

1、使用线程构造器>创建线程对象>新生状态
2、创建线程对象.start()>进入就绪状态>有资格没资源
3、线程对象.run()>进入运行状态>有资格有资源
4、分三种情况
——情况1、时间片段内执行完，死亡状态
——情况2、时间片段内没执行完，重返就绪状态
——情况3、时间片段内出现突发事件，阻塞状态，突发事件处理完返回就绪状态

如何实现线程同步？

当多个线程访问同一个数据时，容易出现线程安全问题，需要让线程同步，保证数据安全，确保资源在某一时刻只被一个线程使用。
线程同步的实现方案：同步代码块和同步方法，均需要使用synchronized关键字
1、同步代码块：public void makeWithdrawal(int amt) {
synchronized (acct) { }
}
2、同步方法：public synchronized void makeWithdrawal(int amt) { }
3、lock锁：
线程同步的好处：解决了线程安全问题
线程同步的缺点：性能下降，可能会带来死锁

序列化的定义、实现和注意事项

想把一个对象写在硬盘上或者网络上，对其进行序列化，把他序列化成为一个字节流。
实现和注意事项：
1)实现接口Serializable：Serializable接口中没有任何方法，实现该接口的类不需要实现额外的方法。
2)如果对象中的某个属性是对象类型，必须也实现Serializable接口才可以
3)序列化对静态变量无效
4)如果不希望某个属性参与序列化，不是将其static，而是transient
5)串行化保存的只是变量的值，对于变量的任何修饰符，都不能保存
6)序列化版本不兼容
7）一般都会为序列化的类，添加序列化id，目的：保证序列化前后的对象，版本一致。

Class类的作用？生成Class对象的方法有哪些？

Class类是Java 反射机制的起源和入口，用于获取与类相关的各种信息，提供了获取类信息的相关方法。Class类继承自Object类
Class类是所有类的共同的设计图纸。每个类也可看做是一个对象，有共同的图纸Class，存放类的结构信息。能够通过相应方法取出相应信息：类的名字、属性、方法、构造方法、父类和接口

反射的使用场合和作用、及其优缺点

1、反射的使用场合和作用
使用场合：在编译时根本无法知道该对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息。
主要作用：通过反射可以使程序代码访问装载到JVM 中的类的内部信息
（1）获取已装载类的属性信息
（2）获取已装载类的方法
（3）获取已装载类的构造方法信息
2、反射的优点
反射提高了Java程序的灵活性和扩展性，降低耦合性，提高自适应能力。它允许程序创建和控制任何类的对象，无需提前硬编码目标类；
Java反射技术应用领域很广，如软件测试、EJB、JavaBean等；许多流行的开源框架例如Struts、Hibernate、Spring在实现过程中都采用了该技术
3、反射的缺点
性能问题：使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此Java反射机制主要应用在对灵活性和扩展性要求很高的系统框架上,普通程序不建议使用。
使用反射会模糊程序内部逻辑：程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂。

---

总结

以上是JavaSE的解释题，感谢各位客官收看。