Java基础

Java语言具有哪些特点

Java为纯面向对象语言。它能够直接反应现实生活中的对象。
具有平台无关性。Java利用Java虚拟机运行字节码，无论是在Windows，Linux还是MacOS等其他平台对Java程序进行编译，编译后的程序可以在其他平台运行。
Java为解释型语言，编译器将Java编译成平台无关的中间代码，然后再JVM上面解释运行，具有很好的移植性。
Java提供了很多的内置类库。如对多线程的支持，对网络通信的支持，最重要的一点是提供了垃圾回收机制。
Java具有较好的安全性和健壮性。Java提供了异常处理和垃圾回收机制，去除了C++中难以理解的指针特性。
Java语言提供了对Web开发的支持。

面向对象的三大特点

继承：对象的一个新类可以从现有的类中派生，派生类可以从它的基类那继承方法和实例变量，且派生类可以修改或新增新的方法使之更适合特殊需求。
封装：将客观事物抽象成类，每个类可以把自身数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
多态：允许不同类的对象对同一个消息做出响应。不同的对象调用相同方法，即使参数也相同，最终表现行为也是不一样的。

字节序定义以及Java属于哪种字节序

字节序是指多字节数据在计算机内存中存储或者在网络中传输时字节的存储顺序。通常由小端和大端两组方式。

小端：低位字节存放在内存的低地址端，高位字节存放在内存的高地址端。
大端：高位字节存放在内存的低地址端，低位字节存放在内存的高地址端。

Java语言的字节序是大端。

JDK与JRE区别

JDK：Java开发工具包（Java Development Kit），提供了Java的开发和运行环境。

JRE：Java运行时环境（Java Runtime Environment），提供了Java运行所需环境。

JDK包含了JRE，如果知识运行Java程序，安装JRE即可。要编写Java程序需要要安装JDK。

Java访问修饰符

default：默认访问修饰符，同一包内可见
private：在同一类中可见，不能修饰类
protected：对同一包内的类和所有的子类可见，不能修饰类
public：对所有类可见

构造方法，成员变量初始化，静态成员变量三者的初始化顺序

静态成员变量，成员变量，构造方法。

详细的先后顺序：父类静态变量，父类静态代码块，子类静态变量，子类静态代码块，父类非静态变量，父类非静态代码块，父类构造函数，子类非静态变量，子类非静态代码块，子类构造函数。

静态代码块和非静态代码块都可以有多个，按照定义的顺序执行。

接口和抽象类的相同点和区别

相同点：

都不能被实例化。
接口的实现类或者抽象类的子类接口需要实现接口或者抽象类中的抽象方法才能被实例化。

不同点：

接口只能有方法的定义，不能有方法的实现，而抽象类可以有方法的定义与实现。
实现接口的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但是只能继承一个抽象类。
当子类和父类之间存在逻辑上的层级接口，推荐使用抽象类，有利于功能的累积。当功能不需要，希望支持差别较大的两个或者更多对象之间的特定交互行为，推荐使用接口。使用接口能降低系统软件的耦合度，便于日后维护或者添加删除方法。

Java为何不支持多重继承

为了程序的结构能够更加清晰，从而便于维护。

假设Java语言支持多重继承，类C继承自类A和类B，如果类A和类B都有自定义的成员方法f()，那么当调用类C中的f()方法会产生二义性。Java通过实现接口间接支持多重继承，接口由于只包含方法定义，不能有方法的实现，类C继承接口A和接口B时，即使它们有共同的方法，也不能直接调用，需要实现具体的方法才能调用，不会产生二义性。

多重继承会使类型转换，构造方法的调用顺序变得复杂，会影响到性能。

Java提供的多态机制

Java提供了两种用于多态的机制，分别是重载和覆盖。

重载：重载是指一个类中有多个同名的方法，但是这些方法有不同的参数列表，在编译期就可以出确定调用哪个方法。
覆盖：覆盖是指派生类重写基类的方法，使用基类指向子类的实例对象，或者接口的引用变量指向其具体实现类的实例对象，在程序调用的运行期，根据引用变量所指的具体实例对象，调用正在运行的那个对象的方法，即需要在运行期才能确定调用哪个方法。

