简单的内部类

简单的内部类

1、内部类的分类

根据内部类定义的位置不同，一般可以分为以下几种形式：

1. 实例内部类(普通内部类：未static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)
2. 局部内部类(不谈修饰符)、匿名内部类 注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中 使用最多的是匿名内部类。

2、实例内部类

2.1、如何实例化内部类对象

 *外部类名.内部类名（拿到内部类的类型）  变量 = 外部类对象的引用.new InnerClass();

2.2、实例内部类当中不能定义静态的成员变量？

 * public static final int data6 = 60;//静态成员加final变常量  编译的时候 值已经确定（必须是static final的）

2.3、实例内部类当中，如果有成员变量和外部类的成员变量重名了？怎么办？

 * 优先使用自己的
 * 如何拿到外部类的呢？
 * System.out.println("&&&&&&&&&"+OuterClass.this.data1);
 * 意识到了：实例内部类当中不仅包含自己的this，还包含  外部类的 this

2.4、不能包含静态方法

上代码：

class InnerClass{
        public int data1 = 1000;
        public  int data4 = 40;
        private int data5 = 50;
        public static final int data6 = 60;//静态成员加final变常量

        /**
         * InerClass的构造方法
         */
        public InnerClass(){
            System.out.println("InerClass的构造方法");
        }
        public void method(){
            System.out.println("InerClass的一个method方法");
            System.out.println("》》》》》》》"+data1);
            System.out.println("&&&&&&&&&"+OuterClass.this.data1);
        }
    }

    public void methodOut() {
        System.out.println(data1);
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.data1);
    }

}



public class TestDemo {

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.methodOut();
        System.out.println("===============");

        //外部类名.内部类名（拿到内部类的类型）  变量 = 外部类对象的引用.new InnerClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.method();
    }

    public static void main1(String[] args) {
        OuterClass outerClass = new OuterClass();
        System.out.println(outerClass.data1);
        OuterClass.InnerClass innerClass2 = new OuterClass().new InnerClass();
        //System.out.println(innerClass.data4);
        //匿名对象，一般是用在 只用一次的情况
        //System.out.println(new OuterClass().data1);
    }
}

【注意事项】

1. 外部类中的任何成员都可以被在普通内部类方法中直接访问
2. 普通内部类所处的成员与外部类成员位置相同，因此也受public、private等访问限定符的约束
3. 在内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名 称.this.同名成员 来访问
4. 普通内部类对象必须在先有外部类对象前提下才能创建
5. 普通内部类的非静态方法中包含了一个指向外部类对象的引用
6. 外部类中，不能直接访问内部类中的成员，如果要访问必须先要创建内部类的对象。

3、静态内部类与匿名内部类

被static修饰的内部成员类称为静态内部类。

静态内部类当中的一些问题

3.1、如何实例化静态内部类

 * OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass();

3.2、在静态内部类当中 只能访问外部类的静态成员如果要访问外部类的非静态成员， 应该怎么访问？

 *   提供外部类对象

class OuterClass2{

    public int data1 = 10;
    private int data2 = 20;
    public static int data3 = 30;

    //static OuterClass2 out = new OuterClass2();

    public void method(){
        System.out.println("OuterClass2::method()");
    }

    static class InnerClass{
        public int data4 = 40;
        private int data5 = 50;
        public static int data6 = 60;

       /* 如果要访问要访问外部类的非静态成员， 应该怎么访问
        OuterClass2 out = new OuterClass2();*/

        OuterClass2 out;//没有初始化  默认为null

        //构造方法
        InnerClass(){
            System.out.println("InnerClass()");
        }

        InnerClass(OuterClass2 out){
            this.out = out;
            System.out.println("InnerClass()");
        }

        public void method(){
            System.out.println(out.data1);
            System.out.println(out.data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println("innerClass的method方法！");
        }
    }
}
class Test{
    public int a = 19;

    public void test(){
        System.out.println("test()!");
    }
}
public class TestDemo2 {
    /**
     * 匿名内部类
     * @param args
     */
    /*public static void main(String[] args) {
        new Test(){

        }.test();
    }*/
    //还可以这样写
    public static void main(String[] args) {
        new Test() {
            public void test1(){
                System.out.println("hahaha!");

                }
            @Override
            public void test() {
                System.out.println("我去!");
            }
        }.test();
    }


    public static void main1(String[] args) {
        //不需要外部类对象，所以静态内部类使用的频率比较多
        OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass(new OuterClass2());
        innerClass.method();
    }
}

【注意事项】

1. 在内部类中只能访问外部类中的静态成员
2. 创建内部类对象时，不需要先创建外部类对象
3. 成员内部类，经过编译之后会生成独立的字节码文件，命名格式为：外部类名称$内部类名称