内部类的详细介绍~

内部类的分类：

1、本地内部类        2、实例内部类        3、静态内部类        4、匿名内部类

一、本地内部类：定义在方法当中的类

public void func(){
        class Test{//本地内部类
            public int a;
        }
    }

缺点：只能在方法中使用

二、实例内部类：定义在类内部了类

Class OuterClass{
    class InnerClass{//实例内部类
    }
}

注意：

1、在实例内部类中不能定义一个静态的成员变量，还要定义只能定义一个静态的常量

class OuterClass{
    public int data1=1;
    private int data2=1;
    public static int data3;
    class InnerClass{//实力内部类，可以把它当作是外部类的一个普通实例的成员
        public int data4=4;
        private int data5=5;
        public static in t data6=6;//会报错，带static的是属于类的，不属于对象，但InnerClass需要依赖外部类对象调用的
        public static final int data7=6;//正确，静态的常量可以定义
        public InnerClass(){
            System.out.println("奴带参数的内部类的构造方法！");
        }
        public void test(){
            System.out.println("InnerClass::test()");
        }
    }

2、如何实例化，实例内部类的对象：外部类名.内部类名   变量=外部类对象的引用.new 内部类

Class OuterClass{
    class InnerClass{
    }
}
public static void main(String[] args) {
    OuterClass outerClass=new OuterClass();
    OuterClass.InnerClass innerClass=outerClass.new InnerClass();//实例内部类对象
}

 3、实例内部类当中，如果包含了和外部类同名的成员变量，如何在实例内部类中访问？

class OuterClass{
    public int data1=1;
    class InnerClass{//实力内部类，可以把它当作是外部类的一个普通实例的成员
        public int data1=99999;
        public void test(){
            System.out.println(OuterClass.this.data1);//才能访问到外面的data1,输出1
            System.out.println(this.data1);//99999
        }
    }
}

public static void main(String[] args) {
        OuterClass outerClass=new OuterClass();
        OuterClass.InnerClass innerClass=outerClass.new InnerClass();//实例内部类对象
        innerClass.test();
}

实例内部类当中有两个this，一个是外部类的this，一个是自己的this

三、静态内部类

class OuterClass{
    static class InnerClass{//静态内部类
    }
}

注意：

1、如何实例化，实例内部类的对象： 

Class OuterClass{
    class InnerClass{
    }
}
public static void main(String[] args) {
    OuterClass.InnerClass innerClass=new OuterClass.InnerClass();//获取静态内部类对象
}

2、如何访问外部类的普通成员变量：

class OuterClass{
    public int data1=1;
    private int data2=2;
    static class InnerClass{
        public int data4=4;
        private int data5=5;
        public static int data6=6;//可以定义静态的
        public void test(){
            System.out.println(data1);//报错，因为调用data1需要外部类的引用，而InnerClass不需要调用外部类的对象
            System.out.println(new OuterClass().data1);//创建一个外部类对象就可以访问外部类的普通成员变量
            System.out.println(data2);//报错，私有的不能访问
        }
    }
}

四、匿名内部类

class Test1{
    public void test(){
        System.out.println("test()haha!");
    }
}
public static void main(String[] args) {
    new Test1(){

    };//匿名内部类
}

匿名内部类调用方法

class Test1{
    public void test(){
        System.out.println("test()haha!");
    }
}
public static void main(String[] args) {
    new Test1(){
        @Override
         public void test() {
            System.out.println("我是重写的test方法");
        }
    }.test();//匿名内部类调用test方法
}