重载和覆盖的区别

覆盖是父类与子类之间的关系，是垂直关系；重载是同一个类方法之间的关系，是水平关系。
覆盖只能由一个方法或者一对方法产生关系，重载是多个方法之间的关系。
覆盖要求参数列表相同，重载要求参数列表不同。
覆盖中，调用方法体是根据对象的类型来决定的，而重载是根据调用时实参列表与形参列表对应来选择的。
重载方法可以改变返回值类型，覆盖方法不能改变返回值类型。

final，finally，finalize区别

final：用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally：作为异常处理的一部分，只能在try/catch语句中使用，finally附带一个语句块用来表示这个语句最终一定被执行，经常被用在需要释放资源的情况下。
finalize：是Object类的一个方法，在垃圾回收器执行的时候会调用回收对象的finalize方法。当垃圾回收器准备和释放对象占用空间时，首先会调用finalize方法，并在下一次垃圾回收动作发生时真正回收对象占用的内存。

出现在Java程序中的finally代码块是否一定会执行

当遇到下面的情况时不会被执行：

当程序在进入try语句块之前就出现异常会直接结束。
当程序在try块中强制退出时，如使用System.exit(0)，也不会执行finally块中的代码。

其他情况下，在try/catch/finally语句执行的时候，try块首先执行，当有异常发生，catch和finally进行处理后程序就结束了，当没有发生异常，在执行完finally块的中代码后，后面的两码会继续执行。

值得注意的是，如果try/catch/finally块中都有return语句，finally中的return语句会覆盖try/catch块中的return语句。

static关键字作用

为某种特定数据类型或者对象分配与创建的对象个数无关的单一的存储空间。
使得某个方法或者属性与类，而不是与对象关联在一起，即在不创建对象的情况下，通过类直接调用方法或者类的属性。

具体有四种用法：

修饰成员变量：用static关键字修饰的静态变量在内存中只有一个副本。只有静态变量所在的类被加载，这个静态变量就会被分配空间，可使用类名或者实例对象两种方式访问静态变量。
修饰成员方法：static修饰的方法无需创建对象就可以被调用。static方法不能使用this和supper关键字，不能调用非static方法，只能访问所属类的静态成员变量和静态成员方法。
修饰代码块：JVM在加载类的时候会执行static代码块，static代码块常用于初始化静态变量。static代码只会被执行一次。
修饰内部类：static修饰的内部类可以不依赖外部实例对象而被实例化，静态内部类不能与外部类有相同的名字，不能访问普通成员变量，只能访问外部类中的静态成员变量和静态成员方法。

Java代码块执行顺序

父类静态代码块（只执行一次），子类静态代码块（只执行一次），父类构造代码块，父类构造函数，子类构造代码块，子类构造函数，普通代码块。

一维数组和二维数据的声明方式

一维数组：

type arrayName[];
type[]  arrayName;

二维数组：

type arrayName[][];
type[][] arrayName;
type[] arrayName[];

其中type为基本数据类型或类类型，arrayName为数组名字。

String与StringBuffer有什么区别

String用于字符串操作，是不可变类。String对象一旦被创建，其值不能被改变。而StringBuffer是可变类。当对象创建后，仍然可以对其值进行修改。

==和equals区别

==比较的是引用，equals比较的是内容。

如果变量是基础数据类型，==用于比较其值是否相等；如果变量是对象，==用于比较两个变量的引用是否指向同一个对象。
equals是Object类的一个方法，每个Java类都继承自Object类，所以每个对象都有这个方法。Object类种定义的equals方法内部是直接调用==比较对象的。我们可以通过覆盖方法来实现比较对象内容。

为什么String不可变

节省空间：字符串常量存放在JVM的字符串常量池中，可以被共享。
提高效率：String会被不同的线程共享，是线程安全的。在涉及多线程操作中不需要同步操作。
安全：String通常被用于用户名，密码，文件名等用途，由于其不可变，可避免黑客对其进行恶意修改。

序列化是什么

序列化是一种将对象状态转换成字节序列的过程，用于解决在对对象进行读写操作时所引发的问题。序列化可以将对象的状态写在流里面进行网络传输，或者保存到文件，数据库等系统，并在需要的时候把该流读取出来重新构造成一个相同的对象。

