要求有一个abstract类，类名为Employee。Employee的子类有 YearWorker，MonthWorker， WeekWorker。YearWorker对象按年领取薪水，MonthWorker按月领取薪水，WeekWorker按周领取薪水。Employee类有一个abstract方法: public abstract earnings(); 子类必须重写父类的eanings()方法，给出各自领取薪水的具体方式。 按年领取薪水的计算方法是：12000 按月领取薪水的计算方法是：12*2300 按周领取薪水的计算方法是：52*780 另外有一个Company类，该类用Employee对象数组作为成员，Employee对象数组的单元可以是YearWorker对象的上转型对象、MonthWorker对象的上转型对象或WeekWorker对象的上转型对象。程序能输出Company对象一年需要支付的薪水总额。即Company需要一个带参的构造方法来初始化Employee数组，需要提供public double salariesPay()方法计算公司一年需要支付的薪水总额，并返回。

好的，这是一个比较长的问题，我先给您提供一个简单的实现思路：

1. 定义一个抽象类 Employee，包含一个抽象方法 earnings()。

2. 在 Employee 中定义三个子类 YearWorker，MonthWorker 和 WeekWorker，分别实现 earnings() 方法，计算薪水的具体方式不同。

3. 定义一个 Company 类，该类用 Employee 对象数组作为成员，实现 salariesPay() 方法计算公司一年需要支付的薪水总额。

下面是简单实现的代码示例：

// Employee 抽象类
abstract class Employee {
    public abstract double earnings();
}

// YearWorker 子类
class YearWorker extends Employee {
    @Override
    public double earnings() {
        return 12000;
    }
}

// MonthWorker 子类
class MonthWorker extends Employee {
    @Override
    public double earnings() {
        return 12 * 2300;
    }
}

// WeekWorker 子类
class WeekWorker extends Employee {
    @Override
    public double earnings() {
        return 52 * 780;
    }
}

// Company 类
class Company {
    private Employee[] employees;

    public Company(Employee[] employees) {
        this.employees = employees;
    }

    public double salariesPay() {
        double totalPay = 0;
        for (Employee employee : employees) {
            totalPay += employee.earnings();
        }
        return totalPay;
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Employee[] employees = new Employee[3];
        employees[0] = new YearWorker();
        employees[1] = new MonthWorker();
        employees[2] = new WeekWorker();

        Company company = new Company(employees);
        System.out.println("公司一年需要支付的薪水总额：" + company.salariesPay());
    }
}

注意，这只是一个简单的实现示例，具体实现方式可能因不同的需求而有所不同。