java-内部类

成员内部类

1.package com.msb.test07;
2.
3./**
4. * 1.类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
5. * 2.一个类TestOuter的内部的类SubTest叫内部类， 内部类 ：SubTest  外部类：TestOuter
6. * 3.内部类：成员内部类 (静态的，非静态的) 和  局部内部类（位置：方法内，块内，构造器内）
7. * 4.成员内部类:
8. *      里面属性，方法，构造器等
9. *      修饰符：private，default，protect，public，final,abstract
10. */
11.public class TestOuter {
12.    //非静态的成员内部类：
13.    public class D{
14.        int age = 20;
15.        String name;
16.        public void method(){
17.            //5.内部类可以访问外部类的内容
18.            /*System.out.println(age);
19.            a();*/
20.            int age = 30;
21.
22.            //8.内部类和外部类属性重名的时候，如何进行调用：
23.            System.out.println(age);//30
24.            System.out.println(this.age);//20
25.            System.out.println(TestOuter.this.age);//10
26.        }
27.    }
28.
29.    //静态成员内部类：
30.    static class E{
31.        public void method(){
32.            //6.静态内部类中只能访问外部类中被static修饰的内容
33.            /*System.out.println(age);
34.            a();*/
35.        }
36.    }
37.    //属性：
38.    int age = 10;
39.    //方法：
40.    public void a(){
41.        System.out.println("这是a方法");
42.        {
43.            System.out.println("这是一个普通块");
44.            class B{
45.
46.            }
47.        }
48.        class A{
49.
50.        }
51.        //7.外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
52.        D d = new D();
53.        System.out.println(d.name);
54.        d.method();
55.
56.    }
57.    static{
58.        System.out.println("这是静态块");
59.    }
60.    {
61.        System.out.println("这是构造块");
62.    }
63.    //构造器：
64.    public TestOuter(){
65.        class C{
66.
67.        }
68.    }
69.
70.    public TestOuter(int age) {
71.        this.age = age;
72.    }
73.}
74.
75.class Demo{
76.    //这是一个main方法，是程序的入口：
77.    public static void main(String[] args) {
78.        //创建外部类的对象：
79.        TestOuter to = new TestOuter();
80.        to.a();
81.
82.        //9.创建内部类的对象：
83.        //静态的成员内部类创建对象：
84.        TestOuter.E e = new TestOuter.E();
85.        //非静态的成员内部类创建对象：
86.        //错误：TestOuter.D d = new TestOuter.D();
87.        TestOuter t = new TestOuter();
88.        TestOuter.D d = t.new D();
89.
90.    }
91.}
92.

局部内部类

1.package com.msb.test08;
2.
3./**
4. * @Auther: msb-zhaoss
5. */
6.public class TestOuter {
7.    //1.在局部内部类中访问到的变量必须是被final修饰的
8.    public void method(){
9.        final int num = 10;
10.        class A{
11.            public void a(){
12.                //num = 20;
13.                System.out.println(num);
14.            }
15.        }
16.    }
17.    //2.如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
18.    public Comparable method2(){
19.        class B implements Comparable{
20.            @Override
21.            public int compareTo(Object o) {
22.                return 100;
23.            }
24.        }
25.        return new B();
26.    }
27.
28.    public Comparable method3(){
29.        //3.匿名内部类
30.        return new Comparable(){
31.
32.            @Override
33.            public int compareTo(Object o) {
34.                return 200;
35.            }
36.        };
37.    }
38.
39.    public void teat(){
40.        Comparable com = new Comparable(){
41.
42.            @Override
43.            public int compareTo(Object o) {
44.                return 200;
45.            }
46.        };
47.
48.        System.out.println(com.compareTo("abc"));
49.    }
50.}