class Super
{
     int i=0;
     public Super(String s)
      {
               i=1;
      }
}
class Demo extends Super
{
         public Demo(String s)
          {
                 i=3;
          }
          public static void main(String[] args)
           {
                       Demo d=new Demo("yes");
                        System.out.println(d.i);
           }
}

楼主这样写，构造函数前面一般不用加修饰符，要养好习惯，呵呵。
class Super
{
      int i=0;
          String s;
       Super(String s)
       {
                i=1;
                                this.s=s;
       }
}
class Demo extends Super
{
          public Demo(String s)
           {
                          super(s);
                  i=3;
           }
           public static void main(String[] args)
            {
                        Demo d=new Demo("yes");
                         System.out.println(d.i);
            }
}
至少在Demo的构造方法中加入super(s),这样就可以执行了，不知道您想要什么样的结果。

楼主这样写，构造函数前面一般不用加修饰符，要养好习惯，呵呵。
class Super
{
      int i=0;
          String s;
       Super(String s)
       {
                i=1;
                                this.s=s;
       }
}
class Demo extends Super
{
          public Demo(String s)
           {
                          super(s);
                  i=3;
           }
           public static void main(String[] args)
            {
                        Demo d=new Demo("yes");
                         System.out.println(d.i);
            }
}
至少在Demo的构造方法中加入super(s),这样就可以执行了，不知道您想要什么样的结果。

就地一个问题  你的是两个类，定义的i就更本调用不到，再说你的两个方法中传的参数没有起作用。
  再说你调用的方法不对，没有符合子父类继承关系。

(1)把很多类的相同特征和行为进行抽取，用一个类来描述。让多个类和这个类产生一个关系。
           这样的话，多个类就可以省略很多代码。这个关系就是继承。java中用extends关键字表示。
        (2)继承的概述
                A:被继承的类称为超类，父类，基类。
                B:继承父类的类被称为子类，派生类。
                C:格式
                        class Demo extends FuDemo
                        {
                       
                        }
        (3)继承的体系结构
                A:多个具体的对象，不断的向上抽取共享的内容，最终形成了一个体系。这个体系叫做继承体系。
                B:继承体系的学习和使用原则
                        **学习顶层的内容。因为他是整个体系的共性内容。
                        **创建子类使用。也就是使用底层的具体对象。
        (4)继承的特点:
                A:java中只能单继承，没有多继承。
                B:java可以有多重(层)继承。 爷爷--父亲--儿子--孙子
        (5)继承的代码体现。
                class Fu
                {
                }

                class Zi extends Fu
                {
               
                }

                Zi z = new Zi();
                用z对象操作。
        (6)子父类中的成员关系
                A:成员变量
                        在子类方法中使用一个变量时：
                        首先，在方法的局部变量中找这个变量，有则使用。
                        否则，在本类中找成员变量，有则使用。
                        否则，在父类中找成员变量，有则使用。
                        否则，报错。
                B:成员方法
                        用子类对象使用一个方法时。
                        首先，在子类中找这个方法，有则使用。
                        否则，在父类中找这个方法，有则使用。
                        否则，报错。

                        当子父类中的方法名相同时的现象被称为重写。

                        重写和重载的区别？
                        重载：在同一类中。方法名相同，参数列表不同。

                        重写：在不同类中(子父类中)。
                              方法声明相同(返回类型，方法名，参数列表)。

                        重载可以改变返回类型。

                        重写需要注意：
                                **子类方法的访问权限要大于等于父类方法的访问权限。
                                **静态只能重写静态。一般不会出现。
                C:构造方法
                        **子类的实例化过程
                                ***子类创建对象时，会先去创建父类的对象。
                                    默认是去调用父类的无参构造方法。
                                ***子类构造方法中，第一行默认是super()
                                ***为什么子类中第一行会默认有super()
                                        因为他继承父类的成员使用，使用前这些成员必须初始化，
                                        而他们是父类的成员，所以，必须通过父类进行初始化。
                                        所以，会先创建一个父类的对象。
                        **当父类没有无参构造方法时
                                必须使用this或者super调用其他的构造方法。
        (7)this和super的区别
                this:代表本类对象的引用。
                super:代表父类的存储空间。

                用法很相似。


看看   从基础学

class Super
{
      int i=0;
      public Super(String s)
       {
                i=1;
       }
}
class Demo20 extends Super
{
          public Demo20(String s)
           {
                             super(s);//出错在这里
                  i=3;
           }
           public static void main(String[] args)
            {
                        Demo20 d=new Demo20("yes");
                         System.out.println(d.i);
            }
}
当Demo20继承Super时，在创建子类对象进行初始化时，子类必须调用父类的构造函数看父类对子类继承父类成员变量的初始化
清楚父类对成员变量的操作动作，以后子类好对这个成员变量做正确的操作动作。

class Super
{
      int i=0;
      public Super(String s)
       {
                i=1;
       }
}
class Demo extends Super
{
          public Demo(String s)
           {
                  i=3;
           }
           public static void main(String[] args)
            {
                        Demo d=new Demo("yes");//new 的时候会隐式调用父类的无参数构造函数，因为父类中已经写了一个带一个参数的构造函数，默认的无参构造函数就没有了，这样造成了子类实例化的时候无法调用父类无参构造函数。这就是错误原因。解决方法如下代码：
                         System.out.println(d.i);
            }
}
class Super
{
      int i=0;
      public Super(String s)
       {
                i=1;
       }
}
class Demo extends Super
{
          public Demo(String s)
           {
                  super(s);//显示调用父类含参数的构造函数。
                  i=3;
           }
           public static void main(String[] args)
            {
                        Demo d=new Demo("yes");
                         System.out.println(d.i);
            }
}

当你写一个类没写构造函数的时候
会给你默认一个无参的构造（隐式）
当你写了自己的带参数的构造函数就不会给你默认一个无参的构造
那么当别的类继承这个类时候就提示需要你（显式）写一个无参的构造，
因为在子类构造函数中会又隐式语句super()自动调用父类无参数构造函数


当然你在子类中写的构造函数内部指定调用父类的那个函数就没问题
当你不指定调用哪个的时候是默认调用无参的那个

• class Super
• {
•      int i=0;
•      Super() {    //或者像楼上一样，在Demo的构造方法中显示的调用super（“String”）方法           
•      }
•      public Super(String s)
•       {
•                i=1;
•       }
• }
• public class Demo extends Super
• {
•          public Demo(String s)
•           {                       
•                          i = 3;
•           }
•           public static void main(String[] args)
•            {
•                        Demo d=new Demo("yes");
•                         System.out.println(d.i);
•            }
• }
  

• 如果类中显示定义了一个或多个构造方法，并且所有的构造方法都带有参数，那么这个类就失去了java语言为其准备的默认构造方法，此时若使用该类的默认构造方法（即不含参数的构造方法）时就是编译出错。
• 在创建子类的对象时，java虚拟机首先执行父类的构造方法，然后再执行子类的构造方法，在多级继承的情况下，将从继承树的最上层得父类开始，依次执行各个类的构造方法，这可以保证子类对象从所有直接或间接父类中继承的实例变量都被正确的初始化。
• 如果子类的构造方法中没有用super语句显示调用父类的构造方法，那么通过这个构造方法创建子类对象时，java虚拟机会自动先调用父类的默认构造方法，而此时若父类没有默认构造方法时，就是编译出错
  

子类构造方法会在第一行默认调用父类的无参构造方法，而父类已经定义了有参构造，则系统不会再提供默认的无参构造，所以必须自己写父类的无参构造