9内部类的访问规则异常

内部类的访问规则

1内部类可以直接访问外部类的成员，包括私有

之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，

格式是外部类.this.对象

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

 

class Outer

{

       int x =3;

       void method()

       {

        System.out.println("Outer"+x);//内部类可以直接调用外部类

       }

 

       class Inter//内部类

       {

              void function()

              {

              System.out.println("out");

              }

       }

}

 

class  InterClassDemo

{

       public static void main(String[] args)

       {

              Outer out = new Outer();

               out.method();

              //外部类不能直接调用内部类，如果有好几个类是同名的，

              //你就不知道调用的是那个类的内部类

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

              in.funtion();//外部类调用内部类。

 

              System.out.println("Hello World!");

       }

}

访问方式：1当内部类定义在外部类的成员位置上，而且非私有，可以再外部其他类中，

可以指直接建立内部类对象。

格式： Outer.Inter in = new Outer().Inter();

2,当内部类在成员位置上，就可以被成员修饰符修饰，比如

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

       static：内部类就具备了静态的特性

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

      

       在外部其他类中，如何访问非静态内部类呢？ new Outer.Inter().funtion();

       在外部其他类中，如何访问静态内部类呢？    new Inter.funtion();

 

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

 

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

       因为内部事物在使用外部事物的内容。eg：  人体和人的心脏，代码最优

 

       内部类定义在局部时，

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

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

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

 

       /*

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

       2往往简写格式都有其好处和弊端。

       定义前提：匿名内部类就执行一次，匿名内部类必须是继承一个类或者实现接口

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

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

异常：就是程序在运行时出现的不正常情况。

异常的由来：问题也是现实生活中一个具体的事物，也可以用java类描述，并封装成对象。

                     其实就是java对不正常情况进行描述后的对象体现

 

对于问题的划分：两种，一种是严重的问题，一种是非严重的问题，

对于严重呢的，java通过Error类进行描述

       对于Error一般不编写针对性代码对其处理，因为不可治愈了

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

       对于Exception可以使用针对性的处理方式进行处理。

举个例子，人得病，不可治愈的就属于Error，像癌症，可治愈的，感冒之类的就是Exception

 

无论Error或者Exception都具有一些共性内容

比如，不正常的情况信息，因为原因等，

这些不正常情况信息，向上抽取，就形成了基本的体系，抽取的父类就是

 

Throwable 类是java语言中所有错误或者异常的超类。

       Error

       Exception

2异常的处理

java提供了特有的语句进行处理

try

{需要被检测的代码；}

catch (异常类 变量)

{处理异常的代码（处理方式）}

finally

{一定会执行的语句}

3，对捕获到的异常对象进行常见方法操作

String gerMessage();获取异常信息。

toString()；返回字符串形式

printStackTrace();

一个面包做出来三天发放到货架上，可能坏了，这就是个异常，但是是可能坏了，这时候就用

throws Exception 抛出异常，无论抛给谁，最后都会抛给jvm，这是不太负责人的做法，负责人做法就是

try{} catch (){}

/*

java都能对异常或者错误进行封装，那我们自己也可以封装异常

因为项目中会出现特有的问题，而这些问题并为被java封装对象，对于这些特有的问题

可以按照java的对问题封装的意思，将特有问题，进行自定义异常封装。

 

需求：在本程序中对于除数是负数也视为是错误的，是无法运算的

那么就需要对这个问题进行自定义的描述。

 

挡在函数内部出现了throw抛出异常对象，那么就必须给出对应的处理动作、

要么在内部try cathc处理

要么在函数上声明，让调用者处理

一般情况在函数内出现异常，函数上需要声明

 

自定义异常：1必须是自定义类继承Exception。

继承Exception的原因：异常体系有个特点，异常类和异常对象会抛出，

他们都具备可抛性，这个可抛性是Throwable这个体系中独有的特点

只有这个体系中的类和对象才可以被throws和throw操作。

*/

class FushuException extends Exception//自己定义异常类，必须要入伙，继承java中的Exception

{//如果这里为空的话，打印的时候就会发现有异常的名称，但是没有异常信息

       FushuException(String msg)

              super(msg);

}

class Demo

{

       int div(int a ,int b)throws FushuException//一般情况在函数内出现异常，函数上需要声明

       {

              if(b<0)

                     throw new FushuException("出现了除数是负数的异常");//手动通过throw关键字抛出一个自定义异常对象呢。

                     return a/b;

       }

}

 

class  ExceptionDemo1

{

       public static void main(String[] args)

       {

              Demo d = new Demo();

              try

              {

                     int x = d.div(4,1);

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

              }

              catch (FushuException e)

              {

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

              System.out.println("除数出现负数了");

              }     }}

/*

throws和throw的区别：

throws使用在函数上，后面跟的是异常类，可以跟多个，用逗号隔开

throw使用在函数内，后面跟的是异常对象

*/

/*

Exception中有一个特殊的子类异常RuntimeException运行时异常。

如果在函数内部抛出抛出该异常，函数上可以不用声明，编译一样通过。

如果在函数上声明了该异常，调用者可以不用进行处理（这里的处理要么tyr要末抛出），编译一样通过。

之所以不用再函数上声明，是因为不需要让调用者处理，当该异常发生，希望该程序停止，因为在运行时出现了无法运算的情况希望停止程序后，由程序员对代码进行修正，

*/自定义异常时，如果该异常的发生无法在继续运算的话，就让自定义的异常继承RuntimeException。

 

对于异常分两种：

1，编译时被检测的异常（抛出的是非RuntimeException或者其子类的异常，而其上面没声明。）程序能处理，继承Exception

       这个问题可以处理，抛出之后声明可以用，就继承Exception

2，编译时不被检测的异常（运行时异常，RuntimeException以及其子类，里边抛出外边不用声明啊，嘿嘿，因为RuntimeException的目的是让程序停下来）

       在自定义异常的时候，不能处理，要继承RuntimeException。

蓝屏异常继承Exception，因为可以标示出去

冒烟异常类继承RuntimeException