abstract类怎么声明对象数组

由于抽象类无法实例化，因此无法声明抽象类的对象数组。但是，可以声明抽象类的子类的对象数组，这些子类必须实现了抽象类中所有的抽象方法。

例如，假设有一个抽象类Animal，它有一个抽象方法move()，并且有两个子类Dog和Cat，它们都实现了move()方法。那么可以这样声明一个Animal类型的对象数组：

Animal[] animals = new Animal[2];
animals[0] = new Dog();
animals[1] = new Cat();

这样就声明了一个包含两个Animal类型的对象的数组，其中第一个元素是Dog类型的对象，第二个元素是Cat类型的对象。可以通过循环遍历数组中的元素，调用它们的move()方法实现多态。

相关问题

编写Java程序，要求有一个 abstract 类，类名为 Employee。Employee 的子类有 YearWorker、MonthWorker、WeekWorker。YearWorker 对象按年领取薪水，onthWorker 按月领取薪水，WeekWorker 按周领取薪水。Employee 类有一个 abstract 方法： public abstract double earnings(); 子类必须重写父类的 earnings()方法，给出各自领取报酬的具体方式。 有一个 Company 类，该类用 Employee 对象数组作为成员，Employee 对象数组的单元可以是 YearWorker 对象的上转型对象、MonthWorker 对象的上转型对象或 WeekWorker 对象的上转型对象。程序能输出 Company 对象一年需要支付的薪水总额。

好的，这是一个经典的面向对象编程问题。以下是一个可能的解决方案：

abstract class Employee {
    public abstract double earnings();
}

class YearWorker extends Employee {
    private double salary;
    public YearWorker(double salary) {
        this.salary = salary;
    }
    public double earnings() {
        return salary;
    }
}

class MonthWorker extends Employee {
    private double salary;
    public MonthWorker(double salary) {
        this.salary = salary;
    }
    public double earnings() {
        return salary * 12;
    }
}

class WeekWorker extends Employee {
    private double salary;
    public WeekWorker(double salary) {
        this.salary = salary;
    }
    public double earnings() {
        return salary * 52;
    }
}

class Company {
    private Employee[] employees;
    public Company(Employee[] employees) {
        this.employees = employees;
    }
    public double calculateTotalSalary() {
        double total = 0;
        for (Employee e : employees) {
            total += e.earnings();
        }
        return total;
    }
}

// 测试代码
Employee[] employees = {
    new YearWorker(10000),
    new MonthWorker(8000),
    new WeekWorker(2000)
};
Company company = new Company(employees);
System.out.println("Total salary: " + company.calculateTotalSalary());

输出结果应该是：

Total salary: 156000.0

这个程序中，我们定义了一个抽象类 `Employee`，它有一个抽象方法 `earnings()`，表示计算员工的收入。然后我们定义了三个具体的子类 `YearWorker`、`MonthWorker`、`WeekWorker`，分别表示按年、按月、按周领取薪水的员工。这些子类都实现了 `earnings()` 方法，根据自己的领取方式计算收入。

最后我们定义了一个 `Company` 类，它有一个成员变量 `employees`，表示公司的员工数组。`Company` 类有一个方法 `calculateTotalSalary()`，用于计算公司一年需要支付的薪水总额。这个方法遍历 `employees` 数组，调用每个员工的 `earnings()` 方法，累加收入即可。

希望这个解决方案能够满足你的需求。如果你有任何问题或建议，请随时告诉我。

要求有一个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()方法计算公司一年需要支付的薪水总额，并返回。

好，根据您的要求，我已经为您编写了这段代码，请您查看：

Employee.java

public abstract class Employee {
    public abstract double earnings();
}

YearWorker.java

public class YearWorker extends Employee {
    public double earnings() {
        return 12000;
    }
}

MonthWorker.java

public class MonthWorker extends Employee {
    public double earnings() {
        return 12 * 2300;
    }
}

WeekWorker.java

public class WeekWorker extends Employee {
    public double earnings() {
        return 52 * 780;
    }
}

Company.java

public class Company {
    private Employee[] employees;
    
    public Company(Employee[] employees) {
        this.employees = employees;
    }
    
    public double salariesPay() {
        double total = 0;
        for (Employee employee : employees) {
            total += employee.earnings();
        }
        return total;
    }
}

这样，您就可以使用上述代码来创建Employee的子类，并计算Company对象一年需要支付的薪水总额了。