标签: inner-classes

我在这里遇到了一个奇怪的结果,我不确定它是Java中的错误还是预期的行为.我有一个内部类,我使用反射来获取声明的字段(class.getDeclaredFields()).但是,当我循环遍历字段列表并检查各个类型时,"this"字段返回外部类而不是内部类.

这是预期的行为吗？这对我来说似乎很奇怪.

例如:

import java.lang.reflect.Field;

public class OuterClass {

    public class InnerClass{
        public String innerClassString;
            public InnerClass innerClass;

    }


    public static void main(String[] args) {

        // print the fields of the inner class
        for( Field field : OuterClass.InnerClass.class.getDeclaredFields())
            System.out.println( field.getName() + "   :::   " + field.getType());
    }
}

输出:

innerClassString   :::   class java.lang.String
innerClass   :::   class OuterClass$InnerClass
this$0   :::   class OuterClass

我希望这个$ 0是OuterClass.InnerClass类型.

这是一个Java错误吗？反正有办法解决这个意想不到的行为吗？

谢谢,

埃里克

是否可以序列化非静态内部类？

如果是,你可以提供一个很好的例子.

我搜索了几个博客和非答案的网站说服了我.

编辑: 内部类具有最终的staic变量怎么样.

我们来看下面的代码:

public class Test {

    class A {
        public A() {}

        private void testMethod() {
            System.out.println("A");
        }
    }

    class B extends A {
        public B() { super(); }

        private void testMethod() {
            System.out.println("B");
        }
    }

    public Test() { }

    public A get() {
        return new B();
    }

    public static void main(String[] args) {
        new Test().get().testMethod();
    }
}

我希望代码写B.A是写的.

可能会觉得奇怪(至少对我来说)一个类可以调用它包含的内部类的私有方法这一事实(为什么它们会这样做？),但我真正无法理解的是为什么多态不会工作.

我的意思是,如果从Test.main()我们可以称之为A.testMethod()显而易见,我们也称之为呼叫B.testMethod().Java还可以确定对象的动态类型,那么为什么Java调用声明类型的方法而不是动态类型的方法呢？可以检查此行为:

public static void main(String[] args) {
    B b = new …

抱歉新手问题 - 在实现MouseListener类(或其他每个内部类)时是否可以省略空函数签名？
那么代码会缩小几行？

    JButton btnExit = new JButton("Exit");
    btnExit.addMouseListener(new MouseListener() {
        @Override public void mouseReleased(MouseEvent arg0) {}
        @Override public void mousePressed(MouseEvent arg0) {System.exit(0);}
        @Override public void mouseExited(MouseEvent arg0) {}
        @Override public void mouseEntered(MouseEvent arg0) {}
        @Override public void mouseClicked(MouseEvent arg0) {}
    });

为什么这段代码不起作用？

public class BB
{
    private class A
    {
        private int x;
    }

    public static void main(String[] args)
    {
        A a = new A();
        a.x = 100;
        System.out.println(a.x);
    }
}

虽然这段代码有效吗？

public class BB
{
    private class A
    {
        private int x;
    }

    static int y = 3;

    public static void main(String[] args)
    {
        BB b = new BB();
        b.compile();
        System.out.println("y = "+ y);
    }
    public void compile()
    {
        A a = new A();
        a.x = 100;
        System.out.println(a.x);
        System.out.println("y = …

我有一个问题,一直阻碍我进一步前进,这个错误在我看来根本不符合逻辑,我从一本书中学习,代码来自那里.这是代码:

package test_area;

public class clzzz {

    class SimpleCircle{
        double radius;

        SimpleCircle()
        {
            radius = 1;
        }

        SimpleCircle(double newRadius)
        {
            radius = newRadius;
        }

        double getArea()
        {
            return radius*radius*Math.PI;
        }

        double getPerimeter()
        {
            return 2*radius*Math.PI;
        }

        void setRadius(double newRadius)
        {
            radius = newRadius;
        }

    }


    public static void main(String[] args)
    {
        SimpleCircle circle1 = new SimpleCircle();

    }



}

这是错误

如果我从void main中消除了静态,那么错误就会消失,但这样做我正在改变主方法的签名.....我真的很困惑,一步一步跟着书中的代码.

为什么以上帝的名义,我需要静态标签？我不需要让相应的类只有一个实例,因为我可以通过对象的名称控制它的实例,因此静态只是一个障碍？

我有以下代码:

class MyThread{
      static volatile java.io.PrintStream s=System.out;
      public static void main(String args[]){
        Runnable r1=new Runnable(){
          public void run(){
            synchronized(s){
              for(int i=0; i<100; i++)
                 system.out.println("in r1");
            }
          }
        };
        Runnable r2=new Runnable(){
          public void run(){
            synchronized(s){
              for(int i=0; i<100; i++)
                 system.out.println("in r2");
            }
          }
        };
        Thread t1=(Thread)r1;
        Thread t2=(Thread)r2;
        t1.start();
        t2.start();
      }
}

我的问题是:由于r1和r2是方法本地内部类,它们怎么能访问's',因为它不是最终的？代码不会给出任何错误.

但它会在行' Thread t1=(Thread)r1; Thread t2=(Thread)r2;' 引发异常,为什么会这样？

提前致谢

我想知道一个对象何时以及为什么会引用它自己.我正在使用'this'关键字阅读内部类,这有点令人困惑.一个简单的例子和​​解释会很棒.

我知道如何使用公共变量实现简单的Parcelable类，但是下面的类要复杂一些。鉴于此类具有内部类和ListEntity，如何实现Parcelable接口？我什至不知道如何开始。任何有关如何执行此操作的详细信息将不胜感激。

import android.os.Parcel;
import android.os.Parcelable;

import java.util.List;

public class ResponsePlaceSearch implements Parcelable {

    // *** Parcelable methods are shown below (Begin) ***

    protected ResponsePlaceSearch(Parcel in) {
    }

    public static final Creator<ResponsePlaceSearch> CREATOR = new Creator<ResponsePlaceSearch>() {
        @Override
        public ResponsePlaceSearch createFromParcel(Parcel in) {
            return new ResponsePlaceSearch(in);
        }

        @Override
        public ResponsePlaceSearch[] newArray(int size) {
            return new ResponsePlaceSearch[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {

    }

    // *** (End) ***


    private List<ListEntity> …

在C#中,公共嵌套类和私有嵌套类之间有什么区别？你什么时候用另一个经文？

据我所知,他们在类的视图中具有相同的可访问性,它们嵌套在任何外部类中.

void Main()
{
    Item i = new Item();
    i.DoSomething();

    GizmoBuilder gb = new GizmoBuilder();//class not accessible
    WidgetBuilder wb = new WidgetBuilder();//class not accessible
}

public class Item
{
    public int Id { get; set; }

    private string ItemName { get; set;}

    public void DoSomething()
    {
        GizmoBuilder g = new GizmoBuilder();
        g.BuildGizmo();
        Console.WriteLine(g.BuildId);
        Console.WriteLine(g.Name);//g.Name not accessible

        WidgetBuilder w = new WidgetBuilder();
        w.BuildWidget();
        Console.WriteLine(w.BuildId);
        Console.WriteLine(w.Name);//g.Name not accessible
    }

    public class GizmoBuilder
    {
        public int BuildId { get; set; }

        private …