Java中的Class对象

Java中对象可分为实例对象和Class对象，每一个类都有一个Class对象，其包含了与该类有关的信息。

获取Class对象的方法：

Class.forName("com.simae.DemoObject");
instance.getClass();
DemoClass.class;

Java反射机制

Java反射机制是指在程序运行的过程中可以构造任意一个类的对象，获取任意一个类的成员变量和成员方法，获取任意一个对象的所属的类的信息，调用任意一个对象的属性和方法。反射机制使得Java具有动态获取程序信息和动态调用对象方法的能力。可以通过以下类调用反射API。

Class类：可获得类属性方法
Field类：获得类的成员变量
Method类：获得类的成员方法
Construct类：获取类的构造方法等信息

注解

Java注解用于为Java代码提供元数据，作为元数据，注解不直接影响代码的执行，但也有一些类型的注解实际上可用于这一目的。

其可以用于提供信息给编译器，在编译阶段时给软件提供信息进行相关的处理，在运行时处理写相应代码，做对应操作。

元注解

元注解可以理解为注解的注解，即在注解中使用，实现想要的功能。有以下几个元注解：

@Retention：表示注解存在阶段是保留在源码，还是在字节码或者运行期。
@Target：表示注解作用的范围
@Documented：将注解中的元素包含到Javadoc中去
@Inherited：一个被@Inherited注解了的注解修饰一个父类，如果它的子类没有被其他注解修饰，则它的子类也继承了父类的注解。
@Repeatable：被这个注解修饰的注解可以同时作用于一个对象多次，但是每次作用注解又开以代表不同的涵义。

Java异常的分类

Java异常分为Error和Exception。这两个类均继承自Throwable。

Error常见类型有StackOverflowError，OutOfMemoryError等。

Exception可分为运行时异常和非运行时异常。对于运行时异常，可以利用try/catch的方式进行处理，也可以不处理。对于非运行时异常，必须处理，不处理的话无法通过编译。

throw和他thorws区别

thorw一般用作方法内部，由开发者定义程序语句出现问题后主动抛出的异常。

throws一般用于方法声明，代表该方法可能会抛出的异常列表。

泛型

泛型也叫参数化类型，为了解决不确定对象具体类型的问题。在编译阶段有效。在泛型使用过程中，操作的数据类型指定为一个参数，这种参数类型在类中称为泛型类，在接口中被称为泛型接口，在方法中称为泛型方法。

泛型擦除

Java编译器生成的字节码是不包含泛型信息的，泛型信息将在编译时被擦除，这个过程被称为泛型擦除是。

Java基本数据类型

byte：占用1字节，范围-128-127
short：占用2字节，范围-2^15-2^15-1
int：占用4个字节，范围-2^31-2^31-1
long：占用8个字节
float：占用4个字节
double：占用8个字节
char：占用两个字节
boolean：占用大小根据实现虚拟机不同有所差异

自动装箱拆箱

对于Java基本数据类型，均对应一个包装类。

装箱就是自动将基本数据类型转换成包装类型。拆箱就是自动将封装类型转换成基本数据类型。

重载与重写

重写即子类重写父类的方法，方法对应的形参和返回值类型都不能改变。

重载即在一个方法内，方法名相同，但是形参列表不同，可以类型或者数量不同。

Java的多态

Java多态可以分为编译时多态和运行时多态。

编译时多态主要指方法的重载，即通过参数列表的不同来区分不同的方法。

运行时多态主要指继承父类和实现接口时，可使用父类引用指向子类对象。

运行时多态的实现：主要依赖方法表，方法表中最先存放的是Object类的方法，接下来是该类的父类的方法，最后是该类的本身的方法。如果子类改写了父类的方法，那么子类和父类的那些同名方法共享一个方法表项，都被认作是父类的方法。因此可以实现运行时多态。

抽象类与接口的区别

抽象类：体现的时is-a关系，例如man is a persion，就可以将person定义为一个抽象类。

接口：体现的时can的关系。是作为模板实现的。如设置接口fly，plane类和bird类均可以实现该接口。

一个类只能继承一个抽象类，但是可以实现多个接口。

