精华内容
下载资源
问答
  • java内部修饰

    2017-05-20 02:47:51
    1.内部类与类中的字段,方法一样是内部类的成员,它与前面可以有访问控制符和其他修饰符。  访问控制符:public,protected,默认及private。  注:外部类只能用public修饰或者默认  final,abstract 2....

    1.内部类与类中的字段,方法一样是内部类的成员,它与前面也可以有访问控制符和其他修饰符。

        访问控制符:public,protected,默认及private。

            注:外部类只能用public修饰或者默认

        final,abstract

    2.static修饰符:

    *用static修饰内部类表明用该内部类实际上是一种外部类

        因为它与外部类的实例无关

        static的类是嵌套类,不是内部类

    *static类在使用时:

        实例化static类时,在new前面不需要使用对象实例变量;

        static类中不能不能访问其外部类的非static的字段和方法,即只能访问static成员

        static方法中不能访问非static的域以及方法,也不能够不带前缀的new一个非static的内部类

    展开全文
  • 注意事项一:在内部类中可以随意使用外部类的成员方法以及成员变量。  众所周知,在定义成员方法或者成员变量的时候,可以给其加上一些权限的修饰词,以防止其他类的访问。如在成员变量或者成员方法前面,加上...

    注意事项一:在内部类中可以随意使用外部类的成员方法以及成员变量。

       众所周知,在定义成员方法或者成员变量的时候,可以给其加上一些权限的修饰词,以防止其他类的访问。如在成员变量或者成员方法前面,加上Private 关键字,则其他类就无法调用这个类中的成员方法或则和成员变量。但是,如果这个类有成员内部类,则不受这方面的限制。也就是说,在成员内部类中可以随意引 用外部类的成员方法以及成员变量,即使这些类成员方法或者成员变量被修饰了private。如在成员外部类中定义了一个i变量,并且利用private关 键字来修饰。此时在其他类中是不能够引用这个私有成员变量的。但是这个类的成员内部类的方法中,则不仅可以引用这个外部类的私有变量,而且还可以对其进行 赋值等操作。这个赋值操作对于外部类也是有效的。即成员内部类可以更改外部类中私有变量的值。

      注意事项二:要在外部类中实例化内部类对象的引用。

       如果一个类定义在另外一个类中,成为成员内部类,此时一定要注意,内部类的实例一定要绑定在外部类的实例上。也就是说,要从外部类中初始化一个内部类的 对象,此时内部类的对象就会绑定在外部类的对象上。这跟普通的类有所不同。普通的类,创建完之后,不一定马上需要实例化。在需要用到这个对象的时候,再进 行实例化即可。但是,如果一个类成为另外一个类的成员内部类,则就不同了。必须要在外部类中实例化内部类对象的引用,以实现将内部类的实例绑定在外部类的 实例上。简单的说,就是在定义外部类的时候,如果有成员内部类,那么就不要望了在外部类中利用new关键字来实例化内部类对象的引用。而对于外部类来说, 则可以在需要的时候再进行实例化。如此就可以保证,利用外部类创建对象的同时创建了内部类的对象。从而可以保证内部类的实例绑定在外部类的实例上。

      注意事项三:成员内部类中成员方法与成员变量的私有性。

       作为成员内部类,可以随意引用外部类中的成员变量与成员方法。那么在成员内部类中定义的成员变量,外部类是否也可以随意访问呢?答案是否定的。内部类可 以访问它外部类的成员,但是内部类的成员(如成员变量或者成员方法)只有在内部类的范围之内是可知的,不能够被外部类直接引用。如现在在外部类中定义了一 个变量i,在内部类中定义了另一个变量ii。此时在成员内部类中,可以直接引用这个外部类中的变量i,也可以对其直接进行赋值,如i=5等等。但是在外部 类中,则不能够直接引用内部类中的成员变量。如在外部类中,利用ii=5的赋值语句改变这个变量的值,就属于语法错误,在编译的时候就会出现错误。如果外 部类真的要引用内部类的成员,那也不是不可以。只是不能够进行直接的引用,而是要使用内部类对象引用的方法才能够调用内部类的成员变量。这一点程序开发人 员需要切记。成员内部类与外部类相互访问彼此的成员方法限制是不同的。特别需要注意的是,如果在外部类和非静态方法之外实例化内部对象,则需要使用外部 类.内部类的形式来制定这个对象的类型。这非常的麻烦。为此要尽量避免在外部类和非静态方法之外实例化内部类对象。再者,内部类对象会依赖于外部类对象, 除非已经存在一个外部类对象,否则类中不会出现内部类对象。简单的说,内部类对象与外部类对象之间的关系非常的紧密。有时候即像一对父子(成员内部类可以 随意使用外部类的成员),有时候又像是陌生人(外部类不能够直接使用内部类中的成员)。作为一个出现的程序开发人员,必须要深入了解外部类对象与内部类对 象的关系。因为在实际工作中,在外部类中定义成员内部类还是很常见的。只有了解他们彼此之间的关系,在编写应用程序中,才可以把控好他们。

      注意实现四:使用this关键字获取内部类与外部类对象的引用。

       在外部类和成员内部类中,都可以定义变量。成员内部类可以随意访问外部类中的变量,而外部类不能够直接访问内部类中的变量,只有通过使用内部类对象来引 用内部类的成员变量。不过需要注意的是,在外部类中定义的变量与内部类中定义的变量名字可以相同。也就是说,在外部类中可以定义一个变量i,在内部类中也 可以定义一个变量i。此时新的问题就出来了。由于在内部类中可以随意访问外部类中成员方法与成员变量。但是此时成员内部类与外部类的变量名相同,那么如果 要在内部类使用这个变量i,编译器怎么知道现在需要调用外部类的变量i,还是内部类的变量i呢?

       在实际工作中,应该尽量避免这种情况。即在定义变量名字的时候,内部类中的变量名字尽量不要与外部类中的变量名字相同。但是如果真的发生这种情况的 话,Java编译器还是有手段可以解决这个变量名字的冲突问题。如果在类中的成员内部类中遇到成员变量名字与外部类中的成员变量名字相同,则可以通过使用 this关键字来加以区别。如现在有一个类名字叫做student。而在这个类中又创建了一个成员内部类,名字叫做age。现在在这两个类中各自定义了一 个成员变量i,用来做循环之用。此时如果在成员内部类中调用这个变量,该如何进行区分呢?通常情况下,如果使用this.i 的方式来调用变量,则表示这个变量是成员内部类中定义的变量。而通过使用student.this.i的形式调用变量时表示此时引用的是外部类的成员变 量。也就是说,如果内部类中引用外部类中同名的成员,需要通过外部类迷名字.this.外部类成员名字的方式加以引用。而且,在引用成员内部类自己的定义 的成员时也需要使用this关键字,以加以区别。显然这非常的麻烦。为此笔者仍然要强调一遍,除非有非常特殊的必要,否则的话要尽量避两外部类与成员内部 类中成员变量或者成员方法采用相同的名字。否则的话,会给后续的引用带来很大的麻烦。

       从以上的总结中可以看出,成员内部类与外部类之间的关系确实很复杂。作为一个Java程序开发人员,必须要了解内部类与外部类成员相互之间引用的准则、 内部类对象与外部类对象的关系。在编写代码的时候,尽量避免内部类与外部类中成员变量与成员方法的命名冲突。如果真的发生重名的话,要学会利用this关 键字来消除这个冲突。笔者上面谈的一些注意实现也是一些比较抽象的内容,需要开发人员在实际工作中去领悟。

    展开全文
  • java内部修饰

    千次阅读 2012-11-10 10:20:57
    内部类可以为四种⒈ 静态内部类⒉ 成员内部类⒊ 局部内部类⒋ 匿名内部类几种内部类的共性:A、内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的.class文件,但是前面冠以外部类的类命和$符号。...
    内部类可以为四种⒈ 静态内部类⒉ 成员内部类⒊ 局部内部类⒋ 匿名内部类几种内部类的共性:A、内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的.class文件,但是前面冠以外部类的类命和$符号。B、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的。2、成员内部类:形式如下 class Outer { class Inner{} } 编译上述代码会产生两个文件:Outer.class和Outer$Inner.class。成员内部类内不允许有任何静态声明!下面代码不能通过编译。
     class Inner{ static int a = 10; }能够访问成员内部类的唯一途径就是通过外部类的对象!A、从外部类的非静态方法中实例化内部类对象。 class Outer { private int i = 10; public void makeInner(){ Inner in = new Inner(); in.seeOuter(); } class Inner{ public void seeOuter(){ System.out.print(i); } } }表面上,我们并没有创建外部类的对象就实例化了内部类对象,和上面的话矛盾。事实上,如果不创建外部类对象也就不可能调用makeInner()方法,所以到头来还是要创建外部类对象的。你可能试图把makeInner()方法修饰为静态方法,即static
     public void makeInner()。这样不创建外部类就可以实例化外部类了!但是在一个静态方法里能访问非静态成员和方法吗?显然不能。它没有this引用。没能跳出那条规则!但是如果在这个静态方法中实例化一个外部类对象,再用这个对象实例化外部类呢?完全可以!也就是下一条的内容。B、从外部类的静态方法中实例化内部类对象。 class Outer { private int i = 10; class Inner{ public void seeOuter(){ System.out.print(i);
     } } public static void main(String[] args) { Outer out = new Outer(); Outer.Inner in = out.new Inner(); //Outer.Inner in = new Outer().new Inner(); in.seeOuter(); } }被注释掉的那行是它上面两行的合并形式,一条简洁的语句。对比一下:在外部类的非静态方法中实例化内部类对象是普通的new方式:Inner in = new Inner();在外部类的静态方法中实例化内部类对象,必须先创建外部类对象:Outer.Inner
     in = new Outer().new Inner();C、内部类的this引用。普通的类可以用this引用当前的对象,内部类也是如此。但是假若内部类想引用外部类当前的对象呢?用“外部类名”.this;的形式,如下例的Outer.this。 class Outer { class Inner{ public void seeOuter(){ System.out.println(this); System.out.println(Outer.this); } } }D、成员内部类的修饰符。对于普通的类,可用的修饰符有final、abstract、strictfp、public和默认的包访问。但是成员内部类更像一个成员变量和方法。可用的修饰符有:final、abstract、public、private、protected、strictfp和static。一旦用static修饰内部类,它就变成静态内部类了。3、方法内部类。顾名思义,把类放在方法内。
     class Outer { public void doSomething(){ class Inner{ public void seeOuter(){ } } } }A、方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。B、方法内部类对象不能使用该内部类所在方法的非final局部变量。因为方法的局部变量位于栈上,只存在于该方法的生命期内。当一个方法结束,其栈结构被删除,局部变量成为历史。但是该方法结束之后,在方法内创建的内部类对象可能仍然存在于堆中!例如,如果对它的引用被传递到其他某些代码,并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长,所以内部类对象不能使用它们。下面是完整的例子:
     class Outer { public void doSomething(){ final int a =10; class Inner{ public void seeOuter(){ System.out.println(a); } } Inner in = new Inner(); in.seeOuter(); } public static void main(String[] args) { Outer out = new Outer(); out.doSomething(); } }C、方法内部类的修饰符。与成员内部类不同,方法内部类更像一个局部变量。可以用于修饰方法内部类的只有final和abstract。D、静态方法内的方法内部类。静态方法是没有this引用的,因此在静态方法内的内部类遭受同样的待遇,即:只能访问外部类的静态成员。4、匿名内部类。顾名思义,没有名字的内部类。表面上看起来它们似乎有名字,实际那不是它们的名字。A、继承式的匿名内部类。
     class Car { public void drive(){ System.out.println("Driving a car!"); } } class Test{ public static void main(String[] args) { Car car = new Car(){ public void drive(){ System.out.println("Driving another car!"); } }; car.drive(); } }结果输出了:Driving another
     car! Car引用变量不是引用Car对象,而是Car匿名子类的对象。建立匿名内部类的关键点是重写父类的一个或多个方法。再强调一下,是重写父类的方法,而不是创建新的方法。因为用父类的引用不可能调用父类本身没有的方法!创建新的方法是多余的。简言之,参考多态。B、接口式的匿名内部类。 interface Vehicle { public void drive(); } class Test{ public static void main(String[] args) { Vehicle v = new Vehicle(){
     public void drive(){ System.out.println("Driving a car!"); } }; v.drive(); } }上面的代码很怪,好像是在实例化一个接口。事实并非如此,接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。C、参数式的匿名内部类。class Bar{ void doStuff(Foo f){}}interface Foo{ void foo();}class Test{ static void go(){ Bar b = new Bar();
     b.doStuff(new Foo(){ public void foo(){ System.out.println("foofy"); } }); }}5、静态嵌套类。从技术上讲,静态嵌套类不属于内部类。因为内部类与外部类共享一种特殊关系,更确切地说是对实例的共享关系。而静态嵌套类则没有上述关系。它只是位置在另一个类的内部,因此也被称为顶级嵌套类。静态的含义是该内部类可以像其他静态成员一样,没有外部类对象时,也能够访问它。静态嵌套类不能访问外部类的成员和方法。 class Outer{ static class
     Inner{} } class Test { public static void main(String[] args){ Outer.Inner n = new Outer.Inner(); } }B、方法内部类对象不能使用该内部类所在方法的非final局部变量。因为方法的...而静态嵌套类则没有上述关系。它只是位置在另一个类的内部,因此也被称为...
    
    展开全文
  • 众所周知,在定义成员方法或者成员变量的时候,可以给其加上一些...也就是说,在成员内部类中可以随意引用外部类的成员方法以及成员变量,即使这些类成员方法或者成员变量被修饰了private.如在成员外部类中定义了一个i
    众所周知,在定义成员方法或者成员变量的时候,可以给其加上一些权限的修饰词,以防止其他类的访问。如在成员变量或者成员方法前面,加上Private关键字,则其他类就无法调用这个类中的成员方法或则和成员变量。但是,如果这个类有成员内部类,则不受这方面的限制。也就是说,在成员内部类中可以随意引用外部类的成员方法以及成员变量,即使这些类成员方法或者成员变量被修饰了private.如在成员外部类中定义了一个i变量,并且利用private关键字来修饰。此时在其他类中是不能够引用这个私有成员变量的。但是这个类的成员内部类的方法中,则不仅可以引用这个外部类的私有变量,而且还可以对其进行赋值等操作。这个赋值操作对于外部类也是有效的。即成员内部类可以更改外部类中私有变量的值。(深入理解嵌套类和内部类)
    

    要在外部类中实例化内部类对象的引用。

    如果一个类定义在另外一个类中,成为成员内部类,此时一定要注意,内部类的实例一定要绑定在Java外部类的实例上。(如何在内部类中返回外部类对象)也就是说,要从外部类中初始化一个内部类的对象,此时内部类的对象就会绑定在外部类的对象上。这跟普通的类有所不同。普通的类,创建完之后,不一定马上需要实例化。在需要用到这个对象的时候,再进行实例化即可。但是,如果一个类成为另外一个类的成员内部类,则就不同了。必须要在外部类中实例化内部类对象的引用,以实现将内部类的实例绑定在外部类的实例上。简单的说,就是在定义外部类的时候,如果有成员内部类,那么就不要望了在外部类中利用new关键字来实例化内部类对象的引用。而对于外部类来说,则可以在需要的时候再进行实例化。如此就可以保证,利用外部类创建对象的同时创建了内部类的对象。从而可以保证Java内部类的实例绑定在外部类的实例上。

    成员内部类中成员方法与成员变量的私有性。

    作为成员内部类,可以随意引用外部类中的成员变量与成员方法。那么在成员内部类中定义的成员变量,外部类是否也可以随意访问呢?答案是否定的。内部类可以访问它外部类的成员,但是内部类的成员(如成员变量或者成员方法)只有在内部类的范围之内是可知的,不能够被外部类直接引用。如现在在外部类中定义了一个变量i,在内部类中定义了另一个变量ii.此时在成员内部类中,可以直接引用这个外部类中的变量i,也可以对其直接进行赋值,如i=5等等。但是在外部类中,则不能够直接引用内部类中的成员变量。如在外部类中,利用ii=5的赋值语句改变这个变量的值,就属于语法错误,在编译的时候就会出现错误。如果外部类真的要引用内部类的成员,那也不是不可以。只是不能够进行直接的引用,而是要使用内部类对象引用的方法才能够调用内部类的成员变量。这一点程序开发人员需要切记。成员内部类与外部类相互访问彼此的成员方法限制是不同的。特别需要注意的是,如果在外部类和非静态方法之外实例化内部对象,则需要使用外部类。内部类的形式来制定这个对象的类型。这非常的麻烦。为此要尽量避免在外部类和非静态方法之外实例化内部类对象。再者,内部类对象会依赖于外部类对象,除非已经存在一个外部类对象,否则类中不会出现内部类对象。简单的说,内部类对象与外部类对象之间的关系非常的紧密。有时候即像一对父子(成员内部类可以随意使用外部类的成员),有时候又像是陌生人(外部类不能够直接使用内部类中的成员)。作为一个出现的程序开发人员,必须要深入了解外部类对象与内部类对象的关系。因为在实际工作中,在外部类中定义成员内部类还是很常见的。只有了解他们彼此之间的关系,在编写应用程序中,才可以把控好他们。

    使用this关键字获取内部类与外部类对象的引用。

    在外部类和成员内部类中,都可以定义变量。成员内部类可以随意访问外部类中的变量,而外部类不能够直接访问内部类中的变量,只有通过使用内部类对象来引用内部类的成员变量。不过需要注意的是,在外部类中定义的变量与内部类中定义的变量名字可以相同。也就是说,在外部类中可以定义一个变量i,在内部类中也可以定义一个变量i.此时新的问题就出来了。由于在内部类中可以随意访问外部类中成员方法与成员变量。但是此时成员内部类与外部类的变量名相同,那么如果要在内部类使用这个变量i,编译器怎么知道现在需要调用外部类的变量i,还是内部类的变量i呢?

    在实际工作中,应该尽量避免这种情况。即在定义变量名字的时候,Java内部类中的变量名字尽量不要与外部类中的变量名字相同。但是如果真的发生这种情况的话,Java编译器还是有手段可以解决这个变量名字的冲突问题。如果在类中的成员内部类中遇到成员变量名字与外部类中的成员变量名字相同,则可以通过使用this关键字来加以区别。如现在有一个类名字叫做student.而在这个类中又创建了一个成员内部类,名字叫做age.现在在这两个类中各自定义了一个成员变量i,用来做循环之用。此时如果在成员内部类中调用这个变量,该如何进行区分呢?通常情况下,如果使用this.i 的方式来调用变量,则表示这个变量是成员内部类中定义的变量。而通过使用student.this.i的形式调用变量时表示此时引用的是外部类的成员变量。也就是说,如果内部类中引用外部类中同名的成员,需要通过外部类迷名字。this.外部类成员名字的方式加以引用。而且,在引用成员内部类自己的定义的成员时也需要使用this关键字,以加以区别。显然这非常的麻烦。为此笔者仍然要强调一遍,除非有非常特殊的必要,否则的话要尽量避两外部类与成员内部类中成员变量或者成员方法采用相同的名字。否则的话,会给后续的引用带来很大的麻烦。

    从以上的总结中可以看出,成员内部类与外部类之间的关系确实很复杂。作为一个Java程序开发人员,必须要了解内部类与外部类成员相互之间引用的准则、内部类对象与外部类对象的关系。在编写代码的时候,尽量避免内部类与外部类中成员变量与成员方法的命名冲突。如果真的发生重名的话,要学会利用this关键字来消除这个冲突。笔者上面谈的一些注意实现也是一些比较抽象的内容,需要开发人员在实际工作中去领悟。

    展开全文
  • 访问修饰符(一)

    2017-09-11 12:21:38
    内部类前面可以修饰public,protected和private 局部内部类前面可以修饰public,protected和private 以上说法都不正确 外部类与内部类 1、对于外部类而言,它也可以使用访问控制符修饰,单外部类只能有...
  • 对于隐藏性来说,平时我们对类的访问权限,都是通过类前面的访问修饰符来限制的,一般的非内部类,是不允许有 private 与protected权限的,但内部类可以,所以我们能通过内部类来隐藏我们的信息。可以看下面的例子 ...
  • PHP 中通过在前面添加访问修饰符 public、protected 或 private 来实现对属性或方法...public(公有的):中的成员将没有访问限制,所有的外部成员都可以访问(读和写)这个成员(包括成员属性和成员方法)。如果...
  • php的权限修饰

    2018-09-07 21:51:38
    public 共有的;权限范围最大,所有都可以访问 ...对类外部不允许访问。 说明: 权限修饰符 作用: 用来说明 属性/方法的权限特点 写在 属性/方法前面 共有3个权限修饰符 private 私有的 , 保护的最...
  • static 可以修饰字段和方法,使用static修饰的成员,只能通过类名访问 virtual abstract override sealed protected 如果没有继承的话,protected和private的功能一样,但是有继承的时候, protected的可以在继承...
  • Java--内部,局部与匿名

    千次阅读 2015-08-06 17:48:40
    在其他地方使用必须在new前面冠以外部类对象。 即:外部对象名.new 内部类(参数)2.内部类可以访问外部类的所有成员,包括private属性。3.在内部类中this.方法及字段指向内部类; 外部类.this方法及字段指向外部类4...
  • java内部

    2017-06-18 23:42:02
    内部类如果定义在外部类域的位置,它能被修饰修饰,也就是内部类的类体前面可以被protected或private修饰;但如果内部类定义在方法内,则不能被任何修饰修饰。 (1)内部类可以直接访问外部类中的所有属性,...
  • 内部

    2021-05-21 21:54:20
    内部类(当作类中的一个普通的成员变量,只不过是class属性)... 创建内部类的时候跟之前的方法不一样,需要在内部类的前面添加外部类来进行修饰 InnerClassDemo.InnerClass inner=new InnerClassDemo().new Inner...
  • Java 内部 异常

    2020-07-20 19:19:10
    创建内部类的时候,跟之前的方法不一样,需要在内部类的前面添加外部类来进行修饰 InnerClassDemo.InnerClass inner = new InnerClassDemo().new InnerClass(); 特点: 1、内部类可以方便的访问外部类的私有属性 2、...
  • javase-内部

    2021-01-08 14:36:36
    内部类一、什么是内部类?二、内部类的使用三、 内部类的...创建内部类的时候,与方法使用不同,需要在内部类的前面添加外部类进行修饰。 三、 内部类的特点 1、内部类可以方便的访问外部类的私有属性 2、外部类不能
  • java内部总结

    2016-07-14 16:58:20
    (而外部类可以外部类只能使用public和默认的)。 内部类分为:成员内部类、局部内部类、静态内部类、匿名内部类 几种内部类的共性:A、内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的.class...
  • Java 内部

    2015-09-12 14:52:26
    内部类(Nested Class),嵌套类。内部类介绍 ...内部类仍然是一个独立的类,在编译之后,内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和 $ 符号。此外,内部类可以使用修饰符(public, prot
  • 常用类1①.内部类-成员内部类-静态内部类-局部内部类-匿名内部类②.Object类-getClass()方法 ①.内部类 内部类的分类 成员内部类:将一个类定义在...内部类可以直接访问外部类的私有成员,而不会破坏封装 内部类可
  • 这里写目录标题一、内部类使用:特点:二、接口三、抽象类和接口的区别: ... 创建内部类的时候,跟之前的方法不一样,需要在内部类的前面添加外部类来进行修饰 InnerClassDemo.InnerClass inner = new InnerCla
  • Java内部的访问权限

    2020-07-11 19:44:11
    关于内部类的资料,与大家共享,有不对的欢迎指正。题目说的应该是3.1,定义在方法外部的内部类: 1.内部类中不能定义静态成员 2.内部类可以直接访问外部类中的成员...方法内部定义的内部类前面不能有访问类型修饰
  • java-内部介绍

    2019-05-12 14:23:00
    内部类(Nested Class) 嵌套类: (1)静态内部类 ...内部类仍然是一个独立的类,在编译之后内部类会被单独编译成独立的.class文件,但是前面冠以外部类的类名和$符号。 内部类可以使用修饰符(public...
  • java内部总结

    2013-04-24 20:01:20
    (而外部类可以外部类只能使用public和默认的)。 内部类分为:成员内部类、局部内部类、静态内部类、匿名内部类 几种内部类的共性:A、内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的.class...
  • Java课堂篇8_内部

    2020-11-26 22:03:48
    内部类可以访问外部类的成员变量,包括private修饰的成员变量;内部类的修饰符为public时外界可以访问创建对象,为private则不行 生成的字节码文件为Outer$Inner.class 开始 一、内部类对象 的创建 依赖 外部类...

空空如也

空空如也

1 2 3 4 5 6
收藏数 115
精华内容 46
关键字:

外部类前面可以修饰