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!");
        }
}

因为 Manager 类中没有 Manager（） 这个无参数的构造方法。


本来java 默认的有 无参构造方法，但是你在程序中重新定义了构造方法Manager(String name,String id,double pay,int jiangJin)
那么原来的无参构造方法就被覆盖了，要想使用需重新定义…………

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.         }

复制代码

构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后，默认的构造函数就没有了。

那在子类 里加了空参的构造函数还是不行啊？

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()
看下代码吧。

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(){}才行

Manager m= new Manager();//提示找不到符号，怎么回事啊？

子类所有的构造函数中隐式地会调用父类无参构造函数，也就是在构造函数的第一句默认的是：super（）；而你的父类Employee中没有定义这个空参构造函数，所以编译器会找不到。

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.         {
    
39. 
    
40.                 Manager m= new Manager();//它在找空参数的构造函数初始化，找到了之后在对象初始化时，要先访问一下父类中对应的构造函数。
    
41.                                                         //而当在类中自定义了构造函数后，默认的构造函数就没有了。所以父类中也要手动加空参构造函数。
    
42.                 m.work();
    
43.                 System.out.println("Hello World!");
    
44.         }
    
45. }

复制代码

{:soso_e127:}这下了解了吧

如果你在类体里没有定义任何构造方法，系统默认给你的是一个无参数的构造方法，一旦你自己定义了构造方法，系统将不提供任何构造方法，所以你 Manager m= new Manager();会提示找不到符号，因为你定义了Manager(String name,String id,double pay,int jiangJin)构造方法，系统就不再为你提供默认的构造方法了。

java程序中，每个class类都会有构造函数，分为无参构造函数和有参构造函数，当你没有定义构造函数的时候，系统会提供一个无参构造函数，但是，当你定义了构造函数，无论是无参构造函数还是有参构造函数，系统都将不再提供无参构造函数了，所以你的Manager m= new Manager();  这里是调用无参构造函数初始化 m 对象，而你的程序中已经有了一个有参构造函数，并没有定义无参构造函数，系统当然就提示报错了。改正的方法是 你在类里边定义一个无参构造函数，或者调用有参构造函数为 m 对象赋值。

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!");
        }
}

楼上的都是正解，
调用基类方法或属性时,会沿着继承链逐级往上寻找,以最近为原则,找到就调用,找不到就报错
添加一句抽象类中的方法必须全都被重写..
你对子类实例化时，调用了基类的属性但没找到基类的属性值，所以报错..

要在类中加入无参的构造函数
manager()
{}

需要在子类中加上空参的构造函数,因为你在子类中定义了一个有参的构造函数,JVM就不会再默认生成一个无参的构造函数,所以需要你显示定义一个无参的构造函数才能建立无参的构造函数,然而子类的构造函数都是默认要先寻找父类的空参构造函数,而你父类的构造函数也定义了有参的.所以一样不会再默认生成一个无参的了.所以你需要在子类的空参构造函数的第一行,显示指定父类的构造函数,或者在父类中也加上一个空参的构造函数.这样就可以创建Manager m= new Manager();这个对象了.. ..你试试..