马兵士课程笔记(续3)
马士兵课程笔记(续3)
抽象类
- 关键字abstract
- 含有抽象方法的类必须声明为抽象类；
- 抽象类必须先被继承，不能直接实例化；
- 抽象方法只需声明不需实现，所以必须在子类中被重写（类似C++中的纯虚函数）
abstract class A {
...
public abstract void b(); // note: 这里没有“{}”了
...
}
- 如果并不打算由抽象类的子类来实现抽象方法，可以将该子类再声明为抽象类，在其中再次声明该抽象方法，由他的子类（“孙子类”）去实现。
final关键字
- final变量的值不能修改（相当于C++的const关键字，当常量用）；
- final成员变量
- final局部变量（形参）：用在引用型形参上就能防止形参指向别处造成的bug
- final方法不能被重写；
- final类不能被继承（如JDK中的String、Math、Boolean等就是final类）。
接口interface
- java本来是单继承的；
- 接口interface是抽象方法和常量值的定义的集合；
- 从本质上讲，interface是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有方法的实现（这个工作交给其实现类来完成）；
public interface Runner {
public static final int id = 1; // 常量前要加“public static final”关键字
public void start(); // interface内的抽象方法不需要加abstract关键字
public void run();
public void stop();
}
接口特性
- 接口支持多重实现；
- 多个无关的的类可以实现同一个接口；
- 一个类可以实现多个无关的接口；
- 接口中声明的属性默认且必须是public static final的；
这是为了避免像C++多继承那样多个父类有同名成员变量而出现的冲突。
- 接口中只能定义抽象方法，而这些方法默认且只能是public的；
- 接口可以继承其他接口，并添加新的属性和抽象方法。
- 与继承关系类似，接口与实现类之间存在多态性。
以接口引用实现类的对象，就只能调用本接口声明了的方法和属性。
定义JAVA类的语法格式：
<modifier> class <name> [extends <superclass>] [implements <interface> [, <interface>]*] {
<declarations>*
}
面向对象Summary
- 内存分析贯穿始终
- 对象和类的概念
- 类（对象）之间的关系
- 面向对象设计思想
- class
- new
- 引用的概念
- 构造方法的概念
- 方法重载
- 构造方法重载
- this
- static
- package 和 import
- private， default， protected， public
- extends
- overwrite重写
- final
- Object
- toString（）
- equals（）
- upcasting， downcasting
- polymophysm / dynamic binding / late binding
- abstract
- interface
- implements
异常exceptions
java异常概念
- 运行期出现的错误
- 观察错误的名字和行号最重要
程序，是调出来的。
- 异常是java提供的用于处理程序中错误的一种机制。
- 错误是指在程序运行过程中发生的一些异常事件（如：除0溢出，数组下标越界，所要读取的文件不存在 等）；
public class TestEx {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
System.out.println(arr[4]); // 与Java不同，在C/C++中并不检查数组越界
}
}
/* 输出:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
at TestEx.main(TestEx.java:6)
*/
- 设计良好的程序应该在异常发生时提供处理这些错误的方法，使得程序不会因为异常的发生而阻断或产生不可预见的错误；
- java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该对象封装了异常事件的信息并将被提交给java Runtime系统，这个过程称为抛出（throw）异常；
- 当Java runtime系统收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获（catch）异常。
异常的分类
- 异常类封装了异常事件发生的信息以及相应方法。
- Error：称为错误，由Java虚拟机生成并抛出，包括动态链接失败、虚拟机错误等，程序对其不做处理（也处理不了）。
- Exception：所有异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显式地声明或捕获。
- RuntimeException：一类特殊的异常，如被0除、数组下标出界等，其产生比较频繁，处理麻烦，如果显式地声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交由缺省的异常处理程序（可不必处理），不过缺省处理程序是打印异常信息后就中止执行了。
- java.lang.Exception
- ClassNotFundException
- IOException
- InterruptedException
- ......
- RuntimeException
- ArithmeticException
- NullPointerException
- ......
- IndexOutOfBoundsException
- ArrayIndexOutOfBoundsException
- StringIndexOutOfBoundsException
import java.io.*;
public class TestEx {
public static void main(String[] args) {
TestEx te = new TestEx();
te.m(0); // 对RuntimeException不做处理有虚拟机缺省处理，编译可以通过，但运行时缺省处理报异常后就停止不往下执行了
// te.n(0); // 而对非RuntimeException必须try/catch或声明，否则编译报错
/* 编译报错
TestEx.java:27: 未报告的异常 java.io.IOException；必须对其进行捕捉或声明以便抛出
te.n(0);
^
*/
try {
te.n(0);
} catch(IOException e) { // 将try{}中抛出的某错误类的对象捕获传给引用e
System.out.println("出错了！");
e.printStackTrace(); // 跟踪异常事件发生时执行堆栈的内容，并在控制台上打印出来，包含了getMessage()。
}
/* 输出：
出错了！
java.io.IOException: 而对非RuntimeException必须try/catch或声明，否则编译报错
at TestEx.n(TestEx.java:39)
at TestEx.main(TestEx.java:22)
程序执行完毕
*/
System.out.println("程序执行完毕");
}
// 方法内创建异常类对象并抛出，注意语法
void m(int i) throws RuntimeException { // throws--声明异常
if(0 == i) throw new RuntimeException("对RuntimeException不做处理有虚拟机缺省处理，编译可以通过，但运行时缺省处理报异常后就停止不往下执行了");
} // note：如果throw语句后面方法内还有语句，当抛出异常时该方法内剩余的语句就不执行了
void n(int i) throws IOException { // IOException不属于RuntimeException
if(0 == i) throw new IOException("而对非RuntimeException必须try/catch或声明，否则编译报错");
}
}
异常的捕获和处理
-
try {}
- try代码段指定了一次捕获并处理例外的范围；
- 在执行过程中，该段代码可能会产生并抛出一种或多种类型的异常对象，那么它后面的catch语句要分别对它们做相应的处理；
- 若没有例外产生，所有的catch段都被跳过。
-
catch(SomeException e) {}
- SomeException e 封装了异常事件发生的信息，在catch段中可以使用该对象的一些方法获取这些信息。如：
- getMessage()，用来得到有关异常事件的信息；
- printStackTrace()，用来跟踪异常事件发生时执行堆栈的内容，包含了getMessage()，因此它更常用。
- 禁止空catch段，这是很危险的。
- note: 当捕获多类异常对象分别处理时，要将子类异常放在前面，否则编译报错“已捕捉到异常”。
- SomeException e 封装了异常事件发生的信息，在catch段中可以使用该对象的一些方法获取这些信息。如：
-
finally {}
- finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序其他部分前，能够对程序的状态做统一的管理；
- 无论是否有例外，finally段中代码都要执行；
- 可以用来完成资源的清理工作，如：
- 关闭打开的文件；
- 删除临时文件
- ... ...
import java.io.*;
public class TestEx {
public static void main(String[] args) {
// 用try/catch结构体捕捉处理异常，之后程序会继续往下执行，注意语法
FileInputStream is = null;
try { // try代码段包含可能产生异常的代码，注意！最小包含原则
is = new FileInputStream("myfile.txt");
int b;
b = is.read();
while (b != 1) {
System.out.print((char) b);
b = is.read();
}
// 当异常发生时，程序会终止当前的流程，根据获取异常的类型去执行相应的catch段
} catch(FileNotFoundException e) { // catch代码段声明其能处理的某一类异常
e.printStackTrace(); // 并在段内提供处理的方法
} catch(IOException e) { // 对try中抛出的多类异常，分别catch处理
System.out.println(e.getMessage()); // getMessage()方法用来得到异常事件的信息。较少用
} finally { // finally段的代码无论是否发生异常都要执行
try {
is.close();
} catch(Exception e) {
e.printStackTrace();
}
}
System.out.println("程序执行完毕");
}
}
-
声明方法抛出的异常——“矛盾上交”
- 若在本方法内处理不了，可以再throws交给外一层处理。
import java.io.*;
public class TestEx {
public static void main(String[] args) {
TestEx te = new TestEx();
// f()方法抛出的异常最终"上交"给main()方法处理了
// 当然main()方法也可以向外声明(throws)上交给虚拟机处理，但这是错误的
// 应当尽力将异常处理在自家门里
try {
te.ff();
} catch(IOException e) {
System.out.println("f()方法抛出的异常最后\"上交\"给main()方法处理了");
e.printStackTrace();
}
}
// 声明方法抛出的异常
void f(boolean b) throws FileNotFoundException, IOException { // 尽管FileNotFoundException是IOException的子类，可以只throws IOException，但作为一种意识还是强烈建议分开抛
if(b) throw new FileNotFoundException("声明方法抛出的异常A");
else throw new IOException("声明方法抛出的异常B");
}
void ff() throws IOException { // 对调用的方法所抛出的异常处理不了的也可以继续向外抛出
f(true);
}
}
使用自定义的异常
通过继承 java.lang.Exception（或RuntimeException） 类声明自己的异常类；然后用法跟普通异常一样。
class MyException extends Exception {
private int id;
public MyException(String message, int id) {
super(message);
this.id = id;
}
public int getId() {
return id;
}
}
声明了异常的类的继承重写
note：重写方法只能抛出与原方法所抛出一样类型（不包括父类、子类）的异常，要么不抛出异常。
异常Summary
- 一个图
- 五个关键字：try，catch，finally，throw，throws
- 先逮小的，再逮大的
- 异常和重写的关系