内部类

在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。

1、实例内部类

即未被static修饰的成员内部类。

//外部类
class OuterClass {
    public int data1 = 1;
    private int data2 = 2;
    public static int  data3 = 3;

    public OuterClass() {
        System.out.println("外部类的构造方法！");
    }



//    内部类
    class InnerClass {
        public int data1 = 1111;
        public int data4 = 4;
        private int data5 = 5;
        public static final int data6 = 6;

    public InnerClass() {
        System.out.println("内部类构造方法！");
    }

    public void printInnerclass() {
        System.out.println("内部类成员方法打印："+data1+data2+data3+data4+data5);
        System.out.println("内部类的data1："+data1);
        System.out.println("外部类的data1："+OuterClass.this.data1);
    }
}
public void printOuterclass() {
        System.out.println("外部类成员方法打印："+data1+data2+data3);
    }
}


public class Test {
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.printOuterclass();

        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.printInnerclass();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

注意事项：

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

实例内部类
1、实例内部类当中 不能定义静态的成员变量？？
       ~~~~~~       如果定义   ~  那么这个静态的成员应该是被final修饰的
     ~~~~     
2、实例内部类当中   ~  不能定义静态的成员方法！！！
     ~~~~     
3、如何实例化    ~~   实例内部类？？
     ~~~~     
外部类类名.内部类      ~~~~     变量      ~~~~     =      ~~~~     外部类引用.new      ~~~~     内部类();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
       ~~~~~~       
4、如何访问实例内部类   ~  和   ~  外部类的同名的成员变量？？
       ~~~~~~       OuterClass.this
       ~~~~~~       实例内部类当中   ~  包含外部类的this
       ~~~~~~       
5、如果是同名的静态的，OuterClass.data3

       ~~~~~~       
       ~~~~~~       

2、静态内部类

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

java接口与内部类教学PPT

application/x-zip 0星 超过10%的资源 40KB

下载

/**
 * 静态内部类：
 *
 */

class OuterClass {
    public int data1 = 1;
    private int data2 = 2;
    private static int data3 = 3;

    public void test() {
        System.out.println(data1+data2+data3);
    }

    /**
     * 1、如何拿到静态内部类的对象？？？
     * OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
     *
     * 2、不能在静态内部类当中，直接访问外部类非静态成员
     */

    static class InnerClass {
        public int data4 = 4;
        private int data5 = 5;
        private static int data6 = 6;

        public InnerClass() {
            System.out.println("静态内部类的构造方法！");
        }

        public void test() {
            System.out.println("test方法执行了！！");
//            如何拿到外部类的非静态成员呢？？
            OuterClass outerClass = new OuterClass();
            System.out.println(outerClass.data1);
            System.out.println(outerClass.data2);
        }
    }
}

public class Test3 {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        innerClass.test();

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

       ~~~~~~       
       ~~~~~~       

局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解下语法
格式。

/**
 * 局部内部类
 */
public class Test4 {
    public static void func() {
        class A {
            public void test() {
                System.out.println("局部内部类！！！");
            }
        }

        A a = new A();
        a.test();
    }

    public static void main(String[] args) {
        func();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

实际用的并不多，仅做了解即可

注意

1. 局部内部类只能在所定义的方法体内部使用
2. 不能被public、static等修饰符修饰
3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$内部类名字.class
4. 几乎不会使用

匿名内部类

后面了解