精华内容
下载资源
问答
  • 如何定义成员内部类那要如何定义成员内部类呢。既然叫成员内部类,说明和成员变量是有类似的地方。从代码的层次结构上来看他是和成员变量处于相同层级的。我们来举个例子。上图代码中,在类OutClass中定义了一个成员...

    JAVA有一个特殊的类形式——内部类(这个词有点为难普通话不好的南方朋友)。今天我们就来聊聊内部类的一种:成员内部类。

    1b82d64bf337e71b19a0c8ee52fd8a21.png

    如何定义成员内部类

    那要如何定义成员内部类呢。

    既然叫成员内部类,说明和成员变量是有类似的地方。从代码的层次结构上来看他是和成员变量处于相同层级的。

    我们来举个例子。

    e280c93b992f2035938c974f29c2c5d0.png

    上图代码中,在类OutClass中定义了一个成员变量name。在OutClass中又定义了一个类InClass,这个InClass是和OutClass的成员变量是同一个层级的,并且是非静态的。像InClass这样的类,我们就称之为成员内部类。

    如何使用内部类

    那这种定义在一个类中的内部类要怎么使用呢。

    我这里从两个角度来说这个使用的方式。

    第一种是,在外部类(如示例代码OutClass中)使用。下面举个例子。

    82d691de839e941136365ba6e5859559.png

    上图代码中,在OutClass类中,定义了一个InClass的成员变量,这样的内部类使用方式从编码的形式来说和使用其他类是没有什么差别的。

    第二种使用方式是在其他类中使用。也来举个例子。

    fd6912c87f45efc0995be4e2da10f3cd.png

    如图中代码所示,要在其他的类中使用内部类,是需要通过外部类的对象才行,因为这个内部类是外部类对象的成员。

    不过在其他类中想要这么使用内部类的前提是,内部类定义的访问权限是可以让外部访问才行,我们试试吧内部类的访问修饰符改一下。

    98e5f9b770599be44ff022b81b01815d.png

    如上面代码所示,将内部类的访问修饰符改为private之后,在其他类中使用时会因为访问不到而报错。也就是说成员内部类是可以和成员变量一样,隐藏在本类内部而只是暴露一定的功能出去的。

    内部类访问外部类的成员变量、方法

    我们知道一个类中访问本类的成员变量、方法可以通过this关键词来访问。那如果内部类要访问外部类要怎么做呢。像上面例子中外部类的成员变量名和内部类的成员变量名重名会不会有什么问题呢(示例中外部类和内部类都有名为name的成员变量)。废话不多说,上代码。

    14df9cbdc935399350f91f839fbf1f83.png

    如上图代码中,内部类要访问外部类的成员变量或者方法,可以通过“外部类名.this.变量名或方法名”(如代码中的OutClass.this.test()、OutClass.this.name)。并且即便外部类的成员变量或方法是私有的,也是可以访问的。另外内部类和外部类的成员变量名重名是没有问题的。执行验证一下。

    658275232949861db3afcb26df7b7a7d.png

    成员内部类不能有静态变量、方法

    因为成员内部类是作为外部类的对象的成员来使用的,所以成员内部类中是不能有静态变量、方法的。

    d0959e2da67fb1c0723cbe209a75007f.png

    如上图中,我把上面的示例代码中的内部类的变量改成了静态的,会报错。添加了一个静态的方法,也是会报错的。

    静态的内容就到了这里了,砖我已经抛好了,希望引来各位的玉。

    展开全文
  • Java内部类-成员内部类的总结 关于内部类其他系列(目前没更完) 静态内部类 内部类我推荐大概了解,因为真正的重点不是内部类,我写这些只是为了更好理解 说实话,Java内部类我是理解了很久(2-3天吧),因为经常搞...
  • java内部类之成员内部类、局部内部类和匿名内部类

    千次阅读 多人点赞 2018-07-15 16:13:30
    1、成员内部类。 2、局部内部类(包含匿名内部类)。 成员内部类 定义格式: 修饰符 class 类名称 { 修饰符 class 类名称 { //... } //... } 注意: 内部类使用外部,可以随意访问,但是外部类使用内部类...

    内部类概念

    一个类中包含另外一个类。

    分类

    1. 成员内部类。
    2. 局部内部类(包含匿名内部类)。

    成员内部类

    定义格式:

    修饰符 class 类名称 {
        修饰符 class 类名称 {
            //...
        }
        //...
    }

    注意:

    内部类使用外部,可以随意访问,但是外部类使用内部类要借助内部类的对象。

    使用成员内部类

    两种方法:
    1. 间接方式:在外部类的方法中,使用内部类,然后main只调用外部类的方法。
    2. 直接方式:公式:
    一般类:类名称 对象名 = new 类名称();
    成员内部类:外部内名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

    Body.java含有一个内部类Heart

    public class Body {
    
        private String name;
    
        //外部类方法
        public void methodBody() {
            System.out.println("外部类的方法");
            new Heart().beat();//在外部类方法中使用内部类。 
        }
    
    
        public  class Heart { //成员内部类
            //内部类方法
            public void  beat() {
                System.out.println("心脏跳动");
                System.out.println("我叫:"+name);
            }
        }
    }

    下面分别介绍两种方式访问内部类:

    间接方式访问内部类

    Demo01InnerClass.java

    public class Demo01InnerClass {
        public static void main(String[] args) {
            Body body = new Body();//外部类对象
    
            //通过外部类的对象,调用外部类的方法,里面间接使用内部类Heart
            body.methodBody();

    直接方式访问内部类

    public class Demo01InnerClass {
        public static void main(String[] args) {
            Body body = new Body();//外部类对对象
    
            //外部内名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
            Body.Heart heart = new Body().new Heart();
            heart.beat();
        }
    }

    外部类和内部类变量重名问题

    当外部类的变量和内部类变量重名时,在内部类方法中访问外部类变量的格式是:外部类.this.外部类成员变量名

    public class Outer {
        int number = 10;
    
        public class Inner {
            int number = 20;
    
            public  void methodInner() {
                int number =30;//内部类方法的局部变量
                System.out.println(number);//就近原则
                System.out.println(this.number);
                System.out.println(Outer.this.number);//外部类的成员变量
            }
        }
    }

    30
    20
    10


    局部内部类

    如果类是定义在一个方法内部的,那么这就是一个局部内部类。
    “局部”:只有当前所属的方法才能使用它,出了这个方法外面就不能用了。

    定义格式

    修饰符 class 外部类名称 {
        修饰符 返回值类型  外部类方法名称(参数列表) {
            class 局部内部类名称 {
                //...
            }
        }
    }

    Outer.java含有局部内部类

    public class Outer {
        public void methodOuter() {
    
            class Inner {
                int num = 10;
                public void methodInner() {
                    System.out.println(num);//10
                }
            }
            //这个内部列只有当前所属方法能够访问这个类,出了这个方法就不能用了
            Inner inner = new Inner();
            inner.methodInner();
        }
    }

    DemoMain.java

    public class DemoMain {
    
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.methodOuter();
        }
    }

    结果:
    10

    注意:

    局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】
    备注:从java 8+开始,只要局部变量事实不变,那么final关键字可以省略。
    原因:
    1. new 出来的对象在堆内存当中。
    2. 局部变量是跟着方法走的,在栈内存当中。
    3. 方法运行结束后,立刻出栈,局部变量就会立刻消失。
    4. 但是new出来的对象在堆当中持续存在,直到垃圾回收消失。

    public class MyOuter {
        public void methodOuter() {
            final int num = 10;//所在方法的局部变量
    
            /*在栈中的局部变量可能随着方法结束出栈消失了,但是创建的内部类对象还存在。
            对象使用常量时能直接将常量copy进来,这时就要保证这个常量是不可更改的,也就是final。
            */
            //num = 20;
    
            class MyInner {
                public  void methodInner() {
                    System.out.println(num);
                }
            }
            Inner myinner = new MyInner();
            inner.methodInner();
        }
    }

    修饰内部类的权限

    public > protected > (default) > private
    定义一个类的时候,权限修饰符规则:

    1. 外部类:public / (default)
    2. 成员内部类:都可以写,public > protected > (default) > private
    3. 局部内部类:什么都不能写,但不是de

    匿名内部类

    如果接口的实现类(或者是父类的子类)只需要使用唯一的一次。
    那么这种情况下就可以省略调该类的定义,而改为使用【匿名内部类】。

    匿名内部类定义格式:

    接口名称 对象名 = new 类名或者接口名称() {
        //覆盖重写所有抽象方法
    };

    代表继承了或者实现了该接口的子类对象。

    ==接口MyInterface.java==

    public interface MyInterface {
        void method1();//抽象方法
        void method2();
    }

    ==接口实现类MyInterfaceImp.java==

    public class MyInterfaceImpl implements  MyInterface {
    
    
        @Override
        public void method1() {
            System.out.println("实现类覆盖重写了方法1");
        }
    
        @Override
        public void method2() {
            System.out.println("实现了覆盖重写方法2");
        }
    }

    测试类

    一、一般接口实现方法

    DemoMain.java

    public class DemoMain {
        public static void main(String[] args) {
    //        MyInterface impl = new MyInterfaceImpl();
    //        impl.method();
            }
    }

    匿名内部类实现接口

    DemoMain.java

    public class DemoMain {
        public static void main(String[] args) {
    
            //使用匿名内部类,但不匿名对象,对象名称就叫obj
            MyInterface objA = new MyInterface() {
                @Override
                public void method1() {
                    System.out.println("匿名内部类实现了方法1-A");
                }
                @Override
                public void method2() {
                    System.out.println("匿名内部类实现了方法2-A");
                }
            };
            objA.method1();
            objA.method2();
    
            System.out.println("----------我是分割线----------");
    
            //使用匿名内部类,而且省略了对象名称,也是匿名对象
            new MyInterface() {
                @Override
                public void method1() {
                    System.out.println("匿名内部类实现了方法1-B");
                }
                @Override
                public void method2() {
                    System.out.println("匿名内部类实现了方法2-B");
                }
            }.method1();
        }
    }

    结果:
    匿名内部类实现了方法1-A
    匿名内部类实现了方法2-A
    ----------我是分割线----------
    匿名内部类实现了方法1-B

    匿名内部内应用

    • 实现倒计时5秒。
    public class Demo02_Time {
        public static void main(String[] args) {
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("倒计时5秒");
                }
            },5000);//倒计时5秒
        }
    }

    注意事项:

    对格式进行解析:"new 接口名称 {...};"进行解析

    1. new代表创建对象的动作
    2. 接口名称就是匿名内部类需要实现那个接口
    3. {…}这才是匿名内部类的内容

    注意:

    1. 这个类只需要使用一次。匿名内部类在创建对象时,只能使用唯一一次。
      如果希望多次希望多次创建对象,而且内容一样的话,那么就必须使用单独定义的实现类。

    2. 匿名对象,在调用的时候,只能调用唯一一次。
      如果希望同一个对象,调用多次方法,那么必须给对象取一个名字。

    3. 匿名内部类是省略了【实现类/子类】,但是匿名对象是省略了【对象命名】。

    强调:匿名和匿名对象不是一回事。

    展开全文
  • 根据成员内部类的定义: 首先生成外部类的实例对象 然后生成绑定到外部类实例对象的成员内部类实例对象 外部类实例对象的生成一定要先于成员内部类实例对象的生成 public class InnerClassDemo{ //对于final修饰...

    根据成员内部类的定义:

    1. 首先生成外部类的实例对象
    2. 然后生成绑定到外部类实例对象的成员内部类实例对象

    外部类实例对象的生成一定要先于成员内部类实例对象的生成

    public class InnerClassDemo{
         //对于final修饰的成员变量,说明该变量是只读变量,只能进行一次赋值操作,只能存在以下两种赋值情况,在这两个地方我们必须给它们赋初值。
         //1)声明该成员变量时赋值:
         //  a)如果表达式的值是常量表达式(返回基本类型数据),则编译器编译时就计算出该表达式的值,知道该值,那么编译器就可能会在编译时期优化程序
         //  b)如果不是常量表达式(返回引用类型数据),则编译器编译时,就不知道该值。
         //2)在构造方法中赋值,运行时赋值,则编译器编译时,就不知道该值
    
         //实例成员被默认初始化为0
         int x;
    
         //static final修饰的变量必须被显示初始化,要么在声明时赋值初始化,要么在静态块中初始化。
         //否则,语法错误
         static final int i;
         static int y;//可以不用初始化,系统会默认赋值0
         static final int j=2;
         //静态块,当类被JVM加载到内存时,静态块的静态代码执行。
         static{
              i=1;
              System.out.println("i="+i);
              System.out.println("j="+j);
          }
    
          public static void main(String[] args){
              InnerClassDemo innerclassdemo=new InnerClassDemo();
              InnerClass innerClass=innerclassdemo.new InnerClass();
              System.out.println("innerclassdemo中x和y的默认值分别是是:"+innerclassdemo.x+y);
              System.out.println("innerClass中i="+innerClass.i);
      System.out.println("innerClass中str="+innerClass.str);
              System.out.println("Welcome!");
          }
    
    class InnerClass{
          //1.在成员内部类中,只有编译器在编译的时候赋值号右边是常量表达式(编译时,可以计算出表达式的基本类型值),
          //左边是只读静态常量的情况才可以存在静态只读常量
          //然后编译器把它当做编译器常量来使用,其实说白了就是和这个外部类的实例无关。
          static final int i=50;
          static final String str='s';
    
         //2.以下均不可以
         //2.1虽然static final为只读静态变量,但是是在构造方法中运行时赋值,编译时不知道其值。
         //static final int i;
         //static final String str
         //2.2虽然static final为只读静态变量,但是赋值号右边不是常量表达式(返回引用类型数据),编译时并不知道其引用的实例值。
         //static final String str=new String("");
    
         //3.没有外部类实例,此内部类不需要外部类实例就初始化了变量,与成员内部类的定义相悖。
         //static InnerClass innerClass=new InnerClass();
    
        //4.静态方法中,但是没有外部类实例
        //static void method(){
        //     InnerClass innerClass=new InnerClass();
        //    }
    
     

    综上,其实内部类并不是完全不能出现static这样的修饰的,只要符合第一种情况的就是可以的。

    编译器其实无法区分第二种,第三种情况的,第三种的情况肯定是不行的与内部成员类的定义相驳,所以第二种情况在语法上也被禁止了。

    第三种情况,根据初始化的流程我们知道,在类加载的时候,static变量就必须被显式初始化,那么我们InnerClass成员内部类的实例对象在没InnerClassDemo外部类的实例对象的时候便生成了。这样这个成员内部类就脱离了外部类的掌控,不需要外部类的对象就可以生成内部类的对象,这与成员内部类的定义就相驳了,因为我们知道成员内部类的对象必须是先有外部类的对象才能创建,成员内部类的对象 脱离了其外部类的对象 就不会存在,并且是绑定在一起的,所以成员内部类不可以定义静态变量。

    第四种情况与第三种情况相同原因。

    程序运行结果:
    在这里插入图片描述

    展开全文
  • * 标题:Java内部类[成员内部类、局部内部类、匿名内部类和静态内部类] * * 作者:Nstar * * 时间:2020年3月13日 * * 内容: * * 问:什么是内部类? * 答:在 Java 中,可以将一个类定义在另一个类里面或者一...
    /**
     * 标题:Java内部类[成员内部类、局部内部类、匿名内部类和静态内部类]
     *  * 作者:Nstar
     *  * 时间:2020年3月13日
     *  * 内容:
     *  * 问:什么是内部类?
     * 答:在 Java 中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类。
     */
    public class Test13 {    //测试类,用于测试案例
        public static void main(String[] args) {
             Test_A ts= new Test_A();       //成员内部类实现 ,首先new一个外部类得对象,
             Test_A.Test_B ab = ts.new Test_B();   //得到外部类对象之后可以通过外部类对象创建内部类对象,
            //因为内部类得形成时依赖于外部类。
             ab.spek();   //通过对象调用方法
    
    
            Test_E.Test_F ts_f= new Test_E.Test_F();    //此案例得实现是基于内部静态类实现得
            //因为内部类使用static关键字修饰,所以它的对象创建不需要依赖于外部类
                       ts_f.print_f();   //通过对象调用方法
    
    
            Myintface mi = new Myintface(){    //内部匿名类实现,
    //            语法:new 接口名/类名()
    //            {
    //             匿名内部类的类体
    //             }
                @Override    //  Java注解,不写也可以
                public void fun(){     //重写接口中的fun抽象方法
                    System.out.println("匿名内部类");
                }
            };   //千万不要忘掉分号,因为创建的匿名内部类是一个语句
                       mi.fun();   //通过对象调用匿名内部类的方法
        }
        }
    
    class Test_A{    // [成员内部类案例]
        // Test_A类属于Test_B类的外部类,如果Test_A类去访问Test_B的成员或方法,必须先创建一个成员内部类的对象
        class Test_B{    //Test_A类的内部成员类
            // 此类可以无条件访问Test_A类的方法和成员包括private修饰的方法和成员
            void spek(){    //内部类Test_B的方法
                System.out.println("成员内部类,Test_B类的方法!");
            }
        }
    }
    class Test_C{   //[局部内部类案例]
        void test_c(){  //类Test_C的方法
            class Test_D{  //Test_D属于局部内部类  ,访问权限仅限于test_c方法中
                //局部内部类就像是方法里面的一个局部变量一样,是不能有 public、protected、private 以及 static 修饰符的。
                void test_d1(){     //局部内部类的方法
                    System.out.println("Test_D类的方法!");
                }
            }
        }
    }
    class Test_E{    //[静态内部类案例]
        static class Test_F{     //因为被static修饰后,创建它的对象时不需要依赖于Test_E类,创建对象时不需要先new一个Test_E类的对象
            void print_f(){
                System.out.println("Test_F静态内部类的方法");
            }
        }
    
    }
    interface Myintface{
        void fun();   //记住,Java规定,接口中除了默认方法和静态方法,其它方法全抽象
    }
    
    
    
    
    
    
    展开全文
  • Java中的静态内部类 在定义的内部类前加static修饰符,此时的内部类就是静态内部类。通过一个例子来了解静态内部类都有哪些特点。 public class Outer { //定义一个实例变量和一个静态变量 private int a; ...
  • 1 内部类的概念 内部类是定义在另一个类中的类;下面类B是类A的内部类。即内部类对象引用了实例化该内部对象的外围类对象。 public class A{ class B {} } 2 为什么需要内部类?(来自JAVA核心技术) 内部类方法...
  • 目录成员内部类静态内部类方法内部类完整程序 成员内部类 成员内部类创建对象必须使用外部类对象来创建内部类对象,而不能直接new内部类构造方法的方式创建; //普通成员内部类创建对象,需通过外部类对象进行...
  • 静态内部类内部类的关系 只有内部类才能被声明为静态类,即...如果一个内部类不是被定义成静态内部类,那么在定义成员变量或者成员方法的时候,是不能够被定义成静态的; 总结: 是否能拥有静态成员:静态内部类.
  • 内部类(成员内部类、静态内部类、方法内部类)

    万次阅读 多人点赞 2018-06-05 15:33:35
    一:成员内部类:最常见的内部类就是成员内部类,也称作普通内部类;1、Inner类定义在Outer类的内部,相当于Outer类的成员变量的位置,Inner类可以使用任意访问修饰符,如:public、private、protected等。2、Inner...
  • 成员内部类可以随意使用外部类的成员方法及成员变量,尽管这些类成员被修饰为private.内部类的实例一定要绑定在外部类对象上。 一个内部类可以定义在一个类中,一个方法中甚至一个表达式中。 分类: 内部类分
  • 成员内部类 局部内部类(包含匿名内部类) 成员内部类 定义格式: 修饰符 class 外部类名称 { 修饰符 class 内部类名称 { // .... } // .... } 内部类的class文件命名为:外部类$内部类.class 使用成员内部类 ...
  • 放在一个类的内部的类...一、成员内部类 定义在类内部的非静态类,就是成员内部类。 public class Out { private static int a; private int b; public class Inner { public void print() { System.out...
  • 分四种:成员内部类、局部内部类、静态内部类和匿名内部类。 1、成员内部类: 即作为外部类的一个成员存在,与外部类的属性、方法并列。 注意:成员内部类中不能定义静态变量,但可以访问外部类的所有成员。 public ...
  • 文章目录1、为什么内部类中有static成员时内部类也必须声明为static2、JVM的类加载规则 :3、成员内部类中为什么不能有静态方法和属性4、静态内部类(public static class)和普通内部类(public class)的区别5、Java中...
  • 有些情况下,我们把一个类放在另一个类的内部定义,称为内部类(innerclasses)。 内部类可以使用public、default、protected 、private以及static修饰。而外部顶级类(我们以前接触的类)只能使用public和default修饰...
  • 1.类指外部类,最大的类,修饰符...2.内部类指位于类内部但不包括位于块、构造器、方法内,且有名称的类,修饰符有public,private,protected访问控制符,也可以用static,final关键字修饰,public和private比较简单,...
  • main方法访问普通内部类的例子: //外部类test public class Test { //非静态的外部类成员变量 int num=1; /** * 普通内部类Person * */ class Person{ int age; } public static void main(String...
  • 看了几篇博客关于一般内部类不能有static修饰的变量,在这里记录一下。问题几种解释如下:1.“if you're going to have a static method, the whole inner class has to be static. Without doing...
  • 成员内部类必须先实例化外部类对象然后再实例化成员内部类; 非static的内部类,在外部类加载的时候,并不会加载它,所以它里面不能有静态变量或者静态方法。1、static类型的属性和方法,在类加载的时候就会存在于...
  • 成员内部类和静态内部类

    千次阅读 2014-07-03 04:48:05
    //java内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类。 //其中成员内部类和静态嵌套类需要在外部类中调用。调用的时候比较麻烦,本文主要针对这两种内部类外部调用做分析。 //方法内部类只能在...
  • java的成员内部类不可以定义静态变量,为什么要设计? 以及真的完全不能静态的东西吗? public class InnerClassDemo { class InnerClass{ //1、这样是可以的,这样编译器会在编译的时候就将这种语句变成常量值...
  • Java 内部类分四种:成员内部类、局部内部类、静态内部类和匿名内部类。
  • 内部类其实就是一个类中还包含着另外一个类 如同一个人是由大脑、肢体、器官等身体结果组成...广泛意义上的内部类一般来说包括这四种:成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来了解一下这四种内部
  • 内部类和枚举类

    千次阅读 2021-02-27 14:57:02
    内部类:内部类的定义 :在一个类的内部又定义了一个类,里面的这个类就是内部类。...1、成员内部类1.将内部类,定义在了外部类的成员位置。2.成员内部类,可以使用成员修饰符:public、static等。但是一般也不写,因...
  • Java如何调用内部类的方法

    千次阅读 2021-02-12 13:58:42
    展开全部参阅下段: 《内部类》内部类是指32313133353236313431303231363533e4b893e5b19e31333262353462在一个外部类的内部再定义一个类。...内部类主要有以下几类:成员内部类、局部内部类、静...
  • 静态内部类和成员内部类的区别

    千次阅读 2014-03-24 11:39:39
    如果你不需要内部类对象与其外围类对象之间有联系,那你可以将内部类声明为static。这通常称为嵌套类(nested class)。Static Nested Class是被声明为静态(static)的内部类,它可以不依赖于外部类实例被实例化。...
  • Java讲课笔记16:内部类

    千次阅读 2020-05-12 19:33:41
    文章目录零、本讲学习目标1、掌握成员内部类的使用2、掌握局部内部类的使用3、掌握静态内部类的使用4、掌握匿名内部类的使用一、内部类概述二、成员内部类(Member Inner Class)1、成员内部类定义2、成员内部类说明...
  • 当时只是回答了静态内部类能访问外部类的静态方法,成员内部类能访问外部类的所有方法。然后面试官问我原因我就答不上来了。还是原来看的不仔细,这里具体整理下。 通俗的理解,在一个类里面定义另一个类,这样的类...
  • Java 内部类成员类、局部类、匿名类等

    万次阅读 多人点赞 2016-10-11 17:49:15
    Java各种称呼类详解Java有各种各样类,内部类、嵌套类、成员类、局部类(本地类)、静态类、匿名类、文件类以及这些组合起来的称呼类,成员内部类,成员匿名类,成员嵌套类,本地匿名类等,真是多的不行,但有些其实...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 580,921
精华内容 232,368
关键字:

成员内部类

友情链接: cmake_for_ESP32.rar