Object类常用方法

hashCode：通过对象计算出的散列码，用于map型或者equals方法。需要保证同一个对象多次调用该方法，总返回相同的整型值。
equals：判断两个对象是都一致。需保证equals方法相同对应的对象的hashCode也相同。
toString：用字符串表示该对象。
clone：深拷贝一个对象

内部类及其作用

成员内部类：作为成员对象的内部类，可以访问private及其以上外部类的属性和方法。外部类想要访问内部类属性或者方法时，必须要创建一个内部类对象，然后通过该对象访问内部类的属性或方法。外部类也可以访问private修饰的内部类属性。
局部内部类：存在于方法中的内部类。访问权限类似局部变量，只能访问外部类的final变量。
匿名内部类：只能使用一次，没有类名，只能访问外部类的final变量。
静态内部类：类似类的静态成员变量。

String/StringBuffer和StringBuilder

String类采用利用final修饰的字符数组进行字符串保存，因此不可变。如果对String类型对象修改，需要新建对象，将老字符和新增加的字符一并存进去。

StringBuilder：采用无final修饰的字符数组进行保存，因此可变，但是线程不安全。

StringBuffer：采用无final修饰的字符数组进行保存，可理解为实现线程安全的StringBuilder。

Java序列化和反序列化的实现

序列化：将Java对象转换成字节序列，由此可以通过网络对象进行传输。

反序列化：将字节序列转换成Java对象。

具体实现：实现Serializable接口，或者实现Externalizable接口中的writeExtenal()和readExternal()方法。

Java的List

List是一个有序队列，在Java中有两种实现方式：

ArrayList使用数组实现，是容量可变的非线程安全列表，随机访问快，集合扩容时会创建更大的数组，把原有的数组复制到新数组。

LinkedList本质是双向链表，与ArrayList相比插入和删除速度更快，但随机访问元素很慢。

Java中线程安全的基本数据结构有哪些

HashTable：哈希表的线程安全版本，效率低。

ConcurrentHashMap：哈希表的线程安全版本，效率高，用于替换HashTable。

Vector：线程安全版的ArrayList。

Stack：线程安全版栈。

BlockingQueue及其子类：线程安全版队列。

Java的Set

Set即集合，该数据结构不允许重复元素且是无序的。Java对Set有三种实现方式：

HashSet通过HashMap实现，HashMap的key即HashSet存储的元素，Value系统自定义一个名为PRESENT的Object类型常量。判断元素是否相同时，先比较hashCode，相同再利用equals比较，查询O(1)。

LinkedHashSet继承自HashSet，通过LinkedHashMap实现，使用双向链表维护元素的插入顺序。

TreeSet通过TreeMap实现，底层数据结构是红黑树，添加元素到集合时安装比较规则将其插入合适的位置，保证插入后的集合仍然有序，查询O(logn)。

Java的HashMap

JDK8之前底层实现是数组+链表，JDK8改为数组+链表/红黑树。主要成员变量包括存储数据的table数组，元素数量size，加载因子loadFactor。

HashMap中数据以键值对的形式存在，键对应菜单hash值用于来计算数组下标，如果两个元素的key的hash值一样，就会发生哈希冲突，被放到一个链表上。

table数组记录HashMap的数据，每个下标对应一条链表，所有哈希冲突的数据都会被存放到同一条链表，Node/Entry节点包含四个成员变量，key，value，next指针和hash值。在JDK8后链表超过8会转化成红黑树。

若当前数据/总数据量>负载因子，HashMap将执行扩容操作。

默认初始化容量为16，扩容必须是2的幂次方，最大容量为1<<30，默认加载因子为0.75。

为何HashMap线程不安全

在JDK1.7中，HashMap采用头插法插入元素，因此并发情况下会导致环形链表，产生死循环。

JDK1.8中采用了尾插法改变这一问题，当时并发情况下的put操作，也会使前一个key被后一个key覆盖。

由于HashMap有扩容机制存在，也存在A线程扩容后，B线程执行get方法出现失误的情况。

Java的TreeMap

