1. 
   
2. class Super
   
3. {
   
4.         int i = 0;
   
5.        
   
6.         public Super(String s)
   
7.         {
   
8.                 i=1;
   
9.         }
   
10. 
    
11. }
    
12. 
    
13. 
    
14. 
    
15. 
    
16. class  Demo extends Super
    
17. {
    
18.         public Demo(String s)
    
19.         {
    
20.        
    
21.                 i = 2;
    
22.         }
    
23. 
    
24. 
    
25.         public static void main(String[] args)
    
26.         {
    
27.                 Demo d = new Demo("yes");
    
28.                 System.out.println(d.i);
    
29.         }
    
30. }
    

复制代码

报错为：

D:\java1203\day10>javac Demo.java
Demo.java:19: 找不到符号
符号： 构造函数 Super()
位置： 类 Super
        {
        ^
1 错误

我知道下面这个地方隐藏有一个super() 那么，如何才能把下面这个改正确呢，在上面不改动父类的情况下。我对这块有点晕了。

public Demo(String s)
                {
                i = 2;
        }

class  Demo extends Super
{
        public Demo(String s)
        {
        
                i = 2;
        }


        public static void main(String[] args)
        {
                Demo d = new Demo("yes");
                System.out.println(d.i);
        }
}
我知道下面这个地方隐藏有一个super() 那么，如何才能把下面这个改正确呢，在上面不改动父类的情况下。我对这块有点晕了。
原理：1因为在父类中已经写了构造函数，那默认空参数的构造函数就没有了。2当父类默认的空参数的构造函数不存在时，子类必须手动指定要初始化父类的哪个构造函数。格式

是super(s)。改完结果如下：
class Super
{
        int i = 0;
        
        public Super(String s)
        {
                i=1;
        }

}




class  Demo extends Super
{
        public Demo(String s)
        {
                super(s);
        
                i = 2;
        }


        public static void main(String[] args)
        {
                Demo d = new Demo("yes");
                System.out.println(d.i);
        }
}

class Super
{
       int i = 0;
      public Super(String s)
       {
                i=1;
       }
}
class  DemoExtends extends Super
{
   public DemoExtends(String s)
   {
        super("yes");  //因为你重写的父类的构造方法，此处默认的是super();
        i = 2;
   }
   public static void main(String[] args)
   {
         DemoExtends d = new DemoExtends("yes");
         System.out.println(d.i);
    }
}

                因为  super(); 子类中的构造方法的第一行都是 super()隐式初始化。

                解决方案1：  是在父类不需要无参数的构造方法，那么在子类构造方法第一行显式初始化----->super("实参");
                解决方案2：  在父类中写入无参数的构造方法。 Super(){}，先进行父类无参数的初始化。
                解决方案3：在子类中定义一个无惨的构造方法 Demo(){super("实参");}  然后在有参数的构造方法中，第一行  this();
                总之，父类没有无参的构造方法，那么我们就不能隐式初始化！只能显式初始化。

子类构造函数默认都会调用super()，你现在的父类的构造函数被你改成了  
    public Super(String s)
       {
                i=1;
       }
子类的构造函数找不到super()  当然报错了  有两种解决方案
1 在你的父类中加入   public Super()
       {
         i=0;
       }
2 在子类的构造函数中加入super(s)就行了

子类初始化时必须调用父类的构造方法，子类是如何调用父类的构造方法的呢？如下：
1，子类构造方法执行体的第一行代码使用super显示调用父类构造方法，系统将要根据super调用里传入的实参列表调用父类对应的构造方法。
2，子类构造方法执行体的第一行代码使用this显式调用本类中重载的构造方法，系统将根据this调用里传入的实参列表调用本类另一个构造方法。执行本类中别一个构造方法时即会调用父类的构造方法。
3，子类构造方法执行体中既没有super调用，也没有this调用，系统将会在执行子类构造方法之前，隐式调用父类无参数的构造方法。
你这个代码属于第三种情况，而父类Super中却没有无参数的构造方法，所以编译会出错，建议在父类中添加一个无参数的构造方法，或者在子类构造方法中用super关键字显示调用父类的构造方法。如下：
15.class  Demo extends Super

16.{

17.        public Demo(String s)

18.        {

19.                super(s);   

20.                i = 2;

21.        }

22.

23.

24.        public static void main(String[] args)

25.        {

26.                Demo d = new Demo("yes");

27.                System.out.println(d.i);

28.        }

29.}

当你父类写了构造函数。。无论多少了。。只要其中你没写一个无参数的构造函数。。那么子类在继承它的时候就必须用super关键字指出你所要用的构造函数是哪一个。。传入对应的参数。。。如果没指定就会去找默认的无参数的构造函数。。找不到就会报错。。。。所以我们一般写了构造函数之后。也会写一个无参的构造函数给它。。。。

我知道下面这个地方隐藏有一个super() ？
父类中写了构造函数，那默认空参数的构造函数就没有了。

如何才能把下面这个改正确呢，在上面不改动父类的情况下？
父类有构造函数：public Super(String s)，所以加个super（“哈哈”）;或者super（“XX”）；自己看着办

我知道下面这个地方隐藏有一个super() 那么，如何才能把下面这个改正确呢，在上面不改动父类的情况下。我对这块有点晕了。

public Demo(String s)
                 {
                 i = 2;
         }




你不想要改动父类的话,那么只能在
public Demo(String s)
                 {

                 super(s);
                /*添加一个指定的父类构造函数的引用,这是因为你在父类中定义了一个带参数的构造函数,
                   所以父类中本来默认会有的空参数构造函数会自动消失,而子类构造函数中必须在第一行
            使用this或者super指定一个构造函数
          */
                 i = 2;
         }

说说我的理解。有不对不准确的地方，多多包含。

首先，纠正楼主的错误。这个例子中，子类构造方法中没有隐藏一个super()。这是因为父类根本没有super()。

关于继承的构造方法的处理。子类不继承父类的构造方法，必须调用父类的构造方法。子类构造方法默认调用父类的默认构造方法。否则，手动调用父类的构造方法。

问题就在这，父类没有默认的构造方法，子类又没有调用父类的构造方法，那么语法上出问题了。