网上看到的一道Java面试题，关于内部类的，大家帮忙看看。

Question

QUESTION NO: 4
1. public class Outer{
2. public void someOuterMethod() {
3. // Line 3
4. }
5. public class Inner{}
6. public static void main( String[]argv ) {
7. Outer o = new Outer();
8. // Line 8
9. }
10. }
Which instantiates an instance of Inner?
A. new Inner(); // At line 3
B. new Inner(); // At line 8
C. new o.Inner(); // At line 8
D. new Outer.Inner(); // At line 8//new Outer().new Inner()
我觉得第8行应该是Outer.Inner i = o.new Inner();
选项是不是有问题，请教大家了。谢谢……(B.T.W:好久没散分了,顶者有分，今天晚上结贴:)~)

Answer 1

A是正确的，其它都是错误的，
我觉得第8行应该是Outer.Inner i = o.new Inner();
//同意楼主

Answer 2

的确是 Outer.Inner i = o.new Inner();
thinking in java里提到过的

Answer 3

做了C＃之后感觉很多Java的概念都混淆了，下面是一段相似的C#代码
using System;
using System.Collections.Generic;
using System.Text;namespace ConsoleApplication2
{
    public class Program
    {
        public void Method()
        {
            A a = new A();//Ok;
        }
        public class A
        {
            public A()
            {
                Console.WriteLine( "a" );
            }        }
        static void Main( string[ ] args )
        {
            Program p = new Program();
            Program.A a1 = new A(); //Ok
            Program.A a2 = new Program.A(); //Ok
            //Error: Program.A a3 = p.new A();
        }
    }
}希望大家能够结合实际讲讲Java的内部类的使用。我会把大家的经验总结出来，以供大家参考，谢谢大家不吝赐教。

Answer 4

正确答案 CA. new Inner(); // At line 3
语法是对的，也能编译通过。
但是该方法根本没有被执行，所以无从创建Inner对象B. new Inner(); // At line 8
这是外部类的构造方法。Inner不是外部类，使用这种方法访问不到C. new o.Inner(); // At line 8
这才是正确的。类本身也是对象，并且在同一类加载器中具有唯一性。非static内部类创建于其外部类的实例里面。D. new Outer.Inner(); // At line 8//new Outer().new Inner()
如果Inner声明为static，可以，但是，这里不行。
而new Outer().new Inner()，和C的效果是一样的，可以。

Answer 5

同意楼主的意见，我也觉得所有选项都不对，第三行放new Inner()虽然语法正确 ，但是没有执行，所以没有产生实例对象，A错。而第八行可以放o.new Inner();或者new Outer().new Inner(),但是不能放new o.Inner(); 故此BCD都是错的

Answer 6

显然都错，这是个public的内部类，所以可以用
OuterClass.InnerClass pc = c.new InnerClass(); 
的形式来创建对象，这里的c是外部类的对象详情参见Thinking in Java，不过Thinking in Java上的写法
new c.InnerClass(); 是错误的。。

Answer 7

只有A可以正确通过！！
B的错误在于：不能够直接new内部类，必须得 
 Ooter o = new Outer();
 Outer.Inner oi = o.new Inner();
如果内部类是static的，则改为：
   new Outer.Inner();
C的错误在于：同B说法；
D的错误在于：同B说法，只有static的内部类才可以这么写。

Answer 8

A通过了但是Inner并没有实例化.呵呵:)

Answer 9

同意楼主的看法
D如果写为new Outer().new Inner()就对了

Answer 10

Outer$1 x= new Outer$1();
这样好象似乎也可以．忘拉要不就是Ｏuter$Inner x= new Ｏuter$Inner();好象有点流氓！

Answer 11

我写的测试代码如下，测试结果表明在main中只有楼主所说的方法可以通过编译（即下面代码中的方法），而在test（）方法中使用new Inner（）是正确的。
下面的测试的输出结果为：
Hello World!
Inner
test
Inner－－－－－－－－－
public class InnerClassTest 
{
public class Inner
{
public Inner()
{
System.out.println("Inner");
}
}; public void test()
{
new Inner();
System.out.println("test");
}
public static void main(String[] args) 
{
System.out.println("Hello World!");
InnerClassTest t = new InnerClassTest();
t.test();
t.new Inner();
}
}

Answer 12

所以A和楼主才是正确的。
忘了说了，我的编译器是jdk1.5.0_06的

Answer 13

因为Inner不是一个静态内部类，所以在第8行的话插入Inner i=o.new Inner();
 Inner i1=new Outer().new Inner();都可以了。

Answer 14

无视某些穿三脚裤的人的说话，明显有很多人在误导！！标准答案是A，SCJP的题。期待带星的达人来回答！！！

Answer 15

选C
A可改为new this.Inner();

Answer 16