TreeMap底层使利用红黑树实现的Map结构。底层实现是一颗平衡的排序二叉树，由于红黑树的插入，删除，遍历时间复杂度都为O(logn)，所以性能上低于HashTable。但是哈希表无法提供键值对的有序输出，红黑树可以按照键值对的大小有序输出。

Collection和Collections区别

Collection使一个集合接口，它提供了对集合对象进行基本操作的通用接口方法，所有集合都是它的子类，比如List，Set等。
Collections使一个包装类，它包含了很多的静态方法，不能被实例化，而是作为工具类使用，比如提供的排序方法：Collections.sort(list)，反转方法：Collections.reverse(list)。

ArrayList、Vector和LinkedList共同点和区别

ArrayList、Vector和LinkedList都是可伸缩的数组，即可动态改变长度的数组。
ArrayList和Vector都是基础存储元素的Object[] array来实现的，它们会在内存中开辟一块连续的空间来存储，支持下标，索引访问。但是在设计插入元素时，可能需要移动容器中的元素，插入效率较低。当存储元素超过容器的初始化容量大小，ArrayList和Vector均会进行扩容。
Vector时线程安全的，其大部分方法时直接或者间接同步的。ArrayList时线程不安全的，其方法不具有同步性质。LinkedList也是线程不安全的。
LinkedList采用双向链表实现，对数据的索引需要从头开始遍历，因此随机访问的效率较低，当时插入元素的时候不需要对数据进行移动，插入效率较高。

HashMap和HashTable有什么区别

HashMap是HashTable的轻量级实现，HashMap允许key和value为null，但最多允许一条记录的key为null，而HashTable不允许。
HashTable中的方法是线程安全的，而HashMap不是。在多线程访问HashMap需要提供额外的同步机制。
HashTable使用Enumeration进行遍历，HashMap使用Iterator进行遍历。

HashMap和TreeMap选择

如果对Map进行插入、删除或者定位一个元素的操作更加频繁，HashMap是更好的选择。

如果需要对Key集合进行有序的遍历，TreeMap是更好的选择。

fail-fast和fail-safe迭代器的区别

fail-fast直接在容器上进行，在遍历的过程中，一旦发现容器中的数据被修改，就会立刻抛出ConcurrentModificationException异常，从而招致遍历失败。常见的使用fail-fast方式的容器有HashMap和ArrayList。
fail-safe这种遍历基于容器的一个克隆。因此对容器中的内容修改不影响遍历。常见的使用fail-safe方式遍历的容器有ConcurrentHashMap和CopyOnWriteArrayList。

HashSet中equals和hashCode之间的关系

equals和hashCode这两个方法都是从Object类中继承过来的，equals主要用于判断对象的内存地址引用是都是同一个地址，hashCode根据定义的哈希规则将对象的内存地址转换成一个哈希码。HashSet中存储的元素是不能重复的，主要通过hashCode与equals两个方法来判断存储的对象是否相同；

如果两个对象的hashCode不同，说明两个对象不同。
如果两个对象的hashCode相同，接着会调用对象的equals方法，如果equals方法的返回结果为true，那么说明两个对象相同，否则不相同。

拆箱装箱原理

装箱过程是通过调用包装器的valueOf方法实现的，将原值赋给对应类。

拆箱过程是通过调用包装器的intValue/doubleValue等方法实现的，返回基本的数据类型。

Java反射原理

Java会在编译期装载所有的类，并将其元信息保存至Class类对象中。

因此可以设计x.class，x.getClass()，Class.forName()等方法获取Class对象。所以反射调用Field，Method，Constructor对象时，可以根据Class类对象进行进一步的操作。

comparator和comparable区别

Comparable是一个接口，用于对象内部的比较方式，该接口需要实现的方法是：

public interface Comparable<T> {
    pubic int compareTo(T o);
}

Comparator也是一个接口，该接口有一个compare方法，该接口需要实现的方法是：

public interface Comparator<T> {
    int compare(T o1, T o2);
}

除该方法外，comparator还可以实现其他方法。

动态代理实现

利用JDK反射机制，实现代理接口。
利用CGLib，对指定类生成子类，进行代理。

OutOfMemoryError

当JVM分配内存不够时会抛出该异常。

StackOverFlowError

调用栈的深度超过限制产生的异常，一般会在递归调用的时候出现。