包装类 String类 可变字符串 BigDecimal(浮点数精确计算类) Calendar SimpleDateFormat 集合 泛型 异常

1、包装类

八个基本类型：byte、short、int、long、float、double、char、boolean。
八个包装类：Byte、Short、Integer、Long、Float、Double、Character、Boolean。
java中基本数据类型能作为一个值让我们运用，没有其他的功能，而他们对应的包装类就提供了很多方法，并且他们也同样能进行相加减，不过在与基本类型相加减的时候回自动转为基本类型。
1.2装箱、拆箱

1. 八种包装类提供不同类型间的转换方式。
2. Number父类中提供的6个共性方法。
   1.parseXXX()静态方法（除了Character）。
   2.valueOf()静态方法。
3. 注意：需保证类型兼容，否则抛出NumberFormatException异常。
4. JDK 5.0之后，自动装箱、拆箱。基本数据类型和包装类自动转换。

装箱实例：

int num=18;
Integer integer=Integer.valueOf(num);

拆箱实例：

Integer integer1=new Integer(10);
int num1=integer1.intValue();

jdk1.5之后提供了自动装箱与拆线箱
int age 10；
Integer age1=age;//自动装箱
int age2=age1//自动拆箱；

1.3基本类型与字符串之间的转化（重点）
实例：
整形转化为字符串

int n1=22;
//1使用+号
String s1=n1+"";
//2使用Integer中的统String（）方法
String s2=Integer.toString(n1);

对应的其他类型转化为字符串也一样，把包装类型换上去就能使用。

字符串转成基本类型

String str="123";
int n=Integer.parseInt(str);//整形
double d=Double.parseDOuble(str);//双精度
//同样其他类型也是把对应的包装类型换上去
//特别之处，Boolean不同
String str1="true";
boolean b1=Boolean.parseBoolean(str1);//b1的值为true
String str2="false";
boolean b2=Boolean.parseBoolean(str2);//b2的值为false
boolean b3=Boolean.parseBoolean(str);//b3的值为false
//当字符串为"true"也仅为这个时，Boolean的值为true,其余都为false.

1.4整数缓冲区（了解）

1. Java预先创建了256个常用的整数包装类型对象。
2. 在实际应用当中，对已创建的对象进行复用

2、String类（重点）

2.1概述：

1. Java程序中的所有字符串文本（例如“abc”）都是此类的实例
2. 字符串字面值是常量，创建之后不可改变。
3. 常用创建方式：

String str1 = “Hello”;
String str2 = new String(“World”)

问题：为什么说String字符串的值不能改变，而我的写法又能改变，例如

String str="123";
//这里str的值为：123
str+="234";
//这里str的值为：123234，这个不就改变了？

解答：上面的字符串相加使得str的值发生改变，是因为java在编译过程中把string的str转化成了StringBuilder类型，这个类型叫做可变字符串类型
class文件反编译代码：

String str = "123";
str =  (new StringBuilder(String.valueOf(str))).append("234").toString();

2.2常用方法：
2.2.1 public char charAt(int index)
该方法为根据下标找字符，很容易理解
2.2.2 public boolean contains(String str)
该方法为判断当前字符串中是否包含str,
可以用在检测字符串有什么非法字符等，运用在注册登录上。
2.2.3 public char[] toCharArray()
该方法为将字符串转化为字符数组，运用的场景比较多，当你相对字符串中的字符进行操作的时候可以先转化为字符数组，之后在通过其他方法转为字符串。
2.2.4 public int indexOf(String str)
该方法为查找str首次出现的下标，存在，则返回改下标（该查找字符串第一个字符的下标）不存在返回-1。精确定位然后截取，一般可以这么用吧。
2.2.5 public int length()
该方法为返回字符串长度，不难理解
2.2.6 public String trim()
该方法为去掉字符串前后的空格，有点鸡肋
2.2.7public String toUpperCase()
该方法将小写转成大写，字符串所有字符转化。
2.2.8 public boolean endsWith(String str)
该方法为判断字符串是否已str结尾，可以用来判断一个文件的后缀。
2.2.9 public String replace(char oldChar,char newChar)
该方法为把oldChar替换成newchar,当用上这个方法，他会把字符串所有的oldChar的子字符串全部换为newChar字符串，假如想只替换第一个oldchar子字符串，可以使用replaceFirst。
2.2.10 public String[] split(String str)
该方法为把str子字符串给去掉，假如它在该字符串的中间，那么该字符串分成两个子字符串，如果str在头或者尾部，则得到一个子字符串，这个方法可以用来统计字符串中有多少目标字符串，在头和尾部分别加上无关字符串，之后使用该方法去查找目标字符串，得到的字符串数组的个数减一就是得到的个数。
2.2.11 public String subString(int beginIndex,int endIndex)
该方法为截取下标从beginIndex开始到下标endIndex结束的字符串，字符串包含下标为beginIndex的值，不包含endIndex的值。

