Exception、抽象类和接口区别、深拷贝和浅拷贝

定义：一种识别及响应错误的一致性，在使用异常的时候，出现异常我们能知道“什么异常”被抛出？异常在哪抛出？为什么会抛出这个异常？

异常的几个关键字：
try:用于监听try语句里面的代码，当发生异常时会调用catch去捕获，发生异常代码后的代码将不会继续执行

catch:用于捕获异常，即try里面的异常

finally:当try和catch里面的代码执行完还没有返回时执行这个方法，通常我们在这个方法中做数据库的关闭、网络连接关闭、流关闭或回收一些资源等

throw:用于抛出异常

throws:用于声明该方法可能抛出异常

finally与return 执行顺序

finally的执行顺序是在try和catch执行完之后、return返回之前，如果finally里面已经执行了return或throw,则不会再去执行try或catch中的return 或throw

Java异常框架

截屏2020-08-19 上午9.00.11.png

1.Throwable:是java语言中所有错误或异常的父类，他有两个子类，分别为Error和Exception,Throwable包含了其线程创建时线程执行堆栈的快照，提供了printStackTrace来获取堆栈跟踪数据等信息

2.Exception:它指出了合理的应用程序想要捕获的条件

3.RuntimeException:这个是运行期间可能抛出的异常的父类，编译器不会检查这一类的异常，可通过修改代码进行修复

4.Error：直接使虚拟机崩溃的错误，编译器不会进行检查

抽象类和接口的区别

1. 抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所 有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2. 抽象类要被子类继承，接口要被类实现。
3. 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
4. 抽象类里可以没有抽象方法。
5. 接口可以被类多实现(被其他接口多继承)，抽象类只能被单继承。
6. 接口中没有 this 指针，没有构造函数，不能拥有实例字段(实例变量)或
   实例方法。
7. 抽象类不能在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.深拷贝

截屏2020-08-19 上午9.23.11.png

代码实现：就是实现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修饰，均不能被序列化。

实现Externalizeable时需要在writeExternal中手动进行序列化，这是与transient无关