成员内部类、静态内部类、局部内部类

1. 成员内部类

 成员内部类最重要的特点/成员内部类和外围类的关系:
      成员内部类可以看成外围类的一个成员。
 *      要想得到成员内部类对象，必须先创建外围类对象。
 *      这是因为: 成员内部类对象的成员变量列表中,会持有外围类对象的引用!!!
 *      成员内部类和外围类之间是强依赖关系,成员内部类依赖于外围类,反过来不成立.
 *
 * 除以上关系外,还要铭记(这不是成员内部类独有的特点):
 *      内部类和外围类之间是"好兄弟",它们之间的访问不受权限限制.
 *
 * 明确以上两点,现在来学习一下成员内部类的访问特点
 * 主要从以下四个角度研究：
 *      1.成员内部类内部访问外围类成员(重要)
 *          访问的位置: 成员内部类的成员方法中(没有静态方法)
 *          成员内部类的成员方法中存在几个对象?
 *              首先肯定存在this指向当前对象,所以必然有自身类对象
 *              除此之外还有外围类对象
 *              有两个对象
 *           既然有两个对象,那么访问外围类成员如何访问呢?
 *              直接访问,而且访问不受权限限制.
 *
 *              极端情况下,会出现外围类,成员内部类同名成员变量,那怎么办呢?
 *              语法:
 *              在成员内部类的成员方法中
 *              this指向当前自身对象
 *              外围类类名.this指向外围类对象
 *
 *
 *      2.外围类访问成员内部类成员成员(重要)
 *          访问的位置:
 *              外围类是一个普通类
 *              它有两种访问位置:
 *              成员方法以及静态方法
 *
 *          这两个访问位置是有区别的
 *              1.外围类的成员方法中访问成员内部类成员
 *              这里存在什么对象?
 *              只有this指向当前自身对象
 *              外围类对象并不依赖于成员内部类
 *              所以这里不存在成员内部类对象
 *              所以想要访问它的成员,必须创建它的对象
 *              如何创建呢?
 *              要想得到成员内部类对象，必须先创建外围类对象。
 *              在外围类对象的基础上,再创建成员内部类对象
 *              这里已经存在外围类对象了,所以可以直接创建成员内部类对象.
 *
 *              2.外围类的静态成员方法中访问成员内部类成员
 *              没有任何对象, 没有外围类对象
 *              所以这里不存在成员内部类对象
 *             所以想要访问它的成员,必须创建它的对象
 *                如何创建呢?
 *                要想得到成员内部类对象，必须先创建外围类对象。
 *               在外围类对象的基础上,再创建成员内部类对象
 *               对象创建完毕后,该咋访问就咋访问.
 *
 *      3.外部类访问成员内部类成员(多数情况下访问不到,不重要)
 *      首先访问的全程都要受权限限制
 *      其次外部类中,无论是成员方法还是静态方法
 *      都没有区别
 *
 *      4.成员内部类访问外部类成员(不重要,受权限限制)
 *          可以访问,该咋访问咋访问
 *          受权限限制.

代码：

public class Demo01 {
    public static void main(String[] args) {
        A a = new A();
        a.test1();
        A.test3();
    }
}

class A {
    int a = 1;
    int b = 2;

    //外围类访问内部类的成员
    //成员方法
    public void test1() {
        //    直接new 一个对象
        B b = new B();
        System.out.println(b.a);
        System.out.println(b.b);
    }
    //静态成员方法
    public static void test3(){
        // 先创建外围类的对象
        A a1 = new A();
        B b = a1.new B();
        System.out.println(b.a);
        b.test();
    }

   private class B {
        int a = 10;

        // static int c=90;
        {
            a = 90;
        }

        int b = 45;
        static final int c = 90;

        // public  static void test(){}
        public void test() {
            System.out.println(a);
            System.out.println(b);
            System.out.println(A.this.a);
            System.out.println(A.this.b);
        }


    }

}

成员内部类和外围类是强依赖关系,成员内部类对象会持有外围类对象的引用

2.静态内部类

 * 那么静态内部类和外围类之间,又有什么关系呢?
 * 没有关系
 * 静态内部类和外围类就是独立的两个类,只不过静态内部类借用外围类保护自己
 *
 * 静态内部类仍然定义在类的成员位置,它的语法是:
 * //外围（普通）类
 * [访问权限修饰符] class EnclosedClazz{
 * // 静态内部类访问权限修饰符，有四个，和普通成员一样
 *   [访问权限修饰符] static class NestedClazz{
 *  }
 * }
 *
 * 静态内部类的自身特点
 * 依然主要从以下几个角度分析：
 *      1.访问权限修饰符
 *          和成员内部类一样,有四种访问级别
 *          四种皆可用
 *      2.成员特点
 *          静态内部类就是一个普通类放入另外一个类的类体中
 *          所以它和普通类的成员没有任何区别
 *
 *          从这个角度出发,静态内部类相比较于成员内部类
 *          静态内部类是更灵活的,不受外围类限制,单纯隐藏类
 *
 *      3.继承和实现
 *          可以继承,可以实现,了解即可
 *

