最近精心总结了一些关于Java核心基础面试知识笔记，以下只是部分知识，文末会给出获取整本笔记地址。
1) 简单易学。Java有丰富的类库，能够通过静态方法封装，降低API的学习成本，提高工作效率。
2) 面向对象。这个也是Java最重要的特性，java能够使得程序耦合度更低，内聚性更高。
3) 可靠安全。Java生态系统包括用于分析和报告安全性问题的各种工具。
4) 与平台无关。Java能够跨平台使用。 5)支持多线程。Java可以采用多线程+协程方式实现更多的并发操作。
2) 从性能上来说。面向过程性能较高，所以单片机、嵌入式开发等一般采用面向过程开发。从性 能上来说， 面向对象比面向过程要低。
3) 从可用性来说。面向对象有封装、继承、多态的特性，所以易维护、易复用、易扩展，可以设 计出低耦合的系统。
注：
1) int是基本数据类型， Integer是int的封装类，是引用类型。 int默认值是0 ，而Integer默认值是null ，所以Integer能区分出0和null的情况。一旦java看到null ，就知道这个引用还没有指向某个对 象，再任何引用使用前，必须为其指定一个对象，否则会报错。
2) 基本数据类型在声明时系统会自动给它分配空间，而引用类型声明时只是分配了引用空间，必须通过实例化开辟数据空间之后才可以赋值。数组对象也是一个引用对象，将一个数组赋值给另一个数组时只是复制了一个引用，所以通过某一个数组所做的修改在另一个数组中也看的见。
3) 虽然定义了boolean这种数据类型，但是只对它提供了非常有限的支持。在Java虚拟机中没有任 何供boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚 拟机中的int数据类型来代替，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素 boolean元素占8位。这样我们可以得出boolean类型占了单独使用是4个字节，在数组中又是1个字 节。使用int的原因是，对于当下32位的处理器( CPU)来说，一次处理数据是32位(这里不是指的 是32/64位系统，而是指CPU硬件层面)，具有高效存取的特点。
命名规则：(硬性要求) 标识符可以包含英文字母， 0-9的数字， $以及_ 标识符不能以数字开头 标 识符不是关键字
命名规范：(非硬性要求) 类名规范：首字符大写，后面每个单词首字母大写(大驼峰式)。
变量名规范：首字母小写，后面每个单词首字母大写(小驼峰式)。 方法名规范：同变量名。
boolean result = obj instanceof Class
其中 obj 为一个对象， Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间 接子类，或者是其接口的实现类，结果result 都返回true ，否则返回false。
注意 ：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定 类型，则通过编译，具体看运行时定。
int i = 0; System.out.println(i instanceof Integer);//编译不通过 i必须是引用类型，不能是基本类型 System.out.println(i instanceof Object);//编译不通过 Integer integer = new Integer(1); System.out.println(integer instanceof Integer);//true //false,在JavaSE规范中对instanceof运算符的规定就是：如果obj为null，那么将返回false。 System.out.println(null instanceof Object);
调用方法： Integer的 valueOf(int) 方法
拆箱就是自动将包装器类型转换为基本数据类型( Integer-->int)。
调用方法： Integer的 intValue方法
在Java SE5之前，如果要生成一个数值为10的Integer对象，必须这样进行：
Integer i = new Integer(10);
而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了：
Integer i = 10;
面试题1 ：以下代码会输出什么?
public class Main {
public static void main(String[] args) {
Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;
System.out.println(i1==i2);
System.out.println(i3==i4);
}
}
运行结果：
true false
为什么会出现这样的结果？输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对 象。此时只需一看源码便知究竟，下面这段代码是Integer的valueOf方法的具体实现：
public static Integer valueOf(int i) {
if(i >= -128 && i <= IntegerCache.high)
return IntegerCache.cache[i + 128];
else
return new Integer(i);
}
其中IntegerCache类的实现为：
private static class IntegerCache {
static final int high;
static final Integer cache[];
static {
final int low = -128;
// high value may be configured by property
int h = 127;
if (integerCacheHighPropValue != null) {
// Use Long.decode here to avoid invoking methods that
// require Integer's autoboxing cache to be initialized
int i = Long.decode(integerCacheHighPropValue).intValue();
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - -low);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
}
private IntegerCache() {}
}
从这2段代码可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。
上面的代码中i1和i2的数值为100，因此会直接从cache中取已经存在的对象，所以i1和i2指向的是同一个对象，而i3和i4则是分别指向不同的对象。
面试题2 ：以下代码输出什么
public class Main {
public static void main(String[] args) {
Double Double Double Double i1 = 100.0;
i2 = 100.0;
i3 = 200.0;
i4 = 200.0;
System.out.println(i1==i2);
System.out.println(i3==i4);
}
}
运行结果：
false false
原因： 在某个范围内的整型数值的个数是有限的，而浮点数却不是。
从字面上看，重写就是 重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下，对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。
总结：
1.发生在父类与子类之间
2.方法名，参数列表，返回类型(除过子类中方法的返回类型 是父类中返回类型的子类)必须相同
3.访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private)
4.重写方法一定不能抛出新的检查异常或者比被重写方法申 明更加宽泛的检查型异常
重载( Overload )
在一个类中，同名的方法如果有不同的参数列表(参数类型不同、参数个数不同甚至是参数顺序不 同 )则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是 否相同来判断重载。
public class Father {
public static void main(String[] args) {
// TODO Auto-generated method stub
Father s = new Father();
s.sayHello();
s.sayHello("wintershii");
}
public void sayHello() {
System.out.println("Hello");
}
public void sayHello(String name) {
System.out.println("Hello" + " " + name);
}
}
重载总结：
1.重载Overload是一个类中多态性的一种表现
2.重载要求同名方法的参数列表不同(参 数类型，参数个数甚至是参数顺序)
3.重载的时候，返回值类型可以相同也可以不相同。无法以返回类型作为重载函数的区分标准。
== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是 否是指相同一个对象。比较的是真正意义上的指针操作。
1、比较的是操作符两端的操作数是否是同一个对象。
2、两边的操作数必须是同一类型的(可以是父子类之间)才能编译通过。
3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true ，如：int a=10与long b=10L 与double c=10.0 都是相同的(为true)，因为他们都指向地址为10的堆。
equals
equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所 以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object 中的equals方法返回的却是==的判断。
总结
所有比较是否相等时，都是用equals 并且在对常量相比较时，把常量写在前面，因为使用object的 equals object可能为null 则空指针。
在阿里的代码规范中只使用equals，阿里插件默认会识别，并可以快速修改，推荐安装阿里插件来 排查老代码使用“==” ，替换成equals。
于是有人发明了哈希算法来提高集合中查找元素的效率。 这种方式将集合分成若干个存储区域，每 个对象可以计算出一个哈希码，可以将哈希码分组，每组分别对应某个存储区域，根据一个对象的 哈希码就可以确定该对象应该存储的那个区域。
hashCode方法可以这样理解：它返回的就是根据对象的内存地址换算出的一个值。这样一来，当 集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理 位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如 果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相 同就散列其它的地址。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。
private final char value[];
每次+操作 ：隐式在堆上new了一个跟原字符串相同的StringBuilder对象，再调用append方法拼接+后面的字符。
StringBuffer和StringBuilder他们两都继承了AbstractStringBuilder抽象类，从AbstractStringBuilder抽象类中我们可以看到
/** * The value is used for character storage. */ char[] value;
他们的底层都是可变的字符数组，所以在进行频繁的字符串操作时，建议使用StringBuffer和 StringBuilder来进行操作。 另外StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所 以是线程安全的。 StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
笔记效果图：
部分页面整体预览效果：
整本笔记获取地址：
文章评论