[toc]

1、如何实现对象克隆

  1. 实现 Cloneable 接口重写 Object 类中的 clone() 办法
  2. 实现 Serializable 接口，通过对象序列化和反序列实现克隆，能够实现真正的深度克隆
@Datapublic class RealizeCloneable implements Cloneable {    private String name;    @Override    protected Object clone() throws CloneNotSupportedException {        return super.clone();    }}
public class RealizeSerializable {    public RealizeSerializable() {        throw new AssertionError();    }    public static <T extends Serializable> T clone(T obj)throws Exception{        ByteArrayOutputStream bos = new ByteArrayOutputStream();        ObjectOutputStream oos = new ObjectOutputStream(bos);        oos.writeObject(obj);        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());        ObjectInputStream ois = new ObjectInputStream(bis);        return (T)ois.readObject();    }}@Dataclass Entity implements Serializable {    private String name;}
public class CloneTest {    @SneakyThrows    public static void main(String[] args) {        Entity entity = new Entity();        entity.setName("Hello");        Entity clone = RealizeSerializable.clone(entity);        System.out.println(clone.toString());        RealizeCloneable realizeCloneable = new RealizeCloneable();        realizeCloneable.setName("Good");        RealizeCloneable clone2 = (RealizeCloneable)realizeCloneable.clone();        System.out.println(clone2.toString());    }}

2、拜访修饰符有哪些，优先级，以及区别

Java 中，有4种不同的修饰符，其优先级别离是 public > protected > default > private

public：所有类可见

protected：子类，同一个包中的类可见

default：通过一个包中可见

private：只能被本人拜访和批改

3、this 与 super 的区别

super()和this()相似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它办法。

从实质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

4、并发和并行有什么区别

并发是指某一时间段内，多个事件正在交替执行

并行是真正意义上，一个时刻多个事件正在同时执行

5、抽象类 和 接口 有什么区别

  1. 抽象类只能单继承，接口能够多实现
  2. 抽象类能够有构造方法，接口中不能有构造方法
  3. 抽象类中能够有成员变量，接口中没有成员变量，只有常量（默认就是 public static final）
  4. 抽象类中能够蕴含非形象办法，在Java7之前接口中的办法都是形象的，Java8后，接口反对非形象办法，default办法和静态方法等，java9反对公有办法、公有静态方法

6、Error 和 Exception 有什么区别

Error 和 Exception 都是 Throwable 的子类，用于示意程序呈现不失常的状况，然而区别是

  1. Error示意零碎级别的谬误，比如说 stackoverflow 栈溢出
  2. Excpetion 异样分为 可检查和不可查看异样，可查看异样在源码里显示进行捕获，不可查看异样就是所谓的运行时异样，相似 OOM，ArrayIndexOutOfBoundsException 数据越界这样

7、try、catch、finally考查

public class TryDemo {    public static void main(String[] args) {        System.out.println(test());    }    public static int test() {        try {            return 1;        } catch (Exception e) {            return 2;        } finally {            System.out.print("3");        }    }}

执行后果为 ： 3 1

在程序执行到 第3行，test() 获取后果之前， test 类中的 finally 代码块优先执行，这个没什么好争执的，大家应该都懂

public class TryDemo {    public static void main(String[] args) {        System.out.println(test1());    }    public static int test1() {        try {            return 2;        } finally {            return 3;        }    }}

执行后果： 3

这里就有个陷阱了，很多人会认为是 3 2 其实不是，在第7行，return 2 之前，执行 finally 代码块，后果这老六不按常理出牌，间接抢在前头就返回了，所以这里只有 3

public class TryDemo {    public static void main(String[] args) {        System.out.println(test1());    }    public static int test1() {        int i = 0;        try {            i = 2;            return i;        } finally {            i = 3;        }    }}

执行后果： 2

这里预计又有人掉陷阱里去了，咱们晓得 return 之前会执行 finally ，然而 finally 中曾经批改为 3 了，那返回的不应该是 3 吗？其实不然，在执行 finally 之前，JVM 会将 i 的后果保存起来，这里用到了两个指令 iload 、istore 最初返回的也是指令中保留的值，而并不是 finally 中批改后的值！

本文由mdnice多平台公布