黑马程序员-Java基础总结06——继承(2)

最新推荐文章于 2014-04-13 05:00:50 发布

生命缘迹

最新推荐文章于 2014-04-13 05:00:50 发布

阅读量591

点赞数

分类专栏： Java基础文章标签： Java 内部类匿名内部类异常体系自定义异常异常包装技术

本文链接：https://blog.csdn.net/zms2100/article/details/23579841

版权

Java基础专栏收录该内容

27 篇文章 0 订阅

订阅专栏

面向对象——继承(2)

-------android培训、java培训、期待与您交流！----------

内容: 内部类(匿名内部类)、异常体系(包括自定义异常、异常包装技术)、包与静态导入。

10、内部类：

将一个类定义在另一个类中，这个类中的类就称为内部类（内置类，嵌套类）。

　　class Person{			// 外部类Person;
　　　　class Child{		// Person类中的内部类Child ;
　　　　    private static int age = 10;       //内部类的成员变量、函数等;
　　　　    public static void getPerson(){ . . . }
　　　　}
　　}

访问特点：（内部类与外部类、外部其他类）

1、内部类可以直接访问外部类中的成员，包括私有成员。

（原因:内部类中持有了一个外部类的引用，格式：外部类名.this.内部类方法）

2、而外部类要访问内部类中的成员必须要建立内部类的对象。

内部类定义在外部类的不同位置的区别：

1、内部类定义在成员位置上：（即与方法等同层次）

A、可以被private、static成员修饰符修饰；

B、private：将内部类在外部类中进行封装；

C、被static修饰的内部类只能访问外部类中的静态成员，出现访问局限性。

2、内部类定义在局部位置上：（内部类在方法中）

A、也可以直接访问外部类中的成员；

B、但是只能访问所在局部中的被final修饰局部变量；

C、局部位置内部类不能被private修饰(因为private是修饰成员的)。

(成员位置)内部类访问格式：

1、当内部类定义在外部类的成员位置上，而且非私有，

可以在外部其他类中，直接建立内部类对象。

格式： 外部类名.内部类名变量名= 外部类对象.内部类对象;

Outer.Inner in = new Outer( ).new Inner();

2、当内部类为静态(static)内部类时，外部其他类如何访问其中的成员？

A、外部其他类，直接访问static内部类的非静态成员方法：

new Outer.Inner( ).function( );

B、外部其他类，直接访问static内部类的静态成员方法：

Outer.Inner.function( );

注意： 1、当内部类中定义了静态成员，该内部类必须被静态(static)修饰。

2、当外部类中的静态方法访问内部类时，该内部类也必须是static的。

11、匿名内部类： 即内部类的简化写法。

前提：该内部类必须继承或实现一个外部类或者接口。

格式为：

new 父类名或者接口名( ) {复写父类或接口中方法(或自定义子类成员) }.子类方法( );

例：new AbsDemo( ) { voidshow( ) {System.out.println(“hehe”); } } .show();

简单理解：就是建立一个带内容的外部(父)类或者接口的子类匿名对象。

注意：

1、匿名内部类可以起名字，不过是以多态形式起父类名，但只能调用父类有的方法；

2、匿名内部类中定义的方法最好不要超过3个（超过则不使用匿名形式）。

12、异常：即程序运行时出现的不正常情况；

Java在设计异常体系时，将容易出现的情况都封装成了对象。

异常的体系：

Throwable 异常

Error

描述程序编译运行中出现的严重问题：运行的类不存在或者内存溢出等。

对于Error一般不编写针对性的代码对其进行处理

Exception

描述程序编译运行时出现的普通非严重问题，

对于Exception可以使用针对性的处理方式(try、catch、finally)来处理。

Exception和Error的子类名都是以父类名作为后缀。

（无论Error或者Exception都具有一些共性内容，比如：不正常情况的信息，引发原因等。）

Exception特有处理方式：【try-catch 或 try-catch-finally两种方式处理】

try{

包含可能发生异常的语句； }

catch(异常类型异常名) { //具有针对性的异常类型。

处理异常的代码； }

finally {

一定会执行的代码；(除非发生虚拟机关闭的情况)

}

（//System.exit(0); //系统退出，jvm结束。）

Throwable中的方法：

(String) .getMessage(); :获取异常原因,返回字符串。（例如:除数为0时原因：by zero；）

【在throw异常对象时可以根据需要修改此原因】

(String) .toString(); : 获取异常信息，返回字符串；（异常类名：异常的原因）

异常名.printStackTrace();:Java异常默认打印内容（它没有返回值，直接打印到控制台）

【异常类名、异常信息、异常出现的位置，这是JVM默认的异常处理机制。】

异常名.printStackTrace(PrintStream s) ：（异常处理日志）

【通常用该方法将异常内容保存在日志文件中，以便查阅。】

补充：

throws和throw的区别:

1、throws使用在函数上，用于抛出异常类，可以同时抛出多个，用逗号“,”隔开；

2、throw使用在函数内，用于抛出异常对象；

