泛型--基本概念
泛型的基本概念
泛型是java se1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
java语言引入泛型的好处是安全简单。
在java se1.5之前，没有泛型的情况下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的，对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。
//泛型的必要性:示例：
import java.util.*;
public class Generics {
public
static void main(String[] args) {
ArrayList<Dog>
al=new ArrayList<Dog>();//<Dog>即泛型的指定参数，提高安全性
ArrayList
bl=new ArrayList();
//创建一只狗
Dog
dog1=new Dog();
//放入到集合中
al.add(dog1);
//取出
Dog
temp=al.get(0);//引用泛型后即可不用强转，Dog temp=(Dog)al.get(0);
Cat
temp1=(Cat)bl.get(0);
}
}
class Cat{
private
String color;
private
int age;
public
String getColor() {
return
color;
}
public
void setColor(String color) {
this.color
= color;
}
public
int getAge() {
return
age;
}
public
void setAge(int age) {
this.age
= age;
}
}
class Dog{
private
String name;
private
int age;
public
String getName() {
return
name;
}
public
void setName(String name) {
this.name
= name;
}
public
int getAge() {
return
age;
}
public
void setAge(int age) {
this.age
= age;
}
}
-------------------------------------------------------------------------------
Java-->反射机制[Demo147.java]
//泛型的必要性
import java.util.*;
import java.lang.reflect.Method;//引入Java反射方法类
public class Demo147 {
public
static void main(String[] args) {
Gen<String>
gen1=new Gen<String>("aa");//<>可以放任意类型
Gen<Bird>
gen2=new Gen<Bird>(new Bird());//<>也可以放入定义好的类
gen1.showTypeName();
gen2.showTypeName();
}
}
//定义一个Bird
class Bird{
public
void test1(){
System.out.println("aa");
}
public
void count(int a,int b){
System.out.println(a+b);
}
}
//定义一个类
class Gen<T>{//T传入什么类型，Gen类就是什么什么类型
private
T o;
//构造函数
public
Gen(T a){
o=a;
}
//得到T的类型名称
public
void showTypeName(){
System.out.println("类型是："+o.getClass().getName());
//通过反射机制，我们可以得到T这个类型的很多信息
//得到成员函数名
Method
[] m=o.getClass().getDeclaredMethods();
//打印
for(int
i=0;i<m.length;i++){
System.out.println(m[i].getName());//打印函数名列表
}
}
}
-------------------------------------------------------------------------------
泛型的优点
使用泛型有下面几个优点：
1、类型安全
2、向后兼容
3、层次清晰
4、性能较高，用GJ(泛型JAVA)编写的代码可以为java编译器和虚拟机带来更多的类型信息，这些信息对java程序做进一步优化提供条件。
===============================================================================
异常处理--基本概念
当出现程序无法控制的外部环境问题(用户提供的文件不存在，文件内容损坏，网络不可用...)时，JAVA就会用异常对象来描述。
java中用2种方法处理异常：
1、在发生异常的地方直接处理；
2、将异常抛给调用者，让调用者处理。
异常分类
1、检查性异常：java.lang.Exception
2、运行期异常：java.lang.RuntimeException
3、错误：java.lang.Error
顶层是java.lang.Throwable类，检查性异常、运行期异常、错误都是这个类的子孙类，java.lang.Exception和java.lang.Error继承自java.lang.Throwable，而java.lang.RuntimeException继承自java.lang.Exception
1、检查性异常：
程序正确，但因为外在的环境条件不满足引发。例如：用户错误及I/O问题--程序试图打开一个并不存在的远程Socket端口，或者是打开不存在的文件时。这不是程序本身的逻辑错误，而很可能是远程机器名字错误(用户拼写错误)，对商用软件系统，程序开发者必须考虑并处理这个问题。java编译器强制要求处理这类异常，如果不捕获这类异常，程序将不能被编译。
2、运行期异常：
这意味着程序存在bug，如数组越界、0被除、入参不满足规范...这类异常需要更改程序来避免，java编译器强制要求处理这类异常。
3、错误：
一般很少见，也很难通过程序解决，它可能源于程序的bug，但一般更可能源于环境问题，如内存耗尽。错误在程序中无需处理，而由运行环境处理。
//异常示例
import java.io.*;
import java.net.*;
public class Demo148 {
public
static void main(String[] args) {
//检查异常
//1、打开不存在的文件
//FileReader fr=new
FileReader("d:\aa.txt");
//2、连接一个192.168.12.12 ip的端口号4567
//Socket s=new
Socket("192.168.1.1",80);
//运行异常
//除0导致异常
//int a=4/0;
//数组越界异常
//int arr[]={1,2,3};
//System.out.println(arr[1234]);
}
}
-------------------------------------------------------------------------------
异常处理
1、try...catch
程序运行产生异常时，将从异常发生点中断程序并向外抛出异常信息。
int x=(int)(Math.random()*5);
int y=(int)(Math.random()*10);
int[] z=new int[5];
try{
System.out.println("y/x="+(y/x));
System.out.println("y="+y+"z[y]="+z[y]);
}
catch(ArithmeticException exc1){//分步捕获算术运算异常信息
System.out.println("算术运算异常:"+exc1.getMessage());
}
catch(ArrayIndexOutOfBoundsException exc2){//分步捕获数据越界异常信息
System.out.println("数据越界异常:"+exc2.getMessage());
}
------------------------------------------------------------------------------
异常处理
2、finally
如果把finally块置try...catch...语句后，finally块一般都会得到执行，它相当于一个万能的保险，即使前面的try块发生异常，而又没有对应异常的catch块，finally块将马上执行。
以下情形，finally块将不会被执行：
1、finally块中发生了异常；
2、程序所在的线程死亡；
3、在前面的代码中用了System.exit()；
4、关闭CPU
//异常示例[Demo148.java]
import java.io.*;
import java.net.*;
public class Demo148 {
public
static void main(String[] args) {
FileReader
fr=null;
//检查异常
//1、打开不存在的文件
//FileReader
fr=new FileReader("d:\aa.txt");
try
{//使用try{}catch(Exception e){}将可能出错的程序放入到里面，当出错时会有相应提示，便于解决bug
//在出现异常的地方就终止执行代码，然后直接进入到catch语句
//如里有多个catch语句，则进入匹配异常的catch语句输入出信息
fr=new
FileReader("d:\aa.txt");
//System.exit(-1);//使用System.exit()后finally语句块不再执行
Socket
s=new Socket("192.168.1.1",21);
}
catch (FileNotFoundException e) {//catch(Exception e)捕获所有错误信息，为了方便一般使用此方法来捕获所有错误信息
// 把异常的信息输出，利于排除bug
//e.getMessage();
System.out.println("文件不存在："+e.getMessage());//.getMessage()不如.printStackTrace()
//e.printStackTrace();//输出bug信息
//处理
}
catch (IOException e2){//UnknownHostException
e2.printStackTrace();
}
finally {
//try..catch..语句块中不管出没出现异常，一般都会执行finally语句块
//一般说，把需要关闭的资源。如[文件]、[链接]、[内存]...
System.out.println("测试进入finally语句块");
if(fr!=null){
try
{
fr.close();
}
catch (Exception e) {
e.printStackTrace();
}
}
}
System.out.println("OK1");
//2、连接一个192.168.12.12 ip的端口号4567
//Socket s=new
Socket("192.168.1.1",80);
//运行异常
//除0导致异常
//int a=4/0;
//数组越界异常
//int arr[]={1,2,3};
//System.out.println(arr[1234]);
}
}
-----------------------------------------------------------------------------
异常处理
将异常抛给调用者，让调用者处理异常thorws
//抛出异常[Demo149.java]
import java.io.*;
public class Demo149 {
public
static void main(String[] args) {
Father
father=new Father();
father.test1();
}
}
class Father{
private
Son son=null;
public
Father(){
son=new
Son();
}
public
void test1(){
System.out.println("1");
try
{
son.test2();
}
catch (Exception e) {
System.out.println("Father在处理Son的异常");
e.printStackTrace();
}
}
}
class Son{
public
void test2() throws Exception{//throws Exception抛出程序块的异常，由调用者解决异常
FileReader
fr=null;
fr=new
FileReader("d:\aaa.txt");
}
}
-------------------------------------------------------------------------------
异常处理
3、多个异常的处理规则
定义多个catch可精确地定位异常。如果为子类的异常定义了特殊的catch块，而父类的异常则放在另外一个catch块中，此时，必需满足以下规则：
子类异常的处理块必需在父类异常处理块的前面，否则会发生编译错误。
所以越特殊的异常越在前面处理，越普通的异常越在后面处理。
这类似于制订防火墙的规则次序：较特殊的规则在前，较普通的规则在后。
自己也可以定义并抛出异常，方法是2步：
创建异常，抛出异常(首先实例化一个异常对象，然后用throw抛出)合在一起就是---throw
new IOException("异常说明信息")，将创建异常，抛出异常合在一起的好处是：创建异常时，会包含异常创建处的行信息，异常被捕获时可以通过堆栈迹(Stack Trace)的形式报告这些信息。如果在同一行代码创建和抛出异常时，对于程序的调试将非常有用。所以，throw new XXX()已经成为一个标准的异常抛出范式。在定义一个方法时，方法块中调用的方法可能会抛出异常，可用上面的throw new XXX()处理，如果不处理，那么必需在方法定义时，用throws声明这个方法全抛出的异常。
对异常的处理，有一条行之有效的默认规则：向上抛出----被调用类在运行过程中对遇到的异常一概不作处理，而是直接向上抛出，一直到最上层的调用类，调用类根据应用系统的需求和特定的异常处理规则进行处理，如向控制台输出异常堆栈信息，打印在日志文件中。用一句形象的话来说，就是谁使用，谁(最上层的调用类)处理。