Java开发之路（4）——Java基础异常深析&&集合入门

Java基础异常深析

一、堆栈异常

在堆栈中，异常是一层层地往外抛的，抛给调用者，最终到了main方法还没有处理，则抛出给JVM，中断异常。

package Java0716_execptions;

public class Fangfazhan {

	public static void main(String[] args) {
		try{
			new Fangfazhan().test1();
			}catch(Exception e) {
				//e.printStackTrace();
			}
		System.out.println("执行完毕");
	}
	void test1() {
		System.out.println("1 before");
		test2();
		System.out.println("1 after");
	} 
	void test2() {
		System.out.println("2 before");
		test3();
		System.out.println("2 after");
	} 
	void test3() {
		System.out.println("3 before");
		//int i = 5/1;
		int i = 5/0;//抛异常
		System.out.println("3 after");
	} 
}

二、try{}catch{}finally{}的细节：

１.不管有没有异常,不管有没有return，都会执行finally中的内容。
２. 异常的嵌套：

package Java0716_execptions;

public class ExceptionQiantao {

	public static void main(String[] args) {
		try {
			int i = 5/1;
			System.out.println("执行代码块");
			try {
				int j = 5/0;
			}catch(Exception e) {
				System.out.println("try中的嵌套");
			}
			return;
		}catch(Exception e){
			System.out.println("出异常");
			try {
				
			}catch(Exception e1) {
				System.out.println("catch中的嵌套");
			}
		}finally {
			System.out.println("finally");
			try {

			}catch(Exception e) {
				System.out.println("finally中的嵌套");
			}
		}
	}
}

三.异常的关键字和异常的抛出

异常不处理的时候会默认抛出，throw和throws显示去做异常的抛出。
throws：用于方法的声明，声明这个方法有风险，调用该方法时必须处理这个方法。

1.throws关键字:用了throws关键字之后,代表该方法有风险,调用该方法的地 方,会提示这个方法有风险,会要求我必须处理这个风险（检查型异常导致的原因）。
2.throw关键字：在代码中写出异常，用于方法内部的某个执行代码段，代表这个地方之前抛出异常。

package Java0716_execptions;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ExecptionKeys {

	public static void main(String[] args) throws FileNotFoundException {
		new ExecptionKeys().test();
	}
	
	void test() throws FileNotFoundException {
		FileInputStream file = new FileInputStream("");
	}
	
	void test2() throws Exception {
		throw new Exception();
	}
}

四、自定义异常

自定义异常的语法其实比较简单，难点在于怎么去应用。
自定义的的异常能够实现个性化说明，其实已有的异常类就能直接给出个性化说明。但是不能能实现分类。所以为了满足面向对象的思想，这个时候就需要自定义异常。
在项目实践中，dao层会自定义一个dao运行时异常。

package Java0716_execptions;

public class Zidingyiyichang {

	public static void main(String[] args) throws MyException {
		// 3.对于异常处理机制，自定义异常类的使用跟其他类一样。
		/*try {
			new Zidingyiyichang().test();
		}catch(MyException e){
			e.printStackTrace();
		}*/
		int j = 1;
		try {
			int i = 5/j;
		}catch(Exception e){
			Exception myExp = new MyException("除数为0",e);//不仅要有个性化说明，还要保留e的全部信息
			myExp.getCause();
		}
	}

	void test() throws Exception {//2.在我自己定义的地方通过throw/throws抛出异常
		throw new Exception("自定义异常");
	}
}
//1.继承之后，普通类可以变为一个异常类
class MyException extends Exception{
//4.自定义异常类，一般会给出自定义的异常信息。
	public MyException(String msg) {
		super(msg);
	}
	public MyException(String msg,Throwable e) {
		super(msg, e);
	}
}

集合入门

一、集合的概念：

集合跟数组一样，是一个可以存放多个元素 的容器，Java自己创建了各种集合类，用于存储。
集合有很多个类都是容器，这些类有共同的特征（放进去，拿出来）。

集合和数组的区别：
数组是定长的，不可变的
集合是可变的

二、集合的作用：

Collection接口：声明了集合能做的共性的事情。
把元素放入集合：add
从集合中移除元素：remove
集合中有多少个元素：size
集合是否是空的：isEmpty
集合中是否包另一个元素：contains
求交集：retainAll
把集合转成数组：toArray
Map接口：容器中放置的是一对一对的元素（key——value）。
一个Map可以变成两个Collectioon集合。

三、集合的框架（常见的集合）：

集合类的共同特征体现在集合类的最上层接口：Collection

四、集合与数据结构

1.常见的集合：集合类做的事情基本上是一样的，这些类的差别在于存放多个数据的时候，采用什么样的结构来存放——数据结构，元素在内存中的位置，不一样的存放结构就会导致集合类不同的应用场景、性能、作用不一样。
2.常见的数据结构：
a.顺序结构（线性表）
b.链式结构：不连续空间
c.栈
d.队列
e.树
f.图
g.哈希：result = fn（source）。碰撞：不一样的source放进去的时候，生成一样的result。

五、几个重要的集合

1.ArrayList

ArrayList是基于数组的，和数组相类似，数据是顺序存储的，因此很方便查询，但是不方便插入。

package Java0716_collections;

import java.util.ArrayList;
import java.util.Date;

public class ArrayListTest1 {

	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		list.add(1);//自动装箱
		list.add("安逸");
		list.add(new Date());
		
		//add(int index,E element):在指定的索引处添加一个元素
		list.add(2,"插入");
		list.remove("安逸");//直接移除集合中的某个元素
		list.remove(new Date());
		
		System.out.println(list.isEmpty());
		System.out.println(list.size());
		Object[] objs = list.toArray();
	}
}

2.LinkList

LinkList是基于链表的，最大的特征：插入和删除很方便，提供很多个first和last相关的方法。

package Java0716_collections;

import java.util.LinkedList;

public class LinkListTest1 {

	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		
		list.add(1);
		list.addFirst(2);
		list.addLast(3);
		
		list.getFirst();
		list.getLast();
		
		list.peek();
		list.peekFirst();
		list.peekLast();
	}
}

set集合

set集合中的元素是不重复的，不会按照存储的顺序来做。
常用的set集合有HashSet和TreeSet。

public class HashSetTest1 {

	public static void main(String[] args) {
		HashSet<Book> set = new HashSet<Book>();
		
		Book book1 = new Book("Java编程思想",79);
		Book book2 = new Book("head first Java",89);
		Book book3 = new Book("图解Java多线程模式",99);
		Book book4 = new Book("深入Java虚拟机",56);
		Book book5 = new Book("从入门到放弃",0);
		
		//泛型限定:集合中可以存放任意类型的元素，Object,加入<Book>限定了集合中只能存放Book类型的数据。
		//HashSet<Book> set = new HashSet<Book>();
		set.add(book1);
		set.add(book2);
		set.add(book3);
		set.add(book4);
		set.add(book5);
		set.add(book5);
		
		
		for(Book book:set) {

		System.out.println(book);
		}
	}
}

class Book{
	String name;
	int price;
	public Book(String name,int price) {
		super();
		this.name = name;
		this.price = price;
	}
	@Override
	public String toString() {
		return "Book [name=" + name + ", price=" + price + "]";
	}	
}