黑马程序员技术交流社区

标题: 找不到构造函数 [打印本页]
作者: 李燕    时间: 2013-3-21 10:30
标题: 找不到构造函数
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 bonus;
        Manager (String name,String id,double pay,int bonus)
{
        super(name,id,pay);
        this.bonus=bonus;
}
        public void work()
{       
        System.out.println("manager work");

}
}
class ProEmployee extends Employee
{
        ProEmployee(String name,String id,double pay)
{       
        super(name,id,pay);
}
        public void work()
{
        System.out.println("pro work");

}
}
class Extends
{
        public static void main(String[]args)
        {
        ProEmployee p=new ProEmployee();
        p.work();
        //Manager m=new Manager();
        //m.work();
}
}
劳驾高手给看看，多谢！
作者: 陈腾跃_2013    时间: 2013-3-21 10:56
  1. class Extends {
  2.         public static void main(String[] args) {
  3.                 ProEmployee p = new ProEmployee("cty","01",2000);
  4.                 p.work();
  5.                 // Manager m=new Manager();
  6.                 // m.work();
  7.         }
  8. }
复制代码
构造函数定义的是这样的：ProEmployee(String name,String id,double pay)
main中new的时候没有传参数呀。

作者: Just_Only    时间: 2013-3-21 11:01
ProEmployee p=new ProEmployee();
new 是创建对象的，你的构造函数中有参数的，要接收传进来的值的，构造函数是用来初始化成员变量用的，
这样写就可以的了ProEmployee p=new ProEmployee("王五","20",5.12);
作者: 谷文仁    时间: 2013-3-21 11:07
abstract class Employee
abstract 是抽象类 ，抽象类只能被子类继承，不能实列化。
建议你去看看abstract 与 接口
作者: 陈丽莉    时间: 2013-3-21 15:45
记得及时处理帖子哦，继续追问，或将分类改成【已解决】~
作者: 汪平乐    时间: 2013-3-21 15:54
1.ProEmployee p=new ProEmployee();是调用无参构造方法建立对象，而你的代码中没有无参构造方法，注意这里没有默认的类中没有默认的空参构造方法，所以解决方法是手动增加空参数构造方法；
2.因你代码只有有参数构造方法，所以在建立对象时应使用有参构造方法，如ProEmployee p=new ProEmployee(“aa”，"aa",12);
  1. abstract class Employee
  2. {
  3.         private String name;
  4.         private String id;
  5.         private double pay;

  7.         Employee()
  8.         {
  9.         
  10.         }
  11.         Employee(String name,String id,double pay)
  12.                 {
  13.                         this .name=name;
  14.                         this .id=id;
  15.                         this .pay=pay;

  17.                 }
  18.         public abstract void work();

  20. }
  21. class Manager extends Employee
  22. {
  23.         private int bonus;
  24.         Manager()
  25.         {
  26.         
  27.         }
  28.         Manager (String name,String id,double pay,int bonus)
  29.                     {
  30.                             super(name,id,pay);
  31.                             this.bonus=bonus;
  32.                     }
  33.         public void work()
  34.                     {        
  35.                             System.out.println("manager work");

  37.                     }
  38. }
  39. class ProEmployee extends Employee
  40. {
  41.         ProEmployee()
  42.         {
  43.             
  44.         }
  45.         ProEmployee(String name,String id,double pay)
  46.                 {        
  47.                         super(name,id,pay);
  48.                 }
  49.         public void work()
  50.                 {
  51.                         System.out.println("pro work");

  53.                 }
  54. }

  56. public class AbstractEmployee {

  58.    
  59.             public static void main(String[] args) {
  60.         // TODO code application logic here
  61.         ProEmployee p=new ProEmployee();
  62.         p.work();
  63.         //Manager m=new Manager();
  64.         //m.work();

  66.     }
  67. }
复制代码
作者: 宋朋山    时间: 2013-3-21 16:14
1、抽象类不能被实例化，可以指向子类对象。
2、当类中没有构造函数时，将默认装配一个无参构造。当有有参构造时，默认模有无参构造，如果需要则必须显示声明。
作者: 唐永康    时间: 2013-3-21 17:07
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;

}


很明显你这里已经矛盾了，你把类加上了abstract,就证明这个类不能被实例化，也就是说不能被new对象了，那么
这个时候就不需要构造方法了，所以这里的Employee这个构造方法是多于的。

当然如果你想保留这个构造方法，可以把abstract去掉，
作者: 汪平乐    时间: 2013-3-21 18:19
唐永康 发表于 2013-3-21 17:07
abstract class Employee
{
        private String name;

1.abstract 修饰的类是可以定义构造函数的；
2.Employee 是父类，没有new对象...
作者: 胡国彬    时间: 2013-3-21 21:39
你main方法里面,new ProEmployee(),调用的是ProEmployee的无参的构造函数,而你的ProEmployee类里面没有定义无参的构造函数,所以就会报错,说找不见构造函数.
其实,一个类定义好了之后,如果我们不手动的去写构造函数,这个类默认都是有一个无参的构造函数的,但是,如果我们手动的写了一个构造函数,默认的无参的构造函数就不存在了.在这里,你手动的定义了一个有参的构造函数,所以类默认自带的无参构造函数不存在了,如果想要调用无参的构造函数去new 对象,只需要在ProEmployee的类中添加一个无参的构造函数 ProEmployee(){}.这样就不会报错了.
作者: strawberry2013    时间: 2013-3-22 13:39
本帖最后由 strawberry2013 于 2013-3-22 13:40 编辑

ProEmployee p=new ProEmployee();是调用无参构造方法建立对象，而你代码构造函数中使用的是有参数的
要知道，类中定义了构造函数,就没有默认的无参的构造函数；在类中没有定义构造函数，就默认为空参的！



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