内部类详解

一、内部类概述

   定义在类体部，方法体部，甚至比方法体更小的代码块内部的类。比如：在类A中定义了一个类B，类B就是内部类。

1、内部类的访问特点：

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

b、外部类要访问内部类的成员，必须创建对象

2、内部类的位置：

a、成员位置：在类体部，方法体外。被称为成员内部类

b、局部位置：定义在方法体，甚至比方法体更小的代码块。被称为局部内部类

二、成员内部类

1、成员内部类无修饰符修饰,如何直接访问内部类的成员？

格式：外部类名.内部类名 对象名=new 外部类名().new 内部类名();

package test.innerclass;/** * @author Nocol * * @TODO *  */class Outer {private  int num = 100; class Inner {               //此时该内部类无任何修饰符修饰public  void show() {System.out.println(num);    //内部类直接访问外部类私有成员}}}class InnerClassDemo {public static void main(String[] args) {// 需求：访问Inner类的show()方法// Inner i = new Inner(); 报错// i.show();报错// 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;Outer.Inner oi = new Outer().new Inner();oi.show();}}

2、成员内部类被private修饰，如何访问该私有内部类的方法？

方法：成员内部类可以看成是外部类的一个成员变量，所以外部类的方法里面可以直接拿内部类创建其对象并使用。因此，我们可以在外部类写一个方法，在这个方法内创建内部类的对象（相当于一个类里面的方法使用成员变量），并用该对象调用私有内部类的方法

package test.innerclass;/** * @author Nocol * * @TODO *  */class Outer1 {private int num = 200; private class Inner {         //内部类被Private修饰public void show() {System.out.println(num);//内部类直接访问外部类私有成员}}public void method() {// 找不到符号// show();Inner i = new Inner();//创建内部类对象，测试时可通过创建外部类Outer对象调用method()方法从而实现对内部类中定义的私有方法的调用i.show();}}class InnerClassDemo2 {public static void main(String[] args) {      //测试  //需求：访问被privaet修饰的Inner类的show()方法Outer1 o=new Outer1();o.method();   //打印10}}

3、成员内部类被static修饰，如何访问内部类的成员？

格式：外部类名.内部类名 对象名 =new 外部类名.内部类名();

需要注意的一点：

静态内部类访问的 外部类数据必须用静态修饰。

比如：静态内部类的静态方法和非静态方法在访问成员变量时，该成员变量必须由static修饰

package test.innerclass;/*** @author Nocol** @TODO * */class Outer3{      //private  int num=300;     //非静态      private static int num2=400;   //静态          //内部类用静态修饰是因为内部类可以看出是外部类的成员      public static class Inner{            /**       * 静态内部类的普通方法       */      public void show(){     // System.out.println(num); 报错， 静态内部类的方法（非静态）访问的 外部类成员变量必须是static静态修饰的。      System.out.println(num2);        }            /**       * 静态内部类的静态方法       */      public static void show2(){     //System.out.println(num); 报错      System.out.println(num2);//静态方法访问静态成员变量      }                  }}public class InnerClassDemo3 {public static void main(String[] args){        //使用内部类//Outer3.Inner oi = new Outer().new Inner();  报错，限定的新静态类//oi.show();//oi.show2();//成员内部类被静态修饰后的访问方式是://格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();Outer3.Inner oi = new Outer3.Inner();oi.show();   //400oi.show2();  //400   //Inner.show2();//show2()的另一种调用方式//由于内部类被static静态修饰，可直接【类名.方法名调用】Outer3.Inner.show2(); //外部类Outer3下的Inner内部类}}

三、局部内部类

1、定义在方法体内。可以访问外部类的成员，包括私有。

2、外部怎么调用方法内内部类里面的方法？
 
可以在该方法内创建局部内部类的对象，通过对象调用内部类的方法。

3、需要注意的几点：

a、若局部内部类定义在非静态的方法体内：
 
   局部内部类可以访问外部类的所有成员。包括私有、包括（非）静态成员变量、（非）静态方法

b、若局部内部类定义在静态的方法体内：

   局部内部类只能访问外部类的静态成员。包括私有、静态成员变量、静态方法

c、若局部内部类访问方法体内的局部变量：
    
   该局部变量必须由final修饰。

原因：局部变量是随着方法的调用而调用，随着调用完毕而消失。 而堆内存的内容并不会立即消失。所以，我们加final修饰。加入final修饰后，这个变量就成了常量。既然是常量。你消失了。 我在内存中存储的是真实的数据，所以，我还是有数据在使用。

package test.innerclass;/** * @author Nocol * * @TODO *  */class Outer4 {private  int num = 10;     /** * 局部内部类定义在非静态方法体内 */public void method() {// int num = 20;                 final int num2 = 20;         //若要被局部内部类访问，该局部内部类的局部变量必须用final修饰    class Inner {                //局部内部类public void show() {System.out.println(num);    //访问的 成员变量 不需要被final修饰System.out.println(num2);  //20 //从内部类中访问本地变量(局部变量)num2; 需要被声明为最终类型test();  //非静态方法中的内部类访问外部类的静态方法（同样可以访问外部类的非静态方法）}}Inner i = new Inner();   //在局部 内部类外 创建其对象，方便实现对内部类内方法的调用i.show();}public static void test(){System.out.println("我是静态方法");}}class InnerClassDemo4 {public static void main(String[] args) {Outer4 o = new Outer4();o.method();}}

四、匿名内部类

1、匿名内部类即局部内部类的一种，其实就是内部类的简化写法。

2、前提：存在一个类或者是接口。（这里的类可以是具体类也可以是抽象类）

3、格式：new 类名或接口名(){ 重写方法;},该整体就是一个对象，本质就是继承了该类或实现了该接口的子类匿名对象

package test.innerclass;/** * @author Nocol * * @TODO *  */interface Person {public abstract void study();}class PersonDemo {public void method(Person p) {// 接口名作为形式参数,其实这里需要的不是接口，而是该接口的实现类的对象                     p.study();}}// 定义接口实现类class Student implements Person {public void study() {System.out.println("study");}}class InnerClassDemo6 {public static void main(String[] args) {// 测试PersonDemo pd = new PersonDemo();Person p = new Student();pd.method(p);System.out.println("-------------------------");// 匿名内部类在开发中的使用// 匿名内部类的本质是 继承类或者实现了接口的子类匿名对象，所以讲该整体对象当做抽象类Person的子类对象传进去                                                         //相当于：new Student();pd.method(new Person() {public void study() {System.out.println("study");}});}}

五、关于内部类的两道面试题

1、内部类访问问题。

package test.innerclass;/** * @author Nocol * * @TODO/* * 面试题： 要求请填空分别输出30，20，10。 *  * 注意：  *     1:内部类和外部类没有继承关系。 *     2:通过外部类名限定this对象 Outer.this */class Outer5 {public int num = 10;class Inner {                  //成员内部类public int num = 20;public void show() {int num = 30;System.out.println(num);System.out.println(this.num);             //this表示本类的num   // System.out.println(new Outer5().num);      //也可以System.out.println(Outer5.this.num);      //Outer5.this 表示是外部类的东西} }}class InnerClassTest {public static void main(String[] args) {Outer5.Inner oi = new Outer5().new Inner();oi.show();}}

2、分析题

package test.innerclass;/** * @author Nocol * * @TODO *  *//*   * 匿名内部类面试题： 按照要求，补齐代码  *              * interface Inter1 {  * void show();               //默认 public abstract void show(); * }  * class Outer7 { //补齐代码 } *  * class OuterTest2 {  * public static void main(String[] args) { *           Outer7.method().show();  *        }  *   }  *    *   要求在控制台输出”HelloWorld” */interface Inter1 {void show();// public abstract}class Outer7 {// 补齐代码public static Inter1 method() {     //接口作为返回值，实际返回该接口实现类的对象，刚好就是匿名内部类// 子类对象 -- 子类匿名对象return new Inter1() {public void show() {System.out.println("HelloWorld");}};}}class OuterTest2 {public static void main(String[] args) {Outer7.method().show();/* * 1:Outer7.method()可以看出method()应该是Outer中的一个 静态方法。 * 2:Outer7.method().show()可以看出method()方法的返回值是一个对象。 * 又由于接口Inter1中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。 */}}