2021-07-15

异常处理方案：
异常抛出
可以通过 throws 关键字在方法上声明该方法要拋出的异常，然后在方法内部通过 throw 拋出异常对象当 throw 语句执行时，它后面的语句将不执行，此时程序转向调用者程序，寻找与之相匹配的 catch 语句，执行相应的异常处理程序。如果没有找到相匹配的 catch 语句，则再转向上一层的调用程序。这样逐层向上，直到最外层的异常处理程序终止程序并打印出调用栈情况。

*异常捕获*
	使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。
	try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。
如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。
一个try代码块后面可以跟随多个catch代码块，语法如下：

try{
   // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}catch(异常类型3 异常的变量名3){
  // 程序代码
}

当我们不知道异常具体类型时，可以使用，异常类型会和catch中的类型逐一进行比较，直到异常被捕获或者通过所有的catch块.
try代码块后面还可以接finally关键字，它出现在 catch 代码块最后，语法如下：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。

throws 声明异常
当一个方法产生一个它不处理的异常时，那么就需要在该方法的头部声明这个异常，以便将该异常传递到方法的外部进行处理。可以使用 throws 关键字在方法的头部声明一个异常，其具体格式如下：

returnType method_name(paramList) throws Exception 1,Exception2,…{…}

throws 关键字和 throw 关键字在使用上的几点区别如下：
throws 用来声明一个方法可能抛出的所有异常信息，throw 则是指拋出的一个具体的异常类型。
通常在一个方法（类）的声明处通过 throws 声明方法（类）可能拋出的异常信息，而在方法（类）内部通过 throw 声明一个具体的异常信息。
throws 通常不用显示地捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法； throw 则需要用户自己捕获相关的异常，而后再对其进行相关包装，最后将包装后的异常信息抛出。

常用类

字符串类
String -->不可变长字符序列
StringBuilder -->可变长字符序列
StringBuffer -->可变长字符序列
三者区别：
运行速度：StringBuilder–>StringBuffer–>String
线程安全: StringBuilder是线程不安全的，而StringBuffer是线程安全的
总体来说：
String：适用于少量的字符串操作的情况
　　StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
　　StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
三者都可使用API工具查询其使用方式；
1.类的作用，类的继承体系
学习一个类 ： 2.构造器
3.方法（静态方法|成员方法）

String构造器：

		//String(String original) 初始化新创建的String对象，使其表示与参数相同的字符序列;
		// 换句话说，新创建的字符串是参数字符串的副本。
        String str1=new String("haha");
        System.out.println(str1);
        //String(byte[] bytes) 通过使用平台的默认字符集解码指定的字节数组构造新的 String 。
        byte[] arr1= "你好".getBytes();
        String str2=new String(arr1);
        System.out.println(str2);
        //String(byte[] bytes, int offset, int length) 通过使用平台的默认
        //字符集解码指定的字节子阵列来构造新的 String 。
        String str3=new String(arr1,3,3);
        System.out.println(str3);
        //String(char[] value) 分配新的 String ，使其表示当前包含在字符数组参数中的字符序列。
        char[] arr2=new char[]{'a','b','g','f'};
        String str4=new String(arr2);
        System.out.println(str4);
        //String(char[] value, int offset, int count) 分配一个新的 String ，
        //其中包含字符数组参数的子数组中的字符。
        String str5=new String(arr2,1,2);
        System.out.println(str5);

StringBuffer:

 		//String转StringBuffer
        String str=new String("skdjk");
        StringBuffer sb1=new StringBuffer(str);
        System.out.println(sb1);
        System.out.println(sb1.length());
        System.out.println(sb1.capacity());

        //StringBuffer(int capacity) 构造一个字符串缓冲区，其中没有字符和指定的初始容量。
        StringBuffer sb2=new StringBuffer(6);
        System.out.println(sb2.length());
        System.out.println(sb2.capacity());

        //StringBuffer append(boolean b) 将 boolean参数的字符串表示形式追加到序列中。
        //StringBuffer append(char c) 将 char参数的字符串表示形式追加到此序列。
        //StringBuffer append(char[] str) 将 char数组参数的字符串表示形式追加到此序列。
        //StringBuffer append(char[] str, int offset, int len) 
        //将 char数组参数的子数组的字符串表示形式追加到此序列。
        sb1.append(false);
        System.out.println(sb1);
        System.out.println(sb1.length());
        System.out.println(sb1.capacity());

        //char charAt(int index) 返回指定索引处的此序列中的 char值。
        System.out.println(sb1.charAt(5));

        //int codePointAt(int index) 返回指定索引处的字符（Unicode代码点）。
        //int codePointBefore(int index) 返回指定索引之前的字符（Unicode代码点）。
        //int codePointCount(int beginIndex, int endIndex) 返回此序列的指定文本范围内的Unicode代码点数。
        System.out.println(sb1.codePointAt(5));
        System.out.println(sb1.codePointCount(5,8));

        //int compareTo(StringBuffer another) StringBuffer字典顺序比较两个 StringBuffer实例。
        //System.out.println(sb1.compareTo(sb2));

        //StringBuffer insert(int offset, char c) 将 char参数的字符串表示形式插入此序列中。
        //StringBuffer insert(int offset, char[] str) 将 char数组参数的字符串表示形式插入此序列中。
        //StringBuffer insert(int index, char[] str, int offset, int len)
        //将 str数组参数的子数组的字符串表示形式插入此序列中。
        sb1.insert(5,'A');
        System.out.println(sb1);

        //StringBuffer reverse() 导致此字符序列被序列的反向替换。
        System.out.println(sb1.reverse());

