-
面向对象和面向过程的区别
-
Java语言有哪些特点
-
什么是JDK/什么是JRE/什么是JVM&三者之间的联系与区别
-
什么是字节码&采用字节码最大好处是什么
-
Java与C++的区别
-
什么是Java程序的主类&应用程序和小程序的主类有何不同
-
Java应用程序和小程序之间有哪些区别
-
字符型常量和字符串常量的区别
-
构造器Constructor是否可被override
-
重载和重写的区别
-
Java面向对象编程三大特性
-
String和StringBuffer、StringBuilder的区别&String为什么是不可变的
-
自动装箱和拆箱
-
在一个静态方法内调用一个非静态成员为什么是非法的
-
在Java中定义一个不做事且没有参数的构造方法的作用
-
import Java和javax有什么区别
-
接口和抽象类有什么区别
-
成员变量和局部变量的区别
-
创建一个对象用什么运算符？对象实体与对象引用有何不同？
-
什么是方法的返回值？返回值在类的方法里的作用省是什么？
-
一个类的构造方法作用是什么？若一个类没有声明构造方法，该程序能正确执行吗？
-
构造方法有哪些特性？
-
静态方法和实例方法有何不同
-
对象的相等与指向他们的引用相等，两者有什么不同
-
在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是？
-
==和equals（重要）
-
hashCode和equals（重要）
-
为什么Java中只有值传递
-
简述线程、程序、进程的基本概念&他们之间关系是什么
-
线程有哪些基本状态？这些状态时如何定义的？
-
关于final关键字的一些总结
-
Java中的异常处理
-
Java序列化中如果有些字段不想进行序列化怎么办
A：
面向对象和面向过程的区别
- 面向过程
优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，较消耗资源；比如单片机、嵌入式开发、Linux/Unix一般采用面向过程开发，性能是最重要的因素。
缺点：没有面向对象易维护、易复用、易扩展。
2. 面向对象
优点：易维护、易复用、易拓展，由于面向对象有封装、继承、多态的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。
缺点：性能比面向过程低。
Java语言有哪些特点
- 面向对象（封装、继承、多态）
- 跨平台（JVM实现平台无关性）
- 可靠性
- 安全性
- 支持多线程（C++语言没有内置的多线程机制，因此必须调用OS的多线程功能来进行多线程程序设计，而java语言却提供了多线程支持）
- 支持网络编程（Java语言诞生本身就是为简化网络编程设计的，因此Java语言不仅支持网络编程而且很方便）
- 编译与解释并存
什么是JDK/什么是JRE/什么是JVM&三者之间的联系与区别
JDK：Java Development Kit，顾名思义是给开发者提供的开发工具箱，它除了包括完整的JRE（Java Runtime Environment）Java运行环境。还包含了其他供开发者使用的工具包。
JRE：普通用户只需要安装JRE来运行Java程序。而程序开发者必须安装JDK来编译、调试程序。
JVM：当我们运行一个程序时，JVM负责将字节码装换为特定机器码，JVM提供了内存管理/垃圾回收和安全机制等。这种独立于硬件和操作系统，正是Java程序可以一次编写，处=多处执行的原因。
区别和联系：
- JDK用于开发，JRE用于运行Java程序
- JDK和JRE都包含JVM
- JVM时Java编程语言的核心并且具有平台独立性
什么是字节码 采用字节码的最大好处是什么
Java中引用了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。
编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特点系统的机器码执行。在Java中，这种供虚拟机理解的代码叫做字节码（即拓展名为.class的文件），它不面向任何特定的处理器，只面向虚拟机。
每一种平台的解释器时不同的，但是实现的虚拟机时相同的。Java源程序经过编译器后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码。然后在特定的机器上运行。这也就是解释了Java的编译和解释并存的特点。
源程序 --【编译器】--> 字节码 --【解释器】--> 机器码
Java源代码--->编译器 ---> JVM可执行的Java字节码（即虚拟指令）---> JVM --->JVM中解释器 --->机器可执行的二进制机器码---> 程序运行
采用字节码的好处：
Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java程序无需重新编译便可在多种不同的计算机上运行。
解释型语言：在运行时将程序翻译成机器语言。解释型语言的程序不需要在运行前编译，在运行时才翻译，专门的解释器负责在每个语句执行时解释程序代码。这样解释型语言每执行一次就要翻译一次，效率比较低。
Java和C++的区别
- 都是面向对象语言，都支持封装、继承、多态
- Java不提供指针来直接访存，程序内存更加安全
- Java的类是单继承的。C++支持多继承；虽然Java的类不可以多继承，但是接口可以多继承
- Java由自动内存管理机制，无需程序手动释放无用内存
什么是 Java 程序的主类 应用程序和小程序的主类有何不同
一个程序中可以有多个类，但是只能有一个主类。在Java应用程序中，这个主类是指包含main()方法的类。而在Havana校程序中，这个主类是一个继承自系统类JApplet或Applet的子类。应用程序的主类不一定要求是public类，但小程序的主类要求必须是public类。主类是Java程序执行的入口点。
Java 应用程序与小程序之间有那些差别
简单说应用程序是从主线程启动(也就是 main() 方法)。applet 小程序没有main方法，主要是嵌在浏览器页面上运行(调用init()线程或者run()来启动)，嵌入浏览器这点跟 flash 的小游戏类似。
字符型常量和字符串常量的区别
- 形式上：字符常量是单引号引起的一个字符，字符串常量是双引号引起的若干个字符
- 含义上：字符常量相当于一个整形值（ASCII值），可以残疾是表达式运算；字符串常量代表一个地址值（该字符串在内存中存放位置）
- 占内存大小：字符常量只占2个字节；字符串常量占若干个字节（至少一个字符结束标志）（注意：char在Java中占2个字节）
| 基本类型 | 大小 | 最小值 | 最大值 | 包装器类型 |
| boolean | - | - | - | Boolean |
| char | 16-bit | Unicode 0 | Unicode 2^16-1 | Character |
| byte | 8 bits | -128 | +127 | Byte |
| short | 16 bits | -2^15 | +2^15+1 | Short |
| int | 32 bits | -2^31 | +2^31-1 | Integer |
| long | 64 bits | -2^63 | +2^63-1 | Long |
| float | 32 bits | IEEE754 | IEEE754 | Float |
| double | 64 bits | IEEE754 | IEEE754 | Double |
构造器 Constructor 是否可被 override
在讲继承的时候我们就知道父类的私有属性和构造方法不能被继承，所以Constructor也就不能被重写（override），但是可以重载（overload），所以你可以看到一个类中有多个构造函数的情况。
重载和重写的区别
重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同、方法返回值和访问修饰符可以不同，发生在编译时。
重写：发生在父子类中。方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方法。
Java 面向对象编程三大特性:封装、继承、多态
封装：封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
继承：继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可用父类的功能，但不能选择性的继承父类。通过使用继承我们能够非常方便的复用一起拿的代码。
注意：
- 子类拥有父类非private的属性和方法
- 子类可以拥有自己属性和方法，即子类可以对父类进行拓展
- 子类可以用自己的方式实现父类的方法
多态：所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法在有程序运行期间才能决定。
在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）、接口（实现接口并覆盖接口中同一方法）
String 和 StringBuffer、StringBuilder 的区别是什么 String 为什么是不可变的
可变性
简单来说：String类中使用final关键字字符数组保存字符串，private final char value[] 所以String对象是不可变的。而StringBuilder与StringBuffer都继承AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串char value[] 但是没用final关键字修饰，所以两种对象都是可变的。
StringBuilder与StringBuffer的构造方法都是调用父类构造方法也就是AbstractStringBuilder实现的，大家可以自行查阅源代码。
AbstractStringBuilder.java
abstract class AbstractStringBuilder implements Appendable, CharSequence { char[] value; int count; AbstractStringBuilder() { } AbstractStringBuilder(int capacity) { value = new char[capacity]; }
线程安全性
String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
String：线程安全
StringBuilder：线程不安全
StringBuffer ：线程安全
性能
每次对String类型进行改变的时候，都会生成一个新的String对象，然后将指针指向新的String对象。StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StringBuilder相比使用String Buffer仅能够获得10%~15%左右的性能提升，，但却要冒多线程不安全的风险。
总结
1.操作少量数据=String
2.单线程操作字符串缓冲区下操作大量数据=StringBuilder
3.多线程操作字符串缓冲区下操作大量数据=StringBuffer
自动装箱与拆箱
装箱：将基本类型用它们对应的引用类型包装起来
拆箱：将包装类型装换位基本数据类型
在一个静态方法内调用一个非静态成员为什么是非法的
由于静态方法可以不通过对象进行调用，因此早静态方法里不能调用其他非静态变量，也不可以访问非静态变量成员。
在 Java 中定义一个不做事且没有参数的构造方法的作用
Java程序在执行子类的构造方法之前，如果没有用super()来调用父类特定的构造方法，则会调用父类中“没用参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没用super（）来调用父类中特定的构造方法，则编译时将发生错误，因为Java程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。
接口和抽象类的区别是什么
1.接口的方法默认public，所有方法在接口中不能有实现（Java 8开始接口方法可以有默认实现），抽象类可以有非抽象方法
2.接口中的实例变量默认时final类型的，而抽象类中则不一定
3.一个类可以实现多个接口，但最多只能实现一个抽象类
4.接口不能用new实例化，但可以声明，但是必须引用一个实现该接口的对象，从设计层面来说，抽象是对类的抽象，是一种模板设计，接口时行为的抽象，是一种行为的规范
成员变量与局部变量的区别有那些
1.从语法形式上看，看成员变量时属于类的，而局部变量时在方法中定义的变量或是方法的参数；成员变量可以被public,private,static等修饰符修饰，而局部变量不能被访问控制修饰符以及static所修饰；但是成员变量和局部变量能被final修饰
2.从变量在内存中的存储方式来看，成员变量时对象的一部分，而对象存在于堆内存中，局部变量存在于栈内存中
3.从变量在内存中的生存时间来看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失
4.成员变量如果没有赋初值则会自动以类型的默认值而赋值（一种情况例外-被final修饰但没有被static修饰的成员变量必须显示地赋值）
创建一个对象用什么运算符？对象实体与对象引用有何不同？
new运算符，new创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球），一个对象可以有n个引用指向它（可以用n条绳子系住一个气球）
什么是方法的返回值？返回值在类的方法里的作用是什么？
方法地返回值是指我们获取到的某个方法体中地代码执行后产生地结果（前提是该方法可能产生结果）。改返回值的作用：接收出结果，使得它可以作用于其他的操作！
一个类的构造方法的作用是什么 若一个类没有声明构造方法，该程序能正确执行吗 为什么
主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。
构造方法有哪些特性
1.名字与类相同
2.没有返回值，但不能用void声明构造函数
3.生成类的对象时自动执行，无需调用
静态方法和实例方法有何不同
1.在外部调用静态方法时，可以使用“类名.方法名”的方式，也可以使用“对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
2.静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。
对象的相等与指向他们的引用相等，两者有什么不同？
对象的相等，比的是内存中存放的内容是否相等。而引用相等，比较的是他们指向的内存地址是否相等。
在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是？
帮助子类做初始化工作。
== 与 equals(重要)
==：他的作用是判断两个对象的地址是不是相等，即判断两个对象是不是同一个对象。（基本数据类型==比较的是值，引用数据类型==比较的是内存地址）
equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
- 情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价通过“==”比较这两个对象。
- 情况2：类覆盖了 equals() 方法。我们都覆盖 equals() 方法来两个对象的内容相等；若他们的内容相等，则返回true，即认为这两个对象相等。
举个栗子：
public class test1 { public static void main(String[] args) { String a = new String("ab"); // a 为一个引用 String b = new String("ab"); // b为另一个引用,对象的内容一样 String aa = "ab"; // 放在常量池中 String bb = "ab"; // 从常量池中查找 if (aa == bb) // true System.out.println("aa==bb"); if (a == b) // false，非同一对象 System.out.println("a==b"); if (a.equals(b)) // true System.out.println("aEQb"); if (42 == 42.0) { // true System.out.println("true"); } } }
说明：
- String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。
- 当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。
hashCode 与 equals（重要）
面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写equals时必须重写hashCode方法？”
hashCode（）介绍
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）
为什么要有 hashCode
我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：
当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals（）方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的Java启蒙书《Head fist java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
hashCode（）与equals（）的相关规定
- 如果两个对象相等，则hashcode一定也是相同的
- 两个对象相等,对两个对象分别调用equals方法都返回true
- 两个对象有相同的hashcode值，它们也不一定是相等的
- 因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖
- hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）
为什么Java中只有值传递
为什么Java中只有值传递？
首先回顾一下在程序设计语言中有关将参数传递给方法（或函数）的一些专业术语。按值调用(call by value)表示方法接收的是调用者提供的值，而按引用调用（call by reference)表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。 它用来描述各种程序设计语言（不只是Java)中方法参数传递方式。
Java程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的一个拷贝，也就是说，方法不能修改传递给它的任何参数变量的内容。
简述线程，程序、进程的基本概念。以及他们之间关系是什么
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即使一个进程从创建，运行到消亡。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令执行，同时，每个进程还占着某些系统资源如CPU时间，内存空间，文件，输入输出设备的使用权等。换句话说，当程序在执行时，将会被OS载入内存。线程时进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会互相影响。从另一角度来说，进程属于OS的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。
线程有哪些基本状态？这些状态是如何定义的?
1.新建（new）：新创建了一个线程对象
2.可运行（runnable）：线程对象创建后，其他线程（比如main线程）调用了该对象的start（）方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权。
3.运行（running）：可运行状态（runnable）的线程获得了CPU时间片（timeslice），执行程序代码。
4.阻塞（block）：阻塞状态是指线程因为某种原因放弃了CPU使用权，也即让出了CPU timeslice，暂时停止运行。直到线程进入可运行状态。
阻塞的情况分三种：
（一）等待阻塞：运行（running）的线程执行o.wait（）方法，JVM会把该线程放入等待队列（waitting queue）中。
（二）同步阻塞：运行（running）的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池（lock pool）中
（三）其他阻塞：运行（running）的线程执行Thread.sleep（long ms）或t.join方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep（）状态超时join（）等待线程终止或者超时，或者I/O处理完毕时，线程重新转入可运行（runnable）状态。
5. 死亡（dead）：线程run（）、main（）方法执行结束，或者因为异常退出run（）方法，则该线程结束生命周期。死亡的线程不可再次复生。
【可以用早起坐地铁来比喻这个过程】
还没起床：sleeping
起床收拾好了，随时可以坐地铁出发：Runnable
等地铁来：Waiting
地铁来了，但要排队上地铁：I/O阻塞
上了地铁，发现暂时没座位：synchronized阻塞
地铁上找到座位：Running
到达目的地：Dead
关于 final 关键字的一些总结
final关键字主要在三个地方：变量、方法、类
1.对于一final变量，如果是基本数据类型变量，则其数值一旦在初始化后便不能改变；若是引用类型变量，则在对其初始化后便不能让其指向另一个对象。
2.当用final修饰一个类表明这个类不能被继承。final类中的所有成员方法都会被隐式指定为final方法
3.使用final修饰方法的原因有两个。第一个是把方法锁定，以防任何继承类修改它的含义；第二个原因式效率。在早期的Java实现版本中，将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式指定为final。
Java 中的异常处理
Java异常类层次结构图
在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 Throwable类。Throwable： 有两个重要的子类：Exception（异常） 和 Error（错误） ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。
Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与程序员执行的操作无关，而表示代码运行时JVM出现的问题。比如，JVM运行错误，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，JVM一般会选择线程终止。
这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
Exception（异常）:是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 异常由Java虚拟机抛出。NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）、ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）和 ArrayIndexOutOfBoundsException （下标越界异常）。
注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。
Throwable类常用方法
- public string getMessage():返回异常发生时的详细信息
- public string toString():返回异常发生时的简要描述
- public string getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
- public void printStackTrace():在控制台上打印Throwable对象封装的异常信息
异常处理总结
- try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
- catch 块：用于处理try捕获到的异常。
- finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。
在以下4种特殊情况下，finally块不会被执行：
- 在finally语句块中发生了异常。
- 在前面的代码中用了System.exit()退出程序。
- 程序所在的线程死亡。
- 关闭CPU。
Java序列话中如果有些字段不想进行序列化 怎么办
对于不想进行序列化的变量，使用transient关键字修饰。
transient关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被transient修饰的变量值不会被持久化和恢复。transient只能修饰变量，不能修饰类和方法。