重载就是同样的一个方法能够根据输入数据的不同，做出不同的处理
重写就是当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法不同类型的对象，
重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。
private/final/static 则子类就不能重写该方法，但是被 static 修饰的方法能够被再次声明。
方法的重写要遵循“两同两小一大”：
== 对于基本类型和引用类型的作用效果是不同的：
== 比较的是值。== 比较的是对象的内存地址。因为 Java 只有值传递，所以，对于 == 来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。
equals() 作用不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。
Object 类 equals() 方法：
public boolean equals(Object obj) {
return (this == obj);
}equals() 方法存在两种使用情况：
equals()方法 ：通过equals()比较该类的两个对象时，等价于通过“==”比较这两个对象，使用的默认是 Object类equals()方法。equals()方法 ：一般我们都覆盖 equals()方法来比较两个对象中的属性是否相等；若它们的属性相等，则返回 true(即，认为这两个对象相等)。例如：
String a = new String("ab"); // a 为一个引用
String b = new String("ab"); // b为另一个引用,对象的内容一样
String aa = "ab"; // 放在常量池中
String bb = "ab"; // 从常量池中查找
System.out.println(aa == bb);// true
System.out.println(a == b);// false
System.out.println(a.equals(b));// true
System.out.println(42 == 42.0);// true
String中的equals方法是被重写过的，因为Object的equals方法是比较的对象的内存地址，而String的equals方法比较的是对象的值。
总结一下，== 比较的是变量(栈)内存中存放的对象的(堆)内存地址,用来判断两个对象的地址是否相同,即是否是指相同一个对象。比较的是真正意义上的指针操作。 equals用来比较的是两个对象的内容是否相等,由于所有的类都是继承自java.lang.Object类的,所以适用于所有对象,如果没有对该方法进行覆盖的话,调用的仍然是Object类中的方法,而Object中的equals方法返回的却是==的判断。
Integer i = 10; //装箱
int n = i; //拆箱装箱其实就是调用了 包装类的valueOf()方法，拆箱其实就是调用了 xxxValue()方法
Integer i = 10 等价于 Integer i = Integer.valueOf(10);int n = i 等价于 int n = i.intValue();如果频繁拆装箱的话，也会严重影响系统的性能。我们应该尽量避免不必要的拆装箱操作。
特点：
构造方法不能被 override（重写）,但是可以 overload（重载）,所以一个类中有多个构造函数的情况。
封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息，但是可以提供一些可以被外界访问的方法来操作属性。
不同类型的对象，相互之间经常有一定数量的共同点。例如，小明同学、小红同学、小李同学，都共享学生的特性（班级、学号等）。同时，每一个对象还定义了额外的特性使得他们与众不同。例如小明的数学比较好，小红的性格惹人喜爱；小李的力气比较大。继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承，可以快速地创建新的类，可以提高代码的重用，程序的可维护性，节省大量创建新类的时间 ，提高我们的开发效率。
继承的三个特点
多态表示一个对象具有多种的状态，具体表现为父类的引用指向子类的实例。
多态的特点:
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
private final char value[];
//...
}String类中用final修饰字符数组保存字符串，因此String类是不可变的。
StringBuilder与StringBuffer都继承自Abstract StringBuilder类，在Abstract StringBuilder中也是使用字符数组保存字符串char[] value 但是没有用 final 关键字修饰，所以这两种对象都是可变的。
线程安全：
String 中的对象是不可变的，也就可以理解为常量，线程安全；StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
性能：
每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的String对象。StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StringBuilder相比使用StringBuffer仅能获得10%~15%左右的性能提升，但却要冒多线程不安全的风险。
使用：
StringStringBuilderStringBuffer
浅拷贝的实现就是在需要拷贝的类上实现Cloneable接口并重写其clone()方法，然后在使用的时候直接调用类的clone方法即可。
例如：Father作为父类，Son实现Cloneable接口，在最后重写了clone方法
class Father{
String name;
public Father(String name) {
this.name=name;
}
@Override
public String toString() {
return "Father{" +
"name='" + name + '\'' +
'}';
}
}
class Son implements Cloneable {
int age;
String name;
Father father;
public Son(String name,int age) {
this.age=age;
this.name = name;
}
public Son(String name,int age, Father father) {
this.age=age;
this.name = name;
this.father = father;
}
@Override
public String toString() {
return "Son{" +
"age=" + age +
", name='" + name + '\'' +
", father=" + father +
'}';
}
@Override
protected Son clone() throws CloneNotSupportedException {
return (Son) super.clone();
}
}
public class test {
public static void main(String[] args) throws CloneNotSupportedException {
Father f=new Father("bigFather");
Son s1 = new Son("son1",13);
s1.father=f;
Son s2 = s1.clone();
System.out.println(s1);
System.out.println(s2);
System.out.println("s1==s2:"+(s1 == s2));//不相等
System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//相等
System.out.println();
//但是他们的Father father 和String name的引用一样
s1.age=12;
s1.father.name="smallFather";//s1.father引用未变
s1.name="son222";//类似 s1.name=new String("son222") 引用发生变化
System.out.println("s1.Father==s2.Father:"+(s1.father == s2.father));//相等
System.out.println("s1.name==s2.name:"+(s1.name == s2.name));//不相等
System.out.println(s1);
System.out.println(s2);
}
}二者的区别：
在 Java 中，所有的异常都有一个共同的祖先 java.lang 包中的 Throwable 类。Throwable 类有两个重要的子类 Exception（异常）和 Error（错误）。Exception 能被程序本身处理也就是用try catch， Error 是无法处理的(只能尽量避免)。
Exception 和 Error 二者都是 Java 异常处理的重要子类，各自都包含大量子类。
Exception :程序本身可以处理的异常，可以通过 catch 来进行捕获。Exception 又可以分为 受检查异常(必须处理) 和 不受检查异常(可以不处理)。Error ：Error 属于程序无法处理的错误 ，我们没办法通过 catch 来进行捕获 。例如，Java 虚拟机运行错误（Virtual MachineError）、虚拟机内存不够错误(OutOfMemoryError)、类定义错误（NoClassDefFoundError）等 。这些异常发生时，Java 虚拟机（JVM）一般会选择线程终止。其中检查型异常 一般在编译期就会被检查到，所以我们肯定会提前在方法内进行捕获处理，或者在方法头部申明并抛出；而非检查型异常，往往无法提前预知，例如被除数是0、空指针等。
Java中常见的八大异常
1.空指针异常类：NullPointerException
简单地说就是调用了未经初始化的对象或者是不存在的对象！
2.类型强制转换异常：ClassCastException
类型转换异常，检查两个类之间是否可以转换！
3、数组下标越界异常：ArrayIndexOutOfBoundsException
数组下标越界，看调用的下标是不是超出了数组的范围，最好先查看一下数组的length，以免出现这个异常。
4、文件或者类未找到异常：FileNotFoundException、java.lang.classnotfoundexception
异常的解释是指定的类或者文件不存在，往往是文件路径错误或者导入的jar不完整！
5、字符串转换为数字异常：NumberFormatException
使用的转换方法不正确，或者字符串的格式不符合要求！
6、操作数据库异常：SQLException
该异常包含所有操作数据库的异常
7、输入输出异常：IOException
所有操作文件的异常！
8、方法未找到异常：NoSuchMethodException
方法不存在异常。当访问某个类的不存在的方法时抛出该异常 try块： 用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。catch块： 用于处理 try 捕获到的异常。finally 块： 无论是否捕获或处理异常，finally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行。在以下 3 种特殊情况下，finally 块不会被执行：
try 或 finally块中用了 System.exit(int)退出程序。但是，如果 System.exit(int) 在异常语句之后，finally 还是会被执行当 try 语句和 finally 语句中都有 return 语句时，在方法返回之前，finally 语句的内容将被执行，并且 finally 语句的返回值将会覆盖原始的返回值。
例如：
public class Test {
public static int f(int value) {
try {
return value * value;
} finally {
if (value == 2) {
return 0;
}
}
}
}
如果调用 f(2)，返回值将是 0，因为 finally 语句的返回值覆盖了 try 语句块的返回值。
序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中。
序列化最重要的作用：在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流，以便在网络上传输或者保存在本地文件中。
反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。