定义：一种识别及响应错误的一致性，在使用异常的时候，出现异常我们能知道“什么异常”被抛出？异常在哪抛出？为什么会抛出这个异常？
异常的几个关键字：
try:用于监听try语句里面的代码，当发生异常时会调用catch去捕获，发生异常代码后的代码将不会继续执行
catch:用于捕获异常，即try里面的异常
finally:当try和catch里面的代码执行完还没有返回时执行这个方法，通常我们在这个方法中做数据库的关闭、网络连接关闭、流关闭或回收一些资源等
throw:用于抛出异常
throws:用于声明该方法可能抛出异常
finally与return 执行顺序
finally的执行顺序是在try和catch执行完之后、return返回之前，如果finally里面已经执行了return或throw,则不会再去执行try或catch中的return 或throw
Java异常框架
1.Throwable:是java语言中所有错误或异常的父类，他有两个子类，分别为Error和Exception,Throwable包含了其线程创建时线程执行堆栈的快照，提供了printStackTrace来获取堆栈跟踪数据等信息
2.Exception:它指出了合理的应用程序想要捕获的条件
3.RuntimeException:这个是运行期间可能抛出的异常的父类，编译器不会检查这一类的异常，可通过修改代码进行修复
4.Error：直接使虚拟机崩溃的错误，编译器不会进行检查
抽象类和接口的区别
- 抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所 有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
- 抽象类要被子类继承，接口要被类实现。
- 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
- 抽象类里可以没有抽象方法。
- 接口可以被类多实现(被其他接口多继承)，抽象类只能被单继承。
- 接口中没有 this 指针，没有构造函数，不能拥有实例字段(实例变量)或
实例方法。 - 抽象类不能在Java 8 的 lambda 表达式中使用。
深拷贝和浅拷贝
对象拷贝：就是一个对象的属性拷贝到另一个有着相同类型的对象中去
1.浅拷贝：值传值、对象传引用（地址）
代码实现:就是实现CloneAble接口并重写其clone方法，其中clone方法调用中使用 super.clone();
对sourceobject的refObj做改变会影响到CopiedObject中的refObj,因为他们两个对象都是使用同一个refObj,对field1改变不影响field2
public class Student implements Cloneable { // 对象引用
private Subject subj;
private String name;
public Student(String s, String sub) {
name = s;
subj = new Subject(sub);
}
public Subject getSubj() {
return subj;
}
public String getName() {
return name;
}
public void setName(String s) {
name = s;
}
/**
* 重写clone()方法 * @return
*/
public Object clone() { //浅拷贝
try {
// 直接调用父类的clone()方法 return super.clone();
} catch (CloneNotSupportedException e) {
return null;
} }
}
2.深拷贝
代码实现：就是实现CloneAble接口，并重写clone方法，在clone方法中创建一个新的对象并将这个对象的属性赋值给他
public class Student implements Cloneable { // 对象引用
private Subject subj;
private String name;
public Student(String s, String sub) {
name = s;
subj = new Subject(sub);
}
public Subject getSubj() {
return subj;
}
public String getName() {
return name;
}
public void setName(String s) {
name = s;
}
/**
* 重写clone()方法 *
* @return
*/
public Object clone() {
// 深拷贝，创建拷贝类的一个新对象，这样就和原始对象相互独立
Student s = new Student(name, subj.getName());
return s;
}
}
序列化
就是将对象转换为流的形式，将内存中的对象变成一连串的字节，可以用于网络传输对象
通过序列化来实现深拷贝
public class ColoredCircle implements Serializable {
private int x;
private int y;
public ColoredCircle(int x, int y) { this.x = x;
this.y = y; }
public int getX() {
return x;
}
public void setX(int x) { this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) { this.y = y;
}
@Override
public String toString() {
return "x=" + x + ", y=" + y;
}
}
------------------------------------------------
public class DeepCopy {
public static void main(String[] args) throws IOException {
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
// 创建原始的可序列化对象
ColoredCircle c1 = new ColoredCircle(100, 100); System.out.println("Original = " + c1);
ColoredCircle c2 = null; // 通过序列化实现深拷贝
ByteArrayOutputStream bos = new ByteArrayOutputStream()
oos = new ObjectOutputStream(bos); // 序列化以及传递这个对象
oos.writeObject(c1);
oos.flush();
ByteArrayInputStream bin = new eam(bos.toByteArray());
ByteArrayInputStr
ois = new ObjectInputStream(bin);
// 返回新的对象
c2 = (ColoredCircle) ois.readObject();
// 校验内容是否相同 System.out.println("Copied
// 改变原始对象的内容
c1.setX(200);
c1.setY(200);
// 查看每一个现在的内容 System.out.println("Original = " + c1); System.out.println("Copied = " + c2);
} catch (Exception e) {
System.out.println("Exception in main = " + e);
} finally {
oos.close();
ois.close();
}
}
}
这种方式实现深拷贝不建议用，他的效率比较慢
Transient
1)一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
2)transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被 transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现 Serializable接口。
3)被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被 transient修饰，均不能被序列化。
