1.可以使用instanceof运算符判断一个对象是否可以转换为指定的类型。

public class TestInstanceof

{

public static void main(String[] args)

{

//声明hello时使用Object类，则hello的编译类型是Object，Object是所有类的父类

//但hello变量的实际类型是String

Object hello = "Hello";

//String是Object类的子类，所以返回true。

System.out.println("字符串是否是Object类的实例：" + (hello instanceof Object));

//返回true。

System.out.println("字符串是否是String类的实例：" + (hello instanceof String));

//返回false。

System.out.println("字符串是否是Math类的实例：" + (hello instanceof Math));

//String实现了Comparable接口，所以返回true。

System.out.println("字符串是否是Comparable接口的实例：" + (hello instanceof Comparable));

String a = "Hello";

//String类既不是Math类，也不是Math类的父类，所以下面代码编译无法通过

//System.out.println("字符串是否是Math类的实例：" + (a instanceof Math));

}

}

截图；

2.下列语句哪一个将引起编译错误?为什么?哪一个会引起运行时错误?为什么?

class Mammal{}

class Dog extends Mammal {}

class Cat extends Mammal{}

public class TestCast

{

public static void main(String args[])

{

Mammal m;

Dog d=new Dog();

Cat c=new Cat();

m=d;

//d=m;

d=(Dog)m;

//d=c;

c=(Cat)m;

}

}

截图；

显示类型转换异常，因为Dog和Cat之间不是继承关系，所以，无法将Dog对象想换换成为Cat对象。

3.运行课件中的例题ParentChildTest.java，回答下列问题：

a) 左边的程序运行结果是什么？

b) 你如何解释会得到这样的输出？

c) 计算机是不会出错的，之所以得到这样的运行结果也是有原因的，那么从这些运行结果中，你能总结出Java的哪些语法特性？

并修改 ParentChildTest.java，验证你的回答结果

a ) 在左边的程序中public class ParentChildTest {

/**

* @param args

*/

public static void main(String[] args) {

Parent parent=new Parent();

parent.printValue();

Child child=new Child();

child.printValue();

parent=child;

parent.printValue();

parent.myValue++;

parent.printValue();

((Child)parent).myValue++;

parent.printValue();

}

}

a) 运行结果；Parent.printValue(),myValue=100

Child.printValue(),myValue=200

Child.printValue(),myValue=200

Child.printValue(),myValue=200

Child.printValue(),myValue=201

b) 第一和第二中父类和子类都分配了空间，调用父类和子类的构造方法，分别输出他们的值；第三个父类等于子类，当子类与父类拥有一样的方法，并且让一个父类变量引用一个子类对象，由于对象是子类，父类调用的是子类的方法，输出子类的值；第四个parent.myValue++是对父类中的变量进行自加运算，而parent.printValue()实际上调用的还是子类的构造方法；第五个((Child)parent).myValue++是将parent对象强制转化成Child，所以指向的是Child类中的变量，进行自加运算之后输出。

c )  当子类与父类拥有一样的方法，并且让一个父类变量引用一个子类对象时，到底调用哪个方法，由对象自己的“真实”类型所决定，这就是说：对象是子类型的，它就调用子类型的方法，是父类型的，它就调用父类型的方法。

这个特性实际上就是面向对象“多态”特性的具体表现。

如果子类与父类有相同的字段,则子类中的字段会代替或隐藏父类的字段，子类方法中访问的是子类中的字段（而不是父类中的字段）。如果子类方法确实想访问父类中被隐藏的同名字段，可以用super关键字来访问它。

如果子类被当作父类使用,则通过子类访问的字段是父类的!

public class ParentChildTest {

public static void main(String[] args) {

Parent parent=new Parent();

parent.printValue();

Child child=new Child();

child.printValue();

parent=child;

parent.printValue();

((Child)parent).myValue--;

parent.printValue();

((Child)parent).myValue++;

parent.printValue();

}

}

class Parent{

public int myValue=100;

public void printValue() {

System.out.println("Parent.printValue(),myValue="+myValue);

}

}

class Child extends Parent{

public int myValue=200;

public void printValue() {

System.out.println("Child.printValue(),myValue="+myValue);

}

}

截图；

4.请阅读并运行AboutException.java示例，然后通过后面的几页PPT了解Java中实现异常处理的基础知识

import javax.swing.*;

class AboutException {

public static void main(String[] a)

{

int i=1, j=0, k;

k=i/j;

try

{

k = i/j;    // Causes division-by-zero exception

//throw new Exception("Hello.Exception!");

}

catch ( ArithmeticException e)

{

System.out.println("被0除.  "+ e.getMessage());

}

catch (Exception e)

{

if (e instanceof ArithmeticException)

System.out.println("被0除");

else

{

System.out.println(e.getMessage());

}

}

finally

{

JOptionPane.showConfirmDialog(null,"OK");

}

}

}

