Java基础面试题总结

1、 面向对象和面向过程的区别

• 面向过程 ：面向过程性能比面向对象高。 因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发。但是，面向过程没有面向对象易维护、易复用、易扩展。
• 面向对象 ：面向对象易维护、易复用、易扩展。 因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，面向对象性能比面向过程低。

2、Java 语言有哪些特点?

1. 简单易学；
2. 面向对象（封装，继承，多态）；
3. 平台无关性（ Java 虚拟机实现平台无关性）；
4. 可靠性；
5. 安全性；
6. 支持多线程（ C++ 语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而 Java 语言却提供了多线程支持）；
7. 支持网络编程并且很方便（ Java 语言诞生本身就是为简化网络编程设计的，因此 Java 语言不仅支持网络编程而且很方便）；
8. 编译与解释并存；

3、JVM、JDK 、JRE

JVM：Java虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。

什么是字节码?采用字节码的好处是什么?

　　在 Java 中，JVM可以理解的代码就叫做字节码（即扩展名为 .class 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效，而且，由于字节码并不针对一种特定的机器，因此，Java程序无须重新编译便可在多种不同操作系统的计算机上运行。

Java 程序从源代码到运行一般有下面3步：

　　

　　我们需要格外注意的是 .class->机器码 这一步。在这一步 JVM 类加载器首先加载字节码文件，然后通过解释器逐行解释执行，这种方式的执行速度会相对比较慢。而且，有些方法和代码块是经常需要被调用的(也就是所谓的热点代码)，所以后面引进了 JIT 编译器，而JIT 属于运行时编译。当 JIT 编译器完成第一次编译后，其会将字节码对应的机器码保存下来，下次可以直接使用。而我们知道，机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语言。

 JDK：（Java Development Kit）Java开发工具包，它拥有JRE所拥有的一切，还有编译器（javac）和工具（如javadoc和jdb）。它能够创建和编译程序。

JRE：（Java Runtime Environment）Java运行时环境，它是运行已编译 Java 程序所需的所有内容的集合，包括 Java虚拟机（JVM），Java类库，java命令和其他的一些基础构件。但是，它不能用于创建新程序。

4、Java和C++的区别?

• 都是面向对象的语言，都支持封装、继承和多态。
• Java 不提供指针来直接访问内存，程序内存更加安全。
• Java 的类是单继承的，C++ 支持多重继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
• Java 有自动内存管理机制，不需要程序员手动释放无用内存。

5、字符型常量和字符串常量的区别?

1. 形式上：字符常量是单引号引起的一个字符；字符串常量是双引号引起的若干个字符。
2. 含义上：字符常量相当于一个整型值( ASCII 值)，可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)。
3. 占内存大小 ：字符常量只占2个字节；字符串常量占若干个字节(至少一个字符结束标志)。 (注意： char在Java中占两个字节)

 一个字节（Byte）占8位（8bit）

5、8大基本数据类型及其字节数？

byte：1字节　　　　short：2字节

int：4字节　　　　long：8字节

float：4字节精确到7位有效数字　　　　double：8字节

char：2字节　　　　boolean：1位

引用类型：4字节 ，1个字节表示8位

 6、构造器 Constructor 是否可被 override?

　　 父类的私有属性和构造方法并不能被继承，所以 Constructor 也就不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。

 7、重载和重写的区别？

• 重载： 发生在同一个类中，方法名必须相同，实质表现就是多个具有不同的参数个数或者类型的同名函数（返回值类型可随意，不能以返回类型作为重载函数的区分标准），返回值类型、访问修饰符可以不同，发生在编译时。 　　
• 重写： 发生在父子类中，方法名、参数列表必须相同，是父类与子类之间的多态性，实质是对父类的函数进行重新定义。返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。

 问：Java 构造方法能否被重写和重载？

　　重写是子类方法重写父类的方法，重写的方法名不变，而类的构造方法名必须与类名一致，假设父类的构造方法如果能够被子类重写则子类类名必须与父类类名一致才行，所以 Java 的构造方法是不能被重写的。而重载是针对同一个的，所以构造方法可以被重载。

 8、Java 面向对象编程三大特性？

