内部类

package com.royal.summer.test;

/**
 * <p>
 * AnonymousInner 匿名内部类(内部类中使用较多的一种，一般用于监听事件)
 * </p>
 *
 * @author zpf
 * @since 2020-06-03
 */
public class AnonymousInner {

    public static int bean = 100;

    public static void main(String[] args) {

        Thread thread = new Thread(){
            @Override
            public void run() {
                int count = 0;
                for (int i = 0; i < 100; i++) {
                    if (AnonymousInner.bean > 0) {
                        count++;
                        AnonymousInner.bean--;
                        System.out.println("(Thread1)当前剩余bean:" + AnonymousInner.bean);
                    }
                }
                System.out.println("运行次数:" + count);
            }
        };

        Thread thread2 = new Thread(){
            @Override
            public void run() {
                int count = 0;
                for (int i = 0; i < 100; i++) {
                    if (AnonymousInner.bean > 0) {
                        count++;
                        AnonymousInner.bean--;
                        System.out.println("(Thread2)当前剩余bean:" + AnonymousInner.bean);
                    }
                }
                System.out.println("运行次数:" + count);
            }
        };

        thread.start();

        thread2.start();
    }
}

package com.royal.summer.test;

/**
 * <p>
 * InnerClass 成员内部类
 * 1. 成员内部类与外部类的关系类似于父类与子类的关系(继承)，成员内部类可以访问外部类的成员属性(包括private属性)
 * 2. 成员内部类的创建需要依赖于外部类
 * 3. 当成员内部类中存在某个成员属性和外部类中的某个成员属性相同时，（外部类的成员属性）会发生隐藏，也就是说，默认访问的是自身的成员属性。
 *    如果一定要访问外部类的成员属性，需要通过 (外部类.this.成员属性)的方法来实现
 * 4. 外部类访问成员内部类的成员属性时，通过（new Inner().成员变量）的方式，需要注意的是，外部类也可以访问成员内部类中private修饰的成员属性
 * </p>
 *
 * @author zpf
 * @since 2020-06-03
 */
// 外部类Outer
public class Outer {

    private int a = 99; // 外部类的私有属性

    // 内部类Inner
    public class Inner{
        public int a = 80;
        private int b = 2; // 内部类的成员属性
        protected int c = 20;


        public void test(){
            System.out.println("访问外部类中的a：" + Outer.this.a);
            System.out.println("访问内部类中的b：" + b);
        }
    }

    public void access_inner(){ // 此方法不能使用static修饰，否则new Inner().b会报错
        System.out.println("b:" + new Inner().b);
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.access_inner();
        Inner inner = outer.new Inner();
        inner.test();
    }
}

package com.royal.summer.test;

/**
 * <p>
 * LocalInner 局部内部类（定义在方法或者作用域中的类）
 * </p>
 *
 * @author zpf
 * @since 2020-06-03
 */
public class LocalInner {

    public void show(){
        final int a = 25;
        int b = 13;
        class MInner{ // 此处不能写public private protected static等修饰符
            int c = 2;
            public void print(){
                System.out.println("访问外部类方法中的常量a:" + a);
                System.out.println("访问内部类中的变量c：" + c);
            }
        }
        MInner mInner = new MInner();
        mInner.print();
    }

    public static void main(String[] args) {
        LocalInner localInner = new LocalInner();
        localInner.show();
    }
}

package com.royal.summer.test;

/**
 * <p>
 * StaticInner 静态内部类 暂时不清楚什么地方需要使用
 * </p>
 *
 * @author zpf
 * @since 2020-06-03
 */
public class StaticInner {

    public static String name = "张三";

    public static class Inner{
        public static String name="李四";
        public void show(){
            System.out.println("外部类name:" + StaticInner.name);
            System.out.println("内部类name:" + name);
        }
    }

    public static void main(String[] args) {
        Inner inner = new Inner();
        inner.show();
    }
}