截图；

使用Java异常处理机制；

（1）Java 中所有可捕获的异常都派生自Exception类。

（2）把可能会发生错误的代码放进try语句块中。

（3）当程序检测到出现了一个错误时会抛出一个异常对象。异常处理代码会捕获并处理这个错误，catch语句块中的代码用于处理错误。

（4）当异常发生时，程序控制流程由try语句块跳转到catch语句块。

（5）不管是否有异常发生，finally语句块中的语句始终保证被执行。

（6）如果没有提供合适的异常处理代码，JVM将会结束掉整个应用程序。

Java中的异常分类；

（7）Throwable类有两个直接子类：Exception：出现的问题是可以被捕获的；Error：系统错误，通常由JVM处理。

（8）可捕获的异常又可以分为两类：check异常:直接派生自Exception的异常类，必须被捕获或再次声明抛出；runtime异常：派生自RuntimeException的异常类。使用throw语句可以随时抛出这种异常对象。

（9）可以有多个catch语句块，每个代码块捕获一种异常。在某个try块后有两个不同的catch块捕获两个相同类型的异常是语法错误。

（10）使用catch语句，只能捕获Exception类及其子类的对象。因此，一个捕获Exception对象的catch语句块可以捕获所有“可捕获”的异常。

（11）将catch(Exception e)放在别的catch块前面会使这些catch块都不执行，因此Java不会编译这个程序。

finally”的功用：

资源泄露：当一个资源不再被某应用程序使用，但此程序并未向系统声明不再使用此资源时发生这种情况

finally语句块主要用于解决资源泄露问题，它位于catch语句块之后，JVM保证它们一定执行。

注意：finally语句块中也可能发生异常，如果这种情况发生，先前的异常被放弃。

5.阅读以下代码（CatchWho.java），写出程序运行结果：

public class CatchWho {

public static void main(String[] args) {

try {

try {

throw new ArrayIndexOutOfBoundsException();

}

catch(ArrayIndexOutOfBoundsException e) {

System.out.println(  "ArrayIndexOutOfBoundsException" +  "/内层try-catch");

}

throw new ArithmeticException();

}

catch(ArithmeticException e) {

System.out.println("发生ArithmeticException");

}

catch(ArrayIndexOutOfBoundsException e) {

System.out.println(  "ArrayIndexOutOfBoundsException" + "/外层try-catch");

}

}

}

运行结果；ArrayIndexOutOfBoundsException/内层try-catch

发生ArithmeticException

6.写出CatchWho2.java程序运行的结果；

public class CatchWho2 {

public static void main(String[] args) {

try {

try {

throw new ArrayIndexOutOfBoundsException();

}

catch(ArithmeticException e) {

System.out.println( "ArrayIndexOutOfBoundsException" + "/内层try-catch");

}

throw new ArithmeticException();

}

catch(ArithmeticException e) {

System.out.println("发生ArithmeticException");

}

catch(ArrayIndexOutOfBoundsException e) {

System.out.println( "ArrayIndexOutOfBoundsException" + "/外层try-catch");

}

}

}

运行结果；ArrayIndexOutOfBoundsException/外层try-catch

7.请先阅读 EmbedFinally.java示例，再运行它，观察其输出并进行总结。

public class EmbededFinally {

public static void main(String args[])

int result；

try {

System.out.println("in Level 1")；

try {

System.out.println("in Level 2");

// result=100/0;  //Level 2

try {

System.out.println("in Level 3");

result=100/0;  //Level 3

}

catch (Exception e) {

System.out.println("Level 3:" + e.getClass().toString());

}

finally {

System.out.println("In Level 3 finally");

}

// result=100/0;  //Level 2

}

catch (Exception e) {

System.out.println("Level 2:" + e.getClass().toString());

}

finally {

System.out.println("In Level 2 finally");

}

// result = 100 / 0;  //level 1

}

catch (Exception e) {

System.out.println("Level 1:" + e.getClass().toString());

}

finally {

System.out.println("In Level 1 finally");

}

}

}

输出；in Level 1

in Level 2

in Level 3

Level 3:class java.lang.ArithmeticException

In Level 3 finally

In Level 2 finally

In Level 1 finally

总结；当有多层嵌套的finally时，异常在不同的层次抛出 ，在不同的位置抛出，可能会导致不同的finally语句块执行顺序。

8.finally语句块一定会执行吗？

