原来Java代码还能这么写?

这是一个典型的匿名类，编译后会产生一个className$1.class

Nested Classes:
http://www.onjava.com/pub/a/onjava/excerpt/HardcoreJava_chap06/index.html
http://www.onjava.com/pub/a/onjava/excerpt/HardcoreJava_chap06/index1.html
http://www.onjava.com/pub/a/onjava/excerpt/HardcoreJava_chap06/index2.html

匿名内部类是Java的一种很优雅的语法, 看看 Spring 中的典型使用方法:

public class ProductDaoImpl implements ProductDao {
    private SessionFactory sessionFactory;
    public void setSessionFactory(SessionFactory sessionFactory); {
        this.sessionFactory = sessionFactory;
    }
    public List loadProductsByCategory(final String category); {
        HibernateTemplate hibernateTemplate =
            new HibernateTemplate(this.sessionFactory);;
        return (List); hibernateTemplate.execute(
            new HibernateCallback(); {
                public Object doInHibernate(Session session); throws  HibernateException {
                    List result = session.find(
                        "from test.Product product where product.category=?",
                        category, Hibernate.STRING);;
                    // do some further stuff with the result list
                    return result;
                }
            }
        );;
    }
}

楼上的楼上的东西要好好看看,上面说内部类是不能被继承是偶说错了,不过觉得think in java上的东西说的还是不很清楚.

Thinking in java 的第8章《接口与内隐类》的课后题24题是这样的：撰写一个class，内含一个inner class ，撰写第二个具备inner class 的class，令其inner class 继承第一个inner class 。

class WithInner {

  class Inner {}

}

public class InheritInner 
    extends WithInner.Inner {

  //! InheritInner(); {}
  // Won't compile
  InheritInner(WithInner wi); {
    wi.super();;
  }

  public static void main(String[] args); {
    WithInner wi = new WithInner();;
    InheritInner ii = new InheritInner(wi);;
  }

} ///:~

这是一个继承内部类的一个例子，继承类中的显视构造函数要调用父类的构造函数，包含类，和内部类的关联是包含类的一个实例，这里需要显示生命，但是他调用构造函数的方式怎么是****wi.super();*****!!!不理解这里啊，
super(),是父类的构造函数，this(),是本类中的构造函数，以前我一直是这么理解的，这里的wi.super()又是什么意思呢？

// 使用内部类的例子
public class aa {
	
  class Contents {
  	
	private int i = 11;
	
	public int value(); { return i; }
	
  }
  class Destination {
  	
	private String label;
	
	Destination(String whereTo); {
	  label = whereTo;
	}
	
	String readLabel(); { return label; }
	
	class ak {
	  // 一个多层的内部类
	}
	
  }
  
  static class test {
  }
  
  public static void main(String[] args); {
	aa p = new aa();;
	aa.Contents c = p.new Contents();;
	aa.Destination d =
	  p.new Destination("Tanzania");;
	  
    // 多层的内部类，只与父层有关，不是静态的要生成父类的实例
	aa.Destination.ak aaaa = d.new ak();;  
	aa.test dd = new test();; // 静态内部类直接使用
  }
} 

class bb{

  void med0(); {
  	// 外部使用一个类的内部类的方法
	aa p = new aa();;
	aa.Contents c = p.new Contents();;
	aa.Destination d =
			  p.new Destination("Tanzania");;
  }

  public static void main(String[] agrs); {
	aa p = new aa();;
	aa.Contents c = p.new Contents();;
	aa.Destination d =
		  p.new Destination("Tanzania");;
  }

}

这是一个使用内部类的例子，p.new 的具体意思是什么？？没有想清楚，只是知道确定了外层跟内层的关系，是不是这个p要成为构造函数的一个参数

p.new Contents()
//Contents是aa的内部类，在其初始化时要获得外部类对象的引用，以便在内部类方法中无需显式引用外部对象而引用外部对象的成员。

这是TIJ 的272页里的例子吧，那里好像讲得比较清楚了的。

以下是我前面所讲的“撰写一个class,内含一个inner class，后者有non-default构造函数，撰写第二个具备inner class 的class，令其inner class继承第一个inner class”的实例：

class WithNonDefault {
  class Inner {
    int i;
    public Inner(int i); {
      this.i = i;
    }
    public Inner(); {
      i = 47;
    }
    public void f(); {
      System.out.println("Inner.f");;
    }
  }
}

public class E24_InnerClassInheritance {
  class Inner2 extends WithNonDefault.Inner {
    // Won't compile -- no WithNonDefault
    // available:
    //! public Inner2(int i); {
    //!   super(i);;
    //! }
    public Inner2(WithNonDefault wnd, int i); {
      wnd.super(i);;
    }
    public void f(); {
      System.out.println("Inner2.f");;
      super.f();;
    }
  }
  public static void main(String args[]); {
    WithNonDefault wnd = new WithNonDefault();;
    E24_InnerClassInheritance ici =
      new E24_InnerClassInheritance();;
    Inner2 i2 = ici.new Inner2(wnd, 47);;
    i2.f();;
  }
} ///:~

跟我猜想的一样

class Inner2 extends WithNonDefault.Inner {

  // Constructors
  public Inner2(aa this$0, WithNonDefault wnd, int i); { }

  // Methods
  public void f(); { }
}

这个继承自内部类的内部类,要给这两个类都有关系,有两个外层类的句柄.
不知道外部类用来做什么??