Java - static关键字 + 内部类

static : 可以用来修饰 方法, 变量, 静态内部类, 静态代码块, 静态导包

1. 静态方法 : 可以通过类名直接访问,因此也就不能使用 this 关键字 ,也不能直接访问非静态方法和变量
2. 静态变量 : 可以通过类名直接访问,被所有对象共享,在内存只有一个副本,在类初次加载的时候初始化
3. 静态代码块 : 一个类中可以有多个,块中不能访问非静态方法和变量,在类初次加载的时候顺序执行一次,优先级>非静态代码块
4. 静态导包 : 用 import static 代替 import, jdk 1.5 中新特性
   1. 用法 import static com.ruojian.Demo.* : 导入Demo 类中静态方法,之后可以直接使用
   2. 可以简化一些操作 System.out.println(…) 可以写成 直接print(…)就可以了

内部类 :

1. 静态内部类 : 用 static 修饰的内部类, java 中唯一的静态类,(public、protected、默认、private)
   1. 可以包含静态和非静态成员,
   2. 可以访问外部类私有成员
   3. 在非外部类中不能访问私有成员
   4. 不可访问外部类的实例成员, 即使实例方法也不能访问外部类的示例成员, 只能访问外部静态成员
   5. 外部类可以通过创建静态内部类实例来调用静态内部类的非静态属性和方法
   6. 外部类可以通过 "外部类.内部类.属性/方法" 直接调用静态内部类的静态属性和方法
   7. 在非外部类中创建 : 外部类名.内部类名 name = new 外部类名.内部类名();
   8. 在外部类中创建 : 内部类名 name = new 内部类名();
2. 成员内部类 :
   1. 不能包含静态成员
   2. 可以访问外部所有成员包括私有
   3. 在非外部类中不能访问私有成员
3. 局部内部类 : 是定义在一个成员方法中的类
   1. 无法在外部创建局部内部类的对象
   2. 不能使用任何的访问修饰符
   3. 会生成两个 class 外部 Outer.class , 内部 Outer$LocalInner.class
   4. 局部内部类访问的局部变量需要 final 修饰 编译前 貌似直接调用 运行也不报错( jdk 8 )
   5. 编译前 貌似直接调用 运行也不报错( jdk 8 )
   6. 编译后 自动被 final 修饰 
