java-接口与异常

1.接口

抽象类表示的是一种继承关系，一个类只能使用一次继承关系，这样限制了类的多重体现 。
接口的特点：
 Java是单继承的语言，利用接口可以模拟多继承；
 接口是对抽象类的进一步抽象，是方法声明和常量的定义集合；
 接口是一种行为规范，是一种“契约”；
 接口不可以被实例化
 实现类必须实现接口的所有方法
 实现类可以实现多个接口
 接口中的变量都是静态常量

为什么接口可以多继承，而类不可以？
如果有两个父类，两个父类里有一个相同的方法，那么作为子类应该怎么继承这个方法？父类1的还是父类2的？但是实现多个接口则没问题，因为不管哪个接口，调用的都是同一个实现，因为只有方法名！而且单继承的目的之一，就是降低复杂度，减少维护难度。

• 接口的使用
  接口的定义格式如下：

<访问符> interface 接口名 { 	
[访问符] <返回类型> 方法名([参数列表])； 	
...... 
}

定义一个接口MultiInterface.java，代码如下：

public interface MultiInterface { 	
	public static final double PI = 3.1415926; 	
	public void callArea(); 	
	default void before(){  //仅限于JDK1.8以后可使用 			
	System.out.println("现在开始计算："); 	
	} 
}

注意：在定义接口的时候，接口中的所有方法和常量自动定义为public。 接口中定义的变量默认是public static final 型，且必须赋初值。
从JDK1.8开始可以使用default关键字来定义一个默认的方法来扩展接口，default关键字修饰的默认方法可以直接调用，不用子类去实现。

• 编码实操
  先声明USB接口：其中规定了要实现USB接口就必须实现接口规定实现的read( )和write( )这两个方法。

interface USB {
  void read();
  void write();
}

然后在写一个U盘类UDisk和一个键盘类Keyboard，这两个类都去实现USB接口。（实现其中的方法）

class UDisk implements USB {
    @Override
    public void read() {
        System.out.println("U盘正在通过USB功能读取数据");
    }
    @Override
    public void write() {
        System.out.println("U盘正在通过USB功能写入数据");
    }
}


class Keyboard implements USB {
    @Override
    public void read() {
        System.out.println("键盘正在通过USB功能读取数据");
    }
    @Override
    public void write() {
        System.out.println("键盘正在通过USB功能写入数据");
    }
}

测试类：

public class Main {
    public static void main(String[] args) {
        //生成一个实现可USB接口（标准）的U盘对象
       UDisk udisk = new UDisk();
        //调用U盘的read( )方法读取数据
        udisk.read();
        //调用U盘的write( )方法写入数据
        udisk.write();
        //生成一个实现可USB接口（标准）的键盘对象
       Keyboard keyboard = new Keyboard();
        //调用键盘的read( )方法读取数据
       keyboard.read();
        //调用键盘的write( )方法写入数据
       keyboard.write();
    }
}

2.异常

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。
异常发生的原因有很多，通常包含以下几大类：
 用户输入了非法数据。
 要打开的文件不存在。
 网络通信时连接中断，或者JVM内存溢出。

要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：
 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

• 异常处理
  异常处理的流程如下：
  
  Java标准库内建了一些通用的异常，这些类以Throwable为顶层父类。
  Throwable又派生出Error类和Exception类。
  错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。
  异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。
  Java异常的分类和类结构图：
  
  Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws。
• 1.捕获异常

try：执行可能产生异常的代码。
catch：捕获异常。
finally：无论是否发生异常，代码总能执行。

public void method(){ 
	try {       
		// 代码段 1       
		// 产生异常的代码段 2       
		// 代码段 3 
	} catch (异常类型 ex) {       
		// 对异常进行处理的代码段4 
	} 
		// 代码段5 
} 

异 常 类 型	说 明
Exception	异常层次结构的父类
ArithmeticException	算术错误情形，如以零作除数
ArrayIndexOutOfBoundsException	数组下标越界
NullPointerException	尝试访问 null 对象成员
ClassNotFoundException	不能加载所需的类
IllegalArgumentException	方法接收到非法参数
ClassCastException	对象强制类型转换出错
NumberFormatException	数字格式转换异常，如把"abc"转换成数字

异常的处理示例：

import java.util.Scanner;
/**
 * 使用try-catch-finally进行异常处理。
*/
public class Test4 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("请输入被除数:");
        try {
            int num1 = in.nextInt();
            System.out.print("请输入除数:");
            int num2 = in.nextInt();
            System.out.println(String.format("%d / %d = %d",
                    num1, num2, num1/ num2));
        } catch (Exception e) {
            System.err.println("出现错误:被除数和除数必须是整数," +
                    "除数不能为零。");
            System.out.println(e.getMessage());
            //System.exit(1); // finally语句块不执行的唯一情况
        } finally {
            System.out.println("感谢使用本程序!");
        }
    }
}

多重异常示例：

import java.util.Scanner;
import java.util.InputMismatchException;
/**
 * 多重catch块。
*/
public class Test7 {
  public static void main(String[] args) {
      Scanner in = new Scanner(System.in);
      System.out.print("请输入被除数:");
	  	try {
          int num1 = in.nextInt();
          System.out.print("请输入除数:");
          int num2 = in.nextInt();
          System.out.println(String.format("%d / %d = %d", 
                  num1, num2, num1/ num2));
      } catch (InputMismatchException e) {
          System.err.println("被除数和除数必须是整数。");
      } catch (ArithmeticException e) {
          System.err.println("除数不能为零。");
      } catch (Exception e) {
          System.err.println("其他未知异常。");
      } finally {
          System.out.println("感谢使用本程序!");
      }
   }
}

多重异常的执行规则：
 排列catch 语句的顺序：先子类后父类
 发生异常时按顺序逐个匹配
 只执行第一个与异常类型匹配的catch语句

• 2.声明异常
  throws：声明方法可能要抛出的各种异常。
  如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。
• 3.抛出异常
  throw：手动抛出异常。
  例子：

public class Person {
	private String name = "";   // 姓名
	private int age = 0;   // 年龄
	private String sex = "男";  // 性别
	public void setSex(String sex) throws Exception {
		if ("男".equals(sex) || "女".equals(sex))
			this.sex = sex;
		else {
			throw new Exception(“性别必须是\"男\"或者\"女\"！");
		}
	}
}