　　封装 继承 多态

 封装：

　　封装就是把抽象的数据和对数据进行的操作封装在一起，数据被保存在内部，程序的其他部分只有通过被授权的操作（成员方法）才能对数据进行操作。

　　java提供了四种控制修饰符控制方法和变量访问的权限：

• public：对外公开
• protected：对子类和同一包中的类公开
• 没有修饰符号：向同一个包的类公开
• private：只有类本身可以访问，不对外公开

 继承：（extends ）

　　继承是使用已存在的类的定义作为基础建立新类的技术。继承可以解决代码复用问题，当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extend语句来声明继承父类。

关于继承如下 3 点请记住：

• 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。
• 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。

多态：

所谓多态，就是指一个引用（类型）在不同情况下的多种状态，你也可以这样理解：父类型的引用指向子类型的对象。

多态有两个好处：

1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承 
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用，

9、String、StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?（重要）

一、区别

1、String是字符串常量，而StringBuffer和StringBuilder是字符串变量。由String创建的字符内容是不可改变的，而由StringBuffer和StringBuidler创建的字符内容是可以改变的。

2、StringBuffer是线程安全的，而StringBuilder是非线程安全的。StringBuilder是从JDK 5开始，为StringBuffer类补充的一个单线程的等价类。我们在使用时应优先考虑使用StringBuilder，因为它支持StringBuffer的所有操作，但是因为它不执行同步，不会有线程安全带来额外的系统消耗，所以速度更快。

二、String为什么是不可变的？

String 类中使用 final 关键字修饰字符数组来保存字符串，private　final　char　value[]，所以 String 对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串char[]value 但是没有用 final 关键字修饰，所以这两种对象都是可变的。

　　String是被声明为final class，除了hash这个属性其它属性都声明为final。因为它的不可变性，所以例如拼接字符串时候会产生很多无用的中间对象，如果频繁的进行这样的操作对性能有所影响。

　　StringBuffer就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类，提供append和add方法，可以将字符串添加到已有序列的末尾或指定位置，它的本质是一个线程安全的可修改的字符序列，把所有修改数据的方法都加上了synchronized。但是保证了线程安全是需要性能的代价的。

　　在很多情况下我们的字符串拼接操作不需要线程安全，这时候StringBuilder登场了，StringBuilder是JDK1.5发布的，它和StringBuffer本质上没什么区别，就是去掉了保证线程安全的那部分，减少了开销。

　　StringBuffer 和 StringBuilder 二者都继承了 AbstractStringBuilder ，底层都是利用可修改的char数组(JDK 9 以后是 byte数组)。

再说说字符串常量池：

　　Java为了避免在一个系统中产生大量的String对象，引入了字符串常量池。

　　创建一个字符串时，首先会检查池中是否有值相同的字符串对象，如果有就直接返回引用，不会创建字符串对象；如果没有则新建字符串对象，返回对象引用，并且将新创建的对象放入池中。但是，通过new方法创建的String对象是不检查字符串常量池的，而是直接在堆中创建新对象，也不会把对象放入池中。上述原则只适用于直接给String对象引用赋值的情况。

　　String str1 = new String("a");  //不检查字符串常量池的
　　String str2 = "bb";   //检查字符串常量池的

　　String还提供了intern()方法。调用该方法时，如果字符串常量池中包括了一个等于此String对象的字符串（由equals方法确定），则返回池中的字符串的引用。否则，将此String对象添加到池中，并且返回此池中对象的引用。

　　在JDK6中，不推荐大量使用intern方法，因为这个版本字符串缓存在永久代中，这个空间是有限了，除了FullGC之外不会被清楚，所以大量的缓存在这容易OutOfMemoryError。

　　之后的版本把字符串放入了堆中，避免了永久代被挤满。

