黑马程序员-java基础之内部类，异常，包

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------

一内部类

概述：将一个类定义在另一个类的里面，里面那个类就叫做内部类，或者嵌套类。

特点，内部类可以直接访问外部类中的成员，包括私有成员，因为内部类中持有外部类引用 格式外部类名.this。而外部类要访问内部类中的成员必须要建立内部类对象。

内部类定义原则：

        当描述事物中，事物的内部还有事物，该事物用内部类来描述。

因为内部事务在使用外部事物中的内容。

成员内部类：

 代码示列

        class Outer{

               static class Inner{

                       static void function(){}

                            }

                     }

Inner内部类

       创建内部类对象格式：

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

当内部类定义在成员位置上时，可以被成员修饰符修饰

如 private static

当内部类被private修饰时外部其他类不能创建内部类对象

当内部类被static修饰时

1内部类只能访问外部类的静态成员，访问出现了局限性

2创建内部类对象 outer..inner in =new outer.inner();in.function（）；也可以直接new

外部类对象匿名调用内部类中的静态成员new outer().inner.function;

3当内部类中定义了静态成员时，内部类必须定义成static

4当外部类中的静态方法调用内部类时，内部类必须是静态的。

局部内部类：

       代码示例

       class Outer

       {

         int x=3;

         void  method()

        {

                final int X=4;

                class Inner

               {       

                              int x=6;

                void function()

                               {

                               //打印外部类成员变量

                               System.out.println(Outer.this.x);

                                      //打印局部常量

                               System.out.println(X);

                                      }

               }

                new Inner().function();

        }

       }

1.不可以被成员修饰符修饰

2.可以直接访问外部类中的成员，因为还持有外部类中的引用外部类名.this

  但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

原因：

     通过说明下此程序在内存中的执行过程，就可以了解 为什么方法中的内部类不能访问方法中的局部变量。

首先JVM找到主函数的入口， 在栈中就开辟了一个main方法的空间 同时 创建了一个 变量o,同时在堆内存中new Outer()分配了一块内存空间，然后将变量O的引用就指向了该内存空间。Outer o=new Outer()语句就执行完毕，在调用function的方法时，就会将方法区中的funtion()方法进入栈中，同时将x=4

加载进栈内存中。如果不将x设置为final ，执行完, o.function()就会将function方法弹栈，此时局部x也就不存在，

        内部类也是一个类，在创建一个改局部类的对象之后，只有没有其他变量引用它，它才会变成垃圾，并且在不定时消失。所以可能发生的情况是 ：在局部变量消失之后，内部类的对象还存活。也就是说在执行 内部类add()方法的时候x已经不存在了。所以，方法中的内部类不能访问方法中的局部变量。

 解决办法 就是将x 前加final 变成该内部类inner对象中的一个数据成员。这样，即使栈中局部变量x已消失，

但由于它是final,其值永不变，因而局部内部类对象在变量x死亡后，照样可以访问final型局部变量。

匿名内部类：

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

2定义匿名内部类的前提

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

3匿名内部类的格式： new 父类或接口名（）

{定义子类的内容}

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

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

二异常

概述：是对问题的描述，将问题封装成对象

异常体系

Throwable

       |---Eroor

       |---Exception

              |---RuntimeException

Throwable中的共性方法

getMessage()

  获取异常信息，返回字符串。

toString()

获取异常类名和异常信息，返回字符串。

printStackTrace() 

  获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

printStackTrace(PrintStream s) 

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

Java默认的处理方式是调用printStackTrace（）方法

异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性

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

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

throw和throws的用法

throw定义在函数内，用于跑出异常对象

throw定义在函数上，用于抛出异常类，也可以抛出多个，用逗号隔开。

当函数内有throw抛出异常对象时，并未进行try处理，必须要在函数上声明，否则编译失败

注意RuntimeException和其子类除外，也就是说，函数内如果抛出的是RuntimeException和其子类异常，函数上可以不用声明。

如果函数上声明了异常，调用者需要进行处理。处理方法可以throws可以try

异常有两种:

编译时被检测异常

       该异常在编译时，如果没有处理（没有抛也没有try），编译失败

       该异常被标识，代表这可以被处理

