看下下面代码，class TongYong
{
        private String name;
        private String id;
        private double gz;
        TongYong(String name,String id,double gz)
        {
                this.name=name;
                this.id=id;
                this.gz=gz;
        }
        public abstract void work();
}
class JingLi extends TongYong
{       
        private int jiangjin;
        JingLi(String name,String id,double gz,int jiangjin)
        {
                super(name,id,gz);
                this.jiangjin=jiangjin;

        }
        public void work()//覆盖的时候必须与父类的方法是一模一样，要用abstract吗？
        {
                System.out.println("lingdao");
        }

}
class Worker extends TongYong
{       

        Worker(String name,String id,double gz)
        {
                super(name,id,gz);
        }
        public void work()//覆盖的时候必须与父类的方法是一模一样，要用abstract吗？
        {
                System.out.println("pugong");
        }
}
class GongSi
{
        public static void main(String[] args)
        {
                        Worker w=new Worker("权跃杰","技术78号",3200);
                        w.work();//抽象方法能覆盖吗？
        }
}


TongYong不是抽象的，并且未覆盖TongYong中的抽象方法work（）class TongYong


这样怎么解决？

class TongYong 这个类不是抽象类，就不能有抽象方法
如果类中有抽象方法，那么这个类必须是抽象类，改成class abstract TongYong
抽象方法可以覆盖啊，

抽象类中可以不包含抽象方法，但是包含抽象方法就一定要定义为抽象类，把类用abstract修饰，你的Tongyong类中含有抽象方法public abstract void work();
所以TongYong类需要定义为抽象方法，抽象方法就是用来覆盖的，子类中具体实现父类中的抽象方法，子类如果为非抽象类，则必须实现父类中定义的抽象方法。子类为非抽象类时就不再用abstract修饰。

abstract class TongYong//加上abstract,类里面有抽象方法，这个类就必须是抽象类
{
        private String name;
        private String id;
        private double gz;
        TongYong(String name,String id,double gz)
        {
                this.name=name;
                this.id=id;
                this.gz=gz;
        }
        public abstract void work();
}
class JingLi extends TongYong
{        
        private int jiangjin;
        JingLi(String name,String id,double gz,int jiangjin)
        {
                super(name,id,gz);
                this.jiangjin=jiangjin;

        }
        public void work()//覆盖的时候必须与父类的方法是一模一样，要用abstract吗？
                    //不用，abstract通常用来定义没有方法体的方法。     
   {
                System.out.println("lingdao");
        }

}
class Worker extends TongYong
{        

        Worker(String name,String id,double gz)
        {
                super(name,id,gz);
        }
        public void work()//覆盖的时候必须与父类的方法是一模一样，要用abstract吗？
                      //不用，abstract通常用来定义没有方法体的方法。
        {
                System.out.println("pugong");
        }
}
class GongSi
{
        public static void main(String[] args)
        {
                        Worker w=new Worker("权跃杰","技术78号",3200);
                        w.work();//抽象方法能覆盖吗？//能覆盖啊，大多数抽象方法都是用来覆盖的        }
}

你的问题可以在以下的第 1> ,3> 中找到答案,另外赠送几点，呵呵。

1. 抽象类的特点：

  1> 抽象方法一定在抽象类中。

  2> 抽象方法和抽象类都必须被abstract关键字修饰。

  3> 抽象类不可以用new创建对象。因为调用抽象方法没意义。

  4> 抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，(若只是覆                盖部分，子类继承后仍有抽象方法，就变成了抽象类）

                 建立子类对象用。如果子类只                        覆盖了部分抽象方法，那么该子类还是一个抽象类。

  5>抽象类具有强制性，强迫子类必须复写

class TongYong中定义了public abstract void work(); 抽象方法，所以类必须定义为抽象类。子类继承了抽象类，如果要用子类创建实例对象，必须实现抽象方法。

ok,是抽象类中可以有不抽象的方法，普通类中不可以有抽象方法，抽象方法必须存在于抽象类中