Java中的内部类

内部类：就是把一个类放在另一个类的内部定义；

内部内的作用：

1. 内部类可以很好的实现细节隐藏

2. 内部类拥有外围类的所有元素的访问权限

3. 内部类仍然是一个独立的类

4. 内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静

态成员变量。

5. 可以避免修改接口而实现同一个类中两种同名方法的调用

分类：成员内部类、私有内部类、静态内部类、局部内部类、匿名内部类。

 

成员内部类：

一、内部类定义在外部类的成员位置

二、具有类的特点,可以继承其他父类,实现其他接口,具有成员的特点,可以被成员修饰符修饰...

注意:

一、成员内部类中不能定义静态内容,除了静态的常量

二、成员内部类中可以直接使用外部类的成员,包括私有的

三、外部类中可以通过成员内部类的对象调用成员内部类的成员

四、通过外部类对象去创建成员内部类的对象,通过成员内部类对象调用成员内部类的成员

区分同名变量问题（this.）

私有内部类:

一、被private关键字修饰的成员内部类

二、私有内部类中可以直接使用外部类的成员,包括私有的

三、在外部类中通过私有内部类的对象调用私有内部类的成员,包括私有的

四、私有内部类只能在当前外部类中使用,其他类中无法使用

静态内部类：

一是静态内部类中可以定义静态内容

二是在静态内部类中可以直接使用外部类的静态内容,需要通过外部类对象使用外部类的成员

三是在外部类中可以通过静态内部类的类名调用静态内部类的静态内容,可以通过静态内部类的对象调用其成员内容

四是在其他类中可以通过外部类类名找到静态内部类,new 静态内部类对象访问其成员,通过静态内部类类名方法其静态内容

局部内部类 ：

一是局部内部类中可以定义成员内容,不可能定义静态内容除了静态的常量

二是只能在局部内部类所在的方法中通过对象访问成员

三是在局部内部类中可以使用所在方法中的局部变量,可以使用外部类的成员

四是如果在局部内部类中使用所在方法中的局部变量(参数),要求局部变量被final修饰,如果jdk1.8以上版本默认被final修饰

public class Class001_Outer {
    //成员 : 类中方法外
    //成员变量
    private int i = 1;
    static int j = 2;

    //成员内部类
    class Inner{
        //成员变量
        int a = 100;
        static final int b = 200;

        //成员方法
        public void testInner(){
            System.out.println(a);
            System.out.println(b);

            System.out.println(i);
            System.out.println(j);
        }
    }

    //成员方法
    public void outer(){
        Inner  in = new Inner();
        System.out.println(in.a);
    }
}

public class Class004_Outer {
    private int i = 1;
    private static int j = 2;

    //私有内部类
    private class Inner{
        private int a = 100;
        private static final int b = 200;

        public void test(){
            System.out.println("私有内部类的成员方法");
            System.out.println(a);
            System.out.println(b);

            System.out.println(i);
            System.out.println(j);
        }
    }

    //外部类的成员方法
    public void outer(){
        Inner in = new Inner();
        System.out.println(in.a);
        in.test();
    }
}

public class Class005_Outer {
    private int i = 1;
    private static int j = 2;

    //静态内部类
    static class Inner{
        int a = 100;
        static int b = 200;

        //成员方法
        public void test(){
            System.out.println(b);
            System.out.println(a);

            System.out.println(j);
            System.out.println(new Class005_Outer().i);
        }

        //静态方法
        public static void testStatic(){
            Inner in = new Inner();
            System.out.println(in.a);

            System.out.println(b);

            System.out.println(new Class005_Outer().i);
            System.out.println(j);
        }
    }

    //外部类的成员方法
    public void outer(){
        System.out.println(Inner.b);
        Inner.testStatic();

        new Inner().test();
    }
}
 

public class Class006_Outer {
    String str = "外部类str";
    public void test(int i){
        //局部
        //int i = 1;

        //局部内部类
        class Inner{
            int a = 100;
            static final int b = 200;

            public void testInner(){
                System.out.println("局部内部类的成员方法");
                System.out.println(i);
                System.out.println(str);
            }
        }

        //i = 6;
        System.out.println(Inner.b);
        Inner in = new Inner();
        System.out.println(in.a);
    }

}