Java内部类的分类

内部类分类：

成员内部类
匿名内部类
局部内部类

一、成员内部类

是指可以用private protect default public任意一个进行修饰的，类文件名：外部类$内部类.class
a)非静态内部类
外部类可以使用内部类和我们平时使用其它的类没什么区别。
1）非静态内部类必须寄存在。因此如果有一个非静态内部类对象被创建，那么它的外部类对象一定会被创建，非静态内部类对象单独属于外部类的某个对象。
2）非静态内部类对象可以单独访问外部类成员，但外部类对象不能直接访问非静态内部类的成员。
3）非静态内部类是属于外部类的某个对象，因此不能有静态方法，属性，静态初始化块。
4）外部类的静态方法不能使用非静态内部类(因为非静态内部类是属于对象的，外部类的静态方法是属于外部类的，外部类对象还未被创建，因此不能用)，包括不能使用非静态内部类定义变量，创建实例,但非静态内部类可以使用外部类的属性及方法。
内部类的成员变量访问要点
1）内部类方法的局部变量：直接访问。
2）内部类属性：this.属性名
3）内部类访问外部类属性：外部类.this.属性名
例子：

package com.liuzeyu12a.OOT;

public class TestInnerClass {
   
    public static void main(String[] args) {
   
        //生成内部类对象
        Outer.inner inner = new Outer().new inner();
        inner.show();

    }
}

class Outer{
   
    public  int age = 100;
    void testOuter(){
   
        System.out.println("外部类对象");
    }
    class inner{
   
        int ageInner = 80;
        public void show(){
   
            int ageFun = 300;
            System.out.println("外部类成员变量："+Outer.this.age);
            System.out.println("内部类成员变量："+this.ageInner);
            System.out.println("内部类成员变量："+ageFun);
        }

    }
}

b)静态内部类

static  class   ClassName {
   
//类体
}

静态内部类使用要点
1）当一个静态内部类存在时并不一定存在外部类对象，内部类属于外部类，不属于外部类对象，因此，静态内部类的实例方法不能直接访问外部类的实例和方法。
2）静态内部类属于外部类的一个静态成员，因此外部类可以通过 “静态内部类.名字”的方式访问静态内部类的静态成员，通过new静态内部类访问静态内部类的实例。
例子：

package com.liuzeyu12a.OOT;

public class TestInnerClass02 {
   
    public static void main(String[] args) {
   
        //创建静态内部类对象
        Outer2.Inner2 inner2 = new Outer2.Inner2();
        inner2.show();

        //执行外部了的方法
        new Outer2().show();
    }
}

class Outer2{
   

    String name;
    int age;
    public void show(){
   
        System.out.println("外部类访问内部类成员"+new Inner2().age);
    }
    //静态内部类
    static class Inner2{
   

        int age = 100;
        public void show(){
   
            /** * 当一个静态内部类对象存在，并不一定存在对应的外部类对象。 * 因此，静态内部类的实例方法不能直接访问外部类的实例方法。 */
            //System.out.println(Outer2.this.age);
            System.out.println("staic inner2");
        }
    }
}

二、匿名内部类

匿名内部类使用要点
1）匿名内部类没有访问修饰符
2）匿名内部类没有构造方法，因为它连名字都没有哪来的构造器

package com.liuzeyu12a.OOT;

public class TestAnonymousInner {
   

    public static void main(String[] args) {
   
        /** * 这里说明一下为什么System.out.println("测试匿名内部类"); * 没有被实现，因为这个是new 接口实现类的时候必须实现的方法 * 但是这个方法并没有被调用，所以并不会被运行 */
        TestAnonymousInner.test(new AA() {
   
            @Override
            public void aa() {
   
                System.out.println("测试匿名内部类");
            }
        });
    }

    static void test(AA aa){
   
        System.out.println("test AA ==>" + AA.aa);
    }
}
//接口AA
interface AA{
   
    int aa = 100;
    void aa();
}

二、局部内部类

还有一种内部类，它是定义在方法内部的，作用域只限于本方法，称为局部内部类。

  局部内部类的的使用主要是用来解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类。局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法中被使用，出了该方法就会失效。

  局部内部类在实际开发中应用很少。

public class Test2 {
   
    public void show() {
   
        //作用域仅限于该方法
        class Inner {
   
            public void fun() {
   
                System.out.println("helloworld");
            }
        }
        new Inner().fun();
    }
    public static void main(String[] args) {
   
        new Test2().show();		//输出helloworld
    }
}