黑马程序员—面向对象（扩展）

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

1.内部类

定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类。

内部类的访问规则：

(1).内部类可以直接访问外部类中的成员，包括私有成员 。之所以可以直接访问外部类的成员，是因为内部类中持有了一个外部类的引用，格式为：外部类名.this

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

(3).当内部类在成员位置上，就可以被成员修饰符所修饰。比如：private、static等等

示例：

class Outer{

     int x = 9;

     class Inner{

            public void show(){

                System. out.println( "内部类");

           }

     }

     public void method(){

           Inner in = new Inner();

           in.show();

     }

}

public class Demp {

     public static void main(String[] args) {

           Outer ou = new Outer();

           ou.method();

     }

}  

如果要直接访问内部类的话可以这么写：Outer.Inner  in = new Outer().new Inner();(前提是内部类不是private修饰)        

静态内部类：

只能直接访问外部类中的static成员，有访问局限。在外部其他类中，直接访问静态内部类的非静态成员格式为：new Outer.Inner().方法名。访问静态成员格式为：Outer.Inner.方法名。

注：(1).当内部类中定义了静态成员时，内部类必须为静态内部类。

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

内部类定义在局部时：

(1).不可以被成员修饰符所修饰。

(2).可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

2.匿名内部类

(1).匿名内部类其实就是内部类的简写形式。

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

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

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

(5).匿名内部类中定义的方法最好不要超过3个。不然定义和调用的时候，可读性差。

示例：

abstract class Rrr{

     abstract void show();

}

class Outerr{

     int temp = 5;

     /*class InnerT extends Rrr{

           void show(){

                System.out.println("内部类");

           }

     }*/

     public void via(){

            new Rrr(){                             //这是一个子类对象

                 void show(){

                     System. out.println( "匿名内部类" );

                }

           }.show();

            //new InnerT().show();

     }

}

public class InnerCast {

     public static void main(String[] args) {

           Outerr ou = new Outerr();

           ou.via();

     }

}

注：如果上面代码也可以写成：

          public void via(){

           Rrr r = new Rrr(){                            

                 void show(){

                     System. out.println( "匿名内部类..." +temp );

                }

           };

           r.show();

          }

实际上利用的是多态，左边的父类，右边是子类。如果子类里面有个单独的方法，则不能用父类的引用来调用子类单独的方法。

3.异常

a.

(1).对于问题的划分：严重的问题和非严重的问题。

(2).对于严重的：java通过Error类进行描述。对于Error不编写针对性的代码处理。

对于非严重的：java通过Exception类进行描述。

(3).Error和Exception的父类是Throwable。

(4).其实JVM处理异常信息就是调用PrintStackTrace()方法来打印异常的堆栈信息。

(5).除了使用try...catch来处理异常之外，还可以用throws Exception来抛出异常。

(6).格式：try...catch、 try...catch...finally、 try...finally

(7).catch是处理异常的，没有catch语句，则不算处理异常。

(8).finally语句：只有在finally语句之前，执行了System.exit(0);则finally语句不执行。

b.

在函数上声明异常。

便于提高安全性，让调用者进行处理。不处理则编译失败。（如果在其他函数中用throws Exception，则在其调用的函数中必须提出解决异常的方法。要么抛出这个异常，要么try...catch处理这个异常。如果一直是抛出这个异常，一直到主方法中还抛出时，这时是给JVM解决。）  

  

c.

对多异常的处理：

(1).声明异常时，建议声明更为具体的异常，这样处理更具体。

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

(3).建议在进行catch处理时，catch中一定要定义具体处理方式。不要写e.PrintStackTrace()方法，也不要简单打印一句输出语句。可以建立一个硬盘日志文件记录异常信息。

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

try{

}catch(Exception e){

     throws new bException();

}

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

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

d.

自定义异常：

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

(2).一般情况下，在函数内出现异常，函数上需要声明。

(3).如何定义异常信息？

因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage方法获取自定义的异常类信息。

必须是自定义类继承Exception

原因：因为异常类和异常对象都被抛出，它们都具备可抛性。这个可抛性是throwable这个体系中的独有特点，只有这个体系中的类和对象才可以被throws和throw操作

例子：

class MyException extends Exception{

     public MyException(String msg){

            super(msg);

     }

}

class Demo{

     int divide(int a, int b) throws MyException{

            if(b<0){

                 throw new MyException( "被除数不能为负数" );//手动通过throw来抛出异常

           }

            return a/b;

     }

}

public class MyExTest {

     public static void main(String[] args) {

           Demo d = new Demo();

            try{

                 int x = d.divide(5, -1);

                System. out.println( "x="+x);

           } catch(MyException me){

                System. out.println(me.toString());

           }

     }

}

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

e.

throw和throws的区别：

(1).throws使用在函数上，throw使用在函数内

(2).throws后面跟的是异常类，可以跟多个，用逗号给开。throw后跟的是异常对象。

记住：throw单独存在时，下面不要定义语句，因为执行不到。其功能跟return或者break相似。

f.

RuntimeException异常：

如果在函数内抛出该异常或其子类异常，函数上可以不用处理，编译一样通过。

如果在函数上声明该异常或其子类异常，调用者可以不用进行处理，编译一样通过。

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

g.

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

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

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

(3).如果父类或者接口的方法中没有异常抛出时，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生异常，就必须要进行try处理，绝对不能抛。