JAVA中的内部类

一、实例内部类

1. 外部类中的任何成员都可以在实例内部类方法中直接访问

public class Text {
    public static void main(String[] args) {

    }
}
class Out{
    int a = 1;
    int b = 2;
    public void fun(){
        System.out.println("out:fun()");

    }
    public static void fun1(){
        System.out.println("static:fun1()");
    }
    class innter{

        public void infun(){
            a = 1;//内部类的方法中访问外部类的成员变量
            fun();//内部类的方法中访问外部类的方法
        }
    }


}

2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
这与外部类的成员变量一样，受访问限定符的约束。

3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问
 

如何访问内部类的方法？

public class Text {
    public static void main(String[] args) {
        Out out = new Out();
        Out.Innter in = out.new Innter();
        in.infun();


    }
}

先创建外部类的对象，Out.Innter为对象名的类型，通过外部类的对象名点的方式来访问内部类在堆空间中的数据。

public class Text {
    public static void main(String[] args) {
        Out out = new Out();
        Out.Innter in = out.new Innter();
        in.infun();


    }
}
class Out{
    int a = 1;
    int b = 2;
    public void fun(){
        System.out.println("out:fun()");

    }
    public static void fun1(){
        System.out.println("static:fun1()");
    }
    class Innter{

        public void infun(){
            a = 3;
            b = 4;
            System.out.println(a);
            System.out.println(b);

        }
    }


}

运行结果如下：

 访问相同名字的外部类的成员：

public class Text {
    public static void main(String[] args) {
        Out out = new Out();
        Out.Innter in = out.new Innter();
        in.infun();


    }
}
class Out{
    public int a = 1;
    public int b = 2;
    public void fun(){
        System.out.println("out:fun()");

    }
    public static void fun1(){
        System.out.println("static:fun1()");
    }
    class Innter{
        int a = 23;
        int b = 33;

        public void infun(){
            System.out.println(a);
            System.out.println(Out.this.a);//外部类名.this.相同变量名.外部类名通过点来访问自己的对象然后又通过点来访问成员变量。
            System.out.println(b);

        }
    }


}

4.实例内部类中不能访问static修饰的成员变量，非要定义必须要有static final修饰。

class Out{
    public int a = 1;
    public int b = 2;
    public void fun(){
        System.out.println("out:fun()");

    }
    public static void fun1(){
        System.out.println("static:fun1()");
    }
    class Innter{
        int a = 23;
        int b = 33;
        public static final int c = 2;
        c=3;//static final修饰的是常量，常量不能给常量赋值

        public void infun(){
            System.out.println(a);
            System.out.println(Out.this.a);
            System.out.println(b);

        }
    }


}

二、静态内部类

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

需要注意的点：

1. 在静态内部类中只能访问外部类中的静态成员
如何访问静态类中的成员？

OutClass2.InnterClass2 innterclass = new OutClass2.InnterClass2();
//外部类的类名.内部类的类名 对象名 = new 外部类类名.内部类的类名（）；

public class Text {
    public static void main(String[] args) {
        OutClass2.InnterClass2 innterclass = new OutClass2.InnterClass2();
        innterclass.fun();

    }
}
class OutClass2 {
    public int a = 1;
    public int b = 2;
    static class InnterClass2{
        public int c = 3;
        public int d = 4;
        public void fun(){
            System.out.println(a);//不能访问外部类的非静态成员。
            //非要访问，需要创建外部类的对象。
            OutClass2 out = new OutClass2();
            System.out.println(out.b);

        }
    }
}

三、局部内部类

1. 局部内部类只能在所定义的方法体内部使用

class OutClass2 {
    public int a = 1;
    public int b = 2;
    public void func(){
        class innter{
            public void fun1(){
                System.out.println("abcdef");
            }
        }
        Innter in = new Innter();
        in.fun1();
    }

2. 不能被public、static等修饰符修饰

3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$内部类名字.clas

 

 4.局部内部类

在接口内容中细讲。