Java中内部类的介绍

一个类TestOuter的内部的类SubTest叫内部类。

内部类：SubTest ，外部类：TestOuter。

内部类：成员内部类 (静态的，非静态的)  和 局部内部类（位置：方法内，块内，构造器内）

1、成员内部类

代码示例：

package Package8_face_the_object.test_inner_class;
/*
内部类的使用介绍：
首先：
1.类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
2.一个类TestOuter的内部的类SubTest叫内部类， 内部类 ：SubTest  外部类：TestOuter
3.内部类：成员内部类 (静态的，非静态的) 和  局部内部类（位置：方法内，块内，构造器内）
4.成员内部类:（本代码示例！！！）
*      里面属性，方法，构造器等(里面甚至可以再加一个内部类，但一般不推荐/常用)
*      修饰符：private，default，protect，public，final,abstract
*/
public class TestOuter {
    //（非静态）成员内部类
    public class D{
        int age = 20;
        String name;
        public void method(){
            //5.内部类可以访问外部类的内容
            /*System.out.println(age);
            a();*/
            int age = 30;
            //8.内部类和外部类属性重名的时候，如何进行调用
            System.out.println(age);//30  -- 就近原则
            System.out.println(this.age); // 20
            System.out.println(TestOuter.this.age); // 10

        }
    }
    //静态成员内部类
    static class E{
        public void method(){
            //6.静态内部类中只能访问外部类中被static修饰的内容
            /*System.out.println(age);
            a();*/
        }
    }

    //下面就属于外部类的内容（内部类之外的）
    //属性
    int age = 10;
    //方法
    public void a(){
        System.out.println("这是a()方法！");
        //普通块
        //普通块可以写在方法里面
        {
            System.out.println("这是一个普通块！");
            class B{  //局部内部类——2)块内
            }
        }
        class A{  //局部内部类——1)方法内
        }
        //7.外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
        //System.out.println(name); //不能直接访问
        D d = new D();
        System.out.println(d.name);
        d.method();
    }
    //静态块  ——  最优先被加载
   static{
        System.out.println("这是一个静态块！");
   }

    //构造块 —— 构造块和构造器，构造块先执行
    {
        System.out.println("这是一个构造块！");
    }

    //构造器
    public TestOuter() {  //空构造器
        class C{  //局部内部类——3)构造器内
        }
    }
    public TestOuter(int age) {  //有参构造器
        this.age = age;
    }
}

//测试类
class Demo{
    public static void main(String[] args) {
        //创建外部类的对象
        TestOuter to = new TestOuter();
        //测试一下method()方法的输出
        //调用a()方法就行了，因为a()方法里调用了method()方法
        to.a();

        //创建内部类的对象：
        //静态成员内部类E  --创建对象
        TestOuter.E e = new TestOuter.E();  //因为是静态的，(外部类)直接调用即可

        //（非静态）成员内部类D --创建对象
        //TestOuter.D d = new TestOuter.D(); //非静态的不能这么调
        //因为 非静态）成员内部类D 也属于类的成员
        //所以，得先有一个外部类（的对象），并通过这个创建的外部类对象去调用！！！
        TestOuter to2 = new TestOuter();
        TestOuter.D d = to2.new D();
    }
}

2、局部内部类

       涉及到 —— 匿名内部类 的概念。

       (即，这个类没有名字，直接通过接口来创建这个类的对象（然后可以用接口去接这个对象）            相当于 —— 接口等于实现类的对象）

代码示例：

package Package8_face_the_object.test_inner_class;
/*
内部类：成员内部类 (静态的，非静态的) 和  局部内部类（位置：方法内，块内，构造器内）

局部内部类:（本代码示例！！！）
（匿名内部类！！！）
*/
public class TestOuter2 {
    //1.在局部内部类中访问到的变量必须是被final修饰的
    public void method(){
        //int num = 10;
        final int num = 10;

        //局部内部类 —— 方法内
        class A{
            public void a(){
                //num =20; // 没有用final修饰,但实际上就是final属性，这也是不能更改其值的原因
                System.out.println(num);  //这里，现在num前面没有用final修饰，
                                          // 可以访问到，但是在JDK1.8之前不行
                //即，要想在a()方法中访问属性num，那么该属性必须是被final修饰的
            }
        }
    }

    //2.如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
        //（对应：为什么不把B类定义在外部）
    public Comparable method2(){   //把void返回值类型改为Comparable接口，
                                   //那么返回值的类型必须是具体实现类的对象
                 // 即，如果把接口作为方法的返回值类型，那么返回值的类型必须是具体实现类的对象
                 //这里，具体实现类为B类       （这也属于一个小的多态的应用）
        class B implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 100;
            }
        }
        return new B();
    }

    //2的同等效果，进行简化(都不用创建B类了)
    //3、匿名内部类(即，这个类没有名字，直接通过接口来创建这个类的对象（然后可以用接口去接这个对象）)
                  //相当于 —— 接口等于实现类的对象
    public Comparable method3(){
        return new Comparable(){     //接口不能创建对象
            @Override            //会提示，让对方法进行重写
            public int compareTo(Object o) {
                return 200;
            }
        }; //return后面(到分号之前)都是一个对象
    }

    //3的等效，
    //既然return后面都是一个对象，那么我们可以用一个 Comparable com 去接收
    public void test(){
        Comparable com= new Comparable(){

            @Override
            public int compareTo(Object o) {
                return 150;
            }
        };
        //com是一个对象，则里面的compareTo()方法可以调用
        System.out.println(com.compareTo("abc"));
    }
}