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();
}
}
劳驾高手给看看，多谢！

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的时候没有传参数呀。

ProEmployee p=new ProEmployee();
new 是创建对象的，你的构造函数中有参数的，要接收传进来的值的，构造函数是用来初始化成员变量用的，
这样写就可以的了ProEmployee p=new ProEmployee("王五","20",5.12);

abstract class Employee
abstract 是抽象类 ，抽象类只能被子类继承，不能实列化。
建议你去看看abstract 与 接口

记得及时处理帖子哦，继续追问，或将分类改成【已解决】~

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;
   
6. 
   
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;
    
16. 
    
17.                 }
    
18.         public abstract void work();
    
19. 
    
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");
    
36. 
    
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");
    
52. 
    
53.                 }
    
54. }
    
55. 
    
56. public class AbstractEmployee {
    
57. 
    
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();
    
65. 
    
66.     }
    
67. }

复制代码

1、抽象类不能被实例化，可以指向子类对象。
2、当类中没有构造函数时，将默认装配一个无参构造。当有有参构造时，默认模有无参构造，如果需要则必须显示声明。

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 17:07
abstract class Employee
{
        private String name;

1.abstract 修饰的类是可以定义构造函数的；
2.Employee 是父类，没有new对象...

你main方法里面,new ProEmployee(),调用的是ProEmployee的无参的构造函数,而你的ProEmployee类里面没有定义无参的构造函数,所以就会报错,说找不见构造函数.
其实,一个类定义好了之后,如果我们不手动的去写构造函数,这个类默认都是有一个无参的构造函数的,但是,如果我们手动的写了一个构造函数,默认的无参的构造函数就不存在了.在这里,你手动的定义了一个有参的构造函数,所以类默认自带的无参构造函数不存在了,如果想要调用无参的构造函数去new 对象,只需要在ProEmployee的类中添加一个无参的构造函数 ProEmployee(){}.这样就不会报错了.

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