当前位置: 首页 > news >正文

JAVA入门到精通-第26讲-异常

1167156-20181130151148972-975755848.png
 try...catch 助手提示键;
  1167156-20181130151151886-2049492404.png
 Surround With  --->  Try/catch Block

1167156-20181130151157304-1755234504.png
 e.printStackTrace( ); 

1167156-20181130151158158-1592392017.png
 异常可以一起捕获或者分别捕获;
  1167156-20181130151200370-1027637653.png
 FileNotFoundException    e
 IOException        e
1167156-20181130151201083-1950368326.png
 在局域网里面找了一圈,找这个IP地址;
  找不到这个IP地址;
1167156-20181130151202146-1629631330.png
UnknownHostException 
1167156-20181130151203277-436687683.png
 go on 没有打出来;
  在抛出异常的地方,就终止执行代码
  然后进入到catch;
  如果有多个catch,则进入匹配异常的那个catch语句;
   1167156-20181130151203901-1368971155.png
  1167156-20181130151204511-864461659.png
e.getMessage( );
e.printStackTrace();    这个处理异常的方法更好。
1167156-20181130151205418-528355204.png
  1167156-20181130151205916-1868565499.png
  一个文件打开没有及时关闭,会很可怕;
  文件没有关闭,保存不进去;
  IO流中,文件没有关闭,是无法保存的;
  对资源必须要进行关闭; finally是万能的保险
   1167156-20181130151206543-1363571102.png
 fr.close( );一定要保证文件流被关闭;
 try...catch...finally 这一套结构是很好的。
  try...finally...  
  try...catch...   都可以直接使用;
1167156-20181130151207224-1196917395.png
 finally 未必一定会被执行,比如 System.exit(-1); 系统退出
 
  抛出异常:
  不想处理,扔出去:throws Exception
1167156-20181130151207781-167142907.png
  1167156-20181130151208312-2099544344.png
要调用son.test2 ( )需要异常 捕获;
当然,虚拟机可以帮你捕获,会造成很难排错;
   1167156-20181130151208738-730880371.png
 抛出一个异常给上一个去处理:
 把一个异常抛给调用者去处理:在Father 里面去处理捕获
1167156-20181130151209101-308956720.png
 错误根本发生在41行,调用在27行,又被10行调用;
 真正的错误看最前面的错误就可以了。

什么是泛型?
  (1)主要解决两个问题:安全和代码重用的问题;
 有自动装箱和拆箱的功能;
  (2)泛型 可以用一个不确定的类型来表示任意一个类型;
  (3)泛型可以通过他的反射机制可以拿到类的一些列信息,提高代码的优越性;

泛型--基本概念

泛型的基本概念

    泛型是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.Exceptionjava.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]);

    }

}

-------------------------------------------------------------------------------

异常处理

1try...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());

}

------------------------------------------------------------------------------

异常处理

2finally

如果把finally块置try...catch...语句后,finally块一般都会得到执行,它相当于一个万能的保险,即使前面的try块发生异常,而又没有对应异常的catch块,finally块将马上执行。

 

以下情形,finally块将不会被执行:

1finally块中发生了异常;

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声明这个方法全抛出的异常。

对异常的处理,有一条行之有效的默认规则:向上抛出----被调用类在运行过程中对遇到的异常一概不作处理,而是直接向上抛出,一直到最上层的调用类,调用类根据应用系统的需求和特定的异常处理规则进行处理,如向控制台输出异常堆栈信息,打印在日志文件中。用一句形象的话来说,就是谁使用,谁(最上层的调用类)处理。


 


来自为知笔记(Wiz)


转载于:https://www.cnblogs.com/xuxaut-558/p/10044316.html

相关文章:

  • Elasticsearch实践(四):IK分词
  • Alpha 冲刺 (10/10)
  • 汉诺塔解析(图解)
  • Go 基础(非常基础)
  • 新海诚画集[秒速5センチメートル:樱花抄·春]
  • 微服务架构介绍及开源框架
  • 【345】机器学习入门 - 李宏毅机器学习笔记
  • 动态删边SPFA: [HNOI2014]道路堵塞
  • Centos6.9安装JDK1.8
  • Android Studio中SVN的使用
  • MySQL索引原理以及类型
  • Java语法
  • Linux中的find(-atime、-ctime、-mtime)指令分析
  • vue中watch,computed,mehtod执行顺序
  • Java基础-时间类
  • Golang-长连接-状态推送
  • Java反射-动态类加载和重新加载
  • KMP算法及优化
  • use Google search engine
  • webpack项目中使用grunt监听文件变动自动打包编译
  • 阿里云应用高可用服务公测发布
  • 大快搜索数据爬虫技术实例安装教学篇
  • 扫描识别控件Dynamic Web TWAIN v12.2发布,改进SSL证书
  • 设计模式走一遍---观察者模式
  • 我的业余项目总结
  • 小程序01:wepy框架整合iview webapp UI
  • ​LeetCode解法汇总2808. 使循环数组所有元素相等的最少秒数
  • #if和#ifdef区别
  • $.type 怎么精确判断对象类型的 --(源码学习2)
  • (+3)1.3敏捷宣言与敏捷过程的特点
  • (07)Hive——窗口函数详解
  • (C)一些题4
  • (C语言)字符分类函数
  • (附源码)springboot家庭装修管理系统 毕业设计 613205
  • (附源码)springboot学生选课系统 毕业设计 612555
  • (附源码)ssm基于jsp高校选课系统 毕业设计 291627
  • (机器学习-深度学习快速入门)第一章第一节:Python环境和数据分析
  • (企业 / 公司项目)前端使用pingyin-pro将汉字转成拼音
  • (深入.Net平台的软件系统分层开发).第一章.上机练习.20170424
  • (一)VirtualBox安装增强功能
  • (原創) 如何讓IE7按第二次Ctrl + Tab時,回到原來的索引標籤? (Web) (IE) (OS) (Windows)...
  • (转) 深度模型优化性能 调参
  • (转载)CentOS查看系统信息|CentOS查看命令
  • .NET CF命令行调试器MDbg入门(四) Attaching to Processes
  • .Net CF下精确的计时器
  • .NET Framework 和 .NET Core 在默认情况下垃圾回收(GC)机制的不同(局部变量部分)
  • .net开源工作流引擎ccflow表单数据返回值Pop分组模式和表格模式对比
  • .net网站发布-允许更新此预编译站点
  • @ 代码随想录算法训练营第8周(C语言)|Day57(动态规划)
  • @Autowired @Resource @Qualifier的区别
  • @cacheable 是否缓存成功_Spring Cache缓存注解
  • @KafkaListener注解详解(一)| 常用参数详解
  • @Transactional类内部访问失效原因详解
  • [ element-ui:table ] 设置table中某些行数据禁止被选中,通过selectable 定义方法解决
  • [2]十道算法题【Java实现】