运行时异常（编译时不检测）

       在编译时，不需要处理，编译器不检查

       该异常的发生，建议不处理，让程序停止，需要对代码进行修正

异常处理语句

try{需要被检测的代码}

catch(接受异常对象 e){处理异常的代码}

finally{一定会执行的代码}

三种格式

1try

{

}

catch(){

}

2try{

}

finally

{

}这种格式异常没有被处理掉

3try

{

}

catch()

{

}

finally

{

}

注意：finally中定义的通常是关闭资源代码，因为资源必须释放

Finally中的代码只有一种情况下不会执行到，当执行到system,exit(0);时finally不会执行，jvm会退出

自定义异常；

       定义类继承Exception或者RuntimeException

       1为了让该类具备可抛性

       2让该类具备操作异常的共性方法

       当要定义自定义异常的信息时，可以使用父类已经定义好的功能，

       将异常信息传递给父类的构造函数

Class MyException extends Exception

{

       MyException（String message）

{

       Super（message）；

}

}

自定义异常：是按照java的面向对象的基本思想，将程序中出现的特有问题进行封装

异常的好处

       1将问题进行封装

       2将正常流程代码与问题代码进行分离。方便与阅读

异常的好处原则：

       1处理方式有两种：try或者throw

       2调用到抛出异常的功能时抛出几个，就处理几个

              一个try对应多个catch

       3多个catch时父类异常对象的catch应放到最下面

       4catch内，需要定义针对性的处理方式，不要简单的定义printstackTrace；输出语句

       也不要什么也不写

       当捕获的异常本功能处理不了时，可以继续在catch中抛出

       Try{throw new AException}

       Catch（AException a）{throw a}

       如果该异常处理不了，且不属于该功能出现的异常

       可以将该异常转换后，再抛出和该功能相关的异常

       或者异常可以处理，但需要将异常产生的和本功能相关的问题提供出去

       让调用者知道，并处理，也可以将捕获异常处理货转换新的异常

       Try{throw new AException}

       Catch（AException a）{throw new BException}

异常的注意事项

       在子父类覆盖时：

1子类抛出的异常必须是父类异常或父类异常的子类当父类抛出的异常为多个时子类可抛对象为父类异常子集

       2父类没有抛出异常时，子类只能进行try处理不能throws

总结：子类抛出的异常要在父类异常体系下，

常见异常

1脚标越界异常IndexOutOfBoundsException

2空指针异常NullPointerException

3类型转换异常：ClassCastException

    4运行时异常 RuntimeException

三包

概述：包用package关键字定义，写在程序的第一行。

一般在定义包名时，因为包的出现是为了区分重名的类。所以包名要尽量唯一。怎么保证唯一性呢？可以使用url域名来进行包名称的定义。

作用

       对类文件进行分层管理

       给类文件提供多层名称空间

类名的全称其实是包名.类名

包与包之间的访问权限

       public

protected：只能是不同包中的子类可以使用的权限。

修饰符的访问权限

                                  本类中    同一个包中 不同包中的子类中  不同包中

       private                   OK  

       默认（default）    OK            Ok          

       protected               OK            Ok               OK

       public                    OK            Ok               OK                             Ok

import关键字-导入

       用来导入包中的类。

       作用：简化书写，不用写全称包名.类名，直接写类名即可。

注意

       导入的只是包中的类，不会导入包中的包

       当导入的两个包中有同名类时，需要写包名.类名以示区分。

常见的软件包:

java.lang : language java的核心包，Object System  String Throwable jdk1.2版本后，该包中的类自动被导入。

java.awt : 定义的都是用于java图形界面开发的对象。

javax.swing:提供所有的windows桌面应用程序包括的控件,比如：Frame , Dialog, Table, List 等等,就是java的图形界面库。

java.net : 用于java网络编程方面的对象都在该包中。

java.io : input  output 用于操作设备上数据的对象都在该包中。比如：读取硬盘数据，往硬盘写入数据。

java.util : java的工具包，时间对象，集合框架。

java.applet: application+let 客户端java小程序。server+let  -->  servlet 服务端java小程序。

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------