一.Java异常
程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。
异常的类型：
1.算术异常
2.类型转换异常
3.不合法的参数异常
4.数组下标越界异常
5.空指针异常
Java异常关键字：
注意：
执行try、catch或其他地方的return、throw语句前，需要执行finally内的代码。如果在finally中有return、throw语句，则在执行finally里的return或throw语句后，方法结束
示例：
public int hello(String fileName) throws RuntimeException{
int a = 10;
try{
File file = new File(fileName);
FileInputStream in = new FileInputStream(file);
return a;
}catch (FileNotFoundException e){
System.out.println("error occurred");
}catch (ArithmeticException | IndexOutOfBoundsException e){
System.out.println("whatever");
} finally{
System.out.println("finally");
a = 20;
}
return -1;
}
public class Test {
public static void main(String[] args) {
String[] strs = new String[] {"a","b","c"};
for(int i = 0; i < 4; i++) {
System.out.println(strs[i]);
}
}
}
public class Test {
public static void main(String[] args) {
A a = null;
System.out.println(a.i);
}
}
class A{
int i;
}
public class Test {
public static void main(String[] args) {
int a = 0;
System.out.println(3/a);
}
import java. util .Scanner ;
public class test
{
public static void main (String [] args )
{
System . out. println( "111111" ) ;
t();
}
public static void t ()
{
Scanner scan = new Scanner ( System. in );
int num1 = scan .nextInt () ;
int num2 = scan .nextInt () ;
int result = devide (num1 , num2 ) ;
System . out. println( "result:" + result) ;
scan .close () ;
}
public static int devide (int num1, int num2 ){
return num1 / num2 ;
}
}
异常处理的基本语法
在编写代码处理异常时， 对于检查异常的处理方式：
1.使用try…catch…finally语句块处理它。
2.在函数签名中使用throws 声明交给函数调用者caller去解决。
try…catch…finally语句块
try{
//try块中放可能发生异常的代码。
//如果发生异常，则尝试去匹配catch块。
}catch(ExceptionName e){
//每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。
//catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常。
//如果try中没有发生异常，则所有的catch块将被忽略。
}catch(ExceptionName1 e){
}finally{
//finally块通常是可选的。
//无论异常是否发生，异常是否匹配被处理，finally都会执行。
//一个try至少要有一个catch块，否则， 至少要有1个finally块。但是finally不是用来处理异常的，finally不会捕获异常。
}
注意：
1、try块中的局部变量和catch块中的局部变量（包括异常变量），以及finally中的局部变量，他们之间不可共享使用。
2、 如果同一个try块下的多个catch异常类型有父子关系，应该将子类异常放在前面，父类异常放在后面，这样保证每个catch块都有存在的意义。
throw和throws的区别
throw关键字：用在方法内部，只能用于抛出一种异常，用来抛出方法或代码块中的异常，受查异常和非受查异常都可以被抛出。
throws关键字：用在方法声明上，可以抛出多个异常，用来标识该方法可能抛出的异常列表。一个方法用 throws 标识了可能抛出的异常列表，调用该方法的方法中必须包含可处理异常的代码，否则也要在方法签名中用 throws 关键字声明相应的异常
throws
throws声明：如果一个方法内部的代码会抛出检查异常（checked exception），而方法自己又没有完全处理掉，则javac保证你必须在方法的签名上使用throws关键字声明这些可能抛出的异常，否则编译不通过。
throws是另一种处理异常的方式，它不同于try…catch…finally，throws仅仅是将函数中可能出现的异常向调用者声明，而自己则不具体处理。
public void test() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN
{
//test内部可以抛出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 类的异常，或者他们的子类的异常对象。
}
throw 异常抛出语句
可以通过throw语句手动显式的抛出一个异常。throw语句的后面必须是一个异常对象。
public void save(User user)
{
if(user == null)
throw new Exception("User对象为空");
//......
}
注意：
当子类重写父类的带有 throws声明的函数时，其throws声明的异常必须在父类异常的可控范围内——用于处理父类的throws方法的异常处理器，必须也适用于子类的这个带throws方法 。这是为了支持多态。
二.集合
集合：
集合类存放于java.util包中。
集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。
集合类型主要有3种：set(集）、list(列表）和map(映射)。
集合就是一个放数据的容器，准确的说是放数据对象引用的容器。
集合主要分为Collection和Map2个接口
Collection又分别被List和Set继承
List被AbstractList实现，然后分为3个子类，ArrayList，LinkList和Vector
Set被AbstractSet实现，又分为HashSet和TreeSet
而Map衍生出的集合分为HashMap,HashTable和TreeMap
Collection集合的方法：
list和set的区别：
List：
ArrayList：底层数据结构是数组，查询快，增删慢，线程不安全，效率高，可以存储重复元素。
LinkedList： 底层数据结构是链表，查询慢，增删快，线程不安全，效率高，可以存储重复元素。
（3）Vector：底层数据结构是数组，查询快，增删慢，线程安全，效率低，可以存储重复元素。
ArrayList构造方法：
public ArrayList(int Capacity)//构造一个具有指定初始容量的空列表。
public ArrayList() //默认构造一个初始容量为10的空列表。
public ArrayList(Collection<? extends E> c)//构造一个包含指定 collection 的元素的列表
Map
Map用于保存具有映射关系的数据，Map里保存着两组数据：key和value，它们都可以使任何引用类型的数据，但key不能重复。
注意：
Map 没有继承 Collection 接口， Map 提供 key 到 value 的映射。一个 Map 中不能包含相同的 key ，每个 key 只能映射一个 value 。
三.泛型
泛型：
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
示例：
List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);
for(int i = 0; i< arrayList.size();i++){
String it = (String)arrayList.get(i);
Log.d("泛型","it = " + it);
}
结果：
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
注意：
ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。
示例：
List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();
Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();
if(classStringArrayList.equals(classIntegerArrayList)){
Log.d("测试","相同");
}
结果：
输出结果：D/测试: 相同
泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型
泛型的使用方式：
泛型有三种使用方式：
1.泛型类
2.泛型接口
3.泛型方法
泛型类：
class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
private 泛型标识 /*（成员变量类型）*/ var;
.....
}
}
public class Generic<T>{
private T key;
public Generic(T key) {
this.key = key;
}
public T getKey(){
return key;
}
}
泛型接口
泛型接口与泛型类的定义及使用基本相同。
//定义一个泛型接口
public interface Generator<T> {
public T next();
}
public class FruitGenerator implements Generator<String> {
private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
@Override
public String next() {
Random rand = new Random();
return fruits[rand.nextInt(3)];
}
}
泛型方法
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
IllegalAccessException{
T instance = tClass.newInstance();
return instance;
}
public class GenericTest {
public class Generic<T>{
private T key;
public Generic(T key) {
this.key = key;
}
public T getKey(){
return key;
}
}
public <T> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
T test = container.getKey();
return test;
}
public void showKeyValue1(Generic<Number> obj){
Log.d("测试","key value is " + obj.getKey());
}
public void showKeyValue2(Generic<?> obj){
Log.d("测试","key value is " + obj.getKey());
}
public <T> T showKeyName(Generic<E> container){
...
}
public void showkey(T genericObj){
}
public static void main(String[] args) {
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
