精华内容
下载资源
问答
  • import java.lang.reflect.Field;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class TestPrintList {public static void main(String args[]){List...

    package com.fpi.safety;

    import java.lang.reflect.Field;

    import java.util.ArrayList;

    import java.util.Iterator;

    import java.util.List;

    public class TestPrintList {

    public static void main(String args[]){

    List testList = new ArrayList();

    List testList2 = new ArrayList();

    //一、调用内部类的第一种方式,将内部类声明为static,直接通过总类调用

    testList.add(new TestPrintList.User(3,”tom”));

    testList.add(new TestPrintList.User(4,”jack”));

    testList.add(new TestPrintList.User(5,”lili”));

    User user = null;

    Iterator it = testList.iterator();

    //输出list对象属性的第一种方式,遍历list,得到list中封装的对象,再通过对象获得属性值

    while (it.hasNext()) {

    user = (User)it.next();

    System.out.println(“———“+user.getName());

    System.out.println(“———“+user.getAge());

    }

    //二、调用内部类的第二种方式

    TestPrintList testPrintList = new TestPrintList(); // 外部类实例化对象

    TestPrintList.User2 user2 = testPrintList.new User2(4,”jack22″); // 实例化内部类对象

    TestPrintList.User2 user22 = testPrintList.new User2(5,”jack5555″);

    testList2.add(user2);

    testList2.add(user22);

    Iterator it2 = testList2.iterator();

    //输出list对象属性的第二种方式,遍历list,得到list中封装的对象,再通过类反射输出对象属性

    while (it2.hasNext()) {

    printFieldsValue(it2.next());

    }

    }

    static class User{

    int age;

    String name;

    public int getAge() {

    return age;

    }

    public void setAge(int age) {

    this.age = age;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public User(int age,String name){

    this.age = age;

    this.name = name;

    }

    };

    class User2{

    int age;

    String name;

    public int getAge() {

    return age;

    }

    public void setAge(int age) {

    this.age = age;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public User2(int age,String name){

    this.age = age;

    this.name = name;

    }

    };

    public static void printFieldsValue(Object obj) {

    Field[] fields = obj.getClass().getDeclaredFields();

    try {

    for (Field f : fields) {

    f.setAccessible(true);

    System.out.println(f.get(obj));

    }

    } catch (IllegalArgumentException e) {

    e.printStackTrace();

    } catch (IllegalAccessException e) {

    e.printStackTrace();

    }

    }

    }

    展开全文
  • Java如何调用内部类方法

    千次阅读 2021-02-12 13:58:42
    展开全部参阅下段: 《内部类内部类是指...内部类可为静态,可用protected和private修饰(而外部只能使用public和缺省的包访问权限)。内部类主要有以下几:成员内部类、局部内部类、静...

    展开全部

    参阅下段: 《内部类》

    内部类是指32313133353236313431303231363533e4b893e5b19e31333262353462在一个外部类的内部再定义一个类。内部类作为外部类的一个成员,并且依附于外部类而存在的。内部类可为静态,可用protected和private修饰(而外部类只能使用public和缺省的包访问权限)。内部类主要有以下几类:成员内部类、局部内部类、静态内部类、匿名内部类

    为什么需要内部类?

    典型的情况是,内部类继承自某个类或实现某个接口,内部类的代码操作创建其的外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。使用内部类最吸引人的原因是:

    每个内部类都能独立地继承自一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力,一些设计与编程问题就很难解决。从这个角度看,内部类使得多重继承的解决方案变得完整。接口解决了部分问题,而内部类有效地实现了“多重继承”。

    A:成员内部类

    作为外部类的一个成员存在,与外部类的属性、方法并列。

    publicclass Outer {

    privatestaticinti = 1;

    privateintj = 10;

    privateintk = 20;

    publicstaticvoidouter_f1() {

    }

    publicvoidouter_f2() {

    }

    // 成员内部类中,不能定义静态成员

    // 成员内部类中,可以访问外部类的所有成员

    class Inner {

    // static int inner_i = 100;//内部类中不允许定义静态变量

    intj = 100; // 内部类和外部类的实例变量可以共存

    intinner_i = 1;

    void inner_f1() {

    System.out.println(i);

    //在内部类中访问内部类自己的变量直接用变量名

    System.out.println(j);

    //在内部类中访问内部类自己的变量也可以用this.变量名

    System.out.println(this.j);

    //在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名

    System.out.println(Outer.this.j);

    //如果内部类中没有与外部类同名的变量,则可以直接用变量名访问外部类变量

    System.out.println(k);

    outer_f1();

    outer_f2();

    }

    }

    //外部类的非静态方法访问成员内部类

    publicvoidouter_f3() {

    Inner inner = new Inner();

    inner.inner_f1();

    }

    // 外部类的静态方法访问成员内部类,与在外部类外部访问成员内部类一样

    publicstaticvoidouter_f4() {

    //step1 建立外部类对象

    Outer out = new Outer();

    //step2 根据外部类对象建立内部类对象

    Inner inner = out.new Inner();

    //step3 访问内部类的方法

    inner.inner_f1();

    }

    publicstaticvoid main(String[] args) {

    //outer_f4();//该语句的输出结果和下面三条语句的输出结果一样

    //如果要直接创建内部类的对象,不能想当然地认为只需加上外围类Outer的名字,

    //就可以按照通常的样子生成内部类的对象,而是必须使用此外围类的一个对象来

    //创建其内部类的一个对象:

    //Outer.Inner outin = out.new Inner()

    //因此,除非你已经有了外围类的一个对象,否则不可能生成内部类的对象。因为此

    //内部类的对象会悄悄地链接到创建它的外围类的对象。如果你用的是静态的内部类,

    //那就不需要对其外围类对象的引用。

    Outer out = new Outer();

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

    outin.inner_f1();

    }

    }

    注意:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

    B:局部内部类

    在方法中定义的内部类称为局部内部类。与局部变量类似,局部内部类不能有访问说明符,因为它不是外围类的一部分,但是它可以访问当前代码块内的常量,和此外围类所有的成员。

    publicclass Outer {

    privateints = 100;

    privateintout_i = 1;

    publicvoid f(finalint k) {

    finalint s = 200;

    int i = 1;

    finalint j = 10;

    //定义在方法内部

    class Inner {

    ints = 300;// 可以定义与外部类同名的变量

    // static int m = 20;//不可以定义静态变量

    Inner(int k) {

    inner_f(k);

    }

    intinner_i = 100;

    voidinner_f(int k) {

    //如果内部类没有与外部类同名的变量,在内部类中可以直接访问外部类的实例变量

    System.out.println(out_i);

    //可以访问外部类的局部变量(即方法内的变量),但是变量必须是final的

    System.out.println(j);

    //System.out.println(i);

    //如果内部类中有与外部类同名的变量,直接用变量名访问的是内部类的变量

    System.out.println(s);

    //用this.变量名访问的也是内部类变量

    System.out.println(this.s);

    //用外部类名.this.内部类变量名访问的是外部类变量

    System.out.println(Outer.this.s);

    }

    }

    new Inner(k);

    }

    publicstaticvoid main(String[] args) {

    // 访问局部内部类必须先有外部类对象

    Outer out = new Outer();

    out.f(3);

    }

    }

    C:静态内部类(嵌套类):(注意:前两种内部类与变量类似,所以可以对照参考变量)

    如果你不需要内部类对象与其外围类对象之间有联系,那你可以将内部类声明为static。这通常称为嵌套类(nested class)。想要理解static应用于内部类时的含义,你就必须记住,普通的内部类对象隐含地保存了一个引用,指向创建它的外围类对象。然而,当内部类是static的时,就不是这样了。嵌套类意味着:

    1. 要创建嵌套类的对象,并不需要其外围类的对象。

    2. 不能从嵌套类的对象中访问非静态的外围类对象。

    publicclass Outer {

    privatestaticinti = 1;

    privateintj = 10;

    publicstaticvoidouter_f1() {

    }

    publicvoidouter_f2() {

    }

    // 静态内部类可以用public,protected,private修饰

    // 静态内部类中可以定义静态或者非静态的成员

    staticclass Inner {

    staticintinner_i = 100;

    intinner_j = 200;

    staticvoidinner_f1() {

    //静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)

    System.out.println("Outer.i" + i);

    outer_f1();

    }

    voidinner_f2() {

    // 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)

    // System.out.println("Outer.i"+j);

    // outer_f2();

    }

    }

    publicvoidouter_f3() {

    // 外部类访问内部类的静态成员:内部类.静态成员

    System.out.println(Inner.inner_i);

    Inner.inner_f1();

    // 外部类访问内部类的非静态成员:实例化内部类即可

    Inner inner = new Inner();

    inner.inner_f2();

    }

    publicstaticvoid main(String[] args) {

    newOuter().outer_f3();

    }

    }

    生成一个静态内部类不需要外部类成员:这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成:Outer.Inner in = new Outer.Inner();而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类(正常情况下,你不能在接口内部放置任何代码,但嵌套类可以作为接口的一部分,因为它是static 的。只是将嵌套类置于接口的命名空间内,这并不违反接口的规则)

    2Q==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • } } } 编译了一下,报错: 解决方法是 创建外部对象,再使用外部对象来new一个内部变量 public class Test2 { public static void main(String[] args) { Test2 test2 = new Test2();// 创建外部Test...

    同学发了这么些代码,报错,问怎么解决。

    public class Test2 {
     
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		 A a =new A(5.5);
    		System.out.println(a.x);
    	}
     
    	class A {
    		public double x;
     
    		public A(double x) {
    			this.x = x;
    		}
    	}
    }
    

    编译了一下,报错:

    解决方法是 创建外部类对象,再使用外部类对象来new一个内部变量

    public class Test2 {
     
    	public static void main(String[] args) {
    		Test2 test2 = new Test2();// 创建外部类Test对象
    		A a = test2.new A(5.5);// 使用外部类对象a来new一个A对象a
    		System.out.println(a.x);
    	}
     
    	class A {
    		public double x;
     
    		public A(double x) {
    			this.x = x;
    		}
    	}
    }
    

    对main方法而言,虽然写在类中,它是游离于任何类之外的,因此某类的非静态内部类对它而言是不直接可见的,也就无法直接访问。需要注意以下几点:
    1:非静态内部类,必须有一个外部类的引用才能创建。
    2:在外部类的非静态方法中,因为有隐含的外部类引用this,所以可以直接创建非静态内部类。
    3:在外部类的静态方法中,因为没有this,所以必须先获得外部类引用,然后创建非静态内部类。
    4:静态内部类,不需要外部类引用就可以直接创建。
    5:同时静态的内部类,也不能直接访问外部类的非静态方法。
    6:非静态内部类之所以可以直接访问外部类的方法,是因为创建非静态内部类时,有一个隐含的外部类引用被传递进来。
    ————————————————
    版权声明:本文为CSDN博主「YearnYea」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/YearnYea/article/details/78701164

    展开全文
  • 后者更明确,如果内部类中存在相同的名称,则可以调用外部类方法。class OuterClass {void foo() { System.out.println("Outer foo"); }View.OnClickListener mListener1 = new View.OnClickListener() {void foo() ...

    后者更明确,如果内部类中存在相同的名称,则可以调用外部类方法。

    class OuterClass {

    void foo() { System.out.println("Outer foo"); }

    View.OnClickListener mListener1 = new View.OnClickListener() {

    void foo() { System.out.println("Inner foo"); }

    @Override public void onClick(View view) {

    foo(); //Calls inner foo

    OuterClass.this.foo(); //Calls outer foo

    }

    }

    View.OnClickListener mListener2 = new View.OnClickListener() {

    @Override public void onClick(View view) {

    foo(); //Calls outer foo

    OuterClass.this.foo(); //Calls outer foo

    }

    }

    }

    展开全文
  • 1、直接调用外部非静态方法报错public class OuterClass {public void printMessage(String message) {System.out.println(message);}private static class InnerClass {public void sayHello() {printMessage(...
  • 在不同的包内的调用类的protected方法(其实,也可以理解和第一个原因是一样的)匿名继承了父类,并调用了父类的protected方法条件:匿名完成上述使命,则需要继承一个或者实现某个接口形式:new 示例1:/**...
  • 内部的使用:内部的使用的优缺点:优点:减少了在文件编译后的产生的字节码文件的大小缺点:使程序结构不清晰使用内部类的注意事项:内部的使用一般都与所在的外部有一定的关联,它是在一个的内部嵌套...
  • 今天学习了内部类的知识,知道内部类是可以持有外部的this,从而在内部类中可以使用OuterClass.this.medthod()来引用相应外部类方法。但是我写出下代码,可以运行,然而其中的调用逻辑我不是很明白,望赐教!...
  • 外部调用外部调用即是在一个调用另一个方法package hello2;//首先定义一个public class Book {String name;String author;double price;public void getInfo(){//以字符串的形式输出书名、作者和价格...
  • 一 点睛分三种情况讨论内部的使用:1 在外部内部使用内部类2 在外部以外使用非静态内部3 在外部以外使用静态内部二 在外部内部使用内部类可以直接通过内部的类名来定义变量,通过new调用内部构造器...
  • 1.使用static可以声明一个内部类, 可以直接在外部调用 class Outer { // 定义外部 private static String info = "hello world"; // 定义外部的私有属性 static class Inner { // 使用static定义内部类为...
  • java使用静态内部类

    2021-03-10 01:13:46
    使用静态内部类提高封装性Java中的嵌套分为两种:静态内部类内部类。静态内部类就是在内部类的申明中加上static的修饰符。实例:````package com.company;public class Person {private String name;private ...
  • 展开全部Java内部调用内部方法主要是通过内部62616964757a686964616fe58685e5aeb931333337396235实现。Java内部分两种,成员内部和方法内部。代码如下:1.成员内部/***成员内部*/publicclassOuter{...
  • Java动态调用类方法

    2021-03-05 22:50:29
    Java中,调用类方法有两种方式:对于静态方法可以直接使用类名调用,对于非静态方法必须使用类的对象调用。反射机制提供了比较另类的调用方式,可以根据需要指定要调用方法,而不必在编程时确定。调用方法...
  • 外部可以通过创建外部对象来创建内部对象再调用内部方法class Outer{ // 定义外部private String info = "hello world" ; // 定义外部的私有属性class Inner{ // 定义内部public void print(){ // 定义内部...
  • 见以下代码:定义了一个Outer,在Outer内中一定了私有成员变量x ,成员方法show()和一个内部类 Inner ; Inner和普通一样也有一个成员变量 x 和成员方法 method2.访问规则1. 内部类可以直接访问外部中的...
  • 方法一:需要使用一个外部对象来new 内部类()----->调用方法 public class JZ1 { public class Solution { public boolean Find() { return false; } } public static void main(String[] args) { ...
  • package day6$6;public class Inside {public static void main(String[] args) {//先创建一个外部对象Outside in=new Outside();//在通过外部对象创建一个内部...//调用内部类自己的属性和方法oi.Swim();System...
  • Java中的内部类使用

    2021-03-09 23:33:45
    一、内部类的作用1.内部类提供更好的封装,可以把内部类隐藏在外部里面,不容许...方法内部类(内部类在外部的一个方法里面)4.匿名内部类三、内部类使用1.成员内部类使用:package com.bluesky;public class...
  • Java内部类是如何调用外部的成员变量和方法的?我们下看看下面的例子 package com.iworktool.libjava; public class Outer{ private String privateValue = "privateValue"; public String publicValue = ...
  • 如果要调用非静态方法,则需要告知要调用它的对象.在您的情况下,您需要内部类对象,但由于您还没有内部类对象,因此您需要创建它...调用内部类对象的方法.你可以这样做:(你只需要记住默认构造函数与其的可见性具有相...
  • import java.lang.reflect.Constructor;public class A {public A() {}public A(String str) {}class Inner {private String name = "Inner";public Inner() {}public Inner(String na) {name...
  • Java-内部类简单使用

    2021-03-09 23:34:04
    一、实例内部类(成员内部类)1.成员内部类可以等同看做成员变量2.成员内部类不能有静态声明3.成员内部类可以访问外部所有的数据public classOuterClass {//静态变量private static String s1 = "Array";//成员变量...
  • } } 追问: 好吧……我放到同一个下面就不报错了。。为什么我分放在3个包内就报错? package P195_6P1; //Interface1 package P195_6P2; //Class1 import P195_6P1.*; package P195_6P3; //Class2 import P195_6...
  • 1.调用外部的私有方法及获取属性值: package org.example; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; public class checkfeflect { public static void main...
  • java内部类

    2021-02-28 06:48:42
    java内部类的几种类型:成员内部类,静态内部类方法内部类,匿名内部类。成员内部类:成员内部类类内部的非静态。成员内部类不能定义静态方法和变量(final修饰的除外)。这是因为成员内部类是非静态的,初始...
  • Java 内部类种类及使用解析内部类Inner Class将相关的组织在一起,从而降低了命名空间的混乱。一个内部类可以定义在另一个里,可以定义在函数里,甚至可以作为一个表达式的一部分。Java中的内部类共分为四种:...
  • 这可能是一个非常基本的问题,但在Java学习的这个阶段让我感到困惑.我有以下代码:package com.soti84;import java.util.ArrayList;public class InvokeMethod {public static void main(String[] args) {ArrayList ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,343,375
精华内容 537,350
关键字:

java调用内部类方法

java 订阅