4. 匿名内部类 : 使用时必须继承一个父类或者实现一个接口
   1. 创建方法 :  new 父类构造器（参数列表）|实现接口（）  {  //匿名内部类的类体部分 }
   2. 匿名内部类中不能定义构造函数
   3. 不能有静态成员
   4. 属于局部内部类,局部内部类的限制对匿名内部类生效
   5. 不能是抽象的,必须实现 继承的类或者实现的接口中所有的抽象方法
5. 内部接口 : 默认 static 修饰
6. 内部类小结 :
   1. 编译完后会生成 Outer.class和 Outer$Inner.class 两个类 Outer : 外部类 Inner : 内部类
   2. 每个内部类都能独立实现接口, 无论外部类是否实现了这个接口
   3. 方便将存在一定逻辑关系的类组织在一起,又可以对外界影藏,可以完成多继承机制
   4. 内部类访问外部成员是时,当内部类拥有和外部类相同的成员时,会影藏外部类成员,默认访问内部类成员,访问外部成员 : 外部类.this.成员
7. 接口 : 默认 public static 修饰, 属性默认 public static final 修饰
   1. 如果可以定义非 final 变量的话,而方法又是 abstract 修饰的,变量的修改就需要实现类来完成,这样不符合接口设计的初衷(接口就像合同,规定了实现类来做什么事)
   2. static 修饰属性,未来子类的 static 也能访问到,可以最大程度上发挥接口属性的功能

package com.qiouou.api.controller.demo;

/**
 * @Classname LiuYin
 * @Date 2021/6/18 15:54
 * @Description
 */
public class InteriorDemo implements Demo.E { // Cyclic inheritance involving 'com.qiouou.api.controller.demo.InteriorDemo'
                                              // 循环继承涉及'com. qiou.api.controller.demo.interiordemo '
                                              // 不能实现自己的内部接口 可以实现别人的内部接口

    //内部类可以访问到 私有成员
    private static int interiorA = 0;
    private int interiorB = 0;
    public int same = 0;

    /**
     * 外部静态方法
     * @param args
     */
    public static void main(String[] args) {
        //在其他类中创建静态内部类
        InteriorDemo.A aBean2 = new InteriorDemo.A();
        aBean2.a_fun2();

        //类名直接访问静态内部类静态成员
        int a = A.a;

        //外部类可以访问内部类私有成员
        A.a_fun1(); // private
        A.a_fun3();

        //创建静态内部类对象访问其非静态成员
        A aBean1 = new A();

        //外部类可以访问内部类私有成员
        aBean1.a_fun2(); // private
        aBean1.a_fun4();

        //创建非静态内部类对象访问其成员
//        B bBean1 = new B(); //静态方法中不能直接创建非静态内部类对象
        //先要创建外部类对象,创建别人的内部类对象时同样
        InteriorDemo interior = new InteriorDemo();
        B bBean2 = interior.new B();
        bBean2.b_fun();
        bBean2.b_fun5();

        int size = 0;
        int age = 1;
        bBean2.b_fun6(size, age);
    }

    /**
     * 外部非静态方法
     */
    public void interiorFun() {
        //在其他类中创建静态内部类
        InteriorDemo.A aBean2 = new InteriorDemo.A();
        aBean2.a_fun2();

        //类名直接访问静态内部类静态成员
        int a = A.a;
        A.a_fun1();

        //创建静态内部类对象访问其非静态成员
        A aBean1 = new A();
        aBean1.a_fun2();

        //创建非静态内部类对象访问其成员
        B bBean1 = new B(); //非静态方法中可以直接创建非静态内部类对象
        //先要创建外部类对象,创建别人的内部类对象时同样
        InteriorDemo interior = new InteriorDemo();
        B bBean2 = interior.new B();
        bBean2.b_fun();
    }


    @Override
    public void e_fun1() {
        System.out.println("InteriorDemo.e_fun1");
    }

    /**
     * 静态内部类
     */
    static class A implements C, D { // Demo.E 可以和外部类同时实现接口
        static int a = interiorA; //可以访问外部静态成员
        int error = interiorB;  //不可访问外部非静态成员 Non-static field 'interiorB' cannot be referenced from a static context -不能从静态上下文引用非静态字段“interiorB”
        int b = interiorA; //可以有非静态成员
        private static void a_fun1(){

        }
        public static void a_fun3(){

        }

        private void a_fun2(){

        }
        public void a_fun4(){

        }

        @Override
        public void c_fun1() {

        }
    }

    /**
     * 非静态内部类
     */
    class B implements C, Demo.E {

        @Override
        public void e_fun1() {
            System.out.println("A.e_fun1");
        }

        public int same = 1;
        int a = interiorA; //可以访问外部静态成员
        static int error = interiorA; //Inner classes cannot have static declarations 内部类不能有静态声明
        int b = interiorB; //可以访问外部非静态成员
        private void b_fun(){

        }

        @Override
        public void c_fun1() {

        }

        private void b_fun5(){
            //成员与外部类相同时,会隐藏外部类成员 默认访问内部类成员
            B bBean1 = new B();
            System.out.println(bBean1.same); // 1
            e_fun1(); // A.e_fun1
            //如需访问外部相同成员
            InteriorDemo interior = new InteriorDemo();
            System.out.println(InteriorDemo.this.same); // 0
            InteriorDemo.this.e_fun1(); // InteriorDemo.e_fun1
        }

        private void b_fun6(int size, int age){
            //局部内部类
            class b_fun6{
                void b_fun7(){
                    //貌似参数被内部类直接调用
                    System.out.println(size);
                    System.out.println(age);
                }
            }
            new b_fun6().b_fun7();
        }
    }

    /**
     * 内部接口 默认 static 修饰
     */
    static interface C {
        /**
         * 接口中属性 默认 public static final 修饰
         * 如果可以定义非 final 变量的话,而方法又是 abstract 修饰的
         * 变量的修改就需要实现类来完成,这样不符合接口设计的初衷(接口就像合同,规定了实现类来做什么事)
         * static 修饰属性,未来子类的 static 也能访问到,可以最大程度上发挥接口属性的功能
         */
        public static final int a; //Variable 'a' might not have been initialized  变量“i”可能没有初始化
        int b = 1; //只能存在静态常量

        /**
         * 接口中方法 默认 public abstract 修饰
         *
         */
        public abstract void c_fun1();
    }

    interface D {
    }
}