new Out().super();怎么理解啊？？

Question

class Out
{
class In
{
public void test()
{
System.out.println("In的test方法");
}
}
class A extends In
{}
}
class OutTest extends Out.In
{
public static void main(String[] args)
{
System.out.println("Hello World");
}

OutTest()
{
new Out().super();
}
}

Answer 1

为啥不能这样呢 super(new Out());

Answer 2

class Out
{
    class In
    {以为In 是Out 的内部类 所以想用In类的话必须先创建Out类的对象！！！

Answer 3

这是一个练习。
new Out()产生Out指针，可是Out并不能调用super构造函数啊
疯狂java的解释是
调用In的构造函数并传入Out对象为参数，但是这个格式让人难以理解，好像是调用OUt的父类的无参构造。

Answer 4

楼主这个例子很有锻炼意义，OutTest继承的是Out的内部类In，在OutTest构造方法中调用new Out().super(),按照这个语法来讲，是Out的父类的无参构造方法以及调用Out类的无参构造方法，可以这么测试：public class OutTest extends Out.In {
public static void main(String[] args) {
System.out.println("Hello World");
new OutTest();
} OutTest() {
new Out().super();
}
}class Out extends Super{
class In {
public void test() {
System.out.println("In的test方法");
}
} class A extends In {
}
}class Super{
public Super(){
System.out.println("Father.Father()...");
}
public Super(int arg){
System.out.println("Father.Father(int arg)...");
}
}
结果很明显了，相信楼主也能知道这其中是要干什么了，谢谢楼主的分享~

Answer 5

不明白楼上的意思，照着这代码执行了下，也只是输出很正规的先构造父类super再构造子类out的顺序。
我自己把代码改了下，猜测其实可能就是调用OutTest的父类Out.In的无参构造super()必须在第一行，而在这之前又必须先创建Out，然而又不能显示的做为参数传进去super(new Out())，所以.在这里大概相当于是个分隔符或者连接符，其实就是先创建外围类Out再创建OutTest的父类也就是外围类的内部类Out.In，也即是依次调用了外围类Out和Out.In的无参构造而已。程序输出
Out init..
In init..class OutTest extends Out.In {
public static void main(String[] args) {
new OutTest();
} OutTest() {
new Out().super();
}
}class Out {
Out()
{
System.out.println("Out init..");
}
class In {
In()
{
System.out.println("In init..");
}
public void test() {
System.out.println("In的test方法");
}
} class A extends In {
}
}

Answer 6

相当于
o = new Out();
new o.In();

Answer 7

你在 out 的构造里面输出 system.out.println( "out construct ");
然后在 In 的构造里面输出 system.out.println( "In construct ");
然后在 main函数中 new OutTest();  不就知道了1、OutTest　extens  Out.In
说明什么？说明OutText  extends 的 Out类的内部类 In2、那么 new Out() 就是调用Out类3、那么new Out().super() 就是先实例化Out类，然后调用其内部类的的构造器，至于super指的是谁，取决于那个内部类被继承。4、那么什么不能直接写 super()； 直接调用超类构造呢？编译报错 ：OutTest.java:34: 错误: 需要包含Out.In的封闭实例
说明，如果继承自一个内部类，需要先构造器外部类。总结
1、如果继承了一个内部类，需要先实例化外部类。
2、out().super() 的意思是： 先实例化一个外部类，然后再调用父类的构造器。

Answer 8

其实父类Out.In是有参数构造的，默认内部类都有外围类的引用作为第一个参数。Out.In(Out this)
{
}

Answer 9

class Out {
  class In {
    In(int a) {
      System.out.println("In constructor " + a);
    }    public void test() {
      System.out.println("Test of In");
    }
  }
}class OutTest extends Out.In {
  public static void main(String[] args) {
    System.out.println("Hello World");
    new OutTest().test();
  }  OutTest() {
    new Out().super(1);
  }
}
这段代码可以证明super就是In的构造器，因为super必须要带一个int才能通过编译，而输出是
Hello World
A constructor 1
Test of In这个原因在于class In不是一个static class，它只存在于Out的实例中。
在创建OutTest实例的时候，你必须要有Out.In这个class的引用，而Out.In是随Out的实例的创建而被创建，所以new Out是必须的。
这时候In的构造函数就可以看成如楼上某位说的，第一个参数为其父类引用的特殊函数，所以如果按照正常逻辑，应该是super(new Out());这样子。
但是super本身又不是一个带有参数的函数，这里就只好折中，用new Out().super()了。这是一个非常丑陋的用法，你的代码里应该永远见不到这样的结构，否则就重构吧

Answer 10

public class OutTest extends Out.In {
public static void main(String[] args) {
new OutTest();
}
OutTest() {
new Out().super();
}
}class Out extends Super{
public Out() {
System.out.println("out");
}
class In {
public In() {
System.out.println("in");
}
}
}class Super {
public Super() {
System.out.println("super");
}
}new Out().super();因为继承的是一个内部类，需要先实例化外部类new Out();super()就是调用父类的构造器。

Answer 11

new Out().super();的意思是向In的构造函数传递Out对象，写法是挺2的，相当于super(new Out());