java 内部类分为成员内部类，局部内部类，匿名内部类，

**

内部类分为成员内部类，局部内部类，匿名内部类，

bagm:

一、 成员内部类即在成员变量处定义一个内部类，

1、内部类与外部类都可以彼此使用类中的方法，即使是 private 私有的
2、内部类的实例一定要在外部类的实例上，如果从外部类中初始化一个内部类，那么内部类就会绑定在外部类对象上，
3、在主方法中实例一个内部类对象，必须在new操作符前提供一个外部类的引用
并且不能使用外部类的类名，而要用外部内实例的对象来创建
4、非内部不能被声明为private 或 protected访问权限类型，
5、内部类可以实现多继承，以及内部类可以还有内部，（关于这两个用法见 附一内容）

 1. package StudyNBNBL;

    class Abcd {
         AbcdinnerClass abcdinnerClass = new AbcdinnerClass();
         private int i = 0;

         public class AbcdinnerClass {
              // 成员内部类
              private int o = 0;

              private void print() {
                   i = 100; // 可以随意使用外部类的私有成员
                   System.out.println(i);
                   System.out.println("内部类的abcdinnerClass");
                   printll(); // 可以随意使用外部类的私有方法
              }
         }

         public void printll() {
              System.out.println("外部类的 printll");
         }

         public void printll2() {
              abcdinnerClass.o = 100; // 外部类使用内部类的私用成员
              System.out.println(abcdinnerClass.o);
              abcdinnerClass.print(); // 调用内部类的方法
         }

         // 还回一个内部类的引用
         public AbcdinnerClass ss() {
              return new AbcdinnerClass();
         } }

    public class StudyNBNBL {
         public static void main(String[] args) {
              Abcd abcd = new Abcd();
              abcd.printll();
              abcd.printll2();
              Abcd.AbcdinnerClass a = abcd.ss(); // 在类外实例化内部类方法1
              Abcd.AbcdinnerClass a2 = abcd.new AbcdinnerClass(); // 在类外实例化内部类方法2
              // 在主方法中实例一个内部类对象，必须在new操作符前提供一个外部类的引用 } }

二、使用接口，将一个权限为私有的内部类向上转型为接用，

1、如果将一个内部类权限为private的内部类向上转型为一个父类对象，或是接口时，在程序中将完成隐藏内部类的具体实现过程，
2、内部类的权限为private 所以除了外部类，其它类都不能防问到，
3、但是其它类可以访问到外部类的doit方法，它刚好返回一个内部类引用，
4、接口可以防部到内部类实现了接口的方法，但是方法的具体实现得到了很好的隐藏起来，这就是内部类的基本用法，
5、如果实现了接口的内部类中实现了该接口的方法，就可以定义多个内部类以不同的方式实现接口中的方法同一方法，而一般一个类不能多次实现接口中同一个方法的，

package StudyNBNBL;

interface Out {     //定义了一个接口，准备接收私有内部类
    public void outprint();
}
class Outclass {   // 外部类定义出来
    private class Outinclass implements Out {  // 内部类定义出来，实现了Out接口
         public void outprint() {   // 实现了接口，就实现方法
            System. out.println("class outinprint --  out outprint");
        }
         public Outinclass(String s) {   //内部类构造方法，显于内部类已经构造完成
            System. out.println(s);
        }
    }
    public Outinclass doit() {   // 外部类方法，返回一个内部类的引用
         return new Outinclass("实例化内部类，访问内部构造方法" );
    }
}
public class Test2 {
    public static void main(String[] args) {  // 在主方法中实现私有内部向上转型为接口
        Outclass outclass = new Outclass();  // 先实列外部类对象
         Out out = outclass.doit();           // 用接口的引用接用返回的内部类对象
        out.outprint();                      // 使用接口调用内部实现的方法
    }
}

三、使用this处理外部类与内部类变量重名的方法

1、如果遇到外部类与内部类重名，可以用this方法解决，
2、使用就近原则
3、内部中使用this调用内部的变量X，使用类名加this的方法调用外部的变量
4、在内存中所有的对象都放置在堆中，方法以及方法中的形参或局部变量放置在栈中，

package StudyNBNBL;

publicclass Test3 {
    private int a = 0;    // 定义外部类的 a
    private class Test3in {
         private int a = 100;  // 定义了内部类的a
         private void adoit (int a) {  // 方法中的形参也为a 是不是乱了
            a++;             // 就近原则，形参的a加了
             this.a ++;        // 内部类的a加了
            Test3. this.a ++;  // 这个用了外部类名加this的当然是外部类的a加了
        }
    }
}

附一： 内部类可以实现多继承，以及内部类可以还有内部 以及同名变量的调用方法使用

package StudyNBNBL;

class AA {         // 定义第一个类
    int i = 50;
    public void aaprint () {
        System. out.println("AA" );
    }
}

class BB {        // 定义第二个类
    int i = 40;
    public void bbprint () {
        System. out.println("BB" );
    }
}

class CC extends AA{ // 定义一个类继承第一个类
    int i = 10;
     class CCin extends BB{// 定义内部类继承第二个类
         int i = 20;
         class CCinin {
             int i =30;
             public void CCininprint (){
                 System. out.println("CCinin" );
             }
             public void CCininprint2(){  // 关于内部类多层，以及多继承的同名变量调用
                 System. out.println(CC.this.i);           
                 System.out.println(CCin.this.i);
                 System. out.println(i );  // 就近原则
                 System.out.println(CCin.super.i);
                 System. out.println(CC.super.i);
             }
         }
     }
}

public class Test6 {
    public static void main(String[] args) {  // 关于内部多层的申明
        CC cc = new CC();
        CC.CCin ccin = cc. new CCin();
        CC.CCin.CCinin ccinin = ccin. new CCinin();
        cc.aaprint();
        ccin.bbprint();
        ccinin.CCininprint();
        CC.CCin.CCinin ccinin2 = new CC().new CCin().new CCinin();  // 一次申明最里面一层内部类的方法
        ccinin2.CCininprint2(); // 测试关于内部类多层，以及多继承的同名变量调用        
    }
}

四、局部内部类

1、即在方法中定义内部类与局部变量类似，方法中的内部类要先定义，后使用，
2、局部内部类不加修饰符，其范围为定义它的代码块
3、局部内部类不能定义静态变量，
4、可以访问外部类的局部变量,但是变量必须是final，（因为局部内部类生命周期的原因，造成访问已经不存在的变量）
5、可以访问外部类的成员变量，
6、变量同名参考this的用法，
7、在类外不能直接生成局部内部类（保证局部类对外不可见的）要想使用局部内部类需外部类对象或接口或使用向上转型，
8、局部类在方法中，该方法以外不能访问局部内部类的成员，
注：局部变量的生命周期与局部内部类对象的生命周期是不一样的，当局部变所处的函数（方法）执行结束后就已经不存在了，可局部内部类还可能一直存在(只要有引用该对象的变量）就会出现访问一个不存在的变量，

package StudyNBNBL;

interface Out2{
    public void show();
}

class Abcd2 {
    int b = 100;
    public Out2 f(final String X) { 
         final int a = 200;
         class AbcdinnerClass implements Out2 {  // 不用加权限修饰符，其范围为代码块

            AbcdinnerClass(String s) {
                s = X;    // 只可以方问外部类final的局部变量
                System. out.println(s);
            }

             public void show() {
                System. out.println(a + " " + b );  // 可以方问外部类final的局部变量，以外部类的成员变量
                System. out.println("Abcinshow" );
            }
        }
         return new AbcdinnerClass( "f -- Abcin" );
    }
}

public class Test4 {
    public static void main(String[] args) {
        Abcd2 abcd2 = new Abcd2();
        Out2 out2 =abcd2.f( "no echo");
        out2.show();
    }
}