参考：https://baijiahao.baidu.com/s?id=1629804867201303563&wfr=spider&for=pc

对于三者使用的总结：

1. 操作少量的数据: 适用String
2. 单线程操作字符串缓冲区下操作大量数据: 适用StringBuilder
3. 多线程操作字符串缓冲区下操作大量数据: 适用StringBuffer

10、自动装箱与拆箱

• 装箱：将基本类型用它们对应的引用类型包装起来；
• 拆箱：将包装类型转换为基本数据类型；

//自动装箱
Integer total = 99; //系统自动执行了Integer total = Integer.valueOf(99);
 
//自定拆箱
int totalprim = total;  //系统自动执行了int totalprim = total.intValue();

问题一：int和Integer的区别？

1. int是基本数据类型，Integer是int的包装类就是将int类型包装成Object对象；

2. Integer变量必须实例化后才能使用；int变量不需要；

3. Integer实际是对象的引用，指向此new的Integer对象；int是直接存储数据值 ；

4. Integer的默认值是null；int的默认值是0。

深入：

• 两个通过new生成的Integer变量永远是不相等的。因为new生成的是两个对象，其内存地址不同。
• Integer与new Integer不会相等。因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同。
•  两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false。
  •  java在编译Integer i = 127的时候,被翻译成 Integer i = Integer.valueOf(127);  java API中对Integer类型的valueOf的定义如下，对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127这个Integer对象进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了。
• Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true。（因为包装类Integer和基本数据类型int比较时，java会自动拆箱为int，然后进行比较，实际上就变为两个int变量的比较）

Integer.valueOf函数源码：

public static Integer valueOf(int i) {
    return  i >= 128 || i < -128 ? new Integer(i) : SMALL_VALUES[i + 128];
}

它会首先判断i的大小：如果i小于-128或者大于等于128，就创建一个Integer对象，否则执行SMALL_VALUES[i + 128]。

SMALL_VALUES[i + 128]是什么东西：

private static final Integer[] SMALL_VALUES = new Integer[256];

SMALL_VALUES本来已经被创建好，也就是说在i >= 128 || i < -128是会创建不同的对象，在i < 128 && i >= -128会根据i的值返回已经创建好的指定的对象。

问题二：为什么有了int还要有设计Integer？

　　对象封装有很多好处，可以把属性也就是数据跟处理这些数据的方法结合在一起，比如Integer就有parseInt()等方法来专门处理int型相关的数据。

　　另一个非常重要的原因就是在Java中绝大部分方法或类都是用来处理类类型对象的，如ArrayList集合类就只能以类作为他的存储对象，而这时如果想把一个int型的数据存入list是不可能的，必须把它包装成类，也就是Integer才能被List所接受。所以Integer的存在是很必要的。

11、为什么不能从静态的方法里调用非静态的方法或变量？

　　非静态的方法可以调用静态的方法，但是静态的方法不可以调用非静态的方法。

　　类的静态成员(变量和方法)属于类本身，在类加载的时候就会分配内存，可以通过类名直接去访问；非静态成员（变量和方法）属于类的对象，所以只有在类的对象产生（创建类的实例）时才会分配内存，然后通过类的对象（实例）去访问。

　　在一个类的静态成员中去访问其非静态成员之所以会出错是因为在类的非静态成员不存在的时候类的静态成员就已经存在了，访问一个内存中不存在的东西当然会出错。

参考https://blog.csdn.net/l18649805795/article/details/48939487

12、静态方法和实例方法有何不同？

1. 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。

2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

问题：static修饰变量、代码块时什么时候执行？执行几次？

　　在类加载的init阶段，类的类构造器中会收集所有的static块和字段并执行；static块只执行一次。

【注】：

• static语句块,不是在实例化的时候被执行的；
• 在调用类中任何一个方法时，jvm进行类加载，static语句块是在类加载器加载该类的最后阶段进行初始化的。并且只会被初始化一次。  （注：若一次性调用多个方法，则只会执行一次static代码块。）

