黑马程序员技术交流社区

标题: 初学继承问题 [打印本页]
作者: 孙飞    时间: 2012-6-22 20:05
标题: 初学继承问题
本帖最后由 feigecal 于 2012-6-23 22:26 编辑

abstract class Employee
{
        private String name;
        private String id;
        private double pay;
        Employee(String name,String id,double pay)
        {
                this.name=name;
                this.id=id;
                this.pay=pay;
        }
        public abstract void work();
}
class Manager extends Employee
{
        private int jiangJin;
        Manager(String name,String id,double pay,int jiangJin)
        {
                super(name,id,pay);
                this.jiangJin=jiangJin;
        }
        public void work()
        {
                System.out.println("ok");
        }
}
class Test
{
        public static void main(String[] args)
        {
                Manager m= new Manager();//提示找不到符号，怎么回事啊？
                m.work();
                System.out.println("Hello World!");
        }
}
作者: 丁二跃    时间: 2012-6-22 20:13
因为 Manager 类中没有 Manager（） 这个无参数的构造方法。


本来java 默认的有 无参构造方法，但是你在程序中重新定义了构造方法Manager(String name,String id,double pay,int jiangJin)
那么原来的无参构造方法就被覆盖了，要想使用需重新定义…………
作者: 张文强    时间: 2012-6-22 20:16
本帖最后由 张文强 于 2012-6-22 20:40 编辑
  1. public class Test
  2. {
  3.         public static void main(String[] args)
  4.         {     // Manager m= new Manager();//它在找空参数的构造函数初始化，如果类中没有，就是说没有与之对应的初始化方式。会提示找不到符号
  5.                 Manager m= new Manager("zhangsan","sss",3443,32);
  6.                 m.work();
  7.                 System.out.println("Hello World!");
  8.         }
复制代码
构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后，默认的构造函数就没有了。


作者: 孙飞    时间: 2012-6-22 20:24
那在子类 里加了空参的构造函数还是不行啊？
作者: 王涛    时间: 2012-6-22 20:56
abstract class Employee
{
        private String name;
        private String id;
        private double pay;
                Employee()        //在父类中写一个空参数的Employee（）方法。
        {
               
        }
        Employee(String name,String id,double pay)
        {
                this.name=name;
                this.id=id;
                this.pay=pay;
        }
        public abstract void work();
}
class Manager extends Employee
{
        private int jiangJin;
        Manager(String name,String id,double pay,int jiangJin)
        {
                super(name,id,pay);
                this.jiangJin=jiangJin;
        }
                Manager()
                {
                       
                }

        public void work()
        {
                System.out.println("ok");
        }
}
class Test
{
        public static void main(String[] args)
        {
               //Manager m= new Manager("wt","13",23,1000);   //提示找不到符号，怎么回事啊？
                Manager m= new Manager();
                               
                                m.work();
                System.out.println("Hello World!");
        }
}

你在父类中写一个空参数的，用子类去继承，然后才可以再子类中调用空参数的Manager()
看下代码吧。
作者: 范家鹏    时间: 2012-6-22 20:57
  1. abstract class Employee
  2. {
  3.          private String name;
  4.          private String id;
  5.          private double pay;
  6.                  Employee(){};
  7.          Employee(String name,String id,double pay)
  8.          {
  9.                  this.name=name;
  10.                  this.id=id;
  11.                  this.pay=pay;
  12.          }
  13.          public abstract void work();
  14. }
  15. class Manager extends Employee
  16. {
  17.          Manager(){};
  18.                  private int jiangJin;
  19.          Manager(String name,String id,double pay,int jiangJin)
  20.          {
  21.                  super(name,id,pay);
  22.                  this.jiangJin=jiangJin;
  23.          }
  24.          public void work()
  25.          {
  26.                  System.out.println("ok");
  27.          }
  28. }
  29. class Test
  30. {
  31.          public static void main(String[] args)
  32.         {
  33.                  Manager m= new Manager();//提示找不到符号，怎么回事啊？
  34.                  m.work();
  35.                  System.out.println("Hello World!");
  36.          }
  37. }
复制代码
这样就行了，
这句话Manager m= new Manager();在创建Manager对象时，
会调用Manager的空参数的构造函数；在类中得添加一个空参数的构造函数Manager(){};
又因为Manager继承了Employee
Manager的空参数构造中有一句隐式的父类空参数构造，也就是Employee的空参数构造，
你在上面写了一个Employee的带参构造，原来默认的无参构造就被覆盖了，
所以在Employee类中必须要手动添加一个Employee(){}才行
作者: 黄连兵    时间: 2012-6-22 20:58
Manager m= new Manager();//提示找不到符号，怎么回事啊？

子类所有的构造函数中隐式地会调用父类无参构造函数，也就是在构造函数的第一句默认的是：super（）；而你的父类Employee中没有定义这个空参构造函数，所以编译器会找不到。
作者: 张文强    时间: 2012-6-22 21:19
  1. abstract class Employee
  2. {
  3.         private String name;
  4.         private String id;
  5.         private double pay;
  6.                  Employee()
  7.         {
  8.              System.out.println("Employee中空参数构造函数");
  9.         }
  10.         Employee(String name,String id,double pay)
  11.         {
  12.                 this.name=name;
  13.                 this.id=id;
  14.                 this.pay=pay;
  15.         }
  16.         public abstract void work();
  17. }
  18. class Manager extends Employee
  19. {
  20.         private int jiangJin;
  21.                 Manager()
  22.         {
  23.              System.out.println("Manager空参数构造函数");
  24.         }
  25.         Manager(String name,String id,double pay,int jiangJin)
  26.         {
  27.                 super(name,id,pay);
  28.                 this.jiangJin=jiangJin;
  29.         }
  30.         public void work()
  31.         {
  32.                 System.out.println("ok");
  33.         }
  34. }
  35. class Test
  36. {
  37.         public static void main(String[] args)
  38.         {

  40.                 Manager m= new Manager();//它在找空参数的构造函数初始化，找到了之后在对象初始化时，要先访问一下父类中对应的构造函数。
  41.                                                         //而当在类中自定义了构造函数后，默认的构造函数就没有了。所以父类中也要手动加空参构造函数。
  42.                 m.work();
  43.                 System.out.println("Hello World!");
  44.         }
  45. }
复制代码
{:soso_e127:}这下了解了吧
作者: 谭立文    时间: 2012-6-22 22:27
如果你在类体里没有定义任何构造方法，系统默认给你的是一个无参数的构造方法，一旦你自己定义了构造方法，系统将不提供任何构造方法，所以你 Manager m= new Manager();会提示找不到符号，因为你定义了Manager(String name,String id,double pay,int jiangJin)构造方法，系统就不再为你提供默认的构造方法了。
作者: 李文龙    时间: 2012-6-22 22:35
java程序中，每个class类都会有构造函数，分为无参构造函数和有参构造函数，当你没有定义构造函数的时候，系统会提供一个无参构造函数，但是，当你定义了构造函数，无论是无参构造函数还是有参构造函数，系统都将不再提供无参构造函数了，所以你的Manager m= new Manager();  这里是调用无参构造函数初始化 m 对象，而你的程序中已经有了一个有参构造函数，并没有定义无参构造函数，系统当然就提示报错了。改正的方法是 你在类里边定义一个无参构造函数，或者调用有参构造函数为 m 对象赋值。
作者: 游洪波    时间: 2012-6-23 19:36
abstract class Employee
{
        private String name;
        private String id;
        private double pay;
        Employee(String name,String id,double pay)
        {
                this.name=name;
                this.id=id;
                this.pay=pay;
        }
        public abstract void work();
}
class Manager extends Employee
{
        private int jiangJin;
        Manager(String name,String id,double pay,int jiangJin)//看到你的构造方法没有，这个里边是需要参数的。

        {
                super(name,id,pay);
                this.jiangJin=jiangJin;
        }
//如果你想你下边的那个实例化不报错的话不防试试java中的方法的重载
         Manager(){//这样下边在实例化的时候就不会报错了，你可以好好看看java中方法重载和重写这块。

}
        public void work()
        {
                System.out.println("ok");
        }
}
class Test
{
        public static void main(String[] args)
        {
                Manager m= new Manager();//而你这边在为Manager 实例化的时候却没有传入对应的参数      
         m.work();
                System.out.println("Hello World!");
        }
}

作者: 常佳杰    时间: 2012-6-23 21:14
楼上的都是正解，
调用基类方法或属性时,会沿着继承链逐级往上寻找,以最近为原则,找到就调用,找不到就报错
添加一句抽象类中的方法必须全都被重写..
你对子类实例化时，调用了基类的属性但没找到基类的属性值，所以报错..
作者: 刘天骆    时间: 2012-6-23 22:56
要在类中加入无参的构造函数
manager()
{}
作者: 陈洋洋    时间: 2012-6-23 23:52
需要在子类中加上空参的构造函数,因为你在子类中定义了一个有参的构造函数,JVM就不会再默认生成一个无参的构造函数,所以需要你显示定义一个无参的构造函数才能建立无参的构造函数,然而子类的构造函数都是默认要先寻找父类的空参构造函数,而你父类的构造函数也定义了有参的.所以一样不会再默认生成一个无参的了.所以你需要在子类的空参构造函数的第一行,显示指定父类的构造函数,或者在父类中也加上一个空参的构造函数.这样就可以创建Manager m= new Manager();这个对象了.. ..你试试..



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2