黑马程序员 ——Java基础之内部类、异常、包

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

内部类

  在类内部可定义成员变量与方法，有趣的是，在类内部也可以定义另一个类。如果在类 Outer 的内部再定义一个类 Inner，此时类 Inner 就称为内部类，而类 Outer 则称为外部类。
  内部类可声明成 public 或 private。当内部类声明成 public 或 private 时，对其访问的限制与成员变量和成员方法完全相同。

【定义内部类格式】

标识符 class 外部类的名称
{
// 外部类的成员

标识符 class 内部类的名称 
{
// 内部类的成员 
}
}

一、内部类访问规则

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

原因：内部类中持有了一个外部类引用，格式：外部类名.this

2，外部类要访问内部类，必须建立内部类对象。

二、访问格式：

当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，可以直接建立内部类对象

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

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

当内部类在成员位置上就可以被成员修饰符所修饰

比如，private：将内部类在外部类中进行封装

static：内部类就具备static的特性

当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限

在外部其他类中，如何直接访问static内部类的非静态成员呢？

new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？

outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的

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

在方法中定义的内部类只能访问方法中的 final 类型的局部变量，因为用 final 定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期。

当描述事物时，事物的内部还有事物，该事物用内部类来描述；因为内部类事物在使用外事物的内容

 

//范例： class Outer{int score = 95;void inst(final int s){final int temp = 20 ;class Inner{void display(){System.out.println("成绩: score = " + (score+s+temp));  }}Inner in = new Inner();in.display();}}public class InnerClass{public static void main(String[] args){Outer outer = new Outer();outer.inst(5) ;}}

输出结果：
成绩: score = 120

 

三、匿名内部类：

1，匿名内部类其实就是内部类的简写格式

2，定义内部类的前提：

内部类必须是继承一个类或者实现接口

3，匿名内部类的格式：new 父类或者接口(){定义子类的内容}

4，其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，可以理解为带内容的对象

5，匿名内部类中定义的方法最好不要超过3个

 //范例： NonameInner.java interface A { public void fun1() ; } class B { int i = 10 ;public void get(A a){a.fun1() ; } public void test(){this.get(new A(){ public void fun1(){System.out.println(i) ;}}) ;} } class TestNonameInner2 { public static void main(String[] args) { B b = new B() ;    b.test() ;        } }

输出结果：
10
分析：由此程序可以发现，在程序中并没有明确的声明出实现接口 A 的类，但是在程序第 14~21 行，可以发现，程序实现了接口 A 中的 fun1()方法，并把整个的一个实现类，传递到了方法 get 中，这就是所谓的匿名内部类。它不用声明实质上的类，就可以使用.

异常

一、概述

1，异常：就是程序在运行时出现不正常情况

2，异常由来：问题也是现实生活中一个具体的事物，也可以通过Java类的形式进行描述，并封装成对象。

  其实就是Java对不正常情况进行描述后的对象体现

 

3，对于问题的划分：两种，一种是严重问题，一种非严重的问题

  ①对于严重的，Java通过Error类进行描述；对于Error一般不编写针对性的代码对其进行处理

  ②对于非严重的，Java通过Exception进行描述；对于Exception可以使用针对性的处理方式进行处理

无论Error还是Exception都具有一些共性内容。

比如：不正常的情况的信息，引发的原因等

二，异常体系 

Throwable类的继承关系图

异常体系的特点：

        1、异常体系中的所有类以及建立的对象都具备可抛性。

        2、也就是说可以被throw和throws关键字所操作。

        3、只有异常体系具备这个特点。

三、异常处理

1，【异常处理的语法格式】

try
{
要检查的程序语句 ；

}
catch(异常类 对象名称)

{ 

异常发生时的处理语句 ；

}
finally
{

 一定会运行到的程序代码 ；

}

语句运行流程图

2，对捕获到的异常对象进行常见方法操作。

①，String getMessage()//获取异常信息

  ②，在函数上声明异常。

便于提高安全性，让调用出进行处理，不处理编译失败。

 

3，多异常处理

①，声明异常时，建议声明更为具体的异常，这样处理的可以更具体

②，对方声明几个异常，就对应有几个catch块，不要定义多余的catch块，如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面

建议在进行catch处理时，catch中一定要定义具体处理方式，不要简单一句e.printSrackTrace（），也不要简单的就书写一条输出语句。

throws和throw的区别

throws使用在函数上，throw使用在函数内

throws后面跟的是异常类，可以跟多个，用逗号隔开

throw后面跟的是异常对象

RuntimeException

Exception中有一个特殊的子类异常RuntimeException 运行异常

如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过

如果在函数上声明了该异常，调用者可以不用处理，编译一样通过

之所以不用再函数上声明，是因为不需要让调用者处理，当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。

自定义异常时，如果该异常的发生，无法再继续进行运算，就让自定义异常继承RuntimeException。

对于异常分两种

1，编译时被检测的异常

2，编译时不被检测的异常（运行时异常，RuntimeException及其子类）

 

四、自定义异常

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作，要么在内部try catch处理，要么在函数上声明让调用者处理。

一般情况在，函数内出现异常，函数上需要声明，发现打印的结果中只有异常名称，却没有异常的信息，因为自定义的异常并未自定义信息。

如何自定义异常信息？