13、在 Java 中定义一个不做事且没有参数的构造方法的作用？

　　Java 程序在执行子类的构造方法之前，如果没有用super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super()来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。

问题：子类继承父类时，父类的构造方法什么时候调用？

　　实例化一个子类对象时会先执行其父类的构造函数，然后再执行子类的构造函数。

　　super()必须先被调用；如果子类构造方法里没有写super()，编译器会自动调用super()方法，即调用父类的默认无参构造方法。所以不可以父类中只定义了有参数的构造方法（在Java中，如果一个类没有定义构造方法，编译器会默认插入一个无参数的构造方法；但是如果一个构造方法在父类中已定义，在这种情况，编译器是不会自动插入一个默认的无参构造方法）

14、构造方法有哪些特性？

1. 名字与类名相同。
2. 没有返回值，但不能用void声明构造函数。
3. 生成类的对象时自动执行，无需调用。

15、接口（interface）和抽象类（abstract class）的区别是什么？

1. 接口中的所有方法必须都是抽象的，不能有非抽象的普通方法（所有方法在接口中不能有实现）；而抽象类中可以包含非抽象的普通方法。
2. 接口中不能有构造方法，抽象类可以有构造方法。
3. 接口中除了static、final变量，不能有其他变量，而抽象类中则不一定。
4. 一个类可以实现多个接口，但只能继承一个抽象类。接口自己本身可以通过extends关键字扩展多个接口。
5. 接口中的抽象方法只能是public类型的，并且默认修饰符是public；抽象方法可以有public、protected和default这些修饰符（抽象方法就是为了被重写所以不能使用private关键字修饰！）。
6. 接口中不能包含静态方法；抽象类中可以包含静态方法。
7. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

接口和抽象类的相同点：

1. 都可以被继承
2. 都不能被实例化
3. 都可以包含方法声明
4. 派生类必须实现未实现的方法

16、成员变量与局部变量的区别有那些？

1. 从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
2. 从变量在内存中的存储方式来看:如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
3. 从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
4. 成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

17、== 与 equals的区别？（重要）

　　1）==比较的是值是否相等

       　　如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

　　　　如果作用于引用类型的变量，则比较的是所指向的对象的地址。

　　2）equals方法不能作用于基本数据类型的变量，只能用于类变量。（对于基本数据类型要用其包装类）

　　　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

　　　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