public class MainClass { public class MainInner
{
public void print()
{
System.out.println("Call print!");
}
}
public MainInner MakeInner()
{
    return new MainInner();
}
/**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
        MainClass main=new MainClass();
        MainInner maininner=main.new MainInner();
        maininner.print();
        maininner=main.MakeInner();
        maininner.print();
}}不知道题目是不是tricky要考察的是非静态的内部类必须依存外部类实例才能创建。
所以，A在外部类的成员函数中创建内部类实例是可以的
C,在外部类实例的基础上创建内部类实例也是正确的。而new Outer().new Inner()
也是可以的，但无法获得外部类的引用了。但内部类实例仍然依附在匿名外部类实例上。
GC不会回收这个匿名类，因为内部类实例的引用仍然指向这个外部类实例。

Answer 17

哦，没看清C的选项，呵呵，应该是o.new Inner();
不过JAVA的这个语法还是很奇怪和丑陋的：）

Answer 18

狗屁，狗屁，狗屁
妈的，我把程序输进去了，这段程序根本不能编译，
内部类和main函数可以放在一起么

Answer 19

改正错误，确实，不能选C。看错了，应该是o.new Inner();

Answer 20

哦，楼上的，我不太懂JAVA，我用的是ECLIPSE 3.1，J2SE1.5不知道语法解释在不同编译器是否有不同。不过我不喜欢你的态度，难怪你信誉值只有87。也许你是CSDN的老鸟了？不过我看不像，还是多学学再出来吧！你到告诉我内部类为什么不能跟MAIN放一起？MAIN不过是一个程序入口点。即使上面的代码出现错误，也会是一个运行时错误。

Answer 21

UnAgain() ( ) 信誉：98  2006-5-19 15:55:05  得分: 0  
 
 
   
正确答案 CA. new Inner(); // At line 3
语法是对的，也能编译通过。
但是该方法根本没有被执行，所以无从创建Inner对象B. new Inner(); // At line 8
这是外部类的构造方法。Inner不是外部类，使用这种方法访问不到C. new o.Inner(); // At line 8
这才是正确的。类本身也是对象，并且在同一类加载器中具有唯一性。非static内部类创建于其外部类的实例里面。D. new Outer.Inner(); // At line 8//new Outer().new Inner()
如果Inner声明为static，可以，但是，这里不行。
而new Outer().new Inner()，和C的效果是一样的，可以。
-----------------------------------------------------------------------------
 同意。。
我也觉得 C 对
 

Answer 22

我改正，C不对。我原来看错了。new o.Inner() 错误正确的写法是：
o.new Inner();所以，选C不对

Answer 23

答案里只有a是对的
应该是o.new Inner()//line 8
因为只要内部类不是静态的就得用这种方法
另外我也有一些困惑:
public class J{
   
  static Inner retur()
{  class Inner
{
public Inner()
{
System.out.println("Inner");
}
}  

return new Inner();
}
public static void main(String[] args){
  retur();
}

}
此段代码由何问题呢？各位高手帮忙指点

Answer 24

To: ljh13835147360()
因为class J没有创建实例，方法声明为静态的，并不等于其所属的类也会被声明为静态。在方法中声明的内部类依附于方法所属的类，而不是依附于该方法。

Answer 25

C
D内部类都在外部类的对象之上建立，D是匿名的。

Answer 26

我完全同意楼主的说法，这个我讲过。内部类有3种实现方式：
1.直接new
2.使用匿名内部类，如：addWindowListener(new WindowAdapter())
3.使用包围类的对象进行实例化：outer ob = new outer();
   outer.inner ob1 = ob.new inner();

Answer 27

大家都看仔细了，C选项的语句是new o.Inner(); // 错误而不是o.new Inner(); // 正确

Answer 28

麻烦各位选答案时先测试一下能否编译通过好不好，很明显只有A能通过语法检测，但是A并没有产生实例，选A是错误的

Answer 29

楼主是对的，应该是    new Outer().new Inner();
其他的都是错的，A并没有创建对象实例网上有篇 文章
http://www.frontfree.net/view/article_704.html
大家有兴趣可以 看一看

Answer 30

摘了一段，作为内部类的总结：Inner class有四类：Inner Classes、Method-local Inner Classes、Anonymous Inner Classes、Static Nested Classes。 
◎ Inner Classes（第一种的inner class）的instantiation方式，若是在Outer class的话，直接使用一般的方式就可以了。若是在Outer class以外的class要instantiate该inner class，则一定要透过outer class的reference才行。例： MyOuter mo = new MyOuter();  //creating outer class reference
MyOuter.MyInner mi = mo.new MyInner();  //creating inner class reference要一行解决的话可以这样写： 
MyOuter.MyInner mi = new MyOuter().new MyInner();
//同样是透过outer class reference◎ 可以用在inner class的modifier：public, protected, private, final, strictfp, abstract, static（会变成static nested class） 
◎ 除非enclosing method内的变量标为final，否则method-local inner class是无法看得到该变量的，可以自己写来试试。 
◎ Anonymouse inner class的写法一定要会。 
◎ Static nested class的instantiation方法（注意与一般inner class的不同）： 
MyOuter.Nested mn = new MyOuter.Nested(); //don’t need outer class reference◎ 各种inner class的instantiation, usage等都要彻底弄懂。最好是多写几个class，自己模拟试试各种写法会发生什么事。马上结贴了。上个星期五停电了。郁闷～ 

Answer 31

public class Test {

public Test() {

Inner i1 =  new Inner();
Inner i2 =  new Test.Inner();
Test.Inner i = new Test.Inner();
System.out.println(i.i);
}


class Inner {
public int i = 0;

}

public static void main(String[] args) {
Test t = new Test();

Inner r = t.new Inner();
System.out.println(r.i);
}}

Answer 32

我在编译器上调试过。
题目给出的答案都是错误的。
正确答案应该是：
 o.new Inner(); //line 8大家不要争了