throws和throw抛出内容的区别：

1、throws异常类 ：标识该函数有可能会发生此异常的代码（需要调用者处理）；

2、throw异常对象：出现于某段代码之后，意为此代码会抛出这种异常；

throws和throw使用情况：

异常又可分为下面两种类型： (严重情况：Error、Exception)

A、编译时被检测的异常: Exception等大多数异常

（如果方法中有代码throw的异常对象属于该类，则在方法上要声明异常/throws异常类）

B、编译时不被检测的异常(运行时异常：RuntimeException及其子类)；

（而在抛出这种类型的异常对象代码的方法上不需要声明异常/throws异常类）

函数上声明异常原因：（即将标识异常声明于函数的“小括号和大括号之间”）

目的：便于提高安全性，让调用者进行处理；不处理编译会失败。

【RuntimeException及其子类异常:

只执行throw抛出异常对象，而不throws抛出异常类（声明异常）】

13、自定义异常: Java仅将编程等过程中可能出现的异常进行描述并封装成对象；

在实际开发项目时也可能出现特有问题，所以需要创建自定义异常及处理方式。

自定义异常必须继承已有异常体系，主要继承分为：Error、Exception和RuntimeException；

【因为异常体系有一个特点：异常类和异常对象都会被抛出，它们具备可抛性；

而只有Throwable体系才具有可抛性这一独有特点】

Error : 严重异常，通常不编写等待么针对其进行处理（所以少继承）。

Exception : 一般可处理异常，该异常需要在内部处理或在函数上声明异常；

RuntimeException : 特殊的异常，主要在于它及其子类不需要在函数上声明异常；

【通过构造函数定义异常信息；通过throw将自定义异常抛出。】

函数内出现异常，执行了throw抛出异常对象，那么就必须要给对应的处理动作。

处理方式： 1、在内部try、catch进行针对性处理；

2、在函数上需要声明，让调用者处理。

异常发生时是否能被处理：（如何选择继承类型？）

可以处理就继承Exception；（即需要在函数上声明异常）

不能被处理，需要停止程序，则用RuntimeException。（不需要声明异常）

异常的处理：

1、对多异常的处理:

a、声明异常时，建议声明更为具体的异常；这样处理时可以更为具体。

b、对方声明几个异常，就对应有几个catch块；不要定义多余的catch块。

如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

【子类异常能具体地处理问题，而Exception父类异常在最尾处理未知异常】

2、处理方式:

建立在进行catch处理时，catch中一定要定义具体处理方式。

（不要简单定义一句e.printStackTrace(),或简单的就书写一条输出语句。）

实际应用中应有“异常处理日志”，同时进行程序恢复，使其保持正常运作。

子类覆盖父类或接口方法时：

1、父类方法抛出异常，子类只能抛出父类异常或该异常的子类；

2、父类方法抛出多个异常，子类只能抛出父类异常的子集；

3、父类方法没有抛出异常，子类不能抛出异常；子类方法发生异常，必须进行try处理，绝对不能抛。

3、finally代码块：定义一定要执行的代码;

（即使在此之前出现return、throw等结束程序动作，它也执行，除非发生虚拟机关闭的情况。）

通常用于关闭资源，例如：关闭与数据库的连接、关闭与系统底层调用的连接等情况。

注意：在编写代码catch异常时，如果有做throw异常或return动作，一定要根据情况决定是否要编写finally代码块(关闭资源或执行一定要运行的代码)。

资料补充：

4、异常的包装技术：

（建议使用，可让用户抛出子系统中的高级异常，而不丢失原始异常的细节）

A、包装异常：

try {      
computer.run();          }
catch(MaoYanException e) {
               //如果是RuntimeException一类异常正常情况下可直接: throw e;
             //但有时会出现不能抛出异常，但必须try时就可以通过包装技术来throw;
//包装方式（代码）:
  Throwable se = new NoWorkException("没办法完成工作啦");
  se.initCause(e);    //将MaoYanException异常添加到Throwable异常包装包中。
  throw se;    //函数上就要声明se的异常类型Throwable;
}

B、当捕获到异常时，可以通过：

catch(Throwable se){
  se.printStackTrace();  //获取全部异常信息(MaoYanException、NoWorkException)；
或  Throwable e = se.getCause();  //提取"父级"异常(即MaoYanException异常)
   e.printStackTrace();           //打印"父级"异常的信息及位置；
}

应用:

1、应用于除RuntimeException、ClassNotFoundException和InvocationTargetException外本身自己没有异常链方案的异常；

2、JavaSE 1.4中的"诱饵"、调用getCause得到异常链；

3、当一个方法中发生一个已检查异常，但不允许抛出时，使用这个包装技术；

就可以通过捕获该已检查异常，并将其包装成为一个运行时异常。

14、包（package）:

1、对类文件进行分类管理；

2、给类提供多层命名空间；

3、写在程序文件的第一行；

4、类名的全称的是: 包名.类名；

5、包也是一种封装形式。

注意： 包名所有字母均小写。