Java 基础知识（一）
知识点包括
- Java面向对象三大特性
- Java四种引用类型
- String、StringBuffer、StringBuilder的区别
- final、finally、finalize的区别
- ==、equals()、hashCode()的区别
- Java 异常的分类
- Java 对象为什么要进行序列化？
- Java如何跳出多层嵌套
一. 三大特性（封装、继承、多态）
封装
封装的好处
- 隔离性：
被封装后的对象，其外部对象是无法直接访问对象的内部实现细节，内部实现细节的的改动不会影响到外部对象的访问原，这是隔离性的体现，同时也是实现高内聚，低耦合的最根本的思想之一； - 可复用性：
被封装后的对象可以被外部多个对象访问，而无需为每个外部对象去指定不同的服务对象。 - 可读性：
被封装后的对象的名称（如：程序集名，类名，方法名）如果命名恰当，那么就能在不看里面的实现细节的前提下，了解该对象的作用；
继承
讲到继承一定少不了这三个东西：构造器、protected关键字、向上转型；
(1).构造器
public class Person {
protected String name;
protected int age;
protected String sex;
Person(String name){
System.out.println("Person Constrctor-----" + name);
}
}
public class Husband extends Person{
private Wife wife;
Husband(){
super("chenssy");
System.out.println("Husband Constructor...");
}
public static void main(String[] args) {
Husband husband = new Husband();
}
}
Output:
Person Constrctor-----chenssy
Husband Constructor...
对于继承而已，子类会默认调用父类的构造器，但是如果没有默认的父类构造器，子类必须要显示的指定父类的构造器，而且必须是在子类构造器中做的第一件事(第一行代码)。在构造器中super和this为什么必须放在第一行？
必须在构造器的第一行放置super或者this构造器，否则编译器会自动地放一个空参数的super构造器的。其他的构造器也可以调用super或者this，调用成一个递归构造链，最后的结果是父类的构造器（可能有多级父类构造器）始终在子类的构造器之前执行，递归的调用父类构造器。在一个构造器中你只能使用this()或者super()之中的一个。
(2).protected关键字
对于protected而言，它指明就类用户而言，他是private，但是对于任何继承于此类的子类而言或者其他任何位于同一个包的类而言，他却是可以访问的。
(3).向上转型
将子类转换成父类，在继承关系上面是向上移动的，所以一般称之为向上转型。由于向上转型是从一个叫专用类型向较通用类型转换，所以它总是安全的，唯一发生变化的可能就是属性和方法的丢失。这就是为什么编译器在“未曾明确表示转型”和“未曾指定特殊标记”的情况下，仍然允许向上转型的原因。
多态
Java实现多态有三个必要条件：继承、重写、向上转型。
多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
经典案例
public class A {
public String show(D obj) {
return ("A and D");
}
public String show(A obj) {
return ("A and A");
}
}
public class B extends A{
public String show(B obj){
return ("B and B");
}
public String show(A obj){
return ("B and A");
}
}
public class C extends B{
}
public class D extends B{
}
public class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
System.out.println("1--" + a1.show(b));
System.out.println("2--" + a1.show(c));
System.out.println("3--" + a1.show(d));
System.out.println("4--" + a2.show(b)); //4--B and A .首先a2是A引用，B实例，调用show（B b）方法，此方法在父类A中没有定义，所以B中方法show(B b)不会调用（多态必须父类中已定义该方法），再按优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)，即先查this对象的父类，没有重头再查参数的父类。查找super.show((super)O)时，B中没有，再向上，找到A中show(A a),因此执行。
System.out.println("5--" + a2.show(c)); //同上
System.out.println("6--" + a2.show(d)); //A and D .查找B中没有show(D d)方法，再查A中，有，执行。
System.out.println("7--" + b.show(b));
System.out.println("8--" + b.show(c)); //B and B .
System.out.println("9--" + b.show(d));
}
}
运行结果：
1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D
二. Java的四种引用类型
强引用（Strong References）
平时开发new对象都属于强引用
只要某个对象有强引用与之关联，JVM必定不会回收这个对象，即使在内存不足的情况下，JVM宁愿抛出OutOfMemory错误也不会回收这种对象。如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
软引用（Soft References）
与软引用关联着的对象，只有在内存不足的时候JVM才会回收该对象。因此，这一点可以很好地用来解决OOM的问题，并且这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。
弱引用（Weak References）
弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。在java中，用java.lang.ref.WeakReference类来表示。
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。
虚引用（Phantom References）
不影响对象的生命周期， 如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。
虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
三. String、String Buffer、String Builder区别
String类型和String Buffer类型的主要性能区别其实在于String是不可变的对象。
StringBuffer线程安全的可变字符序列。一个类似于String的字符串缓冲区，但不能修改。可将字符串缓冲区安全地用于多个线程。StringBuffer上的主要操作是append和insert方法，append方法始终将这些字符添加到缓冲区的末端，而insert方法则在指定的点添加字符。
StringBuilder一个可变的字符序列，是JDK5.0新增的。此类提供了一个与StringBuffer兼容的API，但不保证同步。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。
对比图
四. final、finally、finalize的区别
final修饰符：
被final修饰的类，不能再派生出新的子类，不能作为作为父类而被子类继承。
将变量或方法声明为final，可以保证它们在使用过程中不被改变。被声明为final的变量必须在声明时给出变量的初始值，而在以后的引用中只能读取。被final声明的方法也同样只能使用，不能被重载。
finally
在异常处理时，提供finally块来执行任何清除操作。不管有没有异常被抛出、捕获，finally块都会被执行。
finalize
使用finalize()方法在垃圾收集器将对象从内存中清除出去之前，做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时，对这个对象的调用。它是在object类中定义的，因此所有的类都继承了它。
五. ==、equals()、hashCode()的区别
==
java中的==是比较两个对象在JVM中的地址。
equals
默认的equals方法，直接调用==，比较对象地址。String类源码重写了equals方法如下：
public boolean equals(Object anObject) {
2 if (this == anObject) {
3 return true;
4 }
5 if (anObject instanceof String) {
6 String anotherString = (String) anObject;
7 int n = value.length;
8 if (n == anotherString.value.length) {
9 char v1[] = value;
10 char v2[] = anotherString.value;
11 int i = 0;
12 while (n-- != 0) {
13 if (v1[i] != v2[i])
14 return false;
15 i++;
16 }
17 return true;
18 }
19 }
20 return false;
21 }
从上面的代码中可以看到，
(1)String类中的equals首先比较地址，如果是同一个对象的引用，可知对象相等，返回true。
(2)若果不是同一个对象，equals方法挨个比较两个字符串对象内的字符，只有完全相等才返回true，否则返回false。
hashCode
默认情况下，Object中的hashCode() 返回对象的32位jvm内存地址。
注意
当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
六. Java异常的分类
Java异常架构
Java异常架构
从根部开始分为两大类：Error和Exception。Error是程序无法处理的错误，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。Exception是程序本身可以处理的异常.这种异常分两大类：非运行时异常（发生在编译阶段，又称checkException)和运行时异常（发生在程序运行过程中，又叫uncheckException）。非运行时异常一般就是指一些没有遵守Java语言规范的代码，容易看的出来，并且容易解决的异常；运行时异常是那些在程序运行过程中产生的异常，具有不确定性，如空指针异常等，造成空指针的原因很多，所以运行时异常具有不确定性，往往难以排查，还有就是程序中存在的逻辑错误等等。
七. Java对象为什么要进行序列化？
Java对象序列化机制就是把内存中的Java对象（User之类的JavaBean）转换成二进制流。java对象序列化后可以很方便的存储或者在网络中传输。Java的序列化机制是通过运行时判断类的序列化ID（serialVersionUID）来判定版本的一致性。在反序列化时，java虚拟机会通过二进制流中serialVersionUID与本地的对应的实体类进行比较，如果相同就认为是一致的，可以进行反序列化，正确获得信息，否则抛出序列化版本不一致的异常。所以涉及到数据传输或者存储的类，严格意义上来说都要加上序列化ID，这也是一种良好的编程习惯。
八. Java怎么跳出多层嵌套？
用break+label的方法：
public static void main(String[] args) {
outerloop:
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
if (i * j > 6) {
System.out.println("Breaking");
break outerloop;
}
System.out.println(i + " " + j);
}
}
System.out.println("Done");
}
首先在for循环前加标签，如例子中的outerloop，然后在for循环内break label(如本例的outerloop)，就会跳出该label指定的for循环。