调用各自不同的方法，三者都可以进行转换

基本数据类型和其包装类
基本类型：byte short int long char boolean flooat double
其包装类：Byte Short Integer Long Character Boolean Float Double
（int类型和Integer类）
基本数据类型的优点：有利于节省内存
包装类的优点：
1. 可以提供很多成员功能
2. 可以存储引用数据类型，想要存储基本数据类型，可以先转为对应的包装类型再存
3. 基本数据 类型与对应包装类型数据 的默认值 不同
（例：区分账户余额的两种状态0和null可以表达不同的意思）
自动折装箱：
1. 自动装箱: 基本类型转成包装类的过程,通过调用包装类的valueOf()方法
2. 自动折箱: 包装类转成基本类型的过程,通过调用包装类的intValue(),doubleValue(),*Value()
经典判断题：
int,Integer,new Integer()三者之间比较是否相等

 public static void main(String[] args) {
        int a1=127;
        int a2=127;
        Integer a3=127;
        Integer a4=127;
        Integer a5=new Integer(127);
        Integer a6=new Integer(127);
        Integer a7=128;
        Integer a8=128;
        int a9=128;
        System.out.println(a1==a2);     //t
        System.out.println(a3==a4);     //t
        System.out.println(a5==a6);     //f
        System.out.println(a1==a3);     //t
        System.out.println(a1==a5);     //t
        System.out.println(a3==a5);     //f
        System.out.println(a7==a8);     //f
        System.out.println(a7==a9);     //t
        int b=Integer.valueOf(a3);
    }

总结:

        1.两个基本数据类型只要数据值相等,==比较结果就相等
        2.两个new 包装类比较,无论数据值是否相等,都不相等,因为new在堆中创建新的地址空间
        3.Integer i3,与Integer i4,两个自动装箱的对象比较,在[-128,127]范围之内相等,否则返回new Integer不相等
        4.int与Integer|new Integer() ,只要数据值相等就相等,因为会发生自动拆箱

Math（数学相关类）
使用API查询其使用方式：
了解其常用的方法：abs()、ceil()、floor()、min()、max()、pow()、random()、round()、sqrt()……例：

public static void main(String[] args) {
		//两个常用静态常量
		//static double E double值比任何其他值更接近 e ，即自然对数的基数。  
		//static double PI double值比任何其他 pi更接近，圆的圆周与其直径的比率。  

        //static double abs(double a) 返回 double值的绝对值。
        System.out.println(Math.abs(-3658.3688));

        //static double ceil(double a) 返回大于或等于参数且等于数学整数的最小值（最接近负无穷大） double 。
        System.out.println(Math.ceil(3.15));
        //static double floor(double a) 返回小于或等于参数且等于数学整数的最大值（最接近正无穷大） double 。
        System.out.println(Math.floor(2.9999));

        //static long max(long a, long b) 返回两个 long值中较大的 long 。
        //static double min(double a, double b) 返回两个 double值中较小的 double 。
        System.out.println(Math.max(69,58));
        System.out.println(Math.min(69,58));

        //static double pow(double a, double b) 返回第一个参数的值，该值是第二个参数的幂。
        System.out.println(Math.pow(2,4));

        //static double random() 返回带有正号的 double值，大于或等于 0.0且小于 1.0 。
        System.out.println(Math.random());

        //static long round(double a) 返回与参数最接近的 long ，并将关系四舍五入为正无穷大。
        //static int round(float a) 返回与参数最接近的 int ，并将关系四舍五入为正无穷大。
        System.out.println(Math.round(36.48999));
        System.out.println(Math.round(156.5));

        //static double sqrt(double a) 返回 double值的正确舍入正平方根。
        System.out.println(Math.sqrt(10));
        System.out.println(Math.sqrt(9));

        //static double sin(double a) 返回角度的三角正弦值。
        System.out.println(Math.sin(45));

    }

Date 及 日期格式转换器SimpleDateFormat
Date:after()、before()、toString()、getTime()……
Date() 分配 Date对象并对其进行初始化，使其表示分配时间，测量 Date到毫秒。
long getTime() 返回自此 Date对象表示的1970年1月1日00:00:00 GMT以来的毫秒数。
boolean after​(Date when) 测试此日期是否在指定日期之后。
boolean before​(Date when) 测试此日期是否在指定日期之前。
String toString() 将此 Date对象转换为以下形式的 String ：
SimpleDateFormat：
是一个用于以区域设置敏感的方式格式化和解析日期的具体类。
它允许格式化（日期→文本），解析（文本→日期）和规范化。
日期和时间模式
日期和时间格式由日期和时间模式字符串指定。 在日期和时间模式字符串中，从’A’到’Z’以及从’a’到’z’未加引号的字母被解释为表示日期或时间字符串的组成部分的模式字母。 可以使用单引号（ ’ ）引用文本以避免解释。 "’’"代表单引号。 不解释所有其他字符; 它们只是在格式化过程中被复制到输出字符串中，或者在解析过程中与输入字符串匹配。
定义了以下模式字母（从’A’到’Z’以及从’a’到’z’所有其他字符都是保留的）：