3、可变字符串

3.1概念：可在内存中创建可变的缓冲空间，存储频繁改变的字符串。
java中提供了两个可变字符串类：

1. StringBuilder:可变字符串，jdk5.0提供，运行效率快、线程不安全
2. StringBuffer：可变长字符串，jdk1.0提供，运行效率慢、线程安全。
3. 这两个类中的方法和属性完全一致。

上面String类型字符串提到的不可变，但却可变的特性就是转换为这两个字符串之后做到的。

3.2
常用方法：
3.2.1 public StringBuilder append(String str)
该方法为添加类容，他会在原有字符串后加上str。经常使用吧。
3.2.2public StringBuilder insert(int dstOffset,charSequence s
该方法为将指定字符串插入此序列中，插队吧。
3.2.3public StringBuilder delete(int start, int end)
该方法为移除次序列的子字符串中的字符，容易理解，从下标到下标。
3.2.4 public StringBuilder replace(int start,int end,String str)
该方法为使用给定字符串替换次序列的子字符串，start开始位置，end结束位置，容易理解。
3.2.5 public int length()
该方法为返回长度（字符数）。

4、BigDecimal

4.1什么是BigDecimal，他就是一个精确运算，他可以运算整数和浮点数。

4.2为什么使用BigDecimal?

4.3BigDeicmal基本用法

1. 位置：java.math包中
2. 作用：精确计算浮点数
3. 创建方式：BigDecimal bd=new BigDecimal(“1.0”);
4. 注意：在把浮点数传给它的时候需要用字符串包裹，不然传给他的还是一个有很多小数点后面有很多位的近似值，无法精确运算。

4.4常用方法

BigDecimal add(BigDecimal bd)   //加
BigDeimal subtract(BigDecimal bd)  //减
 BigDecimal  multiply(BigDecimal  bd) //乘
 BigDecimal  divide(BigDecimal bd)  //除
 //注意，这个运算只能和自己（本类型）进行相加减，另外除法可能会遇到无限循环小数，除法还有另一个方法
 divide(BigDecimal bd,int scal,RoundingMode mode)
 //参数scale：指定精确到小数点后几位。
 //参数mode：指定小数部分的取舍模式，通常采用四舍五入的模式。取值为BigDecimal.ROUND_HALE_UP。

4.5 一个计算器方法

//调用时需要输入两个数和一个运算符
public static BigDecimal six(double num1,double num2,String suanfa) {
		String str1=Double.toString(num1);
		String str2=Double.toString(num2);
		BigDecimal bd1=new BigDecimal(str1);
		BigDecimal bd2=new BigDecimal(str2);
		BigDecimal result=null;
		switch(suanfa) {
		case "+":result=bd1.add(bd2);break;
		case "-":result=bd1.subtract(bd2);break;
		case "*":result=bd1.multiply(bd2);break;
		case "/":result=bd1.divide(bd2);break;
		default:System.out.println("没有这种运算");
		}
		return result;
	}

5、Date

5.1概念： Date表示特定的瞬间，精确到毫秒。

Date有个很实用的方法：getTime（）；
这个方法得到的结果是一个毫秒值，自1970年1月1日以来到现在的毫秒值。1秒等于1000毫秒
因为date很多方法都被舍弃掉了，所以主要学习calendar

6、Calendar

1. Calendar提供了获取或设置各种日历字段的方法
2. protected Calendar() 构造方法为protected修饰，无法直接创建该对象。

6.1常用方法

static Calendar getInstance()  //使用默认时区和区域获取日历
void set(int year,int month,int date,int hourofday,int minute,int second)  //设置日历的年、月、日、时、分、秒。
int get(int field) //返回给定日历字段的值。

6.2 方法的实际运用

Calendar c=Calendar.getInstance();
System.out.println(c);//输出c里面有什么值
int year=c.get(Calendar.YEAR); //得到当前年份
int month=c.get(Calendar.MONTH)+1;//得到当前月份，其中加一是因为java中月份是从零开始。
int day=c.get(Calendar.DAY_OF_MONTH);//得到当前的日期
int hour=c.get(Calendar.HOUr_OF_DAY);//得到当前小时
int minute=c.get(Calendar.MINUTE);//得到当前分钟
int second=c.get(Calendar.SECOND);//得到当前秒数
//等等

7、SimpleDateFormat

1. SimpleDateFormat是以与语言环境有关的方式来格式化和解析日期
2. 进行格式化（日期->文本）、解析（文本->日期）.。

7.1常用时间模式字母

7.2案例演示：
sdf.format();//格式化
sdf.parse();//解析

public class TestSimpleDateFormat{
	public staitc void main(String[] args)throws Exception{
		//先设置一个格式
		SimpleDateFormat sdf=new SimpleDateForMat("yyyy/mm/dd  HH-mm-ss");
		//创建一个date对象
		Date date=new Date();
		System.out.println(date)//输出：Tue Jul 13 20:14:26 CST 2021
		//1.把date经过格式化变成字符串
		String str=sdf.format(date);
		System.out.println(str);//输出：2021/07/13  20:14:26
		//2.把字符串解析成日期
		//字符串的格式必须和sdf设置的格式一样，否则不能报异常
		//给出一个字符串
		String str1="1919/05/04  12-34-45";
		//解析
		Date date1=sdf.parse(str1);
		System.out.println(date1);//输出：Sun May 04 12:34:45 CST 1919
	}
}

8、System

System系统类，主要用于获取系统的属性数据和其他操作。
8.1常用方法

9、集合

9.1集合的概念

1. 对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
2. 位置：java.util.*;

集合与数组的区别：

1. 数组长度固定，集合长度不固定。
2. 数组可以存储基本类型和引用类型，集合只能存储引用类型。

9.2Collection体系集合

Collection父接口：
特点：代表一组任意类型的对象，无序、无下标。

常用方法（重点）

boolean add(Object obj)
//添加一个对象数据，数据类型是object所以所有的引用数据类型都可以添加，如果添加的是八大基本类型数据，他会自动帮你转成包装类数据
boolean addAll(Collection c)
//将一个集合中的所有对象添加到此集合中，假如有相同的数值等也会添加进来。
void clear()
//清空此集合的所有对象
boolean contains(Object o)
//检查此集合中是否包含o对象，如果包含则返回true,不包含返回false
boolean equals(Object o)
//检测此集合是否与指定对象相等
boolean isEmty()
//判断此集合是否为空
boolean remove(Object o)
//在此集合中移除o对象，如果没有该对象则返回false
int size()
//返回此集合的元素个数
Object[] toArray()
//将此集合转换成数组

函数使用示例

public calss TestCollection{
	public static void main(String[] args){
		//创建集合(导包省略)
		Collection lis=new ArrayList();//因为Collection是一个接口无法实例化，所以一般都是使用Collection变量指向其子类对象。
		//添加元素
		lis.add("苹果");//String类型加入其中
		lis.add(2);//Integer类型加入其中，本行代码的发编译代码为：lis.add(Integer.valueOf(2));
		//删除元素
		lis.remove(2);
		//遍历元素，使用foreach
		for (Object object : lis) {
			System.out.println(object);
		}//输出：苹果
		//输出集合元素个数
		System.out.println(lis.size());
		//使用迭代器
	}
}

9.3List接口与实现类（重点）

9.3.1List接口
特点：有序、有下标、元素和重复继承collection接口。
常用方法：

void add(int index,object o)
//传入的参数为下标和对象，方法的作用是在index位置插入对象o
boolean addAll(int index,Collection c)
//传入的参数有下标和一个Collection集合，作用将一个集合中的元素添加到index的位置，该位置及以后的数据都往后移
Object get(int index)
//传入下标，获取下标位置的对象
List subList(int forMIndex,int toIndex)
//返回fromIndex和toIndex之间的集合元素

案例演示：

public class TestList{
	public static void main(String[] args){
		//先创建集合对象
		List list=new ArrayList();
		//添加元素
		list.add("苹果");
		list.add("小米");
		//在小米之前加上华为
		list.add(0,"华为");
		//使用foreach遍历
		for(Object object:list){
			System.out.println(object);
		}
		//得到集合指定位置的对象
		String str=(String)list.get(0);//已经知道华为是一个字符串，所以用String类型接收,但是它返回的是一个object类，所以需要用到强转。
		System.out.println(str);
	}
	
}

9.3.2集合的遍历方式

public class BianliList{
	public static void main(String[] args){
		//创建集合并添加一些值
		List list=new ArrayList();
		list.add("java");
		list.add("c");
		list.add("c++");
		list.add("c#");
		list.add("php");
		//1.使用for循环遍历
		for(int i=0;i<list.size();i++{
			System.out.println(list.get(i);	
		}
		//2.使用foreach循环遍历
		for(Object object:list){
			System.out.println(object);
		}
		//3.使用迭代器遍历(集合专属遍历器)
		//使用迭代器
		Iterator it=list.iterator();
		while(it.hasNext()){//初始时它在集合第一个元素之前，然后一个一个往下找，直到最后一个元素。
			System.out.println(it.next());

		}

	}


}

9.3.3 List实现类
ArrayList(常用）
数据结构实现，查询块、增删慢。
ArrayList实现List接口的方法，使得在ArrayList集合里的数据以类似于数组的形式保存，该集合可以通过下标直接获取元素，并且可以通过下标插入元素。
LinkedList(一般·)
链表结构实现，增删块，查询慢。
LinkedList集合里的数据通过双向链表链接，增删查改的时候只需把相应的链条改变就行，所以增删速度快，再查找元素的时候则需要从第一个开始，一次查询，速度慢，不过这些速度跟现在学习得我没有关系。
Vector(不常用）
数组结构实现，查询块、增删慢。

10、泛型

概念：
java泛型是jdk1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
常见的形式有泛型类、泛型接口、泛型方法
语法：
<T,…>T称为类型占位符，表示一种引用类型。
优点：
提高代码的重用性。
防止类型转换异常，提高代码的安全性。
案例演示:
1、泛型类：

//首先创建一个普通类
public class Ordinary{
	String name;//字符串类型
}//这是个普通类，里面有一个name属性
//创建一个泛型类
public class Generic<T>{
	String name;
	T sex;//泛型类型属性，它的类型由创建该类对象的时候传递的类型决定，如果在创建对象的时候没有传递类型，则它默认为Object类。
	public T show(T sss){
		return sss;
	}//泛型同样可以用在该类的方法中。
}

基于上面的泛型类，创建一个对象

public class Test{

	public static void main(String[] args){
		Generic g=new Generic<String>();
		System.out.println(g.show("123");
		//不出意外控制台上输出了123；
		//此时泛型类中的T为字符串类型。
	}

}

2、泛型方法

public class Commer{
	//这是个普通类，不能使用泛型，但是这时我的一个方法需要用到泛型该如何？
	//这时可以使用泛型方法，如下
	public <T> show(T t){
		System.out.println("泛型方法"+t);
		return t;
	}//泛型方法的写法就是在普通方法的访问权限与返回值之间加上<T>，此时这个泛型的使用范围仅仅这个方法范围

	//对泛型方法的调用，为了方便直接写在这个类里
	public static void main(String[] args){
		//因为上面的方法不是静态方法，所以调用的时候需要创建一个类对象，因为静态方法无法直接调用非静态方法
		Commer c=new Commer();
		String str=c.ceshi("看看如何调用非泛型类里的泛型方法");//因为我传入的是字符串类型，所以泛型方法中的T也就是字符串类型，所以用字符串接收。
	
}

}

3、泛型接口（有点复杂）
首先弄一个泛型接口

public interface MyInterface<T>{
	T server(T t);//简写，全写：public abstract T server(T t);  默认公共抽象类方法
}

再弄一个类实现接口

public class shixian<T> implements MyInterface<T>{
	@Override
	public T show(T t) {
		return t;
	}
}
//前面一个<T>的作用用来标明这个是个泛型类，泛型占位符T,后面一个用来传递类型，假如后面<T>省略则它的重写方法类型只能是object

最后调用类

public class Diaoyong{
	public static void main(String[] args){
	//我要传入字符串类型,这里强调只能传入引用类型，基本类型不可以
		Shixian<String> s=new Shixian<String>();
		String str=s.show("abc");
		//最后控制台能输出abc
		//传入整型
		Shixian<Integer> s1=new Shixian<Integer>();
		int a=s.show(123);
		//控制台输出123
	}

}

泛型集合
参数化类型、类型安全的集合，强制集合元素的类型必须一致。
特点：
编译时即可检查，而非运行时抛出异常。
访问时，不必类型转换（拆箱）。
不同泛型之间引用不能相互赋值，泛型不存在多态。

举个写法

ArrayList<String> arr=new ArrayList<String>();
//这个集合只能添加字符串类型的值
arr.add("abc");
//当添加其他的值时会报错
arr.add(123);//会提示无法添加整形。这就是泛型的规范作用吧。

11、Collections工具类

集合工具类，定义了除了存取以外的集合常用方法。
常见方法：

public static void reverse(List<?>list)
//反转集合中元素的顺序
public static void shuffle(List<?>ist)
//随机重置集合元素的顺序
public static void short(List list)
//因为该方法在排序的过程中会用到comparable的方法，而默认调用的这个方法它的哈希值是不确定的，所以要重写Comparable接口方法，让它的哈希值来源确定。（大概是这个意思）升序排序（元素类型必须实现Comparable接口）
public static int binarySearch(list,T key)
//传入一个集合以及要找的关键字，二分查找

12、Set集合

12.1 Set接口
特点：
无序、无下标、元素不可重复（重点）。
方法：
全部继承自Collection中的方法。
使用foreach循环遍历：
for(数据类型 局部变量：集合名){
//循环内部的局部变量，代表当次循环从集合中取出的对象
}

set集合的保存数据，增删查改都和list差不多，只是少了下标查找，重要的是在插入多个相同的数据时，只会保存最后一个，遍历输出的时候也只有一次。（自动把相同类型覆盖，只留下最后一个）

12.2 Set实现类
12.2.1HashSet(常用)
基于HashCode实现元素不重复。
当存入的元素的哈希码相同是，会调用==或equals进行确认，结果为true，拒绝后者存入。

HashSet存储方式采用数组链表结合，首先用哈希码在数组中寻找空间，如果空间没有被占，那么直接占据该空间，如果空间被其他数值给占了，那么就与他比较一下，如果相同，则被抛弃，不存储，假如不相同，则通过链表的形式被挂载同一个数组位置。

12.2.2 LinkedHashSet(不常用)
链表实现的HashSet,按照链表进行存储，即可保留元素的插入顺序。

12.2.3 TreeSet（比较常用）
基于排列顺序实现元素不重复。
实现了SortedSet接口，对集合元素自动排序。
元素对象的类型必须实现Comparable接口，指定排序规则（自然排序）。
通过CompareTo方法确定是否重复元素。

TreeSet排序使用的是二叉树排序法，首先第一个加入的元素为根节点，其余的元素分别于节点比较，比节点大，则保存在节点右方向，比节点小则保存在左方向。

13、Map集合

Map接口特点：
用于存储任意键值对（Key-Value）。
键：无下标、不可重复（唯一）
值：无下标可以重复。

13.1Map接口
特点：
称为“映射”存储一对数据（Key-Value），坚不可重复，值可以重复

常用方法：

V put(k key,V value)
//讲对象存入到集合中，关联键值，key重复原则覆盖原值。（这个方法也可以作为map单独修改某一键值对应的value值）
Object get(Object key)
//根据键获取对应的值。传入键获得值，很容易理解。
Set keySet()
//返回所有Key值，这个方法可以用做Map的遍历
Collection values()
//返回包含所有值的Collection集合。和上面一个方法类似，这次返回的是value值。
Set<Map.Entry<K,V>>entrySet()
//键值匹配的Set集合。这个方法也可以用做Map的遍历

案例演示：

public class TestMap{
	public static void main(String[] args){
		//创建Map集合
		Map<String,String> map=new HashMap<String,String>();//这里创建了一个键值和value值都是字符串类型的Map集合
		//1.添加元素
		map.put("CN","中国");
		map.put("UK","英国");
		//输出集合中元素个数
		System.out.println("元素个数"+map.size());
		//输出map集合
		System.out.println(map.toString());
		//2.删除
		map.remove("UK");
		//3.遍历
		map.put("USA","美国");
		map.put("WTO","菜市场");
		//3.1使用keySet()遍历
		Set<String>keyset=map.keySet();
		for(String key:keyset){
			System.out.println(key+":"+map.get(key));
		//3.2使用entrySet()方法
		Set<map.Entry<String, String>>entries=map.entrySet();
		for(Map.Entry<String,String>> entries=map.entrySet();
			System.out.println(entry.getKey()+":"+entry.getValue();
		//4判断
		System.out.println(map.containsKey("CN"));
		System.out.println(map.containsValue("其他"));//有则返回true，没有则返回false
		}
	}

}

13.2 Map实现类
13.2.1 HashMap(常用)
允许使用null作为key或者value。
存储结构：哈希表

13.2.2 TreeMap
实现了SortedMap接口（Map的子接口），可以对key自动排序，key需实现Comparable接口。（因为要排序，假如key使用的是字符串，那么我们就不能准确知道顺序，所以要实现Comparable然他按照自己的想法排序）
13.2.3 其他实现类
Hashtable:不允许null作为key或者value
properties:Hashtable的子类要求key和value都是String。通常用于配置文件的读取。

14、异常

14.1概念
异常：程序在运行过程中出现的特殊情况。

14.2 异常的必要性
任何程序都可能存在大量的未知问题、错误。
如果不对这些问题进行正确处理，则可能导致程序的中断，造成不必要的损失。

14.3 异常分类
14.3.1 错误
Error:JVM、硬件、执行逻辑错误，不能手动处理。
常见错误：StackOverFlow、outOfMemoryError等。
14.3.2 异常
Exception:程序在运行和配置中产生问题，可处理。
RuntimeException：运行时异常，可处理，可不处理。
CheckedException：检查是异常，必须处理。

常见运行时异常：

案例演示

public class Demo1{
	public static void main(String[] args){
		//NullPointerException
		String name=null;
		System.out.println(name.equals("zhangsan"));
		//ArrayIndexOutOfBoundsException
		int[] arr={10,30,50];
		System.out.println(arr[3]);
		//ClassCastException
		Object str="hello";
		Integer i=(Integer)str;
		//NumberFormatExceptionint n=Integer.parseInt("100a");
		System.out.println(n);
		//ArithmeticException
		int n=10/0
		System.out.println(n);
		
	}

}

14.5 异常产生和传递
异常产生
自动抛出异常：当程序在运行时遇到不符合规范的代码或结果是，会产生异常。
手动抛出异常：语法：Throw new 异常类型（“实际参数（或者说要给出的错误提示）”）。
产生异常结果：相当于遇到return语句，导致程序异常而终止。

传递
在一个方法中产生了异常，我们有两个选择，一个是抛出，一个是try，catch处理，如果选择处理，那么程序的异常就能完结，如果选择抛出那么异常就会跑到调用此方法的程序中，这时候如果它还选择抛出那么继续往上，最终会在JVM中被终止程序。
总结：异常出现，不处理就一直往上抛。直到被处理，或者到JVM里使得程序终止。

14.6异常处理（重点）
java的异常处理是通过5个关键字来实现：
try：执行可能产生异常的代码。
catch：捕获异常，并处理。
finally：无论是否发生异常，代码总能执行。
throw：手动抛出异常。
throws：声明方法可能要抛出的各种异常。

14.6.1 try…catch…
语法：

try{
	//可能出现异常的代码
}catch(Exception e){
	//异常处理的相关代码，如：getMessage()、printStackTrace()
}

实例演示

public class TestException2 { 
	public static void main(String[] args) {
	 Scanner input=new Scanner(System.in); 
	 int result=0; 
	 try {
	 	System.out.println("请输入第一个数字"); 
	 	int num1=input.nextInt();
	 	//InputMismatchException 
	 	System.out.println("请输入第二个数字"); 
	 	int num2=input.nextInt(); 
	 	result=num1/num2;
	 	//发生异常
	 	// ArethmicException 
	 	}catch (Exception e) {//捕获 Exception：是所有异常的父类 
	 	//处理 //e.printStackTrace(); 
	 	System.out.println(e.getMessage()); }
	 	System.out.println("结果是:"+result); 
	 	System.out.println("程序结束了..."); } }
	 	//可能出现的情况：1正常请求 2、出现异常并处理 3、异常类型不匹配

14.6.2 try…catch…finally…
语法：
try{
//可能出现异常的代码
}catch(Exeption e){
//异常处理的相关代码，如：getMessage()、printStackTrace()
}finally{
//是否发生异常都会执行，可以释放资源等。
}

当代吗执行到try里面之后finally里的代码会必定执行，当try里有return关键词的时候，会在执行return之前执行finally的代码再执行return（这是个特例）如果遇到了前方有System.exit（）,这种情况是唯一不会执行的情况。

14.6.3 多重catch
语法：
try{
//可能出现异常的代码。
}catch(异常类型1){
//满足异常类型1执行的相关代码。
}catch(异常类型2){
//满足异常类型2执行的相关代码。
}
…

14.6.4 try…finally…
try…finally…不能捕获异常，仅仅用来当发生异常时，用来释放资源。一般用在底层代码，只释放资源不做异常处理，把异常向上抛出。

语法：
try{
//可能出现异常代码
}finally{
//是否发生异常都会执行，可以释放资源等
}

14.7 声明、抛出异常
声明异常
如果在一个方法中抛出了异常，如何通知调用者？
throws关键字：声明异常（提前告知，本方法可能会遇到的异常类型，并且将不会对他进行处理，由调用函数以及上面的函数进行处理）
实例：

public class TestException6 { 
public static void main(String[] args){

try {
	divide(); 
} catch (Exception e) { //当抓取到divide方发中的异常之后进行处理，这样就能够保证程序不会被异常终止。
//e.printStackTrace(); 
	System.out.println(e.getMessage()); 
	} 
}
public static void divide() throws Exception {//当输入的num2为0的时候就会产生算术异常。
 	Scanner input=new Scanner(System.in); 
	 System.out.println("请输入第一个数字"); 
 	int num1=input.nextInt(); 	
 	System.out.println("请输入第二个数字"); 	
 	int num2=input.nextInt(); 
 	int result=num1/num2; 
 	System.out.println("结果:"+result); } }

14.6.4 自定义异常
编写自定义异常
需继承Exception或者Exception的子类，代表特定问题。
异常类型名称忘文生义，可在发生特定问题是抛出对应的异常
常用构造方法：
无参构造方法。
String message参数的构造方法。

一个实例，比如我要弄一个年龄的异常（当输入的年龄超过120岁或者低于0岁抛出异常），再弄一个性别异常（人类只分男人和女人，当输入其他性别的就抛出异常）

年龄异常创建：

public class AgeException extends RuntimeException{ //首先定好自定义异常类型然后选择继承哪类异常，如果不清楚就继承Exception总异常。（我这里是运行时异常，就继承RuntimeException）

	public AgeException() {
		super("根据科学统计，人类的寿命一般在0-120岁之间，如果你超出了这个范围，请走人工通道");
		//创建构造函数调用父类的有参构造方法，不需要写其他的一些内容，只需要把你要给与的异常提示传递上去。（默认异常提示）
	}

	public AgeException(String message) {
		super(message);
		//有参构造函数，把异常信息接收依旧传给父类。（自定义异常提示）
	}

	
}

性别异常创建（同上）

public class SexException extends RuntimeException{

	public SexException() {
		super("据我所知，地球上除了男人就是女人");
	}

	public SexException(String message) {
		super(message);
	}

	
}

创建一个学生类，里面有三个属性：姓名，年龄，性别，然后在赋值的时候把异常加上去。代码如下

public class Student {

	private String name;
	private int age;
	private String sex;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age<0||age>120) {//判定超过120或者低于0岁抛出自定义年龄异常
			throw new AgeException("在我的认知中，正常人的年龄是0-120岁,如果你属于特例，请走人工车道");//这里将会调用年龄异常的有参构造函数，并把异常提示传给父类，（自定义异常提示）。
		}
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		if(!(sex.equals("男")||(sex.equals("女")))){//判断假如输入的是第三种性别则抛出自定义性别异常。
			throw new SexException("你不是人？");
		}
		this.sex = sex;
	}
	
}

测试，代码如下：

public class Test {

	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		System.out.println("请输入姓名：");
		String name=input.next();
		System.out.println("请输入年龄");
		int age=input.nextInt();
		System.out.println("请输入性别");
		String sex=input.next();
		Student s=new Student();
		try {
			s.setAge(age);
		} catch (AgeException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		s.setName(name);
		try {
			s.setSex(sex);
		} catch (SexException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("流程完毕");
	}
}

大概就是这样全过程。