05-接口和异常处理

接口和异常处理

接口部分

前言：接口是 一个特殊的抽象类，接口中的所有方法没有方法体。

定义接口

Java语言 使用关键字 interface 来定义 一个接口。

[修饰符]interface 接口名[extends 父接口名列表]{
[public][static][final] 常量；
[public][abstract]方法；
}
1
2
3
4

1. 修饰符 可选，用于指定接口的访问权限 ，可选值：public ，缺省 则使用默认的访问权限
2. 接口名 必选， 用于指定接口名称，符合 Java接口命名规则
3. 方法： 接口中的方法只有定义，没有具体实现；
4. Java接口文件 的文件名必须 与接口名相同

//定义一个Calculate接口，在该接口中定义一个常量PI和两个方法

public interface Calculate{
	final float PI =3.1415F; 			// 定义用于 表示圆周率的常量PI
	float getArea(float r);				// 定义一个用于计算面积的方法
	float getCircumference(float r);	// 定义一个用于计算周长的方法
}
1
2
3
4
5
6
7

接口的继承

接口是可以被继承的，可以实现多继承，也即是说 接口 可以有多个 父接口。

当一个接口继承多个父类接口时，多个父类接口 排列在 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);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

接口的实现

接口可以被类实现，也可以被其他接口继承 ，在类中实现接口，可以使用关键字 implements

[修饰符]  class <类名> [extends 父类名][implements 接口列表]{

}
1
2
3

1. 修饰符 可选 用于指定 类的访问权限 ，可选值 为 public、final、abstract

2. 在类中 实现接口，方法的名字、返回值类型、参数的个数、参数的类型 都必须 和接口中的方法 完全一致，并且必须实现接口中的所有方法

3. 每个类 都是 单继承 多接口 ，此时容易出现常量 或方法名 冲突， 常量冲突 ，需要明确指定 常量的接口， 用使用 接口名.常量 来实现；若方法冲突，则只要实现一个方法就可以了；

接口与抽象类的区别和联系

共同特点：

1. 都不可被实例化，能被其他类实现或继承
2. 都可以包含抽象方法，将实现接口或继承抽象类的普通子类 必须实现这些抽象方法

区别：

1. 接口指定 系统各模块间 遵循的标准， 一旦被定义 不应该经常改变，一旦改变，对整个系统 造成影响，对接口的实现者而言， 接口规定 实现者 必须向外提供那些服务；对于 接口的调用者而言，接口规定 调用者可以到调用哪些服务，当多个应用程序 之间使用接口，接口是多个程序之间的通信标准
2. 抽象类 作为多个子类的父类，更多体现的是 模板式设计，可以被当做中间产品，还需 进一步完善
3. 接口中只能包含 抽象方法，不可有普通方法，但是抽象类中却可以
4. 接口中 不可定义静态方法，抽象类中可以定义
5. 接口中 只能定义 静态常量属性，不能定义普通属性，抽象类中可以定义 静态常量属性，也可以定义普通属性
6. 接口中不可包含构造器，抽象类中可以包含构造器，抽象类中的构造器是为了让子类调用并完成初始化操作
7. 接口中不能包含初始化块，但是抽象类却可以
8. 一个类最多只能有一个直接父类，包含 抽象类；但是 一个类却可以有多个接口；

接口回调

接口也是一种数据类型，使用接口声明的变量被称作接口变量；

接口变量中可以存放 实现该接口的类的实例的引用；

即存放 对象的引用 ；

接口回调 ：把实现某一接口的类所创建的对象的引用 赋值给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口方法。实际上，当接口变量调用被类实现的接口方法时，就是通知相应的对象调用这个方法。

 假设 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("我是学生");				//接口回调
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

接口与多态

由接口是实现的多态 就是指不同的类再实现同一个接口 的时候 可能具有不同的表现方式

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("我是小猫");				//接口回调
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

接口参数

若一个方法的参数是接口类型的参数，将任何实现该接口的类的实例 的引用 传递给该接口参数，那么接口参数就可以回调类实现的接口方法

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());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

面向接口编程

面向接口编程 是对多态特性的一种体现 ，面向接口 编程 是使用 接口来约束类的行为，并为类和类之间的通信建立实施标准。使用面向接口编程，增加程序的可维护性和可扩展性；

可维护性：当子类的功能被修改时，只要接口不发生改变，系统其他代码不需要改动

可扩展性：当增加一个子类时，测试类和其他子类不需要改动，若子类增加其他功能，只需要子类实现其他接口即可

使用接口可以实现 程序设计的“开——闭原则” 对扩展开放，对修改关闭

异常部分

前言：异常是指 程序在运行时产生的错误。

Java语言中 异常也是通过一个对象来表示的，程序运行时抛出的异常，实际上就是一个异常对象。该对象不仅封装错误信息，还提供一些处理办法

如 getMessage()方法获取异常信息, printStackTrace()方法输出对异常的详细描述

对于可能出现的异常，都需要预先进行处理，保证程序的有效进行，否则程序会报错,提高程序的稳健性；

常见异常列表

异常处理

异常产生后，若不进行任何处理，程序终止。为保证程序有效进行，需要对产生的异常进行相应的处理。

Java语言中，若某个方法抛出异常，即可以在 当前方法中进行捕获，然后处理该异常，也可以将异常向上抛出，有方法的调用者来处理

使用try……catch 语句

try{
		可能产生异常的代码
}catch（异常类 异常对象）{
	异常处理代码
	} finally{
	语句块
	}
1
2
3
4
5
6
7

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("爱护地球！");  //数据出错，抛出异常
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

使用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());
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

异常类

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;
    }
}
1
2
3
4
5
6
7
8
9

Java 异常强制用户去考虑程序的健壮性和安全性。异常处理不应用来控制程序的正常流程。其主要作用是捕获程序在运行时发生的异常并进行相应的处理。

转载请备注出处