问题：怎么父类中，用构造函数编译不能通过，但是换成方法void method()之后有可以编译通过呢，是不是用具体方之后，子类就不会继承默认的super()了

class Demo2
{
        public static void main(String[] args)
        {
                Zi z = new Zi();
                Zi zz = new Zi(1);
                //z.method();
}

class Fu
{
       
        Fu(int x)
        {
                System.out.println("Fu......."+x);
        }
       
        /*
        void method()
        {
        System.out.println("Fu.......");
        }
        */
}

class Zi extends Fu
{
       
        Zi()
        {
                //super();
                System.out.println("Zi run");
        }
       
        Zi(int x)
        {
                //this();
                System.out.println("zi....."+x);
        }
}

1. class Demo2
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Zi z = new Zi();
   
6.                 Zi zz = new Zi(1);
   
7.                 //z.method();
   
8.         }        //哥们此处忘记写"}"了，
   
9. }
   
10. 
    
11. class Fu
    
12. {
    
13.         Fu(int x)
    
14.         {
    
15.                 System.out.println("Fu......."+x);
    
16.         }
    
17.         
    
18.         /*
    
19.         void method()
    
20.         {
    
21.         System.out.println("Fu.......");
    
22.         }
    
23.         */
    
24. }
    
25. 
    
26. class Zi extends Fu
    
27. {
    
28.         Zi()
    
29.         {
    
30.                 super(22);        //调用自定义构造函数，即便调用父类构造，此处也必须有参数
    
31.                         //如果没有super();语句，程序调用的是默认的构造函数(即空参构造)，而不是自定义的构造函数，所以会报错
    
32.                 System.out.println("Zi run");
    
33.         }
    
34.         
    
35.         Zi(int x)
    
36.         {
    
37.                 this();        //此处的this调用了Zi里的Zi();构造，
    
38.                 System.out.println("zi....."+x);
    
39.         }
    
40. }

复制代码

但是Fu类不用构造函数，用method方法就可以正常运行哦，如果用构造函数就编译不能通过，求解析

lz问题是怎么解决的呢 能告诉我哈么  我也碰到类似的问题？

class  TestDemo {
         
         
         



public static void main(String[] args)
{
                        TestDemo.Zi z=new TestDemo.Zi();
                         Zi zz = new Zi(1);
                         zz.method();
}

         class Fu
         {
               
                 Fu(int x)
                 {
                         System.out.println("Fu......."+x);
                 }
                
                
                 void method()
                 {
                 System.out.println("Fu.......");
                 }
                
         }

         static  class  Zi extends Fu
         {
                
             

                        public  Zi()
                 {
                         super(s);编译通不过，求真相
                         System.out.println("Zi run");
                 }
                
                public Zi(int x)
                 {
                        this();
                         System.out.println("zi....."+x);
                 }
         }


}

赵学刚 发表于 2012-12-4 11:51
class  TestDemo {
         
         

你的s是什么？？？？？~

传给父类构造方法的x的实际参数

一句话，重载下父类无参的构造方法。不懂原因，去看视频自己找答案，或者谷歌一下查查super和this的用法。查过后你一辈子都记得是什么原因

楼主的问题2楼已经回答了,的确如楼主所说一个类有了具体构造方法,就不会再隐式的给它一个参数为空的构造方法了.
而子类会默认在构造方法第一句调用父类的构造方法,如果不写会隐式调用父类参数为空的构造方法,如果父类没有,编译肯定不通过.

4楼的问题和楼主是不同的问题,关键是出在内部类和static修饰符上.
若把内部内Zi的static修饰符去掉,或者把Fu,Zi和TestDemo写成三个并排类都没有问题.若非要写成内部类还要加static修饰符那么必须把Fu也加上static修饰,
代码如下

1. public class Test
   
2. {
   
3.         private static int s = 0;
   
4.         public static void main(String[] args)
   
5.         {
   
6.               Test.Zi z=new Test.Zi();
   
7.               Zi zz = new Zi(1);
   
8.               zz.method();
   
9.         }
   
10. 
    
11.         static class Fu
    
12.         {
    
13.                 Fu(int x)
    
14.                 {
    
15.                         System.out.println("fu........" + x);
    
16.                 }
    
17. 
    
18.                 void method()
    
19.                 {
    
20.                         System.out.println("fu......");
    
21.                 }
    
22.         }
    
23. 
    
24.         static class Zi extends Fu
    
25.         {
    
26.                 public Zi()
    
27.                 {
    
28.                         super(s);// 编译通不过，求真相
    
29.                         System.out.println("Zi run");
    
30.                 }
    
31. 
    
32.                 public Zi(int x)
    
33.                 {
    
34.                         this();
    
35.                         System.out.println("zi....." + x);
    
36.                 }
    
37.         }
    
38. }
    

复制代码

原因就在static的加载是先与类的加载,换句话说就是static修饰的东西不能调用对象的属性,因为那个时候对象还不存在,你的内部类Zi已经存在了,而Zi存在的时候还用super(s)造出了一个还不该出现的Fu对象,明显不可以.
另外需要说的是如果将static都去掉,要想创建一个内部类对象,必须先有外部类对象,因为这个时候内部类是外部类对象的一个属性,没有对象是不能调用非静态属性的,就得写成Test.Zi z= new Test().new Zi();

嗯  谢谢楼上罗同学