1.当创建一个子类时，子类构造器总会调用父类的构造器，那么在创建非静态内部类的子类呢，非静态内部类的子类不一定是内部类，他也可以使一个外部类
上代码：

1. class Out
   
2. {
   
3. class In
   
4. {
   
5. public In(String msg)
   
6. {
   
7. System.out.println();
   
8. }
   
9. void show(){}
   
10. }
    
11. 
    
12. }
    
13. 
    
14. public class SubClass extends Out.In
    
15. {
    
16. public SubClass()
    
17. {
    
18. //怎样调用父类的构造函数的
    
19. }
    
20. 
    
21. }

复制代码

问题一：他是怎样调用父类的构造函数的？

问题二：既然内部类是外部类的成员，那么是否可以为外部类定义子类，在子类中再定义一个内部类来重写其父类中的内部类，求原理？

问题三：谁了解回调，就是
interface Teacher
{
     void work();
}

class Programmer
{
   private String name;
   public programmer(){}
   public programmer(String name)
   {
      this.name=name;
    }
    ......省略  setter 和getter方法
  public void work()
  {
     System.ot.println(name+"写代码");
   }
}

就是说现在有一个人如培训java的老师一样，他既是程序员，同时也是一名老师,也就是说需要定义一个特殊的类，既要实现Teacher接口，也需要实现Programmer父类
用内部类该怎样解决？
如果这样定义
class     TeacherProgrammerTest  extends Programmer implements Teacher
{
   public void work()
   {
         System.out.println("讲课");
   }
}
这样定义只有一个work，只能讲课，不能编程了，肯定不行了，但实际需要teacherprogram类既包含“讲课”的work方法，也包含“编程”的work方法
问题有点多，呵呵
class TeacherProgrammerTest extends Programmer
{
  public TeacherProgrammer(String name)
   {
       super(name);
   }
   public Teacher getInstance()
   {
       return new  Teacher()
         {
               public void work()
               {
                 System.out.println("讲课");
                }
          };
   }
public static void main(String[] args)
{
   TeacherProgramTest  tpt=nw TeacherProgamTest();
     tpt.work();
     tpt.getInstance().work();
}

}
问题三，今天早上想到了，按照上面的实现，分享一下，顺便大家看看有错没，呵呵，但还有上面两个问题没想通，帮忙解释一下

楼主虽然我没学到继承那边  但是我看了一道很好的题目 您可以看看  我收藏了都 估计对你有用要弄明白程序的执行顺序首先要明白 继承继承静态代码块构造代码块构造函数 的执行顺序，他们的顺序是：
父类静态代码块>>子类静态代码块>>父类构造代码块>>父类构造函数>> 子类构造代码块>>子类构造函数。
执行步骤（个人见解）
class Root    //第5步：找到Root，开始执行
{
static {  //第6步：由于有静态代码块，先执行静态代码块，进行初始化，打印1:Root静态构造代码块
   System.out.println("1:Root静态构造代码块") ;
}   
{   //第9步：执行父类的构造代码块，打印2:Root普通构造代码块
   System.out.println("2:Root普通构造代码块") ;
}
public Root() { //第10步：执行父类构造函数，打印3:Root构造函数
   System.out.println("3:Root构造函数") ;
}
}
class Mid extends Root    //第4步：找到Mid类，他又继承了Root，再去找Root类
{
static {     //第7步：Root初始化完成后寻找子类，也有静态代码块，先执行，并打印4:Mid静态构造代码块
   System.out.println("4:Mid静态构造代码块") ;
}
{   //第11步：执行性次构造代码块 打印5:Mid普通构造代码块
   System.out.println("5:Mid普通构造代码块");
}
public Mid() { //第12步：执行此构造函数，打印6:Mid无参构造函数
   System.out.println("6:Mid无参构造函数") ;
}
public Mid(String msg) {   //第13步：执行此构造函数打印7:Mid有参构造函数"+msg，msg由Leaf（）调用super传入疯狂java讲义，所以打印Mid有参构造函数疯狂java讲义
   this ();
   System.out.println("7:Mid有参构造函数"+msg) ;
}
}
class Leaf extends Mid   
{
static {    //第8部：理由同第六步，打印8eaf静态构造代码块。静态代码块都完成了，再找父类的构造代码块
   System.out.println("8eaf静态构造代码块") ;
}
{   //第14部最后执行子类的构造代码块，打印9eaf普通构造代码块
   System.out.println("9eaf普通构造代码块") ;
}
public Leaf() {   //第2步，要new对象，找到Leaf的构造函数
   super("疯狂java讲义");  //第3步，调用父类，并且有参数 疯狂java讲义
   System.out.println("10eaf有参构造函数") ;  //第15步，打印10eaf有参构造函数
}
}
public class demo {
public static void main(String[] args) {
   new Leaf() ;        //第1步：找到main方法开始执行这一句，
}
}

interface Teacher//实现一个接口 接口名字是Teacher
{
      void work();//接口的调用Work这个方法。
}

class Programmer
{
    private String name;  
    public programmer(){}
    public programmer(String name)
    {
       this.name=name;
     }
    // ......省略  setter 和getter方法
   public void work()
   {
      System.ot.println(name+"写代码");
    }
}


class     TeacherProgramerTest  extends Programmer implements Teachable //继承了Programmer 这个类 实现 Teachable这个也没有对应的接口啊？ 您定义的接口不是Theacher吗？
{
    public void work()
    {
          System.out.println("讲课");
    }
}
多态：可以理解为事物存在的多种体现形态。

1.多态的体现
父类的引用只想了自己的子类对象
父类的引用也可以接受自己的子类对象
2.多态的前提
必须是类与类之间有关系。要么继承， 要么实现。
通常还有一个前提，存在覆盖。

接口：是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法
全部覆盖后，子类才可以实例化。否则子类是一个抽象类。

这是我自学时候看毕老师讲的 现在在上毕老师真人班的课呵呵 具体还没讲到那 我没那个能力 不知道能不能帮到楼主 尽力了

但是我这有错的 希望告诉我啊 我也想学习学习啊

李志群 发表于 2012-7-13 01:29
interface Teacher//实现一个接口 接口名字是Teacher
{
      void work();//接口的调用Work这个方法。

那个是Teacher，不是Teachable ，昨天晚上太晚了，我打错了，抱歉，这个今天早上我用匿名内部类实现了