内部类(Inner Class)是定义在其他类中或方法中的类，包含内部类的类通常称作Enclosing Class

内部类的功能通常与包含它的类的功能有紧密的关联
内部类的存取控制方式与同他在同一位置上的成员是相同的

静态内部类(Static inner class)
成员内部类(Member inner class)
本地内部类(Local inner class)
匿名内部类(Anonymous inner class)

定义静态内部类的方法类似于声明类的一个静态成员：

public class OutClass {
    private static int staticOutMem=0;
    public static class InnerClass{
        //private static int staticOutMem=1;　　//若是这里注释去掉，会有两个成员变量，名字相同，根据调用方法，选择究竟是哪一个
        
        public void innerMethod() {
            System.out.println(staticOutMem);     //先在内部类自己里面找，找不到会去外部类中找，同继承一样，会继承外部类的全部财产，不过更加彻底，会继承私有类
        }
    }
    
    public static void main(String[] args) {
        //声明
        OutClass.InnerClass InnerObj;
        //创建
        InnerObj= new OutClass.InnerClass();
        //使用
        InnerObj.innerMethod();
    }
}

public class OutClass {
    private static int staticOutMem=0;
    
    private static void setOutMem(int a) {
        staticOutMem=a;
    }
    
    public static class InnerClass{
        private static int staticOutMem=1;
        
        public void innerMethod() {
            setOutMem(staticOutMem+12);
            System.out.println(staticOutMem);     //先在内部类自己里面找，找不到会去外部类中找
            System.out.println(OutClass.staticOutMem);　　//输出会知道调用的方法修改的是这个值
        }
    }
    
    public static void main(String[] args) {
        //声明
        OutClass.InnerClass InnerObj;
        //创建
        InnerObj= new OutClass.InnerClass();
        //使用
        InnerObj.innerMethod();
    }
}

1.静态内部类不能与其Enclosing Class同名

2.静态内部类是类的成员，因此静态内部类可以直接访问Enclosing Class中的所有静态成员，包括private和protected成员；

3.但是，在Enclosing Class中不能直接访问静态内部类的成员（必须加上静态内部类名） 作为类的静态成员，不能在静态内部类中直接访问Enclosing Class的非静态成员

定义成员内部类的方法类似于定义一个类的普通成员：

public class OutClass {
    public int OutMem;
    
    public class InnerClass{
        public void innerMethod() {
            System.out.println(OutMem);
        }
    }
    
    
    public static void main(String[] args) {
        //声明
        OutClass.InnerClass InnObj;
        //定义
        InnObj= new OutClass().new InnerClass();
        InnObj.innerMethod();
    }
}

1.成员内部类不能与它的Enclosing Class同名，而且成员内部类中不能定义静态的成员变量或方法！！

2.成员内部类可以访问Enclosing Class中的所有成员，不论静态成员还是非静态成员；而Enclosing Class中不能直接访问成员内部类的成员

3.在成员内部类的方法中this是内部类当前对象的引用，如果需要访问当前的外部类对象需要使用Enclosing.this

本地内部类(Local Inner Class)是定义在方法中的内部类：

public class OutClass {
    private int age=10;
    
    public void LocalInnerClass() {
        //本地内部类不能使用访问限定符
        //只能在方法中使用,外部无法获取
        class LocalInner{
            public String name="a";
            
            public void getInfo() {
                System.out.println(name+" "+age);
            }
        }
        
        LocalInner LI = new LocalInner();
        LI.getInfo();
    }
    
    public static void main(String[] args) {
        OutClass oc = new OutClass();
        oc.LocalInnerClass();
    }
}

本地内部类不能与它的Enclosing Class同名，而且本地内部类中不能定义静态的成员变量或方法

本地内部类可以访问Enclosing Class中的所有成员，不论静态成员还是非静态成员；而Enclosing Class中不能直接访问本地内部类的成员

匿名内部类是没有名字的内部类，起作用是在建立对象的时候完成对类的定义，而不需要给类起名字

定义匿名内部类时需要给出类的超类
也可以通过指定类要实现的接口来创建匿名内部类，但是只能有一个接口

//必须有一个超类或者接口才可以进行调用
interface SuperClass{
    public void getInfo();
}

public class OutClass {
    
    
    public static void main(String[] args) {
        SuperClass sc=new SuperClass() {　　//相当于父类指针，所以父类必须有这个方法getInfo的接口
            public void getInfo() {
                System.out.println("this non class");
            }
        };
        
        sc.getInfo();　　
    }
}

//必须有一个超类或者接口才可以进行调用
abstract class SuperClass{
    public int age;
    public SuperClass(int a) {
        age=a;
    }
    
    public abstract void getInfo();
}

public class OutClass {
    
    
    public static void main(String[] args) {
        SuperClass sc=new SuperClass(10) {
            public void getInfo() {
                System.out.println("age is "+age);
            }
        };
        
        sc.getInfo();
    }
}

匿名内部类对Enclosing Class的访问权限同本地内部类相同
注：匿名内部类最常见的用途是在建立GUI应用程序时为组件添加事件监听器对象
   …