精华内容
下载资源
问答
  • 2021-03-15 10:28:12

    内部类:

    ①静态内部类中可以有非静态的方法

    ②当内部类中有静态方法或者静态成员变量时,一定是静态内部类

    一般内部类在外部类的成员变量位置,像这样:

    1 public classOuter {2 classInner{3

    4 }5 }

    1、外部类访问内部类:

    内部类被static修饰:可以直接new

    Inner in = new Inner();

    内部类没有被static修饰:得先new出来外部类的实例,再new内部类的

    Inner in = new Outer().new Inner();

    2、内部类访问外部类:(外部类.this.变量)

    1 public classOuter {2 int x = 9;3 classInner{4 int x = 8;5 public voidtest(){6 int x = 7;7 System.out.println(x);8 System.out.println(this.x);9 System.out.println(Outer.this.x);10 test1();11 }12 }13

    14 private voidtest1(){15 System.out.println("test");16 }17 public static voidmain(String[] args) {18 Inner in = new Outer().newInner();19 in.test();20 }21 }

    输出为:7,8,9,test

    分析:第七行第八行相信大家都没有什么问题,第九行输出的是9,说明访问到了外部类的变量,而输出的test说明内部类访问到了外部类的test1方法

    总结:

    输出是9的原因:因为内部类持有一个外部类的引用,格式:外部类名.this

    可以调用private方法原因是:因为他们在一个类Outer中所以可以调用

    3、外部类和内部类中的方法相互访问:

    ①外部类的静态方法test和非静态内部类的非静态方法voice的相互访问:

    !  test----->voice       先new外类再new内类,再调方法

    1 public classOuterclass {2 classInner{3 public voidvoice(){4 System.out.println("voice()");5 }6 }7 public static voidtest(){8 new Outerclass().newInner().voice();9 }10 public static voidmain(String[] args) {

    //主函数调用test方法11 test();13 }14 }

    输出:voice();

    !!  voice----->test        外类.this.方法(持有的外部类的引用)

    1 public classOuterclass {2 classInner{3 public voidvoice(){4 Outerclass.this.test();5 }6 }7 public static voidtest(){8 System.out.println("test()");9 }10 public static voidmain(String[] args) {

    //主函数调用voice()11 Inner in = new Outerclass().newInner();12 in.voice();13 }14 }

    输出:test();

    ②外部类的非静态方法test和静态内部类中的非静态方法voice之间的相互调用

    ! voice------>test

    1 public classOuterclass {2 static classInner{3 public voidvoice(){4 newOuterclass().test();5 }6 }7 public voidtest(){8 System.out.println("test()");9 }10 public static voidmain(String[] args) {

    //主函数调用voice()方法11 newOuterclass.Inner().voice();12 }13 }

    输出:test();

    !!  test----->voice

    1 public classOuterclass {2 static classInner{3 public voidvoice(){4 System.out.println("voice()");5 }6 }7 public voidtest(){

    //1、其他类访问外部类中的静态内部类的非静态方法8 // newOuterclass.Inner().voice();

    //2、此处的Outerclass中的test方法访问静态内部类中的非静态方法

    new Inner().voice();9 }10 public static voidmain(String[] args) {

    //主函数调用test方法11 newOuterclass().test();12 }13 }

    输出:voice();

    4、总结:

    外部类访问内部类:必须建立内部类的对象

    内部类访问外部类:内部类可以直接访问外部类的成员包括私有成员,因为外部类持有内部类的引用

    特例:内部类写在外部类的方法中(即局部变量的位置)

    1、内部来外部类均可定义变量/常量

    2、只能被final/abstract修饰

    3、只能访问被final/abstract修饰的变量

    4、可以直接访问外部类中的成员,因为还持有外部类的引用

    更多相关内容
  • 内部类与外部类之间的访问

    千次阅读 2022-04-14 17:54:16
    1.内部类与外部类 2.内部类的特点:内部类可以直接访问外部类的成员(成员变量和成员方法),包括私有成员。 3.内部类与外部类之间的访问 在测试类中调用成员内部类中的方法: 外部类访问成员内部类中的成员: 静态...

    目           录

    1.内部类与外部类

    2.内部类的特点:内部类可以直接访问外部类的成员(成员变量和成员方法),包括私有成员。

    3.内部类与外部类之间的访问

    在测试类中调用成员内部类中的方法:

     外部类访问成员内部类中的成员:

    静态的成员内部类,只能访问外部类的静态成员

    私有的成员内部类,外界就无法直接创建其对象,可以通过外部类的方法访问

     局部内部类,在外界没有直接创建其对象的语法

    局部内部类访问外部类的局部变量:


    1.内部类与外部类

    将一个类A 定义到另一个类B的内部,那么类A叫做内部类,类B叫做外部类。

    根据内部类在外部类中定义的位置不同,分为 成员内部类,和局部内部类

    • 成员内部类: 定义在外部类的成员位置。
    • 局部内部类: 定义在外部类的局部位置,也就是外部类中的方法内部。
    class B {           //B是外部类
       
        class A {       //A是成员内部类
    
        }
    
        public void show() {
            
            class C {    //C是局部内部类
    
            }
        }
    
    }

    2.内部类的特点:内部类可以直接访问外部类的成员(成员变量和成员方法),包括私有成员。

    
    package org.xingyun.interface1;
    
    public class Wai {           //外部类
        int num = 20;
        private int a = 60;
    
        //成员内部类
        public class Nei {
            public void neiShow() {
                System.out.println("内部类的show方法");
                //内部类的特点:内部类可以直接访问外部类的成员,包括私有成员。
                System.out.println(num);              //外部类的成员变量
                System.out.println(a);                //外部类的私有变量
                waiShow();                            //外部类的成员方法
                hehe();                               //外部类的私有方法
            }
        }
    
        public void waiShow() {
            System.out.println("外部类的show方法");
        }
    
        private void hehe() {
            System.out.println("外部类的私有方法");
        }
        
    }
    

    如果外部类与内部类的成员有重名的话 ,可以这样拿到外部类的成员:外部类名.this.变量名(其中 Outer.this 表示外部类对象)

    class Outer {
        //外部类的成员变量
        public int num = 10;
    
        class Inner {
            //内部的成员变量
            public int num = 20;
    
            public void show() {
                //局部变量
                int num = 30;
                System.out.println(num);      //30(就近原则)
                System.out.println(this.num); //20(内部类的变量)
    
                System.out.println(Inner.this.num); //20(内部类的变量,也可以这样取到)
               
                System.out.println(new Outer().num); //10(创建了一个外部类的对象去取变量)这样太繁琐了
                // 可以这样Outer.this.num .   (Outer.this 表示外部类对象)
                System.out.println(Outer.this.num);  //10
     
            }
        }
    }

    3.内部类与外部类之间的访问

    在测试类中调用成员内部类中的方法:

    需要先创建成员内部类的对象的语法格式:外部类名.内部类名 对象名 = new 外部类名().new 内部类名();

     class Wai {       //外部类
         private int a=100;
        //成员内部类
        public class Nei {
    
            public void neiShow() {
                System.out.println("内部类的show方法" );
            }
        }
    
        public void waiShow() {
            System.out.println("外部类的show方法");
        }
    }
    
    
    public class Test {
        public static void main(String[] args) {
            //在测试类里面,调用内部类的方法
            //创建成员内部类的对象    外部类名.内部类名 对象名 = 外部类对象.内部类对象
            Wai.Nei nei = new Wai().new Nei();
            nei.neiShow();
            System.out.println("====================================");
            //内部类可以直接访问外部类的成员,包括私有成员。
            Wai wai = new Wai();
            wai.waiShow();
        }
    }
    //执行结果:
    /*
    内部类的show方法
    ====================================
    外部类的show方法
     */

     外部类访问成员内部类中的成员:

    需要先创建成员内部类的对象:     内部类名 对象名 =new 内部类名();

    public class Wai {        //外部类
    
        //成员内部类
        public class Nei {
            //内部类的成员变量
            int n = 5;
            int x = 100;
    
            //内部类的成员方法
            public void neiShow() {
                System.out.println("内部类的show方法");
            }
        }
    
        public void waiShow() {
            System.out.println("外部类的show方法");
        }
        //外部类访问内部类的成员
        public void test() {
            //创建内部类对象
            Nei nei = new Nei();
            //访问内部类的成员变量
            System.out.println(nei.n);
            System.out.println(nei.x);
            //访问内部类的成员方法
            nei.neiShow();
            
            //直接访问外部类成员
            waiShow();
        }
    }
    

    静态的成员内部类,只能访问外部类的静态成员

    静态的成员内部类,创建对象的语法: 外部类名.内部类名 对象名 = new 外部类名.内部类名();

    public class Test {
        public static void main(String[] args) {
            //静态的成员内部类,创建对象的语法
            Wai.Nei nei = new Wai.Nei();
            nei.neiShow();
            //静态的成员内部类,只能访问外部类的静态成员。
        }
    }
    
    
     class Wai{
        static int num = 100;
    
        //static 也可以修饰内部类
        public static class Nei {
            public void neiShow() {
                //静态的成员内部类,只能访问外部类的静态成员。
                System.out.println(num);
            }
        }
    }

    私有的成员内部类,外界就无法直接创建其对象,可以通过外部类的方法访问

    public class privateNei {
        public static void main(String[] args) {
            //私有的成员内部类,外界就无法创建其对象了
            //通过外部类的方法访问
            Outer outer = new Outer();
            outer.waiShow();
        }
    }
    
    class Outer {     //外部类
        //内部类可以私有修饰
        private class Inner {        //成员内部类
            public void neiShow() {
                System.out.println("nei show");
            }
        }
    
        public void waiShow() {
            //可以外部类访问内部类,创建内部类对象
            Inner inner = new Inner();
            inner.neiShow();
        }
    }

     局部内部类,在外界没有直接创建其对象的语法

    public class Test {
        public static void main(String[] args) {
            //局部内部类,在外界没有直接创建其对象的语法。通过外部类方法访问
            Wai wai = new Wai();
            wai.waiShow();
        }
    }
    
    class Wai {
        int num = 20;
        private double a = 3.5;
    
        public void waiShow() {
            //局部内部类
            class Nei {
                int t = 50;
    
                public void neiShow() {
                    System.out.println(num);
                    System.out.println(a);
                }
            }
            //创建局部内部类对象
            Nei nei = new Nei();
            nei.neiShow();
        }
    }

    局部内部类访问外部类的局部变量:

    局部内部类访问外部类的局部变量,局部变量必须用final修饰,使之成为常量.

    为什么呢? 因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。为了让数据还能继续被使用,就用final修饰,这样,在堆内存里面存储的其实是一个常量值。(JDK1.8之后,final会默认加上)

    class Outer {
        public void waiShow(final int a) {
            //局部变量
            final int num = 20; 
    
            //定义局部内部类
            class Inner {
                public void neiShow() {
                    //局部内部类,要访问外部类的局部变量,局部变量,必须用final修饰,使之成为常量
                    System.out.println(num);    //20
                    System.out.println(a);      //20
                }
            }
        }
    }

    (小编也在努力学习更多哟!以后会多多分享哒!)  

    希望对友友们有所帮助!!!

    展开全文
  • java内部类 和外部类的区别

    千次阅读 2021-03-07 00:47:13
    下面说一说内部类(Inner Class)和静态内部类(Static Nested Class)的区别:定义在一个类内部的类叫内部类,包含内部类的类称为外部类。内部类可以声明public、protected、private等访问限制,可以声明 为abstract的...

    下面说一说内部类(Inner Class)和静态内部类(Static Nested Class)的区别:

    定义在一个类内部的类叫内部类,包含内部类的类称为外部类。内部类可以声明public、protected、private等访问限制,可以声明 为abstract的供其他内部类或外部类继承与扩展,或者声明为static、final的,也可以实现特定的接口。外部类按常规的类访问方式使用内部 类,唯一的差别是外部类可以访问内部类的所有方法与属性,包括私有方法与属性。

    (1)创建实例

    OutClass.InnerClass obj = outClassInstance.new InnerClass(); //注意是外部类实例.new,内部类

    AAA.StaticInner in = new AAA.StaticInner();//注意是外部类本身,静态内部类

    (2)内部类中的this

    内 部类中的this与其他类一样是指的本身。创建内部类对象时,它会与创造它的外围对象有了某种联系,于是能访问外围类的所有成员,不需任何特殊条件,可理 解为内部类链接到外部类。 用外部类创建内部类对象时,此内部类对象会秘密的捕获一个指向外部类的引用,于是,可以通过这个引用来访问外围类的成员。

    (3)外部类访问内部类

    内部类类似外部类的属性,因此访问内部类对象时总是需要一个创建好的外部类对象。内部类对象通过‘外部类名.this.xxx’的形式访问外部类的属性与方法。如:

    System.out.println("Print in inner Outer.index=" + pouter.this.index);

    System.out.println("Print in inner Inner.index=" + this.index);

    (4)内部类向上转型

    内部类也可以和普通类一样拥有向上转型的特性。将内部类向上转型为基类型,尤其是接口时,内部类就有了用武之地。如果内部类是private的,只可以被它的外部类问,从而完全隐藏实现的细节。

    (5)方法内的类

    方法内创建的类(注意方法中也能定义类),不能加访问修饰符。另外,方法内部的类也不是在调用方法时才会创建的,它们一样也被事先编译了。

    (6)静态内部类

    定义静态内部类:在定义内部类的时候,可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。

    通常称为嵌套类,当内部类是static时,意味着:

    [1]要创建嵌套类的对象,并不需要其外围类的对象;

    [2]不能从嵌套类的对象中访问非静态的外围类对象(不能够从静态内部类的对象中访问外部类的非静态成员);

    嵌 套类与普通的内部类还有一个区别:普通内部类的字段与方法,只能放在类的外部层次上,所以普通的内部类不能有static数据和static字段, 也不能包含嵌套类。但是在嵌套类里可以包含所有这些东西。也就是说,在非静态内部类中不可以声明静态成员,只有将某个内部类修饰为静态类,然后才能够在这 个类中定义静态的成员变量与成员方法。

    另外,在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。普通非静态内部类的 对象是依附在外部类对象之中的,要在一个外部类中定义一个静态的内部类,不需要利用关键字new来创建内部类的实例。静态类和方法只属于类本身,并不属于 该类的对象,更不属于其他外部类的对象。

    (7)内部类标识符

    每个类会产生一个.class文件,文件名即为类名。同样,内部类也会产生这么一个.class文件,但是它的名称却不是内部类的类名,而是有着严格的限制:外围类的名字,加上$,再加上内部类名字。

    (8)为何要用内部类?

    1.   内部类一般只为其外部类使用;

    2.   内部类提供了某种进入外部类的窗户;

    3.   也是最吸引人的原因,每个内部类都能独立地继承一个接口,而无论外部类是否已经继承了某个接口。因此,内部类使多重继承的解决方案变得更加完整。

    加深印象,参考一下:

    packagecom.test.xml;

    publicclassOutClassTest{

    staticinta;

    intb;

    publicstaticvoidtest(){

    System.out.println("outer class static function");

    }

    publicstaticvoidmain(String[]args){

    OutClassTestoc =newOutClassTest();

    // new一个外部类

    OutClassTestoc1 =newOutClassTest();

    // 通过外部类的对象new一个非静态的内部类

    OutClassTest.InnerClassno_static_inner =oc1.newInnerClass();

    // 调用非静态内部类的方法

    System.out.println(no_static_inner.getKey());

    // 调用静态内部类的静态变量

    System.out.println(OutClassTest.InnerStaticClass.static_value);

    // 不依赖于外部类实例,直接实例化内部静态类

    OutClassTest.InnerStaticClassinner =newOutClassTest.InnerStaticClass();

    // 调用静态内部类的非静态方法

    System.out.println(inner.getValue());

    // 调用内部静态类的静态方法

    System.out.println(OutClassTest.InnerStaticClass.getMessage());

    }

    privateclassInnerClass{

    // 只有在静态内部类中才能够声明或定义静态成员

    // private static String tt = "0";

    privateintflag =0;

    publicInnerClass(){

    // 三.非静态内部类的非静态成员可以访问外部类的非静态变量和静态变量

    System.out.println("InnerClass create a:"+a);

    System.out.println("InnerClass create b:"+b);

    System.out.println("InnerClass create flag:"+flag);

    //

    System.out.println("InnerClass call outer static function");

    展开全文
  • java中的外部类和内部类 | 学步园

    千次阅读 2021-02-12 14:20:49
    1.概念外部类:这是一个相对内部类的概念,如果一个类中嵌套了另外一个类,我们就把这个类叫做外部类。内部类:顾名思义,就是定义在里边的那个类。 见以下代码:定义了一个类Outer,在Outer内中一定了私有成员变量x...

    1.概念

    外部类:这是一个相对内部类的概念,如果一个类中嵌套了另外一个类,我们就把这个类叫做外部类。

    内部类:顾名思义,就是定义在里边的那个类。  见以下代码:

    f2384e17e6b2930846357aeb783ea974.png

    定义了一个类Outer,在Outer内中一定了私有成员变量x ,成员方法show()和一个内部类 Inner  ; Inner类和普通类一样也有一个成员变量 x 和成员方法 method

    2.访问规则

    1. 内部类可以直接访问外部类中的成员

    2.外部类访问内部类有两种方式:

    第一种方式: 在主函数中直接用创建内部类对象的方式 , 如  :  Outer out = new Outer();

    Outer.Inner in = out.new Inner();

    这种方式通常不会用到,不建议使用

    第二种方式:   在外部类方法中创建内部类对象;

    在主函数中创建外部类对象,直接调用外部类方法 。 见以下代码 :

    613826c585672bb6371e436b637f87b9.png

    3.访问内部类中的成员变量。

    思考一个问题,上边的代码中,打印出来的 x 的值是几 ?

    没错,是 6  . 再看看以下的代码

    3cf0c749e7b3ce5bd4632a16d6777ef0.png

    定义了一个局部变量, 问 现在打印的x 的值是多少了 ?

    答案是 4 。

    这说明了什么 ?

    如果 x 前面什么都没有,那么内部类中方法访问的是局部变量 ; 如果没有局部变量的,就访问 类中的成员变量 x  .

    再来看看以下的代码 : 继续思考 打印的x值会是多少

    c26a722718e282f6dd3b5ccafa4d6ab5.png

    这时候就变成 3 了 , 所如果要访问外部成员变量 要加上 Outer.this   。

    注: 当然,就想Inner类中如果没有局部变量 x ,即使不加也无所谓程序打印的一样是 6 ,也就是说 如果没有局部变量x Inner类中也没有成员变量x ,这个时候即便 x 前边什么也不加访问的也是 外部的 x 值3 了  。 见代码所示 :

    dcec14b9d284dd52fd1fd8c2662e9585.png

    7a5ef674cbe971354bd5c529764242f5.png

    展开全文
  • 注意:在内部类构造的时候,会将外部类的引用传递进来,并且作为内部类的一个属性,所以内部类会持有一个其外部类的引用。当内部类调用外部类的私有属性时,其真正的执行是调用了编译器生成的属性的静态方法(即acess...
  • java内部类引用外部类中方法解析

    千次阅读 2021-02-12 14:20:50
    内部类引用外部类方法,逻辑有些绕。1.内部类生成对外部类对象的引用外部类名称+.this;2.外部类提供实例化内部类的方法,因为拥有外部类对象之前是不能创建内部类对象的,内部类对象会暗暗地连接到创建她的外部类...
  • 外部类可以调用内部类方法吗?

    千次阅读 2021-02-12 14:20:49
    外部类可以通过创建外部对象来创建内部对象再调用内部方法class Outer{ // 定义外部类private String info = "hello world" ; // 定义外部类的私有属性class Inner{ // 定义内部类public void print(){ // 定义内部...
  • 做Android的,或者做Java开发的同学,通常都会听到一句话,内部类持有外部类的引用,可能会导致父类内存泄漏? 知道大家很忙,那就先把结论抛出来 Java中内部类会持有外部类的引用,可能引发内存泄漏 Kotlin存在...
  • Java内部类、外部类之间访问权限

    千次阅读 2020-08-24 19:07:07
    Java内部类、外部类之间访问权限啥是内部类内部类可以访问外部类的所有成员吗那外部类能访问内部类的所有成员吗静态内部类呢 啥是内部类 顾名思义,内部类就是在一个类中定义了另一个类,比如在类A中定义了一个类B,...
  • 问题1:内部类为什么会持有外部类的引用 这是因为内部类虽然和外部类写在同一个文件中,但是编译后还是会生成不同的class文件,其中内部类的构造函数中会传入外部类的实例,然后就可以通过this$0访问外部类的成员。...
  • 首先解释一下什么是内部类,内部类是定义在一个类内部的类。... 静态内部类虽然也定义在外部类的里面, 但是它只是在形式上(写法上)和外部类有关系, 其实在逻辑上和外部类并没有直接的关系。而一般的内部类...
  • 后者更明确,如果内部类中存在相同的名称,则可以调用外部类方法。class OuterClass {void foo() { System.out.println("Outer foo"); }View.OnClickListener mListener1 = new View.OnClickListener() {void foo() ...
  • 内部类和外部类

    千次阅读 多人点赞 2019-04-10 21:13:34
    外部类: 最普通的,我们平时见到的那种类,就是在一个后缀为.java的文件中,直接定义的类,比如 public class Student { private String name; private int age; } 内部类: 内部类,顾名思义,就是包含在外部类...
  • 内存泄漏-内部类持有外部类引用

    千次阅读 2019-11-25 00:28:45
    1.内部类持有外部类引用 我们在处理Android内存泄漏的时候,经常会遇到一些是由于内部类持有外部类引用而引发的。严格来说是非static的内部类的非static对象或匿名内部类的非static对象持有了当前所在外部类的引用...
  • 内部类如何调用外部类的方法

    千次阅读 2019-09-28 17:18:45
    内部类如何调用外部类的方法 直接上代码 public class test{ public static void main(String[] args) { Outer.Inner p=new Outer().new Inner(); p.show(); } } class Outer{ int sum; class Inner{ ...
  • java外部类与内部类的关系

    千次阅读 多人点赞 2018-12-04 21:48:16
    在学习外部类与内部类之前我们首先要弄明白private,public,protected,default在访问权限上有什么不同,这对我们之后的理解会有一定的帮助。 1、private:访问权限最低的访问控制符,被它修饰的变量只能访问本类...
  • 这篇文章通过反编译讲解了为什么内部类能用外部类private成员和为什么外部类能用内部类private成员 在Java编程中,使用private关键字修饰了某个成员,只有这个成员所在的类和这个类的方法可以使用,其他的类都无法...
  • 昨天下午字节跳动的面试中,问到了这个问题:内部类能访问外部类的成员吗? 当时只是回答了静态内部类能访问外部类的静态方法,成员内部类能访问外部类的所有方法。然后面试官问我原因我就答不上来了。还是原来看的...
  • 内部类没有使用static关键字修饰,并且和外部类的成员变量和方法属于同一级别,这样的是非静态成员内部类(可以使用权限修饰符修饰,和final、abstract关键字修饰)。 public class Atest { private String name = ...
  • java内部类获得外部类对象

    千次阅读 2018-11-06 22:32:13
    前几天遇到一个问题,在内部类中获取外部类的引用,怎么获取? 外部类名.this
  • 其中一个疑惑就是为什么内部类对象可以访问外部类对象中的成员(包括成员变量和成员方法)? 早就想对内部类这个特性一探究竟了,今天终于抽出时间把它研究了一下。内部类就是定义在一个类内部...
  • 外部类: 最普通的,我们平时见到的那种类,就是在一个后缀为.java的文件中, 直接定义的类,比如 public class Student { private String name; private int age; } 内部类: 内部类,顾名思义,就是包含在外部...
  • 首先:外部类是不能直接有static 修饰的,静态内部类能不能实例化? 既然使用到了内部类有没有必要使用public来修饰静态内部类 内部类是不是用于隐藏的? 初步理解: 通过示例可以看出 静态内部类是可以通过new ...
  • 内部类调用外部类变量

    千次阅读 2019-09-12 15:07:08
    要求:使用已知的变量,在控制台输出30,20,10。 class Outer { public int num = 10; class Inner { public int num = 20; public void show() { int num = 30; Sy...
  • 2. 编写一个程序要求定义一个外部类 Outer,然后在 Outer 类中定义一个内部类 Inner 和局部类 Local,内部类 Inner 和局部类 Local 的任务都是显示出外部类中的数组元素, 然后求出这些数组元素的平均值。 请按模版...
  • 1.B是A的内部 2.A有方法methodA(),B有方法methodB(); 3.现已获得B的实例b。 问:如何通过b调用A的methodA()方法? 具体com.sun.media.sound.DirectAudioDevice和DirectSDL
  • Test.java(测试):package cn.xxx.demo; public class Test { public static void main(String[] args) { ... // 内部对象创建格式。 in.inner(); // 调用内部对象方法。 } } Outer.ja...
  • 怎么在外部类外访问内部类

    千次阅读 2018-11-08 10:56:01
    外部类外访问内部类: Wai.Nei wn=new Wai().new Nei(); 上式相当于:Wai w=new Wai(); Wai.Nei wn=w.new Nei(); package a; class Wai { class Nei { int i=5; int ii=6; } } package a; public ...
  • 格式:外部类名称.this.外部类成员变量名 如何创建内部类对象 格式:外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称(); 实例如下: 定义一个包含内部类的外部类: package NeiBuLei; //...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,235,947
精华内容 494,378
关键字:

外部类

友情链接: asuran-english-1529330.zip