黑马程序员_六、内部类及异常体系

来源：互联网发布：网络第一神书悟空传编辑：程序博客网时间：2024/06/05 12:44

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

六、内部类及异常体系

这两天主要就学了内部类和异常以及Eclipse工具的使用，之前因为一直看的老毕视频

也没有教用Eclipse，话说听我们老师说现在老毕在上海重新录制基础视频啊，来传智也没

看到老毕遗憾啊。这两天的知识点是没有什么问题，觉得还是多亏了老毕的启蒙教学，到

现在老毕的25天视频已经基本看完了，我们这边的课程也马上进行到了多线程，不多说，

继续为进黑马做努力，今天休息，这篇博客写完得赶紧去上自习，宿舍就我一个人了...

-------------------------------------------------------------------------------------------------------------------------

一、内部类

（1）将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

       （2）访问特点：(也是考虑是否使用内部类的条件)
                      内部类可以直接访问外部类中的成员，包括私有成员。
                       外部类要访问内部类中的成员必须要建立内部类的对象。

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

（3）内部类位置：

A：内部类定义在成员位置上

可以被private static成员修饰符修饰。

被static修饰的内部类只能访问外部类中的静态成员。

B：内部类定义在局部位置上

也可以直接访问外部类中的成员。

同时可以访问所在局部中的局部变量，但必须是被final修饰的。

（4）成员内部类：

代码如下：

class Outer{private int num = 10;private static int num2 = 10;private class Inner{public void show(){System.out.println(num);}}/*局部方法是静态的，类必须是静态的。静态类中访问的时候，只能访问外部静态成员。*/static class Inner2{public void function(){System.out.println("inner2"+num2);}public static void function2(){System.out.println("function2"+num2);}}public void method(){//访问内部类方法show()Inner i = new Inner();i.show();}}class InnerClassDemo2{public static void main(String[] args){//Outer.Inner oi = new Outer().new  Inner();//没被私有时访问规则Outer o = new Outer();//被私有后，通过外部类方法获取对象o.method();//类用静态修饰后访问规则//格式：外部类名.内部类名 变量 = new 外部类.内部类名();Outer.Inner2 oi = new Outer.Inner2(); //Outer起限定作用oi.function();oi.function2();//调用静态内部类中的静态方法Outer.Inner2.function2();}}

总结：当内部类在成员位置上，就可以被成员修饰符所修饰。

private：将内部类在外部类中进行封装。

static:内部类就具备static的特性。

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

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

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

把类定义在方法中。

                使用局部内部类的好处：安全性，效率
                局部内部类访问局部变量：局部变量必须被final修饰。
                       因为提高局部变量的生命周期，让内部类中可以继续使用。

代码如下：

class Outer{private int num = 10;public void method(){final int num = 20;class Inner{public void show(){System.out.println("show "+num);System.out.println("show "+Outer.this.num); //this如果没限定，代表当前类的。而用外部类限定后，用的就是外部类的this对象。}}//创建对象Inner i = new Inner();i.show();}}class InnerClassDemo3{public static void main(String[] args){Outer o = new Outer();o.method();}}

（6）匿名内部类

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

2，定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

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

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

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

代码如下：

interface Inter{void show();void show2();}class Outer{private int num = 10;public void method(){new Inter(){public void show(){System.out.println("show");}public void show2(){System.out.println("show2");}}.show();//匿名内部类的时候，一般就是在方法只有一个的时候才使用。//少于3个。//如果接口中的方法多于3个Inter i = new Inter()  //多态{public void show(){System.out.println("show");}public void show2(){System.out.println("show2");}};i.show();i.show2();}}class NiMingInnerClassDemo {public static void main(String[] args) {Outer o = new Outer();o.method();}}

（面试题）：

interface Inter{void method();}class Test {//补足代码。通过匿名内部类。static Inter function(){return new Inter(){public void method(){System.out.println("method run");}};}}class InnerClassTest {public static void main(String[] args) {//Test.function():Test类中有一个静态的方法function。//.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。//因为只有是Inter类型的对象，才可以调用method方法。Test.function().method();}

（7）Object类的掌握

                       A：Object类是所有类的超类。所有的类都直接或者间接继承自Object类。
                       B：Object类的方法：
                                   a:public String toString()：返回对象的字符串表示。
                                      getClass().getName() + '@' + Integer.toHexString(hashCode())
                                      它表示的是对象的地址信息，对我们没有意义。所以，一般我们需要重写。

