成员内部类不能够有静态属性。（为何？）

成员内部类不能够有静态属性。（为何？）

 

若是在外部类的外部访问内部类，使用out.inner.

 

创建内部类对象时应注意：

在外部类的内部能够直接使用inner s=new inner();（由于外部类知道inner是哪一个类，因此能够生成对象。）

而在外部类的外部，要生成（new）一个内部类对象，须要首先创建一个外部类对象（外部类可用），而后在生成一个内部类对象。

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

错误的定义方式：

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

注意：当Outer是一个private类时，外部类对于其外部访问是私有的，因此就没法创建外部类对象，进而也没法创建内部类对象。

 

①  局部内部类：在方法中定义的内部类称为局部内部类。

与局部变量相似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。

 

注意：局部内部类不只能够访问外部类实例变量，还能够访问外部类的局部变量（但此时要求外部类的局部变量必须为final）？？

在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。

要想使用局部内部类时须要生成对象，对象调用方法，在方法中才能调用其局部内部类。

 

②  静态内部类：（注意：前三种内部类与变量相似，因此能够对照参考变量）

静态内部类定义在类中，任何方法外，用static定义。

静态内部类只能访问外部类的静态成员。

生成（new）一个静态内部类不须要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象能够直接生成：

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

而不须要经过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。

静态内部类不可用private来进行定义。例子：

对于两个类，拥有相同的方法：

People

{

  run();

}

Machine{

   run();

}

此时有一个robot类：

class Robot extends People implement Machine.

此时run()不可直接实现。

注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。

用接口不能彻底地实现多继承，用接口配合内部类才能实现真正的多继承。

 

③  匿名内部类（必须掌握）：

匿名内部类是一种特殊的局部内部类，它是经过匿名类实现接口。

IA被定义为接口。

IA I=new IA(){};

注：一个匿名内部类必定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，咱们使用其父类名。

因其为局部内部类，那么局部内部类的全部限制都对其生效。

匿名内部类是惟一一种无构造方法类。

匿名内部类在编译的时候由系统自动起名Out$1.class。

 

若是一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。

因匿名内部类无构造方法，因此其使用范围很是的有限。

（下午：）Exception（例外/异常）（教程上的MODEL7）

对于程序可能出现的错误应该作出预案。

例外是程序中全部出乎意料的结果。（关系到系统的健壮性）

 

JAVA会将全部的错误封装成为一个对象，其根本父类为Throwable。

Throwable有两个子类：Error和Exception。

一个Error对象表示一个程序错误，指的是底层的、低级的、不可恢复的严重错误。此时程序必定会退出，由于已经失去了运行所必须的物理环境。

对于Error错误咱们没法进行处理，由于咱们是经过程序来应对错误，但是程序已经退出了。

咱们能够处理的Throwable对象中只有Exception对象（例外/异常）。

Exception有两个子类：Runtime exception（未检查异常）

非Runtime exception（已检查异常）

（注意：不管是未检查异常仍是已检查异常在编译的时候都不会被发现，在编译的过程当中检查的是程序的语法错误，而异常是一个运行时程序出错的概念。）

在Exception中，全部的非未检查异常都是已检查异常，没有另外的异常！！

 

未检查异常是由于程序员没有进行必要的检查，由于他的疏忽和错误而引发的异常。必定是属于虚拟机内部的异常（好比空指针）。

 

应对未检查异常就是养成良好的检查习惯。

已检查异常是不可避免的，对于已检查异常必须实现定义好应对的方法。

已检查异常确定跨越出了虚拟机的范围。（好比“未找到文件”）

 

如何处理已检查异常（对于全部的已检查异常都要进行处理）：

首先了解异常造成的机制：

当一个方法中有一条语句出现了异常，它就会throw（抛出）一个例外对象，而后后面的语句不会执行返回上一级方法，其上一级方法接受到了例外对象以后，有可能对这个异常进行处理，也可能将这个异常转到它的上一级。

对于接收到的已检查异常有两种处理方式：throws和try方法。

 

注意：出错的方法有多是JDK，也多是程序员写的程序，不管谁写的，抛出必定用throw。

 

