一.异常处理
1.1.异常发生的原因有很多，通常包含以下几大类：
1.用户输入了非法数据。
2.要打开的文件不存在。
3.网络通信时连接中断，或者JVM内存溢出。
错误：
1.语法错误：有语法问题无法编译。
2.运行时错误：可以编译，但执行过程中出错，级别低的就是异常。
3.逻辑错误：运行的顺序，条件或者计算方法出错.能编译能运行，不报错，但结果出错。
1.2.Exception（异常）类是 Throwable类的子类。除了Exception类外，Throwable还有一个子类Error
Throwable（可抛出异常）
/
Error Exception
/
IOException RuntimeException
(输入输出异常) （运行时异常）
Throwable：Throwable 类是 Java 语言中所有错误或异常的超类。
Error：Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。
Exception：Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。
有很多的子类，常见子类：
RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。
IOException 输入输出异常
1.3.异常类型：
Exception异常根类
常见子类
受检类型（Checked)
IOException:输入输出异常
SQLException:sql异常
ClassNotFoundException:找不到类
...
不受检类型(unchecked)
RuntimeException
NullPointerException:引用的对象是null
IndexOutOfBoundsException:下标越界
ArrayIndexOutOfBoundsException
StringIndexOutOfBoundsException
ClassCastException:类型转换出错
...
1.4五个关键字处理异常，两种方法（处理和向上抛）：
try catch捕获 finally throw抛 throws抛出
//用法1:作为代码块的一个部份,处理异常 try{ }catch(异常类型 变量){ }finally{ } //用法2:定义方法时定义异常，并抛出异常 public void fun() throws 异常类型{ if(条件) throw new 异常(); }
//处理异常（捕获异常） //try,catch,finally用法 try{ //可以会发生错误的代码 }catch(异常类型 变量){ //错误的处理代码 }finally{ //始终要执行的代码 }
注意：
1.try必须跟至少一个catch或finally块,try不能单独存在。
2.catch块可以有多个,但是异常类型必须不同(先子类后父类)。
3.所有非RuntimeException类型(及子类)的异常必须处理。
try代码是用于监控代码块,可能会发生异常的代码
catch代码块处理异常，如果发生异常就执行匹配类型catch块
finally代码块是无论有没有错误都去执行代码块
//处理异常（抛出异常） Exception ex = new Exception();//创建一个异常对象 throw ex；//抛出一个异常对象 //或 throw new Exception（）;//抛出一个匿名异常对象 //使用throw关键字在代码块中抛出异常 //一般用法： //if（条件） //throw...
注意：
如果抛出异常，可以马上捕获或者向上抛出
1.5自定义异常
//自定义异常，必须继承Exception类(子类),名称为区别普通类，一般定义为XxxxException class XxxxException extends Exception{ public XxxxException(){} public XxxxException(String message){super(message)}; } //示例:设置不能为负数的年龄异常 class AgeException extends Exception{ public AgeException(){ super("年龄不能为负数!"); } public AgeException(String message){ super(message); } } //使用异常 class Student{ private String name; private int age; public void setName(String name){ this.name = name; } public String getName(String name){ return name; } //定义设置年龄,可能出现异常 public void setAge(int age) throws AgeException{ if(age<0) throw new AgeException();//throw抛出一个错误对象 this.age = age; } public int getAge(){ return age; } public String toString(){ return "姓名:"+name+"年龄:"+age; } } public class Test{ public static void main(String args[]){ Student s1 = new Student(); s1.setName("张三"); s1.setAge(18);//可能发生错误 System.out.println(s1); } }
1.6捕获异常
try{ //代码块 }catch(异常类型 ex){ //异常处理 } //JDK1.7+,可以同时匹配多个异常类型 try{ //代码块 }catch(异常类型1|异常类型2|... ex){ //异常处理 } try{ //代码块 }catch(异常类型1 ex){ //异常处理 }catch(异常类型2 ex){ //异常处理 }catch... try{ //代码块 }finally{ 始终要执行的代码块(释放资源) } //JDK1.7+,可以自动释放资源 try(资源){ //代码块 }catch(异常类型 ex){ //异常处理 } try{ //代码块 }catch(异常类型 ex){ //异常处理 }finally{ //始终要执行的代码块 }
1.7抛出异常
//在声明方法时，声明异常同时在代码块中抛出异常 public void fun() throws 异常类型1,异常类型2,...{ if(条件) throw new XxxException1(); try{ ... }catch(XxxException2 ex){ throw ex; } }
1.8自定义异常类型
1.必须继承Exception或Exception的子类
2.名称建议以Exception结尾，标注是一个异常类型
public X1Exception extends Exception{ public X1Exception(){super("默认的错误提示信息!");} public X1Exception(String msg){super(msg);} } public X2Exception extends RuntimeException{ public X1Exception(){super("默认的错误提示信息!");} public X1Exception(String msg){super(msg);} }
1.9异常处理的顺序
1 ... 2 try{ 3 ... 4 ... 5 ... 6 ... 7 }catch(异常类型1 变量){ 8 错误的处理代码 9 }catch(异常类型2 变量){ 10 错误的处理代码 11 }finally{ 12 始终要执行的代码 13 } 14 ... //如果代码没有任何异常,执行顺序 //1->3->4->5->6->12->14 //如果代码4发生"异常类型1"异常,执行顺序 //1->3->8->12->14 //如果代码6发生"异常类型2"异常,执行顺序 //1->3->4->5->10->12->14 //如果代码5发生异常与“异常类型1和类型2”都不匹配,执行顺序 // 1->3->4->12
二.API Application Programming Interface(类库)
java.lang包(语言language)中常用类：
1.认识类
2.构造器,实例化对象
3.常用方法和属性
String:String 类代表字符串
2.1如何创建String类的对象?
1.字面量(直接量)
String str = "abcd";
2.构造器实例化
String str = new String("abcd");
String(byte[] bytes)
通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
//示例: byte[] arr = {'a',97,65,'5','u0061'}; String str = new String(arr); System.out.println(str); //输出结果:aaA5a //4.String(byte[] bytes, int offset, int length) //示例: byte[] arr = {'a',97,65,'5','u0061'}; String str = new String(arr,2,3); System.out.println(str); //输出结果:A5a
2.2其它常用构造器:
1.String(char[] value)
分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
2.String(char[] value, int offset, int count)
分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
3.String(int[] codePoints, int offset, int count)
分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。
4.String(String original)
初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
5.String(StringBuffer buffer)
分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。
6.String(StringBuilder builder)
分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。
2.3三个内容的区别：
String str1=new String();//引用一个空白内容的字符串 String str2 = "";//引用一个空白内容的字符串 String str3 = null;//空引用，没有引用任何对象
都调用length()方法，获取字符串长度时，str1和str2的长度都是0,而str3会抛出NullPointerException。
字符串比较相关方法:
str1==str2:比较str1与str2引用的是不是同一个对象,返回boolean结果.
str1.equals(str2):比较str1与str2字符串的内容是不是相等,返回boolean结果.
str1.equalsIgnoreCase(str2):比较str1与str2字符串的内容是不是相等(不区分大小写),返回boolean结果.
str1.compareTo(str2):比较str1与str2的大小,如果str1>str2为正数，str1<str2为负数,否则为0。
"aa"与"aaa",大的是:"aaa"
"ab"与"aa",大的是"ab"
"Aa"与"a",大的是"a"
"aba"与"aaw",大的是"aba"
str1.compareToIgnoreCase(str2):比较str1与str2的大小,如果str1>str2为正数，str1<str2为负数,否则为0(不区分大小写)。
2.4转大小写：
String toUpperCase()转大写
String toLowerCase()转小写
2.5字符串截取：
substring()
String substring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串。
String substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。
char charAt(int)
2.6字符串连接：
String str = "abc"+"def";
String str = "abc".concat("def");
2.7搜索:
boolean contains(CharSequence s)
当且仅当此字符串包含指定的 char 值序列时，返回 true。
//s1字符串是否包含s2字符串: String s1="广东南方IT学院"; String s2="南方it"; boolean bl = s1.contains(s2) if(bl) System.out.println("包含"); else System.out.println("不包含"); //s1是否包含s2,返回值是true /* if(s1.indexOf(s2)>=0) System.out.println("包含"); else System.out.println("不包含"); */
int length() 求字符串长度
boolean isEmpty()是不是空字符串
String trim() 修整,去左右的空格
String repalce() 替换
String replace(char oldChar, char newChar)
返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)
使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
StringBuffer:字符串缓冲区
构造器(4个)
StringBuffer()
构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
StringBuffer(CharSequence seq)
public java.lang.StringBuilder(CharSequence seq) 构造一个字符串缓冲区，它包含与指定的 CharSequence 相同的字符。
StringBuffer(int capacity)
构造一个不带字符，但具有指定初始容量的字符串缓冲区。
StringBuffer(String str)
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
String与StringBuffer的区别:
String是一个不可变长度字符序列(没有容量，只能长度)
StringBuffer是一个线程安全的可变字符序列（有容量的概念）
常用方法
append(int):向字符串缓冲区追加内容
append(String)
append(char[])
....
capacity():获取字符串缓冲区的容量,返回是一个整数
length():获取字符串缓冲区的字符个数,返回是一个整数
delete(int start, int end)
移除此序列的子字符串中的字符。返回移除的对象
insert()
将参数的字符串表示形式插入此序列中
reverse()
将此字符序列用其反转形式取代。
=================================================================
String
常用方法
int length()
boolean equals(Object)
boolean equalsIgnoreCase(Object)
String substring(int)
String substring(int beginIndex, int endIndex)
char charAt(int index)
int compareTo(String)
int compareToIgnoreCase(String)
boolean contains()
boolean startsWith()
boolean endsWith()
int indexOf()
int lastIndexOf()
byte[] getBytes()
String[] split(String)
String toUpperCase()
String toLowerCase()
StringBuffer|StringBuilder
常用方法
append()
capacity()
length()
insert()
delete()
indexOf()
lastIndex()
substring()
equals()
repalce()
reverse()
toString()
String->StringBuffer
String s="abc";
StringBuffer s1 = new StringBuffer(s);
StringBuffer->String
StringBuffer s1 = new StringBuffer("abc");
String s2 = s1.toString();
=================================================================
java.util.Random
伪随机数类，可以生成随机数系列
Random r1 = new Random();
Random r2 = new Random(long 种子);
常用方法:
实现随机数算法,继承Random类,重写int next(int)
int nextInt()
int nextInt(int maxNum)
float nextFloat() 0-1
double nextDouble()
void nextBytes(byte[] arr);
...
=================================================================
java.util.Date
Date记录日期时间的类
类 Date 表示特定的瞬间，精确到毫秒。
构造器
Date()//当前系统日期时间
Date(long date)//date以毫秒为单位的一个数值
boolean after(Date when)
测试此日期是否在指定日期之后。
boolean before(Date when)
测试此日期是否在指定日期之前。
Object clone()
返回此对象的副本。
int compareTo(Date anotherDate)
比较两个日期的顺序。
boolean equals(Object obj)
比较两个日期的相等性。
long getTime()
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
=================================================================
java.text包
SimpleDateFormat
此类的实例可以根据指定的模式格式化日期，解析得到日期
是日期类的对象与字符串字之间的转换工具类
设置模式，以字符串格式指定:
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss E");
常用方法:
String fromat(Date):将指定日期对象，按指定模式格式为一个日期字符串
示例:
Date now = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss E");
String time = sdf.format(now);
输出:
2017/3/29 10:54:20 星期三
Date parse(String date):将日期格式的字符串，按指定模式解析为一个日期对象,可能会抛出解析异常
示例:
String date = "1998-5-10";//日期格式的字符串
Date birthday = null;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
birthday = sdf.parse(date);
java.util包
Calendar
此类的实例可以设置或获取日期时间指定部份(日期字段)的值
如何获取一个日期对象(Calendar是抽象类)
Calendar cal = new Calendar();//错，抽象类不能实例化对象
Calendar cal = Calendar.getInstance();
Calendar cal = new GregorianCalendar();
常用字段(属性)
YEAR 年
MONTH 月
DAY_OF_MONTH 日
DATE 日
DAY_OF_YEAR 年中的天数
DAY_OF_WEEK 星期
HOUR 时
MINUTE 分
SECOND 秒
JANUARY 一月 0
FEBRUARY 二月 1
MARCH 2
APRIL
MAY
JUNE
JULY
AUGUST
SEPTEMBER
OCTOBER 十月 9
NOVEMBER 10
DECEMBER 十二月 11
SUNDAY 星期日 1
MONDAY 2
TUESDAY 3
WEDNESDAY 4
THURSDAY
FRIDAY
SATURDAY 星期六 7
常用方法
set(int 字段, int 值)设置日历指定字段的值
get(int 字段)获取日历指定字段的值
=================================================================
java.lang
String,StringBuffer,StringBuilder,Math
Math：
近似值
3 3.4999 3.6
double ceil(double a) 3 4 4 上舍
double round(double a) 3 3 4 四舍五入
double floor(double a) 3 3 3 下舍
double n = 3.68;
int n2 = (int)Math.ceil(n);
abs()绝对值
pow(底数，指数)幂运算
sqrt()开平方
random()随机小数(0-1)
sin(double 弧度)
cos(double 弧度)
asin(double 弧度)
=================================================================
java.util
Random,Date,Calendar
Random
种子
实现随机算法，重写next()
Date
实例对象保存一个瞬间值(毫秒)
getTime() after() before compareTo() equals()
Date() Date(Long)
Calendar
日历对象，方便设置或获取日历指定部分的字段值
这个抽象，唯一个实现的子类是GregorianCalendar
常用字段：YEAR,MONTH,...
常用方法:
int get(int 日期字段)
void set(int 日期字段,int 值)
void set(int year,int month, int date)
void add(int 日期字段,int 值)
void roll(int 日期字段,int 值)
Date getTime()
void setTime(Date date)
void setTimeInMillis(long 毫秒值)
=================================================================
java.text
Format(String format(obj), Object parse(String))
NumberFormat
DecimalFormat
DateFormat
SimpleDateFormat
=================================================================
Object类
所有类的根类
自定义类，一般常要重写的方法
String toString()：对此类对象的字符串描述
boolean equals(Object obj)：此对象是不是等于指定对象
int hasCode():返回此对象的一个唯一数字标识
八大包装类
原始类型:boolean byte char short int long float double
包装类型:Boolean Byte Character Short Integer Long Float Double
Byte：此类的对象包装了一个byte值。
Byte 类将基本类型 byte 的值包装在一个对象中。一个 Byte 类型的对象只包含一个类型为 byte 的字段。
此外，该类还为 byte 和 String 的相互转换提供了几种方法，并提供了处理 byte 时非常有用的其他一些常量和方法。
byte byteValue()
作为一个 byte 返回此 Byte 的值。
double doubleValue()
作为一个 double 返回此 Byte 的值。
float floatValue()
作为一个 float 返回此 Byte 的值。
int intValue()
作为一个 int 返回此 Byte 的值。
long longValue()
作为一个 long 返回此 Byte 的值。
short shortValue()
作为一个 short 返回此 Byte 的值。
数字格式字符串(进制不同，基数不同)与byte类型转换
static byte parseByte(String s)
将 string 参数解析为有符号的十进制 byte。
static byte parseByte(String s, int radix)
将 string 参数解析为一个有符号的 byte，其基数由第二个参数指定。
示例:
"10"这样的字符串,得到一个byte值
基数是11：
byte b = Byte.parseByte("11");//结果11
或
byte b = Byte.parseByte("11",10);//结果11
基数是:16(十六进制)
byte b = Byte.parseByte("11",16);//结果17
基数是:2(二进制)
byte b = Byte.parseByte("11",2);//结果3
static Byte decode(String nm)
将 String 解码为 Byte。
//引子:java中表示一个数:10, 0xA09,010
示例:
"0x10"这样的字符串,得到一个byte值
btye b = Byte.decode("0x10");//不需要指定基数,0x打头就是十六进制数。
//将一个byte值，数字字符串，数字字符串加基数作为参数，获得一个Byte对象
static Byte valueOf(byte b)
返回表示指定 byte 值的一个 Byte 实例。
static Byte valueOf(String s)
返回一个保持指定 String 所给出的值的 Byte 对象。
static Byte valueOf(String s, int radix)
返回一个 Byte 对象，该对象保持从指定的 String 中提取的值，该值是在用第二个参数所给定的基数对指定字符串进行解析时提取的。
int compareTo(Byte anotherByte)
在数字上比较两个 Byte 对象。
boolean equals(Object obj)
将此对象与指定对象比较。
int hashCode()
返回此 Byte 的哈希码。
String toString()
返回表示此 Byte 的值的 String 对象。
static String toString(byte b)
返回表示指定 byte 的一个新 String 对象。