面向对象（内部类） 异常 包

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

访问特点：a，内部类可以直接访问外部类中的成员，包括所有成员

                    b，而外部类要访问内部类中的成员必须要建立内部类的对象

一般用于类的设计

         分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容

这时，就是还有的事物定义成内部类来描述

内部类修饰符：

     static void function （ ）//如果内部类中定义了静态成员，该内部类也必须是静态的

     {

              system .out.println ("funtion run +++"+num);

     }

内部类的细节:为什么内部类能直接访问外部类中的成员呢？

             那是因为内部类持有了外部类的引用，外部类名.this

内部类——局部内部类

   内部类可以存放在局部位置上

   内部类在局部位置上只能访问局部中被final 修饰的局部变量

匿名 内部类：就是内部类的简写格式

      必须有前提：内部类必须继承或者实现一个外部类或者接口

 匿名内部类;其实就是一个匿名子类对象

匿名内部类——应用

  通常的使用场景之一;当函数参数是接口类型时，而且接口中的方法不超过三个

       可以匿名内部类作为实际参数进行传递

匿名内部类细节;

 主函数静态不能在非静态中 static

 public void method （ ）

 {

          this.new Lnnet（ ）；

 }

 

异常

* 异常的体系

         *Throwable

          *Error

                a，通常出现重大问题如，运行的类不存在或者内存溢出等

                 b，不编写针对代码对其处理

            *Exception

                      a，在运行时运行出现的一起情况，可以通过 try catch finally

* Exception和Error的子类名都是以父类名作为后缀

异常：是在运行时期发生不正常情况

在java中用类的形式对不正确情况进行了描述和封装对象

描述不正常的情况的类，就称为异常类

以前正常流程代码和问题处理代码分离，提高阅读性

其实异常就是java通过面向对象的思想将问题封装成了对象

用异常类对其进行描述  不同的问题用不同的类进行具体的描述 比如角标越界 空指针等等

异常体系;问题很多，意味着描述的类很多

                 将其共性进行向上抽取，形成了异常体系

 最终问题（不正常情况）就分成了两大类

Throwable：无论是Error，还是异常，问题，问题发生就应该可以抛出，让调用者知道并处理

该体系的特点就在于Throwable及其所有的子类都具有可抛性

可抛性到底指的什么呢？怎么体现可抛性呢？其实是通过两个关键字来体现的

throws throw，凡是可以被这两个关键字 所操作的类和对象都具备可抛性

1——1，一般不可处理的Error

     特点：是由Jvm抛出的严重性的问题

               这种问题发生一般不针对性处理。直接修饰程序

1——2，可以处理的，Exception

     该体系的特点：子类的后缀名都是用其父类名作为后缀，阅读性很强

异常——自定义异常&异常类的抛出throws

      对于角标是整数不存在，可以用角标越界表示

     对于负数为角标的情况，准备用负数的角标异常来表示

    负数角标这种异常在java中并没有定义过

   那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述，并封装成对象

         这种自定义的问题描述成为自定义异常

注意：如果让一个类称为异常类，必须要继承异常体系，因为只有称为异常体系的子类，才有资格具备可抛性。才可以被两个关键字所操作，throws，throw

异常：编译时，检测异常和运行时异常的区别&throw和throws的区别

异常的分类：1，编译时被检测异常，只要是Exception和其子类都是除了特殊子类runtime Exception体系，这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式，这样的问题都可以针对性的处理

2，编译时不检测异常（运行时异常）就是Exception中的Runtime Excetion和其子类

这种问题的发生，无法让功能继续，，运算无法进行，更多是因为调用者的原因导致的或者引发了内部状态的改变导致的，那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行修正

所有的自定义异常时，要么继承Exception，要么继承runtime Exception

throws和throw区别

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

2，throws抛出的是异常类，可以抛出多个，用逗号隔开

       throw抛出的是异常对象

面向对象（异常——异常捕捉 try catch）

异常处理的捕捉形式：

这是可以对异常进行针对性处理方式

具体格式：

try

{

   //需要被检测异常的代码

}

catch（异常类 变量）//该变量用于接收发生的异常对象

{

    //处理异常的代码

}

finally

{

         //一定会被执行的代码

}

异常——异常处理原则：

1，函数内容如果抛出需要检测的异常，那么函数上必须声明，否则必须在函数内用try catch捕捉，否则编译失败

2，如果调用到了声明异常的函数，要么try catch 要么throws，否则编译失败

3，什么时候catch什么时候throws呢？

      功能内容可以解决，用catch

     解决不了，用throws告诉调用者，由调用者解决

4，一个功能如果抛出了多个异常，那么调用时，必须有多个catch进行针对性处理 内部又几个需要检测异常，就抛几个异常，抛出几个，就catch几个

try catch finally 代码块组合特点;

1,try  catch  finally 

2，try  catch (多个)当没有必要资源需要释放时，可以不用定义finally

3，try finally 异常无法直接catch处理，但是资源需要关闭

void show ( )throws Exception

{

    try

   {

             //开启资源

            throw  new Exception（ ）；

   }

   finally

  {

            //关闭资源

  }

 /*

catch (Exception e)

{

}

*/

}

异常注意事项：

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

b，如果父类抛出多个异常，那么子类只能抛出父类异常的子类

简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集

注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try

包（package）

a，对象文件进行分类管理

b，给类提供多层命名空间

c，写在程序文件的第一行

d，类名的全称的包名，类名

e，包也是一种封装形式

pack mypack：

class package Demo

{

          public static void main （string[  ]args)

          {

                   system.out.printLn("Hello package！”）；

            }

}

包与包之间访问——protected

package mypack；

class package Demo

{

          public static void main （string[  ]args)

          {

                   packa.DemoA d=new.acka.emoA（ ）；

                   d.show( );

                   pack b.DemoB b=new packb.Demo B( );

                   b.method( );

                   system.out.printLn("Hello package！”）；

            }

}

总结;包与包之间的访问，被访问的包中的类必须是public，被访问的包中的类的方法也必须是public的

包——导入import

package mypack；

//import packa.DemoA;//导入了packa包中的DemoA类

//import packa.DemoAA;

/*import packa.*;//导入了packa包中所有的类

import packa.abc.*；

packa\DemoA.class

packa\abc\DemoAbc.class

*/

//导包原则：用到哪个类就导入哪个类

import 干嘛用的啊？为了简化类名书写