                                   b:public final Class<?> getClass()：返回的是class文件的类文件描述(反射)。

c:public int hashCode()：返回对象的哈希码值。

d:protected void finalize()：当对象没有被引用变量指向的时候，jvm调用此方法进行垃圾回收。

e:public boolean equals(Object obj)：默认比较的是对象的地址值。
一般来说没有意义。所以，我们也会根据需求重写该方法。

       （8）==和equals的区别？
                       ==：
                            基本类型：比较的是值是否相同
                             引用类型：比较的是地址值是否相同
                       equals：
                             引用类型：默认比较的是地址值是否相同。
                                               但是我们可以根据自己的需求重写该方法。

二、包：文件夹。
       （1）作用：
                        对类文件进行分包管理。
                        给类提供多层命名空间。
                        写在程序文件的第一行。
                        包也是一种封装形式。

       （2）表示：package
                使用：
                        格式 package 包名;

                带包的类的使用：创建包：package cn.itcast;
                        方式1：(手动建包)
                        方式2：(自动建包)
                                   javac -d . Hello.java

                                   java cn.itcast.Hello
        （3）如果在不同包下使用类，多次时候最好导包。
                 导包：
                        import cn.itcast.Hello;

                        注意：不要写cn.itcast.*; 用谁就导谁。
        （4）顺序：
                        package -- import -- class

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

不同包中的子类还可以直接访问父类中被protected权限修饰的成员。

包与包之间可以使用的权限只有两种，public protected。

public protected default private

同一个类中 ok ok ok ok

同一个包中 ok ok ok

不同包子类 ok ok

不同包中 ok

三、异常

       （1）异常的体系：异常的情况有很多种，由这些不同的异常向上抽取共性的内容，最终形成了异常的体系：
                  Throwable：Throwable 类是 Java 语言中所有错误或异常的超类。
                         |--Error
                                     通常出现重大问题如：运行的类不存在或者内存溢出等。
                                     不编写针对代码对其处理,因为这本身就是代码的问题，必须改正代码。
                         |--Exception
                                     在运行时运行出现的一些情况，可以通过try catch finally进行处理。
                                     Exception:检查时异常：在编译期间就报错。@Override
                                     RuntimeException:运行时异常：在运行的过程中发生的异常。也是必须修改代码才能实现的。
                        Exception和Error的子类名都是以父类名作为后缀。

（2）Throwable中的方法

getMessage()

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

toString()

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

printStackTrace()

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

printStackTrace(PrintStream s)

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

       （3）jvm处理异常的机制
                      采用的是默认处理机制。
                      在控制显示出现异常的名称，异常错误信息，及异常的位置。

       （4）自己处理异常：
                     A:try...catch...finally
                         try{
                                  可能有问题的代码;
                         }
                        catch(异常类名变量名){
                                  可以通过变量名操作。
                                 //getMessage()
                                 //toString()
                                  变量名.printStackTrack();
                         }
                        finally{
                                  //永远执行的代码
                                  //除非在此之前推出了jvm
                        }
                     B:throws
                                  抛出异常。把异常交给调用者处理。

如果一个异常是编译期间的Exception，必须处理或者继续抛出。
如果一个异常是运行期间的RuntimeException，可以不用处理。

针对异常能处理，就处理。否则就抛。

       （5）Exception和RuntimeException
                      A:Exception 编译期间异常,需要编写代码进行异常处理。
                      B:RuntimeException 运行时期异常，不需要编写代码处理。

       （6）throw和throws的区别？
                      A:throw: 放在方法中，后面跟的是异常类的对象名称。
                                   如果throw后面跟的Exception的异常，必须在方法上声明或者处理。
                     B:throws: 方法名称后面，后面跟的是异常类的名称。
                                  如果throws后面跟的是Exception的异常，必须处理。

（7）自定义异常：
必须是Exception或者RuntimeException的子类。

代码：

class MyException extends Exception // RuntimeException{public MyException(){}public MyException(String message){//将来可以通过getMessage()方法获取异常信息。super(message);}}

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

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

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

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

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

（9）finally

A:finally中定义的通常是关闭资源代码。因为资源必须释放。

B:finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。

（10）异常的处理原则：

A:处理方式有两种：try 或者 throws。

B:调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。

C:多个catch，父类的catch放到最下面。

D:catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。

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

try{

throw new AException();

}

catch (AException e){

throw e;

}

如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，在抛出和该功能相关的异常。

或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，当调用者知道，并处理。

也可以将捕获异常处理后，转换新的异常。

try{

throw new AException();

}

catch (AException e){

// 对AException处理。

throw new BException();

}

总结：内部类的理解（一般不多用）但匿名内部类需要熟练掌握

Object类的概述和基本方法的掌握

异常的处理机制，及自定义异常，和一些重点的面试题需要掌握

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