【注】Object类中的equals方法和“==”是一样的，没有区别，而String类，Integer类等等一些类，是重写了equals方法，才使得equals和“==不同”，所以，当自己创建类时，自动继承了Object的equals方法，要想实现不同的等于比较，必须重写equals方法。

    String a = new String("ab");  // a为一个引用
    String b = new String("ab");  // b为另一个引用,对象的内容一样
    String aa = "ab";   //放在常量池中
    String bb = "ab";   //从常量池中查找
        
    System.out.println(aa==bb);//true

    System.out.println(a==b); //false，非同一对象
            
    System.out.println((a.equals(b)); //true
            
    System.out.println((42 == 42.0); //true

• String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。
• 当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。

 18、为什么重写equals时必须重写hashCode方法？ (重要)

当对象的equals()方法被重写时，通常有必要重写 hashCode() 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

          （1）两个对象相等，hashcode一定相等

          （2）两个对象不等，hashcode不一定不等

          （3）hashcode相等，两个对象不一定相等

          （4）hashcode不等，两个对象一定不等

          hashcode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进行判断是否相同的。这样如果我们对一个对象重写了euqals，意思是只要对象的成员变量值都相等那么euqals就等于true，但不重写hashcode，那么我们再new一个新的对象，当原对象.equals（新对象）等于true时，两者的hashcode却是不一样的，由此将产生了理解的不一致。

https://www.cnblogs.com/wang-meng/p/7501378.html

HashMap中的get与put：

（1）put：

              1.首先根据put元素的key获取hashcode，然后根据hashcode算出数组的下标位置，如果下标位置没有元素，直接放入元素即可。
              2.如果该下标位置有元素，则需要已有元素和put元素的key对象比较equals方法，如果equals不一样，则说明可以放入进map中，会在该数组位置创建一个链表，后put进入的元素到放链表头，原来的元素向后移动。       
（2）get：
             根据元素的key获取hashcode，然后根据hashcode获取数组下标位置，如果只有一个元素则直接取出。如果该位置是一个链表，则需要调用equals方法遍历链表中的所有元素与当前的元素比较,得到真正想要的对象。（当两个对象的hashcode不同的话，肯定他们不能equals。）

19、Java 中 final、finally、finalize 的区别？

（1） final 是一个修饰符，

1. 如果一个类被声明为 final 则其不能再派生出新的子类，所以一个类不能既被声明为 abstract 又被声明为 final [所谓不可同时出现]的；
2. 将变量或方法声明为 final 可以保证它们在使用中不被改变（对于对象变量来说其引用不可变，即不能再指向其他的对象，但是对象的值可变）。

　　　注：

1. 被声明为 final 的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改，被声明为 final 的方法也同样只能使用不能重载。
2. 使用 final 关键字如果编译器能够在编译阶段确定某变量的值则编译器就会把该变量当做编译期常量来使用，如果需要在运行时确定（譬如方法调用）则编译器就不会优化相关代码；将类、方法、变量声明为 final 能够提高性能，这样 JVM 就有机会进行估计并进行优化；接口中的变量都是 public static final 的。

final关键字主要用在三个地方：变量、方法、类。

1. 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
2. 当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。
3. 使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。

（2）finally：用来在异常处理中，如果抛出一个异常，则相匹配的 catch 子句就会执行，然后控制就会进入 finally 块

　　finally是对Java异常处理模型的最佳补充。finally结构使代码总会执行，而不管无异常发生。使用finally可以维护对象的内部状态，并可以清理非内存资源。特别是在关闭数据库连接这方面，如果程序员把数据库连接的close()方法放到finally中，就会大大降低程序出错的几率。

异常处理：

• try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
• catch 块：用于处理try捕获到的异常。
• finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。

在以下4种特殊情况下，finally块不会被执行：

1. 在finally语句块第一行发生了异常。 因为在其他行，finally块还是会得到执行
2. 在前面的代码中用了System.exit(int)已退出程序。 exit是带参函数 ；若该语句在异常语句之后，finally会执行
3. 程序所在的线程死亡。
4. 关闭CPU。

（3）finalize()：是一个方法，它是在对象被垃圾回收之前由Java虚拟机来调用的。

　　finalize()方法是GC运行机制的一部分，finalize()方法是在GC清理它所从属的对象时被调用的，如果执行它的过程中抛出了无法捕获的异常，GC将终止对改对象的清理，并且该异常会被忽略；直到下一次GC开始清理这个对象时，它的finalize()会被再次调用。

20、this、super

（1）this：代表对象本身，可以理解为：指向对象本身的一个指针。

this的用法在java中大体可以分为3种：

1）普通的直接引用

这种就不用讲了，this相当于是指向当前对象本身：

2）形参与成员名字重名，用this来区分：

3）引用构造函数

this（参数）：调用本类中另一种形式的构造方法（应该为构造方法中的第一条语句）

 

（2）super：代指父类，可以用于调用父类的普通方法和构造方法。

调用父类构造方法：super()(无参构造方法)或 super(参数)(有参构造方法)

调用父类普通方法：super.方法名(参数)

 

21、Java序列化中如果有些字段不想进行序列化，怎么办？

 　　对于不想进行序列化的变量，使用transient关键字修饰。

　　transient关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被transient修饰的变量值不会被持久化和恢复。transient只能修饰变量，不能修饰类和方法。

 22、 获取用键盘输入常用的的两种方法

 方法1：通过 Scanner

Scanner sc = new Scanner(System.in);
String s  = sc.nextLine();
input.close();

方法2：通过 BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
String s = input.readLine();

 参考：https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/Java%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.md