Java基础知识回顾（面试整理）

一、名词解释

1、Java的四个特征：
抽象：就是把现实生活中的某一类东西提取出来，用程序代码表示，我们通常 叫做类或者接口。抽象包括两个方面：一个是数据抽象，一个是过程抽象。数据抽象也就是对象的属性。过程抽象是对象的行为特征。
继承：是对有着共同特性的多类事物，进行再抽象成一个类。这个类就是多类事物的父类。父类的意义在于抽取多类事物的共性。
封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行封装隐藏。封装分为属性的封装和方法的封装。
多态：允许不同类的对象对同一消息做出响应。方法的重载、类的覆盖正体现了多态。

2、重载：重载(overloading) 是在一个类里面，方法名相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
重载规则:
被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

3、重写：重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。
重写规则:
参数列表必须完全与被重写方法的相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。
重写与重载的区别：

4、构造函数：java构造函数，也叫构造方法，是java中一种特殊的函数。函数名与类名相同，无返回值。当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，默认构造方法的访问修改符和类的访问修改符相同(类为 public，构造函数也为 public；类改为 private，构造函数也改为 private)。一旦你定义了自己的构造方法，默认构造方法就会失效。
作用：一般用来初始化成员属性和成员方法的，即new对象产生后，就调用了对象了属性和方法。在现实生活中，很多事物一出现，就天生具有某些属性和行为。比如人一出生，就有年龄、身高、体重、就会哭；汽车一出产，就有颜色、有外观、可以运行等。这些，我们就可以将这些天然的属性和行为定义在构造函数中，当new实例化对象时，也就具有这些属性和方法了，没必要再去重新定义了，从而加快了编程效率。构造函数是对象一建立就运行，给对象初始化，就包括属性，执行方法中的语句。而一般函数是对象调用才执行，用".方法名“的方式，给对象添加功能。 一个对象建立，构造函数只运行一次。而一般函数可以被该对象调用多次。

5、析构函数：析构函数（destructor）与构造函数相反，当对象结束其生命周期时（例如对象所在的函数已调用完毕），系统会执行析构函数。在java中，我们一般用不到它，因为 java 有自动内存回收机制，无须程序员手动释放。java 对象析构时会调用 finalize() 方法。java秉承一切皆为对象的思想，对象仅能通过new来创建，因此java的对象是在堆上分配的内存。这些堆上的对象，如果没有作用了（无引用指向它），将等待垃圾回收器来回收其占用的内存。而垃圾回收期何时运行，无法提前预知，甚至有的时候直到程序退出都没有进行垃圾回收，程序所占内存直接由操作系统来回收。所以在java中，对象的内存在哪个时刻回收，取决于垃圾回收器何时运行。

6、抽象类：在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

7、抽象方法：Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。
声明抽象方法会造成以下两个结果：
如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

================================================

二、Java基础知识

1、java类命名遵循：驼峰法。（尽可能）
2、Java 中主要有如下几种类型的变量：
局部变量
类变量（静态变量）
成员变量（非静态变量）
3、Java程序执行流程：

4、java中数据类型所占字节数：
类型 所占字节数
Byte 1
int 2
short 4
long 8
float 4
double 8
boolean 2
char 1
5、在java中用final关键字来修饰常量：（final关键字修饰类，类不能被继承，final修饰方法，方法不能被重写）
final double PI=3.1415926 //常量尽可能用大写字母表示
6、java转义字符：

7、Java强制类型转换：

8、注意：long类型后家l，float、double后加f、d。
9、访问控制符权限：

10、访问控制和继承：

（可理解为子类声明的父类中的方法不能比父类的控制权限高）
11、abstract修饰符：
抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
abstract class Caravan{
private double price;
private String model;
private String year;
public abstract void goFast(); //抽象方法
public abstract void changeColor();//抽象方法
}
抽象方法：
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();。
public abstract class SuperClass{
abstract void m(); //抽象方法
}
class SubClass extends SuperClass{
//实现抽象方法
void m(){
…
}
}
12、其余访问修饰符：
1）synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
2）序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
3）volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个 volatile 对象引用可能是 null。
13、java的位运算符：

14、instanceof运算符：
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
String name=”James”;
Boolean result=name instanceof String; //result=true
15、java运算符优先级：

16、Java的增强For循环：

17、For-Each循环：（用于数组遍历）

18、二维数组：

19、Arrays类：
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：

1. 给数组赋值：通过 fill 方法。
2. 对数组排序：通过 sort 方法,按升序。
3. 比较数组：通过 equals 方法比较数组中元素值是否相等。
4. 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
   

20、java的可变长参数：（可用于不同长度的数组使用）
typeName… parameterName
21、java的throws关键字，表示不处理异常。
22、java的Scanner类：（获取用户输入）
Scanner s = new Scanner(System.in); //import java.util.Scanner
通过s.next()、s.nextLine()等其他函数调用scan

next() 与 nextLine() 区别：
next():
1、 一定要读取到有效字符后才可以结束输入。
2、 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、 next() 不能得到带有空格的字符串。
nextLine()：
1、 以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。
如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取：
scan.hasNextInt() --------判断输入的是否是整数
i = scan.nextInt() --------接收输入的整数
scan.hasNextFloat() ---------判断输入的是否是浮点型
f = scan.nextFloat() --------接收输入的浮点数
23、类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。
24、entends关键字，用来继承类（单继承）。
Implements关键字，用来继承接口（实现java的多继承）。
Interface关键字，定义接口。
25、Super与this关键字：
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。当调用父类带参数的成员函数时，必须使用super关键字。
this关键字：指向自己的引用。
26、抽象类的实现方法：重写、接口、抽象类和抽象方法。
27、抽象类总结：（abstract声明）
抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
28、接口：接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象类。

29、接口、类以及抽象类异同比较：
接口与类相似点：
一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别：
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。（Implements实现）
接口支持多继承。（这也是java可以实现多继承的方式）
抽象类与接口的区别：
抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。
30、标记接口：最常用的继承接口是没有包含任何方法的接口。标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。标记接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。
没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的：建立一个公共的父接口、向一个类添加数据类型。
31、HashMap的实现原理
HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每个Entry包含一个key-value关键值对。（其实所谓的HashMap其实就是保存了两个对象之间的映射关系的一种集合）
transient Entry[] table = (Entry[]) EMPTY_TABLE;
如下为Hash Map的结构图：

简单里说，HashMap由数组+链表组成，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。