JAVASE_09天_@面向对象_内部类和异常

1.内部类

概念:-------事物中还有事物，比如容器里面有迭代器，那么将迭代器定义成内部类

---内部类.......也叫内置类,嵌套类

内部类大访问规则:

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

            之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式:   外部类名.this.成员

     2.外部类要访问内部类,必须建立内部类对象.

代码:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class  Outer{      private  int  x =  3 ;      class  Inner{ //内部类直接访问外部类成员,包括私有          public   void   function(){              System.out.println(x); //访问外部私有成员变量             method();//访问外部类成员方法          }      }      private   void   method(){          //第一种 : 外部类访问内部类必须建立内部类对象(成员函数内部)          Inner in =  new  Inner();          in.function();      } } public  class  Test5 {      public  static  void  main(String[] args){          //第二种情况 : 外部类访问内部类(主函数内部)          Outer.Inner oi =  new  Outer(). new  Inner();          oi.function();      }   }

---

---

问题:
如下代码为例，引出内部类的实现机制!
<1>内部类如何访问外部private成员?????

<2>内部类访问局部为何要final？？？？

final关键字的目的就是为了保证内部类和外部函数对变量“认识”的一致性.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public  class  OuterInnerTest {      private  int  number =  1 ;      public  void  start( int  x,  final  boolean  bool){          final  int  y =  0 ; //也是局部变量          class  Inner{ //内部类在局部               public  void  add() {                   if  (bool) //访问局部变量                       System.out.println(number); //访问私有                   System.out.println(x); //编译失败                   System.out.println(bool); //编译成功                   System.out.println(y); //编译成功,...访问内部类所在的局部变量必须final               }          }      } }

1,首先,分析一下为什么内部类可以直接访问外部类的----1成员变量----2成员函数----3局部变量????

通常一个类A要想访问另一个类B的成员,不能直接访问,先要获得B的对象,然后对象访问!

解析问题:

javac编译器会把Outer中Inner类编译为一个独立的class文件;

其形式如下(类名为:外部类$内部类):

1 2 3 4 5 6 7 8 9 10 11

class  Outer$1Inner {      // 添加的构造函数，参数为外部类对象的引用和该内部类访问的局部变量的引用（这里为boolean类型）      Outer$1Inner(Outer, boolean )      // 内部类原有的函数      public  void  add();      // 局部变量的引用      final  boolean  val$bool;      // 外部类对象的引用      final  Outer  this $ 0 ; }

通过上述类的定义，
我们可以看出内部类在 构造的时候，
会被编译器自动传入外部类对象的一个引用，同时也会传入内部类访问的局部变量的引用，

这也就解释了内部类对象为什么可以访问外部类的成员变量和函数还有局部变量了

2,一个类的私有方法和成员变量是不能被其他类访问的,那么内部类又是如何访问外部类的私有成员变量和函数呢?

在编译时进行时，JAVA虚拟机并没有什么所谓的内部类的概念，

在JAVA虚拟机看来，该内部类和外部类是两个独立的class文件;
现在,外部类中有一个私有的int型的变量number,我们想在内部类中访问它。
其实在编译的时候，为了内部类可以访问外部类的私有变量，JAVA编译器还偷偷做了一些额外的工作.
编译器除了上文提到的会生成一个内部类class，同时还会修改我们的外部类代码。其修改如下：

1 2 3 4 5 6 7 8

class  Outer {      // 编译器自动添加的函数，用来访问私有成员变量counter      static  int  access$ 0 (Outer);      // 原有的函数       public  void  start();      // 私有成员变量       private  int  counter }

为了访问问counter私有成员变量， 编译器偷偷的为我们添加了一个access$0的静态函数，
它接收一个Outer对象的引用，并返回该对象内的私有成员变量number的值
并且编译器会把我们在内部类中用到number的地方都替换为Outer.access$0(this$0).

3,上述2问是内部类的实现机制，现在看一下，访问局部变量为什么要求局部变量添加final关键字？

现在我们看一下上面外部类的start（）函数代码的执行过程：
如果bool变量不被标注为final，那么就意味着我们可以随时修改bool的值，
假设我们在创建了Outer对象后修改了bool的值，那么这时我们的内部类所看到的bool的值还是之前通过构造函数传递进去的老值，
这样就导致内部类和外部函数对bool值“认识”的不一致。
所以final关键字的目的就是为了保证内部类和外部函数对变量“认识”的一致性。

---

---

---

---

2.静态内部类  

访问格式：

1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

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

格式

    外部类名.内部类名  变量名 = 外部类对象.内部类对象;

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

 

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

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

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

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

 

        在外部其他类中，如何直接访问static内部类的非静态成员呢？

        new Outer.Inner().function();

 

        在外部其他类中，如何直接访问static内部类的静态成员呢？

        outer.Inner.function();

 

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class  TD{      int  y= 6 ;      class  Inner{          static  int  y= 3 ;            void  show()          {              System.out.println(y);          }      } } class  TC{      public  static  void  main(String[] args){          TD.Inner ti= new  TD(). new  Inner();          ti.show();      } } //编译失败，非静态内部类中不可以定义静态成员。 内部类中如果定义了静态成员，该内部类必须被静态修饰。 参考文献：

class  Outer{

     private  int  x =  3 ;

     class  Inner{ //内部类直接访问外部类成员,包括私有

         int  x =  4 ;

         public  void  function(){

             int  x =  5 ;

             System.out.println( "内部类" +x); //结果是5

             System.out.println( "内部类" + this .x); //结果是4

             System.out.println( "内部类" + Outer.this.x ); //结果是3

         }

     }

     void  method(){ //外部类访问内部类必须建立内部类

         Inner in =  new  Inner();

         in.function();

     }

}

public  class  InnerClassDemo {

     public  static  void  main(String[] args){

         Outer t =  new  Outer();

         t.method();

         //直接访问内部类中的成员.

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

         in.function();

     }

}







/*

内部类定义在局部时:

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

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

class  Out{      int  x =  3 ;      void  method( final  int  a){          final  int  y =  4 ; //          class  In{              void  function(){                  System.out.println(x+ "---" +y+ "---" +a); //注意              }          }          new  In().function(); // //注意 内部类没对象不运行，function()方法在没对象时不运行            } }    public  class  Ty {      public  static  void  main(String[] args){          Out ot =  new  Out();          ot.method( 7 ); //结果3---4---7          ot.method( 8 ); //结果3---4---8      }    }

---

---

3.内部类定义原则

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

因为内部事务在使用外部事物的内容。

4.匿名内部类

匿名内部类---

目的:简化书写,覆盖方法

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

2.定义匿名内部类的前提:-------> 内部类必须是继承一个类或者实现接口(除了Object)

3.匿名内部类的格式: new 父类或者接口后(){实现接口中的方法};

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

abstract  class  AbsDemo{      abstract  void  show(); } class  Outer_4{      int  x =  3 ;      /*      class Inner_4 extends AbsDemo{          void show(){              System.out.println("method :"+x);          }      }      public void function(){          new Inner_4().show();      }      */      //上面代码变成匿名内部类:      public  void  function(){          new  AbsDemo(){              void  show(){                  System.out.println( "x=" +x);              }          }; //这是一个对象,AbsDemo类的匿名子类对象          new  AbsDemo(){              void  show(){                  System.out.println( "x=" +x);              }          }.show(); //对象调用方法      }               } public  class  InnerClassDemo4 {      public  static  void  main(){ //      new Outer_4().function();      } }

什么时候会用到匿名内部类

1,当调用函数,函数参数是一个接口类型时

show( new InterfaceX(){             public void method(){                 System.out.println("method show run");             }          });   public  static  void  show(Inter in){      in.method(); }

2,在没有父类或接口是也可以写匿名类  ------Object

1 2 3 4 5 6 7 8 9 10

class  InnerClassTest {      public  static  void  main(String[] args){          new Object(){             public void function(){                 System.out.println("haha");             }         }.function();                 } }

---

---

5.异常机制 java.lang.Throwable

一.体系

Throwable

        |--Error

        |--Exception

二.异常try-catch

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

1.try

{

 需要被检测的代码；

}

catch(异常类 变量)

{

 处理异常的代码；(处理方式)

}

finally

{

 一定会执行的语句；

}

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

     String getMessage()：获取异常信息。 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class  Demo{      int  div( int  a, int  b) throws  Exception{ //在功能上通过throws的关键字声明了该功能有可能会出现问题。          return  a/b;      } }     class   ExceptionDemo{      public  static  void  main(String[] args) {          Demo d =  new  Demo();          try {              int  x = d.div( 4 , 1 );              System.out.println( "x=" +x);          }          catch  (Exception e){ //Exception e = new ArithmeticException();              System.out.println( "除零啦" );              System.out.println(e.getMessage()); //  / by zero;              System.out.println(e.toString()); // 异常名称 ： 异常信息。                 e.printStackTrace(); //异常名称，异常信息，异常出现的位置。                              //其实jvm默认的异常处理机制，就是在调用printStackTrace方法。                              //打印异常的堆栈的跟踪信息。 Stack:堆栈,Trace:追踪          }                   System.out.println( "over" );          } }

---

---




6.自定义异常

自定义异常：

必须是自定义类继承Exception。

 

 

继承Exception原因：

异常体系有一个特点：因为异常类和异常对象都被抛出。

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

 

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

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

要么在内部try catch处理。

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

class  FuShuException  extends  Exception{     //自定义负数异常 } class  Demo{      public  int  div( int  a, int  b)  throws  FuShuException{ //          if (b< 0 )              throw  new  FuShuException(); //手动通过throw关键字抛出一个自定义的异常对象          return  a/b;      } } public  class  EXceptionDemo {      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());          }      } }

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

发现打印的结果中只有异常的名称，却没有异常的信息。

因为自定义的异常并未定义信息。

 

如何定义异常信息呢？

因为父类中已经把异常信息的操作都完成了。

所以子类只要在构造时，将异常信息传递给父类通过super语句。

那么就可以直接通过getMessage方法获取自定义的异常信息。

class  FuShuException  extends  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;

     }

}

 

 

*/

7.throw和throws的区别

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

    2.throws后面跟的是异常类.可以跟多个.用逗号隔开;

       throw后跟的是异常对象.... throw语句后面的语句无法执行

8.RuntimeException

Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。 
如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。 
如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；
之所以不用在函数声明，是因为不需要让调用者处理。
当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，
对代码进行修正。

 

 

 

 

自定义异常时：如果该异常的发生，无法在继续进行运算，

就让自定义异常继承RuntimeException。

 

 

对于异常分两种：

1，编译时被检测的异常。

     

2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)

Exception体系包括RuntimeException体系和其他非RuntimeException的体系 ：
① RuntimeException：RuntimeException体系包括错误 类型转换 、 数组越界访问 和 试图访问空指针 等等。

处理RuntimeException的原则是：如果出现RuntimeException，那么一定是程序员的错误。

例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。 
②其他非RuntimeException（IOException等等）：这类异常一般是外部错误，

例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。

 

*/

*************************************************************************

         1.NullPointException

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class  Person{      public  void  checkName(String name){          if (name.equals( "root" )) //当name传的值是null时,无法调用函数发生空指针异常NullPointException              //修改为:if("root".equals(name))              //相当于if(name!=null && name.equals("root"))              System.out.println( "YES" );          else              System.out.println( "NO" );      } }    public  class  ExceptionDemo4 {      public  static  void  main(String[] args){          Person p =  new  Person();          p.checkName( null ); // 发生异常      } }

练习:毕老师用电脑上课(分层思想)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

package  day09; /*   * 毕老师用电脑上课   *    * 电脑 运行时可能发生的异常:1.Blue Screen 2.冒烟   */ class  BlueScreenException  extends  Exception{      BlueScreenException(String msg){          super (msg);      } } class  SomkingException  extends  Exception{      SomkingException(String msg){          super (msg);      } } class  Computer{      private  int  state =  3 ; //电脑的状态      public  void  run()  throws  BlueScreenException,SomkingException{          if (state ==  2 )              throw  new  BlueScreenException( "蓝屏了" );          if (state ==  3 )              throw  new  SomkingException( "冒烟了" );          System.out.println( "电脑运行" );      }      public  void  reset(){          state =  1 ;          System.out.println( "电脑重启" );      } } class  NoPlanException  extends  Exception{      NoPlanException(String msg){          super (msg);      } } class  Teacher{      private  String name;      private  Computer cpt;      Teacher(String name){          this .name = name;          cpt =  new  Computer();      }      public  void  prelect()  throws  NoPlanException{          try {              cpt.run();          }          catch (BlueScreenException e){              System.out.println(e.getMessage());              cpt.reset();          }          catch (SomkingException e){              throw  new  NoPlanException( "课时无法继续_原由:" +e.getMessage());          }          System.out.println( "老师上课" );      } } public  class  ExceptionTest {      public  static  void  main(String[] args){          Teacher t =  new  Teacher( "毕老师" );          try  {              t.prelect();          }  catch (NoPlanException e) {              System.out.println(e.toString());              System.out.println( "换老师或者放假!" );          }            }   }