public class Demo02 {
    public static void main(String[] args) {
        // 可以近似把静态内部类看成外围类的静态成员
        C.D d = new C.D();
        d.test();
    }
}

class C {
    int a = 90;

    public void test1() {
        D d = new D();
        System.out.println(d.b);
    }

    static class D {
        int a = 12;
        int b = 20;

        public void test() {
            C c = new C();
            System.out.println(c.a);
            System.out.println(a);
        }
        public static void test01(){
            C c = new C();
            System.out.println(c.a);
            System.out.println(new D().a);
            System.out.println(new D().b);
        }
    }

}

3. 局部内部类

* 局部内部类是定义在一个方法或者一个作用域里面的类
 * 简单来说，将局部内部类看成是局部变量即可
 * 该局部内部类的有效范围仅在作用域内部。
 * （这意味着要创建它的对象，必须在作用域内部创建）
 *
 * 从语法和具体使用上看，局部内部类和成员内部类很相似
 * 有点类似于直接把一个成员内部类放进局部位置，语法是：
 *局部内部类语法
 * // 局部位置
 * class Inner{
 * }
 * // 局部位置
 *
 * 局部内部类自身特点
 * 主要从以下几个角度分析：
 *      1.访问权限修饰符
 *          局部内部类的作用范围就仅在大括号内部
 *          它不需要做权限控制
 *          除此之外,它也不能用static修饰
 *          这些都很类似于局部变量
 *
 *      2.成员特点
 *          局部内部类的成员特点和成员内部类完全一模一样
 *          没有static声明,但是可以定义不触发类加载的全局常量
 *
 *      3.继承和实现(重点)
 *          开发中使用局部内部类主要的用途就是
 *          用它继承/实现
* 在说明以下访问特点之前,我们要明确两个点:
 *      1.局部内部类仅在定义它的作用域内部生效,这意味着即便是外围类
 *          也不能任意访问它
 *          只能在作用域内部去访问/使用它
 *
 *      2.内部类和外围类是"好兄弟"的原则,在局部内部类中发生了改变:
 *          局部内部类仍然可以无条件访问外围类(不受限制)
 *          外围类只能在作用域内部访问,作用域之外是不能直接访问这个局部内部类的
 *
 *局部内部类的访问特点，我们仍然主要从以下几个角度研究：
 *      1.局部内部类内部访问外围类(重点)
 *          可以正常访问,并且局部内部类没有静态声明
 *          所以只能在成员方法中访问外围类
 *
 *          (重点)局部内部类处在外围类的不同方法时,效果是不同的:
 *              a.外围类静态方法中的局部内部类
 *                  就是一个单纯的内部类,和外围类对象之间没有任何关系(类似于静态内部类)
 *
 *              b.外围类成员方法中的局部内部类
 *                  这时局部内部类对象,会持有外围类对象的引用,作为它的成员变量(类似于成员内部类)
 *
 *      2.外围类访问局部内部类成员(一般)
 *          在作用域内部创建对象,可以无条件访问
 *          作用域之外不能直接访问局部内部类
 *
 *      3.外部类访问局部内部类成员(了解)
 *          外部类肯定无法直接访问局部内部类
 *      4.局部内部类访问外部类成员(了解)
 *          可以访问,创建对象,受权限限制
 *
 * 以上语法,1是相对比较重要的,但是总体而言,都不是很常用.

public class Demo03 {
    public static void main(String[] args) {
        E e = new E();
        e.test();
        System.out.println("==================");
        E.test03();
    }
}


class E{
    int a=12;
    int b=23;
    //外围类的成员方法中的局部内部类
    public void test(){
        class G{
            int a=45;
            int b=23;
            static final int h=90;
            public void test1(){
                System.out.println(a);
                System.out.println(b);
                System.out.println(E.this.a);
                System.out.println(E.this.b);
            }
        }
        G g = new G();
        g.test1();
    }


//    外围类的静态成员方法
    public static void test03(){
        class G{
            int a=45;
            int b=34;
            //只有this指向当前对象,没有外围类对象
            public void test(){
                System.out.println(a);
                System.out.println(b);
            }
        }
        G g = new G();
        g.test();
    }
}