例：public void print() throws Exception.

 

对于方法a，若是它定义了throws Exception。那么当它调用的方法b返回异常对象时，方法a并不处理，而将这个异常对象向上一级返回，若是全部的方法均不进行处理，返回到主方法，程序停止。（要避免全部的方法都返回的使用方法，由于这样出现一个很小的异常就会令程序停止）。

 

若是在方法的程序中有一行throw new Exception()，返回错误，那么其后的程序不执行。由于错误返回后，后面的程序确定没有机会执行，那么JAVA认为之后的程序没有存在的必要。

 

对于try……catch格式：

try  {可能出现错误的代码块}   catch(exception e){进行处理的代码} ；

                                对象变量的声明

 

用这种方法，若是代码正确，那么程序不通过catch语句直接向下运行；

若是代码不正确，则将返回的异常对象和e进行匹配，若是匹配成功，则处理其后面的异常处理代码。（若是用exception来声明e的话，由于exception为全部exception对象的父类，全部确定匹配成功）。处理完代码后这个例外就彻底处理完毕，程序会接着从出现异常的地方向下执行（是从出现异常的地方仍是在catch后面呢？利用程序进行验证）。最后程序正常退出。

 

Try中若是发现错误，即跳出try去匹配catch，那么try后面的语句就不会被执行。

一个try能够跟进多个catch语句，用于处理不一样状况。当一个try只能匹配一个catch。

咱们能够写多个catch语句，可是不能将父类型的exception的位置写在子类型的excepiton以前，由于这样父类型确定先于子类型被匹配，全部子类型就成为废话。JAVA编译出错。

 

在try，catch后还能够再跟一子句finally。其中的代码语句不管如何都会被执行（由于finally子句的这个特性，因此通常将释放资源，关闭链接的语句写在里面）。

 

若是在程序中书写了检查（抛出）exception可是没有对这个可能出现的检查结果进行处理，那么程序就会报错。

而若是只有处理状况（try）而没有相应的catch子句，则编译仍是通不过。

如何知道在编写的程序中会出现例外呢

1．  调用方法，查看API中查看方法中是否有已检查错误。

2．  在编译的过程当中看提示信息，而后加上相应的处理。

 

Exception有一个message属性。在使用catch的时候能够调用：

Catch(IOException e){System.out.println(e.message())};

Catch(IOException e){e.printStackTrace()};

上面这条语句回告诉咱们出错类型所历经的过程，在调试的中很是有用。

 

开发中的两个道理：

①如何控制try的范围：根据操做的连动性和相关性，若是前面的程序代码块抛出的错误影响了后面程序代码的运行，那么这个咱们就说这两个程序代码存在关联，应该放在同一个try中。

①  对已经查出来的例外，有throw(积极)和try catch（消极）两种处理方法。

对于try catch放在可以很好地处理例外的位置（即放在具有对例外进行处理的能力的位置）。若是没有处理能力就继续上抛。

 

当咱们本身定义一个例外类的时候必须使其继承excepiton或者RuntimeException。

Throw是一个语句，用来作抛出例外的功能。

而throws是表示若是下级方法中若是有例外抛出，那么本方法不作处理，继续向上抛出。

Throws后跟的是例外类型。

断言是一种调试工具（assert）

其后跟的是布尔类型的表达式，若是表达式结果为真不影响程序运行。若是为假系统出现低级错误，在屏幕上出现assert信息。

Assert只是用于调试。在产品编译完成后上线assert代码就被删除了。

 

方法的覆盖中，若是子类的方法抛出的例外是父类方法抛出的例外的父类型，那么编译就会出错：子类没法覆盖父类。

结论：子类方法不可比父类方法抛出更多的例外。子类抛出的例外或者与父类抛出的例外一致，或者是父类抛出例外的子类型。或者子类型不抛出例外。

若是父类型无throws时，子类型也不容许出现throws。此时只能使用try catch。

 

练习：写一个方法：int add(int a,int b)

{

  return a+b；

}

当a+b=100;抛出100为异常处理。