java基础第十篇之异常

1.1接口概念
类:具备相同属性和功能的事物集合

接口是功能的集合，一样可看作是一种数据类型，是比抽象类更为抽象的”类”。

接口只描述所应该具有的方法，并无具体实现，具体的实现由接口的实现类(至关于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。
请记住：一切事物均有功能，即一切事物均有接口。

与定义类的class不一样，接口定义时须要使用interface关键字。
定义接口所在的仍为.java文件，虽然声明时使用的为interface关键字的编译后仍然会产生.class文件。这点可让咱们将接口看作是一种只包含了功能声明的特殊类。

使用interface代替了原来的class，其余步骤与定义类相同：
 接口中的方法均为公共访问的抽象方法
 接口中没法定义普通的成员变量

类与接口的关系为实现关系，即类实现接口。实现的动做相似继承，只是关键字不一样，实现使用implements。
其余类(实现类)实现接口后，就至关于声明：”我应该具有这个接口中的功能”。实现类仍然须要重写方法以实现具体的功能。

在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类须要重写该抽象方法，完成具体的逻辑。
 接口中定义功能，当须要具备该功能时，可让类实现该接口，只声明了应该具有该方法，是功能的声明。
 在具体实现类中重写方法，实现功能，是方法的具体实现。
因而，经过以上两个动做将功能的声明与实现便分开了。(此时请从新思考：类是现实事物的描述，接口是功能的集合。)

1.4接口中成员的特色
一、接口中能够定义变量，可是变量必须有固定的修饰符修饰，public static final 因此接口中的变量也称之为常量，其值不能改变。后面咱们会讲解static与final关键字
二、接口中能够定义方法，方法也有固定的修饰符，public abstract
三、接口不能够建立对象。
四、子类必须覆盖掉接口中全部的抽象方法后，子类才能够实例化。不然子类是一个抽象类。

1.5接口特色
 接口能够继承接口
如同类继承类后便拥有了父类的成员，可使用父类的非私有成员。A接口继承B接口后，A接口便拥有了A、B两个接口中全部的抽象方法。
 Java支持一个类同时实现多个接口，或一个接口同时继承多个接口。
 类能够在继承一个类的同时，实现多个接口。
接口与父类的功能能够重复，均表明要具有某种功能，并不冲突。

三、经过上面的例子总结接口和抽象类的区别：
相同点:
 都位于继承的顶端,用于被其余类实现或继承;
 都不能直接实例化对象;
 都包含抽象方法,其子类都必须覆写这些抽象方法;
区别:
 抽象类为部分方法提供实现,避免子类重复实现这些方法,提升代码重用性;
 接口只能包含抽象方法;
 一个类只能继承一个直接父类(多是抽象类),却能够实现多个接口;(接口弥补了Java的单继承)

 抽象类为继承体系中的共性内容,接口为继承体系外的扩展功能

 

两者的选用:
 优先选用接口,尽可能少用抽象类;
 须要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

包的特色:
A:能够有多层
B:不一样包下的文件名能够

C:包的声明必须是第一行代码

不一样包之间的互相访问
1.使用类的全名

2.使用关键字import 将类导入

注意:*表明得是通配符,表明导入了这个包全部的类,并无导入子包下的类

相同包下的类能够直接访问,不须要作其余的操做

类的全名:包名.类名

权限修饰符:
public 当前类,相同包下不一样的类,不一样包下的类
default 当前类,相同包下不一样的类,
private 当前类
protected 当前类,相同包下不一样的类

default : 当前包下使用
protected:让子类对象使用

在Java中提供了四种访问权限，使用不一样的访问权限时，被修饰的内容会有不一样的访问权限，如下表来讲明不一样权限的访问能力：
public protected default private
同一类中 √ √ √ √
同一包中(子类与无关类) √ √ √
不一样包的子类 √ √
不一样包中的无关类 √
概括一下：在平常开发过程当中，编写的类、方法、成员变量的访问
A:要想仅能在本类中访问使用private修饰
B:要想本包中的类均可以访问除了private修饰符,其它均可以
C:要想本包中的类与其余包中的子类能够访问使用protected修饰
D:要想全部包中的全部类均可以访问使用public修饰。
注意：若是类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

成员内部类:
* 在类的成员位置,和成员变量以及成员方法所在的位置是同样的.
* 在内部类当中,科院直接访问外部类的成员,包括私有成员

成员内部类的修饰符:
* 可使用权限修饰符修饰成员内部类,可是若是使用私有来修饰,则没法再其余类中被访问.
* 咱们可使用static 修饰成员内部类,不用在建立外部类的对象了
*
* 咱们可使用abstract,final修饰成员内部类

局部内部类:
* 在方法内,出了方法以后就没法使用

局部内部类:
* 在方法内,出了方法以后就没法使用
*
* 匿名内部类:
* 能够把匿名内部类当作是一个没有名字的局部内部类
* 定义在方法当中
* 必须在定义匿名内部类的时候建立他的对象
* 格式:
* new 类/接口() {
* 若是是建立了继承这个类的子类对象,咱们能够从新父类的方法
* 若是是建立了实现这个接口的子类对象,咱们必需要实现该接口的全部方法
* }
*
* 原理:而是建立了继承这个类的子类对象或者是建立了实现这个接口的子类对象
*
* 匿名内部类的应用场景:
* 做为参数进行传递

Object : equals , toString

Object类中的equals:
* 默认比较的是两个对象的地址,是当前对象和参数传入的对象
* 可是咱们能够重写equals方法,让比较按照咱们的想法比较
* 好比java中String也是重写了equals,比较了字符串的内容,而不是地址
*
* Object类中的toString方法:
* 这个方法 能够方法一个字符串,这个字符串用来表示当前对象
* 默认返回值:包名.类名@地址值
* 实际上 syso(对象名) 等价于 syso(对象名.toString())
* 可是咱们也能够重写toString 打印出咱们要的信息 而不是一个地址值
*
* 总结:实际开发中定义一个类 咱们一般
* 1.封装
* 2.构造
* 3.重写equals
* 4.toString();//方便查看对象的信息


* 程序的异常:(程序中出现的问题)
* 根类Throwable
* |- Error(错误类)是程序很严重的问题,若是出现了 改代码
* 人:肝癌,脑壳被砍了
* |- Exception(编译时异常类)也是程序出现问题,本身能够处理的小问题
* 人:感冒,发烧,牙疼..
* |- RuntimeExcetpion(运行时异常)
*
* java中异常类的常见操做
*
* 1.先要有异常,通常来讲 java的异常java本身常见对象,咱们本身定义一个异常,咱们本身常见对象
*
* 2.抛出异常(无论了)
*
* 3.捕获异常(本身处理)
*
* 抛出异常的关键字:throw, 抛出的动做,是真正的把异常对象抛出去


* 1.throw:抛出异常动做
*
* 2.throws:一种声明,throws是给方法作声明的,表示这个方法可能抛出异常,要求方法的调用者去处理
*
* 3.处理异常的方法:
* 3.1再声明抛出
* 3.2捕获方式:
* try{
* 可能出现异常的代码;
* }catch(Exception e){
* //若是上面的代码,真的出现了异常 那么就会被抓住
* //就是把异常对象赋值给了 e
* //本身处理
* }finally{
* //最终必需要执行的代码
* //通常放释放资源的代码
* }
* 捕获异常还有其余的方式:
* try{
* }finally{
* }
* try{
* }catch(Exception e){
* }
* 关于catch抓住异常 也有其余写法
* 处理：
* 1多个异常分别处理 咱们基本不用
* 2多个异常一次捕获屡次处理
* 3多个异常一次捕获一次处理 ***********
*


* 异常的分类:
* 1.编译时异常: Exception以及它的子类(RuntimeException)
* 2.运行时异常: RuntimeExcetion以及它的子类
*
* 咱们如何区分哪一个是编译异常 哪一个是运行异常?

编译期异常抛出，未来调用者必须处理。
运行期异常抛出，未来调用能够不用处理。

javac出来的异常就是编译时异常，就是说把源代码编译成字节码（class）文件时报的异常，通常若是用Eclispe,你敲完代码保存的时候就是编译的时候。

Java出来的异常就是运行时异常

/自定义异常固定的套路
//1.必须继承Exception或者RuntimeException
//2.写两个构造,一个空参,一个带有异常信息的String类型参数
//throw new NoSuchAgeException("年龄不合法的异常");

可以辨别程序中异常(Exception)和错误(Error)的区别
* 错误:是程序出现很是严重的问题,必须修改源代码
* 异常:是程序出现的小问题,给出问题的代码加上处理方式
*
* 说出异常的分类:
* 根类:Throwable
* |-Error
* |-Exception:编译时异常
* |-RuntimeException:运行时异常
* 说出虚拟机处理异常的方式
* 终断方式:
* 1.打印异常信息
* 2.终止JVM运行
* 列举出常见的四个运行期异常
* NullPointerException
* ArrayIndexOutofBoundsException
* StringIndexOutofBoundsException
* ClassCastException;//类型转型异常,猫不能转成狗
*
* 可以使用try...catch关键字处理异常
* 标准方式: try{..可能出异常的代码..}catch(异常类型 变量名){...}finally{..释放资源的代码..}
* 奇葩的方式:
* try{....}finally{...}
* try{....}catch(异常类型 变量名){..}
* catch捕获异常的方式:
* 1.一个异常一个捕获 一次处理 (多个try 多个catch)
* 2.多个异常一次捕获 屡次处理(一个try,多个catch);
* 3.多个异常一个捕获,一次处理(一个try 一个catch)
* 可以使用throws关键字处理异常
* throw:就是真正抛出一个异常
* throws:给方法用的,给方法作声明,声明这个方法可能抛出异常,要求调用者去处理
* 可以自定义异常类
* 固定套路:
* 1.定义一个Exception结尾异常类,继承Exception或者RuntimeException
* 2.两个构造:无参数,带有异常信息的String类型参数
* 可以处理自定义异常类
* 若是自定义异常继承RuntimeException 编译时不会出错,咱们也不须要处理
* 若是自定义异常继承Exception,这时候咱们须要处理(throws声明抛出,try..catch)
* 可以理解Object的equals方法
* equals方式定义在Object类中,默认实现判断当前对象和形式参数对象,是否地址相同
* public boolean equals(Object obj){
*
* return (this==obj);
* }
* 若是咱们想改变equals判断规则,那么咱们本身重写equals
*
* 能偶理解Object的toString方法
* toString方法定义在Object类中,默认实现打印下面的格式: 包名.类名@地址值
* 咱们也能够重写toString打印出来咱们要的对象信息
*
* syso(对象名)====>syso(对象名.toString())
*

当定义一个Animal类时,咱们发现咱们并无写成员方法,可是能调用,这是由于它继承了Object类.
Object类是Java语言中的根类，即全部类的父类。它中描述的全部方法子类均可以使用。全部类在
建立对象的时候，最终找的父类就是Object。

equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较。Object类
中的equals方法内部使用的就是==比较运算符。

注意：在复写Object中的equals方法时，必定要注意public boolean equals(Object obj)的参数是Object类型
，在调用对象的属性时，必定要进行类型转换，在转换以前必须进行类型判断。
友情提示:须要重写的时候能够利用eclipse提供的快捷键直接生成 alt+shift + s + h

1.toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
2.在咱们直接使用输出语句输出对象名的时候,其实经过该对象调用了其toString()方法.
可是toString返回值的地址 对咱们来讲没有实际价值的
3.因为toString方法返回的结果是内存地址，而在开发中，常常须要按照对象的属性获得相应的
字符串表现形式，所以也须要重写它。alt+shift + s + s

根类Throwable(异常):
Error(错误类):程序很严重的问题,没法处理的异常,若是出现了,改代码.
Exception(编译时异常类):若是出现了问题,本身处理.
RuntimeExcetpion(运行时异常):

java中异常类的常见操做:

1.先要有异常,通常来讲java的异常java本身常见对象,咱们本身定义一个异常,咱们本身常见对象

2.抛出异常(无论了)

3.捕获异常(本身处理)

对于顶级类(外部类)来讲，只有两种修饰符：public和默认(default)。由于外部类的上一单元是包，
因此外部类只有两个做用域：同包，任何位置。所以，只须要两种控制权限
：包控制权限和公开访问权限，也就对应两种控制修饰符：public和默认(default)。

既然你问的类使用了private修饰符，说明是个内部类。内部类的上一级是外部类，那么对应的有四
种访问控制修饰符：本类(private)，同包(default)，父子类(protected)，任何位置(public)。
种访问控制修饰符：本类(private)，同包(default)，父子类(protected)，任何位置(public)。
当一个内部类使用了private修饰后，只能在该类的外部类内部使用。

Object类中的equals: * 默认比较的是两个对象的地址,是当前对象和参数传入的对象 * 可是咱们能够重写equals方法,让比较按照咱们的想法比较 * 好比java中String也是重写了equals,比较了字符串的内容,而不是地址 * * Object类中的toString方法: * 这个方法 能够方法一个字符串,这个字符串用来表示当前对象 * 默认返回值:包名.类名@地址值 * 实际上 syso(对象名) 等价于 syso(对象名.toString()) * 可是咱们也能够重写toString 打印出咱们要的信息 而不是一个地址值 * * 总结:实际开发中定义一个类 咱们一般 * 1.封装 * 2.构造 * 3.重写equals * 4.toString();//方便查看对象的信息 程序的异常:(程序中出现的问题) * 根类Throwable * |- Error(错误类)是程序很严重的问题,若是出现了 改代码 * 人:肝癌,脑壳被砍了 * |- Exception(编译时异常类)也是程序出现问题,本身能够处理的小问题 * 人:感冒,发烧,牙疼.. * |- RuntimeExcetpion(运行时异常) * * java中异常类的常见操做 * * 1.先要有异常,通常来讲 java的异常java本身常见对象,咱们本身定义一个异常,咱们本身常见对象 * * 2.抛出异常(无论了) * * 3.捕获异常(本身处理) * * 抛出异常的关键字:throw, 抛出的动做,是真正的把异常对象抛出去 1.throw:抛出异常动做 * * 2.throws:一种声明,throws是给方法作声明的,表示这个方法可能抛出异常,要求方法的调用者去处理 * * 3.处理异常的方法: * 3.1再声明抛出 * 3.2捕获方式: * try{ * 可能出现异常的代码; * }catch(Exception e){ * //若是上面的代码,真的出现了异常 那么就会被抓住 * //就是把异常对象赋值给了 e * //本身处理 * }finally{ * //最终必需要执行的代码 * //通常放释放资源的代码 * } * 捕获异常还有其余的方式: * try{ * }finally{ * } * try{ * }catch(Exception e){ * } * 关于catch抓住异常 也有其余写法 * 处理： * 1多个异常分别处理 咱们基本不用 * 2多个异常一次捕获屡次处理 * 3多个异常一次捕获一次处理 *********** * 异常的分类: * 1.编译时异常: Exception以及它的子类(RuntimeException) * 2.运行时异常: RuntimeExcetion以及它的子类 * * 咱们如何区分哪一个是编译异常 哪一个是运行异常 //自定义异常固定的套路 //1.必须继承Exception或者RuntimeException //2.写两个构造,一个空参,一个带有异常信息的String类型参数 //throw new NoSuchAgeException("年龄不合法的异常"); public class TestDemo { public static void main(String[] args) { //一个try 多个catch try{ System.out.println("try"); int[] arr = {1,2,3}; arr[10] = 10;//数组下标越界 System.out.println(10/0);//数学异常 String s = "abc"; char ch = s.charAt(10);//字符串下标越界 }catch(ArithmeticException ae){ System.out.println("数学异常"); }catch(ArrayIndexOutOfBoundsException aioe){ System.out.println("数组越界"); }catch(StringIndexOutOfBoundsException sioe){ System.out.println("字符串下标越界"); }finally { } }}