请通过 SystemExitAndFinally.java示例程序回答上述问题

public class SystemExitAndFinally {

public static void main(String[] args)

{

try{

System.out.println("in main");

throw new Exception("Exception is thrown in main");

//System.exit(0);

}

catch(Exception e)

{

System.out.println(e.getMessage());

System.exit(0);

}

finally

{

System.out.println("in finally");

}

}

}

结果；in main

Exception is thrown in main

如果没有提供合适的异常处理代码，JVM将会结束掉整个应用程序

9.请通过 PrintExpressionStack.java示例掌握上述内容。

// UsingExceptions.java

// Demonstrating the getMessage and printStackTrace

// methods inherited into all exception classes.

public class PrintExceptionStack {

public static void main( String args[] )

{

try {

method1();

}

catch ( Exception e ) {

System.err.println( e.getMessage() + "\n" );

e.printStackTrace();

}

}

public static void method1() throws Exception

{

method2();

}

public static void method2() throws Exception

{

method3();

}

public static void method3() throws Exception

{

throw new Exception( "Exception thrown in method3" );

}

}

结果；Exception thrown in method3

java.lang.Exception: Exception thrown in method3

at PrintExceptionStack.method3(PrintExceptionStack.java:28)

at PrintExceptionStack.method2(PrintExceptionStack.java:23)

at PrintExceptionStack.method1(PrintExceptionStack.java:18)

at PrintExceptionStack.main(PrintExceptionStack.java:8)

当程序中出现异常时，JVM会依据方法调用顺序依次查找有关的错误处理程序。

可使用printStackTrace和getMessage方法了解异常发生的情况：

printStackTrace：打印方法调用堆栈。

每个Throwable类的对象都有一个getMessage方法，它返回一个字串，这个字串是在Exception构造函数中传入的，通常让这一字串包含特定异常的相关信息。

10.一个方法可以声明抛出多个异常

import java.io.*;

public class ThrowMultiExceptionsDemo {

public static void main(String[] args)

{

try {

throwsTest();

}

catch(IOException e) {

System.out.println("捕捉异常");

}

}

private static void throwsTest()  throws ArithmeticException,IOException {

System.out.println("这只是一个测试");

// 程序处理过程假设发生异常

throw new IOException();

//throw new ArithmeticException();

}

}

结果；这只是一个测试

捕捉异常

11.OverrideThrows.java示例展示了Java子类的throws子句抛出的异常，不能是其基类同名方法抛出的异常对象的父类。

import java.io.*;

public class OverrideThrows

{

public void test()throws IOException

{

FileInputStream fis = new FileInputStream("a.txt");

}

}

class Sub extends OverrideThrows

{

//如果test方法声明抛出了比父类方法更大的异常,比如Exception

//则代码将无法编译……

public void test() throws FileNotFoundException

{

//...

}

}

结果；这只是一个测试

捕捉异常

12.ExceptionLinkInRealWorld.java示例展示了典型的异常处理代码模板

/**

* 自定义的异常类

* @author JinXuLiang

*

*/

class MyException extends Exception

{

public MyException(String Message) {

super(Message);

}

public MyException(String message, Throwable cause) {

super(message, cause);

}

public MyException( Throwable cause) {

super(cause);

}

}

public class ExceptionLinkInRealWorld {

public static void main( String args[] )

{

try {

throwExceptionMethod();  //有可能抛出异常的方法调用

}

catch ( MyException e )

{

System.err.println( e.getMessage() );

System.err.println(e.getCause().getMessage());

}

catch ( Exception e )

{

System.err.println( "Exception handled in main" );

}

doesNotThrowException(); //不抛出异常的方法调用

}

public static void throwExceptionMethod() throws MyException

{

try {

System.out.println( "Method throwException" );

throw new Exception("系统运行时引发的特定的异常");  // 产生了一个特定的异常

}

catch( Exception e )

{

System.err.println(

"Exception handled in method throwException" );

//转换为一个自定义异常，再抛出

throw new MyException("在方法执行时出现异常",e)；

}

finally {

System.err.println(

"Finally executed in throwException" );

}

// any code here would not be reached

}

public static void doesNotThrowException()

{

try {

System.out.println( "Method doesNotThrowException" );

}

catch( Exception e )

{

System.err.println( e.toString() );

}

finally {

System.err.println(

"Finally executed in doesNotThrowException" );

}

System.out.println(

"End of method doesNotThrowException" );

}

}

结果；Method throwException

Exception handled in method throwException

Finally executed in throwExceptionMethod doesNotThrowException

在方法执行时出现异常

系统运行时引发的特定的异常

Finally executed in doesNotThrowException

End of method doesNotThrowException