java高级

java高级知识点:
泛型: 泛型接口、泛型类、泛型方法
异常处理: 异常类、捕获异常(trycatch)、抛出异常(throws)
IO: File类、字节流和字符流、对象序列化、NIO
Jdbc编程: jdbc驱动类型、jdbc连接、jdbc常用接口、执行SQL方式、事务处理、Jdbc连接池
网络编程: TCP和UDP协议、Socket通信
注解、类加载过程、反射、动态代理
设计模式
JDK1.8新特性: 
    Lambda表达式
    方法引用
    接口可以定义默认实现方法和静态方法
    StreamAPI，函数式编程风格
    DateTimeAPI,加强日期时间的处理
    Optional容器，解决空指针异常

I/O流

异常处理

Throwable类是所有错误(Error类)跟异常类(Exception)的超类

异常类包括编译时异常和运行时异常(RuntimeException)

常见的异常类？(运行时异常？编译时异常？区别？)

​ 运行时异常: 父类是Exception，是不可查的异常，编译器不会强制处理，它是在运行时发生的异常

​ 常见的运行时异常类:

​ 算术异常(ArithmeticException)

​ 空指针异常(NullPointerException)

​ 数组下标越界异常(IndexOutOfBoundsException)

​ 数字格式异常(NumberFormatException )

​ 强制转换类型异常(ClassCastException)

​ 非法参数异常(IllegaArguementException)

​ 编译时异常: 父类是RuntimeException，是可检查的异常，编译器会检查的异常，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过

​ 常见的编译时异常类:

​ 数据库异常(SQLException)

​ I/O异常(IOException)

​ 文件找不到异常(FileNotFoundException)

​ 类找不到异常(ClassNotFoundException)

final、finally、finalize区别

* final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值
* finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码
* finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调用，当我们调用System的gc()方法的时候，由垃圾回收器调用finalize(),回收垃圾

反射和动态代理

java反射的功能

* 在运行时判断任意一个对象所属的类
* 在运行时构造任意一个类的对象
* 在运行时判断任意一个类具有的成员变量和方法
* 在运行时调用任意一个对象的方法

java序列化是什么？什么情况下使用？

​ java序列化: 为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来

​ java使用场景:

*  把内存中的对象状态保存到一个文件中
*  用套接字在网络上传送对象的时候
* 通过RMI传输对象的时候

动态代理是什么？有哪些应用？

​ 动态代理: 当想要给实现了某个接口的类中的方法，加一些额外的处理。比如说加日志，加事务等。可以给这个类创建一个代理，就是创建一个新的类，这个类不仅包含原来类方法的功能，而且还在原来的基础上添加了额外处理的新类。这个代理类并不是定义好的，是动态生成的。具有解耦意义，灵活，扩展性强

​ 动态代理的应用:

* Spring的AOP
* 加事务
* 加权限
* 加日志

​ 怎么实现动态代理: 首先必须定义一个接口，还要有一个InvocationHandler(将实现接口的类的对象传递给它)处理类。再有一个工具类Proxy(习惯性将其称为代理类，因为调用他的newInstance()可以产生代理对象,其实他只是一个产生代理对象的工具类）。利用到InvocationHandler，拼接代理类源码，将其编译生成代理类的二进制码，利用加载器加载，并将其实例化产生代理对象，最后返回

怎么实现对象克隆？

​ 方式1: 实现Cloneable接口并重写clone()方法

​ 方式2: 实现Serializable接口，通过对象的序列化和反序列化实现克隆(该方式能实现深度克隆)

class Student implements Cloneable {

    private String stuId;
    private String stuName;
    private int stuAge;

    public Student(String stuId, String stuName, int stuAge) {
        this.stuId = stuId;
        this.stuName = stuName;
        this.stuAge = stuAge;
    }

    public String getStuId() {
        return stuId;
    }

    public void setStuId(String stuId) {
        this.stuId = stuId;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public int getStuAge() {
        return stuAge;
    }

    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        //要重写该方法
        return super.clone();
    }
}


public class CloneDemo1 {

    public static void main(String[] args) throws Exception {
        Student stu1 = new Student("1901","小明",21);
        Student stu2 = (Student)stu1.clone();   
        Student stu3 = stu1;    
        System.out.println(stu1);
        System.out.println(stu2);
        System.out.println(stu3);
        System.out.println(stu1==stu2);     //false
        System.out.println(stu1==stu3);     //true
        System.out.println("====================");
        stu2.setStuAge(17);
        System.out.println(stu1);
        System.out.println(stu2);
        System.out.println(stu1==stu2);     //false
        System.out.println("====================");
        stu3.setStuAge(19);
        System.out.println(stu1);
        System.out.println(stu3);
        System.out.println(stu1==stu3);     //true
    }
}

深拷贝和浅拷贝的区别

​ 浅拷贝: 只是复制对象的引用地址，2个对象指向同一地址，修改其中任意对象的值，另一个对象的值也会变

​ 深拷贝: 复制对象和值，一个对象的值被修改，另一个对象的值不会变

常用的设计模式

JDK1.8新特性

• Lambda表达式
• 方法引用
• 接口可以定义默认实现方法和静态方法
• StreamAPI，函数式编程风格
• DateTimeAPI,加强日期时间的处理
• Optional容器，解决空指针异常

Lambda表达式

​ 作用: 简化匿名内部类的代码

​ 格式: (形参列表) -> {方法体代码}

​ 条件: 只能简化接口中只有一个抽象方法的匿名内部类 (jdk在接口上添加注解@FunctionalInterface说明该接口有且仅有一个抽象方法，可写Lambda表达式)

//实例: Lambda表达式简化Comparator接口
//匿名内部类排序(按年龄升序)
Collections.sort(list,new Compartor<Person>(){
    @Override
    public int compare(Pesrson p1,Person p2){
        return p1.getAge()-p2.getAge();
    }    
});

//Lambda表达式简化
Collections.sort(list,(Pesrson p1,Person p2) -> {
    return p1.getAge()-p2.getAge();
});

方法引用

​ 作用: 进一步简化Lambda表达式

​ 格式: xx : : xx

​ 条件: 被引用的参数列表和函数式接口的抽象方法的参数列表一致才能使用

//静态方法Lambda表达式
Collections.sort(list, (p1,p2) -> Student.compareTo(p1,p2));

//方法引用简化
Collections.sort(list, Student::compareTo);

接口可以定义静态方法和默认方法

​ 说明: jdk1.8之前接口中只能声明常量和抽象方法，jdk1.8之后接口可以声明静态方法和默认方法

interface MyInterface{
    //静态方法
    static String getName(String name){
        return "接口的静态方法:"+name;
    }
    //默认方法
    default String getId(String id){
        return "接口的默认方法:"+id;
    }
}