05-接口和异常处理
接口和异常处理
文章目录
- 接口和异常处理
- 接口部分
- 定义接口
- 接口的继承
- 接口的实现
- 接口与抽象类的区别和联系
- 接口回调
- 接口与多态
- 接口参数
- ==面向接口编程==
- 异常部分
- 常见异常列表
- 异常处理
- 使用try……catch 语句
- finally子句的用法
- 使用throws关键字抛出异常
- 使用throw关键字
- 异常类
- 自定义异常
接口部分
前言:接口是 一个特殊的抽象类,接口中的所有方法没有方法体。
定义接口
Java语言 使用关键字 interface 来定义 一个接口。
[修饰符]interface 接口名[extends 父接口名列表]{
[public][static][final] 常量;
[public][abstract]方法;
}
- 修饰符 可选,用于指定接口的访问权限 ,可选值:public ,缺省 则使用默认的访问权限
- 接口名 必选, 用于指定接口名称,符合 Java接口命名规则
- 方法: 接口中的方法只有定义,没有具体实现;
- Java接口文件 的文件名必须 与接口名相同
//定义一个Calculate接口,在该接口中定义一个常量PI和两个方法
public interface Calculate{
final float PI =3.1415F; // 定义用于 表示圆周率的常量PI
float getArea(float r); // 定义一个用于计算面积的方法
float getCircumference(float r); // 定义一个用于计算周长的方法
}
接口的继承
接口是可以被继承的,可以实现多继承,也即是说 接口 可以有多个 父接口。
当一个接口继承多个父类接口时,多个父类接口 排列在 extends 关键字后,各个父类接口 之间使用英文逗号隔开
public interface interfaceA{
int one = 1;
void sayA();
}
public interface interfaceB{
int two = 2;
void sayB();
}
public interface interfaceC extends interfaceA,interfaceB{
int three = 3;
void sayC();
}
public class app{
public static void main(String[] args){
System.out.println(interfaceC.one);
System.out.println(interfaceC.two);
System.out.println(interfaceC.three);
}
}
接口的实现
接口可以被类实现,也可以被其他接口继承 ,在类中实现接口,可以使用关键字 implements
[修饰符] class <类名> [extends 父类名][implements 接口列表]{
}
-
修饰符 可选 用于指定 类的访问权限 ,可选值 为 public、final、abstract
-
在类中 实现接口,方法的名字、返回值类型、参数的个数、参数的类型 都必须 和接口中的方法 完全一致,并且必须实现接口中的所有方法
-
每个类 都是 单继承 多接口 ,此时容易出现常量 或方法名 冲突, 常量冲突 ,需要明确指定 常量的接口, 用使用 接口名.常量 来实现;若方法冲突,则只要实现一个方法就可以了;
接口与抽象类的区别和联系
共同特点:
- 都不可被实例化,能被其他类实现或继承
- 都可以包含抽象方法,将实现接口或继承抽象类的普通子类 必须实现这些抽象方法
区别:
- 接口指定 系统各模块间 遵循的标准, 一旦被定义 不应该经常改变,一旦改变,对整个系统 造成影响,对接口的实现者而言, 接口规定 实现者 必须向外提供那些服务;对于 接口的调用者而言,接口规定 调用者可以到调用哪些服务,当多个应用程序 之间使用接口,接口是多个程序之间的通信标准
- 抽象类 作为多个子类的父类,更多体现的是 模板式设计,可以被当做中间产品,还需 进一步完善
- 接口中只能包含 抽象方法,不可有普通方法,但是抽象类中却可以
- 接口中 不可定义静态方法,抽象类中可以定义
- 接口中 只能定义 静态常量属性,不能定义普通属性,抽象类中可以定义 静态常量属性,也可以定义普通属性
- 接口中不可包含构造器,抽象类中可以包含构造器,抽象类中的构造器是为了让子类调用并完成初始化操作
- 接口中不能包含初始化块,但是抽象类却可以
- 一个类最多只能有一个直接父类,包含 抽象类;但是 一个类却可以有多个接口;
接口回调
接口也是一种数据类型,使用接口声明的变量被称作接口变量;
接口变量中可以存放 实现该接口的类的实例的引用;
即存放 对象的引用 ;
接口回调 :把实现某一接口的类所创建的对象的引用 赋值给该接口声明的接口变量,那么该接口变量就可以调用被类实现的接口方法。实际上,当接口变量调用被类实现的接口方法时,就是通知相应的对象调用这个方法。
假设 Peo 是一个接口 Stu类是实现Peo接口的类,用Stu创建名字为object的对象,那么object对象不仅可以调用Stu类中原有的方法,还可以调用Stu类实现的接口方法
Stu object = new Stu();
public interface People{
void Say(String s);
}
public class Teacher implements People{ //Teacher类实现People接口
public void Say(String s){
System.out.println(s);
}
}
public class Student implements People{ //Student类实现People接口
public void Say(String s){
System.out.println(s);
}
}
public class app{
public static void main(String [] args){
People tea; // 声明接口变量
tea = new Teacher(); // 接口变量中存放 对象的引用
tea.Say("我是老师"); //接口回调
tea = new Student(); //接口变量中存放 对象的引用
tea.Say("我是学生"); //接口回调
}
}
接口与多态
由接口是实现的多态 就是指不同的类再实现同一个接口 的时候 可能具有不同的表现方式
public interface Animals{
void Say(String s);
}
public class Dog implements Animals{ //Teacher类实现People接口
public void Say(String s){
System.out.println(s);
}
}
public class Cat implements Animals{ //Student类实现People接口
public void Say(String s){
System.out.println(s);
}
}
public class Zoo{
public static void main(String [] args){
Animals ani; // 声明接口变量
ani = new Dog(); // 接口变量中存放 对象的引用
ani.Say("我是小狗"); //接口回调
ani = new Cat(); //接口变量中存放 对象的引用
ani.Say("我是小猫"); //接口回调
}
}
接口参数
若一个方法的参数是接口类型的参数,将任何实现该接口的类的实例 的引用 传递给该接口参数,那么接口参数就可以回调类实现的接口方法
public interface Eatfood{
void Eatfood();
}
public class Chinese implements Eatfood{
public void Eatfood(){
System.out.println("中国人习惯使用筷子吃饭");
}
}
public class America implements Eatfood{
public void Eatfood(){
System.out.println("美国人习惯使用刀叉吃饭");
}
}
public class EatMethods{
public void lookEatMethods(Eatfood eat){
eat.Eatfood();
}
}
public class Test{
public static void main(String[] args){
EatMethods em = new EatMethods();
em.lookEatMethods(new Chinese()); //注意是如何 使用接口参数的
em.loolEatMethods(new America());
}
}
面向接口编程
面向接口编程 是对多态特性的一种体现 ,面向接口 编程 是使用 接口来约束类的行为,并为类和类之间的通信建立实施标准。使用面向接口编程,增加程序的可维护性和可扩展性;
可维护性:当子类的功能被修改时,只要接口不发生改变,系统其他代码不需要改动
可扩展性:当增加一个子类时,测试类和其他子类不需要改动,若子类增加其他功能,只需要子类实现其他接口即可
使用接口可以实现 程序设计的“开——闭原则” 对扩展开放,对修改关闭
异常部分
前言:异常是指 程序在运行时产生的错误。
Java语言中 异常也是通过一个对象来表示的,程序运行时抛出的异常,实际上就是一个异常对象。该对象不仅封装错误信息,还提供一些处理办法
如 getMessage()方法获取异常信息, printStackTrace()方法输出对异常的详细描述
对于可能出现的异常,都需要预先进行处理,保证程序的有效进行,否则程序会报错,提高程序的稳健性;
常见异常列表
异常类名称 | 异常类含义 |
---|---|
ArithmeticException | 算术异常类 |
ArrayIndexOutOfBoundsException | 数组下标越界异常类 |
ArrayStoreException | 将与数组类型不兼容的值赋值给数组元素时抛出的异常 |
ClassCastException | 类型强制转换异常类 |
ClassNotFoundException | 未找到相应类异常 |
EOFException | 文件已结束异常类 |
FileNotFoundException | 文件未找到异常类 |
IIIegalAccessException | 访问某类时被拒绝时抛出的异常 |
InstantiationException | 试图通过newInstance()方法创建一个抽象类或抽象接口的实例时抛出的异常 |
IOException | 输入输出异常类 |
NegativeArraySizeException | 建立元素个数为负数的数组异常类 |
NullPointerException | 空指针异常类 |
NumberFormatException | 字符串转化为数字异常类 |
NoSuchFieldException | 字段未找到异常类 |
NoSuchMethodException | 方法未找到异常类 |
SecurityException | 小应用程序(Applet)执行浏览器的安全设置禁止的动作时抛出的异常 |
SQLException | 操作数据库异常类 |
StringIndexOutOfBoundsException | 字符串索引超出范围异常 |
异常处理
异常产生后,若不进行任何处理,程序终止。为保证程序有效进行,需要对产生的异常进行相应的处理。
Java语言中,若某个方法抛出异常,即可以在 当前方法中进行捕获,然后处理该异常,也可以将异常向上抛出,有方法的调用者来处理
使用try……catch 语句
try{
可能产生异常的代码
}catch(异常类 异常对象){
异常处理代码
} finally{
语句块
}
try 语句块中的代码可能同时存在多种异常,那么到底捕获哪种类型的异常,是由catch语句中的异常类参数指定 异常类必须是 Throwable类的子类,用来指定catch语句 要捕获的异常;异常类对象可在catch语句块中被调用,
在使用 多个catch语句捕获try语句块中代码抛出的异常时,要注意catch语句的顺序,之间要有继承关系,则用来捕获子类的catch语句要放在捕获父类的catch语句前面;
finally子句的用法
finally子句 需要与try……catch语句一同使用,不管程序有无异常发生,不管之前try……catch语句是否顺利执行完毕,最终都会执行finally语句块中的代码
使用throws关键字抛出异常
若某个方法可能会发生异常,但不想在当前方法中来处理这个异常,那么可以将该异常抛出,然后在调用该方法的代码中捕获该异常并进行处理;
将异常抛出,可通过throws 关键字来实现,throws关键字 通常被应用在声明方法 时,用来指定方法可能抛出的异常,多个异常可用逗号分隔;
代码中dofile()方法声明抛出一个IOException异常,在该方法的调用者main()方法中捕获并处理该异常
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class Demo{
public static void main(String[] args){
try{
Demo.dofile("C:\\mytxt.txt");
}catch(IOException IOe){
System.out.println("调用dofile()方法出错!");
System.out.println("错误:"+IOe.getMessage());
}
}
public static void dofile(String name) throws IOException{
File file = new File(name);
FileWriter fw = new FileWriter(file);
fw.Writer("Hello World");
fw.close();
fw.writer("爱护地球!"); //数据出错,抛出异常
}
}
使用throw关键字
使用throw关键字也可以抛出异常,throw用于方法体内,并且抛出一个异常类对象,而throws用在方法声明中,来指明 方法可能抛出的多个异常
//创建People类,该类中的check()方法首先将传递进来的String类型参数转化为int型,然后判断该int型整数是否为负数,若为负数,则抛出异常,然后在该类的main方法中捕获并处理该异常
public class People{
public static int check(String strage)throws Exception{
int age = Integer.parseInt(strage); //转换字符串 为int型
if(age<0)
throw new Exception("年龄不可为负数!");// 抛出一个Exception异常对象
return age;
}
public static void main(String[] args){
try{
int myage = check("-101"); //调用check()方法
System.out.println(myage);
}catch(Exception e){ //捕获Exception异常
System.out.println("数据逻辑错误");
System.out.println("原因:"+e.getMessage());
}
}
}
异常类
Java语言中提供一些 内置的异常类来描述经常较容易发生的错误,这些类都继承java.lang .Throwable类。
Throwable类有两个子类:Error 和Exception
Error 类 及其子类 通常用来描述 Java运行系统中的内部错误以及 资源耗尽的错误,是 比较严重的。仅靠修改程序本身是无法恢复的,成为致命异常类。建议终止程序。
Exception类及其子类称为非致命异常类,通过捕获处理后可正常运行,保持程序的可读性和可靠性。在开发Java程序过程中进行处理的异常,主要就是针对该类及其子类的异常处理。
分为两类:RuntimeException异常(编译通过,运行时由JVM抛出);检查异常(必须通过 try……catch语句)捕获处理异常或throws抛出处理 上述 表中 加粗均为 检查异常
自定义异常
有时根据需要 ,创建自己的异常类并将它们 用于程序中来描述 Java内置异常类所不能描述的一些特殊情况;
必须继承Throwable类,才可被视为异常类;通常 是继承或继承其子孙类;
与创建一个普通类 的语法相同
创建自定义异常类
在方法中通过throw抛出异常对象
public class MyException extends Exception{
private String content;
public MyException (String content){
this.content = content;
}
public String getContent(){
return this.content;
}
}
Java 异常强制用户去考虑程序的健壮性和安全性。异常处理不应用来控制程序的正常流程。其主要作用是捕获程序在运行时发生的异常并进行相应的处理。
转载请备注出处