因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类，通过super语句

那么久可以通过getMessage方法获取自定义的异常信息。 

自定义异常：

必须是自定义类继承Exception

 

继承Exception原因：

异常体系有一个特点：因为异常类和异常对象都被抛出

他们都具有可抛性，这个可抛性是Throwable体系独有的特点

只有这个体系中的类和对象才可以被throws和throw操作

 

<span style="font-size:14px;">class MyException extends Exception{private String msg;ZiDingYiException(String msg){super(msg);//将会返回输入的信息     }}</span><strong style="color: rgb(0, 0, 255);"></strong>

异常finally

Finally代码块：定义一定执行的代码

通常用于关闭资源

 

异常在子父类覆盖中的体现

1，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常或者该异常的子类

2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能覆盖抛出父类异常的子集

3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常

如果子类发生了异常，就必须要进行try处理，绝对不能抛

包

 当一个大型程序由数个不同的组别或人员开发共同开发时，用到相同的类名称是很有可能的事。如果这种情况发生，还要确保

程序可以正确运行，就必须通过 package关键字来解决。

包也是一种封装形式。在包中可以有很多类文件，但是只提供一个类文件，供外界使用。

一、包的作用

        1、为避免多个类重名的情况，如果出现两个相同名字的类，可通过包将两者区分，从而避免冲突。

        2、对类文件进行分类管理，可以将相关的一些类放在同一个包中。

        3、给类提供多层命名空间，如a包中的Demo.class文件，如果要创建Demo对象，就要在使用时加上a.如：

a.Demo demo=new a.Demo（）；

        4、包的出现可以将java的类文件和源文件相分离。

二、包的使用规则      

        1、包必须写在程序的第一行。因为要先有包，才知道类文件的存放地方。

        2、类的全称：包名.类名。

        3、编译定义了包的程序文件时，在编译时要指定包的存储目录。

       如：javac –d c:\mypack类名.java

三、包与包之间的访问

1，包与包之间进行访问，被访问的包中的类以及类中的成员，需要被public 修饰

2，不同包中的子类还可以访问父类中被protected权限修饰的成员包与包之间可以使用的权限只有两种，public 和 protected

访问权限

public

protected

default

private

同一类中

ok

ok

ok

ok

同一包中

ok

ok

ok

 

子类

ok

ok

 

 

不同包中

ok

 

 

四、import 语句的使用
若要访问不同 package 内某个 public 类的成员时，在程序代码内必须明确地指明“被访问 package 的名称.类名称”。

【package 的导入格式】 

import package 名称.类名称 ；

通过 import 命令，可将某个 package 内的整个类导入，因此后续的程序代码便不用再写上被访问package的名称了。

五、JDK 中常见的包

 1、java.lang——包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能在java.lang包中还有一个子包：java.lang.reflect用于实现java类的反射机制。

2、java.awt——包含了构成抽象窗口工具集（ abstract window toolkits） 的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。

3、javax.swing——此包用于建立图形用户界面，此包中的组件相对于java.awt

包而言是轻量级组件。

4、java.applet——包含applet 运行所需的一些类。

5、java.net——包含执行与网络相关的操作的类。

6、java.io——包含能提供多种输入/输出功能的类。

7、java.util——包含一些实用工具类，如定义系统特性、与日期日历相关的 函数。

注意：java1.2以后的版本中，java.lang这个包会自动被导入，对于其中的类，不需要使用import语句来做导入了，如前面经常使用的System

Java 的命名习惯

◆ 包名中的字母一律小写，如： demo.java。
◆ 类名、接口名应当使用名词，每个单词的首字母大写，如： TestPerson。
◆ 方法名，第一个单词小写，后面每个单词的首字母大写，如： talkMySelf。
◆ 常量名中的每个字母一律大写，如： COUNTRY。

Jar 文件的使用

开发者用的 JDK 中的包和类主要在 JDK 的安装目录下的 jre\lib\rt.jar 文件中，由于 Java 虚拟机会自动找到这个 jar 包，所以在开发中使用这个 jar 包的类时，无需再用classpath 来指向它们的位置了。

jar 文件就是 Java Archive File，而它的应用是与 Java 息息相关的。 jar 文件就是一种压缩文件，与常见的 ZIP 压缩文件格式兼容，习惯上称之为 jar 包。如果开发者开发了许多类，当需要把这些类提供给用户使用时，通常都会将这些类压缩到一个 jar文件中，以 jar 包的方式提供给用户使用。只要别人的 classpath 环境变量的设置中包含这个 jar 文件， Java 虚拟机就能自动在内存中解压这个 jar 文件，把这个 jar 文件当作一个目录，在这个 jar 文件中去寻找所需要的类及包名所对应的目录结构。
jar 命令是随 JDK 一起安装的，存放在 JDK 安装目录下的 bin 目录中， Windows 下的文件名为 jar.exe， Linux 下的文件名为jar。 jar 命令是 Java 中提供的一个非常有用的命令，可以用来对大量的类(.class 文件)进行压缩，然后存为然后存为.jar 文件。

.jar 压缩文件的优点

一方面，可以方便管理大量的类文件，另一方面，进行了压缩也减少了文件所占
的空间。

可以在命令行窗口下运行 jar.exe 程序，就可以看下图示：