Java 为什么我的多态父类从自身内部调用子类方法？

这是我到目前为止编的代码。它功能齐全，我唯一抱怨的是，我的周薪和年薪输出总是每周的……我不知道如何从这两种方法中得到它

public class PolyEmployees {
    public static void main(String[] args) {

        Employee [] myEmployees = {
            new Hourly("Joan Rivers", "Human Resources", 12.45, 34.3),
            new Hourly("Jason Nezbit", "Accounting", 15.25, 46.0),
            new Hourly("Ingrid Homes", "Secretary", 10.11, 38.7),
            new Salaried("Amy Liberman", "Human Resources Executive", 32.50),
            new Salaried("Xander Xavar", "Resource Processing", 29.20),
            new Salaried("Milly Rockhome", "PR Executive", 65.28)
        };

        // Output all employee types
        for (int i = 0; i < myEmployees.length; i++)    {
            System.out.println("\n" + myEmployees[i].toString());
        }                 
    }

}

/*
 * Employee abstract class
 */

abstract public class Employee {
    private String mName;
    private String mDepartment;
    protected Double mRate;

    // Constructor
    public Employee(String mName, String mDepartment, Double mRate) {
        this.mName = mName;
        this.mDepartment = mDepartment;
        this.mRate = mRate;
    }

    // Annual Pay
    public Double pay() {   // 40 Hours a Week, 52 weeks in a year
        return ((this.mRate * 40) * 52);
    }

    @Override
    public String toString() {
        return "Employee: " + this.mName + "\nDepartment: " + this.mDepartment + "\nAnnual Pay: " + this.pay();
    }
}

/*
 * Hourly employee class
 */

public class Hourly extends Employee {
    private Double mHours;

    public Hourly(String mName, String mDepartment, Double mRate, Double mHours) {
        super(mName, mDepartment, mRate);
        this.mHours = mHours;
    }

    @Override
    public Double pay() {   // Weekly Pay, deals with overtime for hourly employee

        if (this.mHours > 40.0) {
            return ((40 * this.mRate) + ((this.mHours-40) * (this.mRate * 1.5)));
        }
        else    {
            return (this.mHours * this.mRate);
        }       
    }

    public String toString() {
        return super.toString() + "\tWeekly Pay: " + pay();
    }

}

/*
 * Salaried Employee Class
 */

public class Salaried extends Employee{

    public Salaried(String mName, String mDepartment, Double mRate) {
        super(mName, mDepartment, mRate);
    }

    @Override
    public Double pay() {   // Weekly Pay
        return (this.mRate * 40);
    }

    @Override
    public String toString() {
        return super.toString() + "\tWeekly Pay: " + this.pay();
    }
}

公共级多员工{
公共静态void main（字符串[]args）{
员工[]我的员工={
每小时新增一次（“Joan Rivers”，“人力资源”，12.45,34.3），
新的小时制（“Jason Nezbit”，“会计”，15.25,46.0），
新的小时制（“英格丽德之家”，“秘书”，10.11,38.7），
新领薪水（“艾米·利伯曼”，“人力资源主管”，32.50），
新工薪阶层（“Xander Xavar”，“资源加工”，29.20），
新工薪阶层（“米莉·洛克霍姆”，“公关主管”，65.28）
};
//输出所有员工类型
for（int i=0；i40.0）{
返回（（40*this.mRate）+（（this.mHours-40）*（this.mRate*1.5））；
}
否则{
返回（this.mHours*this.mRate）；
}       
}
公共字符串toString（）{
返回super.toString（）+“\tWeekly Pay:”+Pay（）；
}
}
/*
*工薪阶层
*/
公共类受薪员工{
公共受薪人员（字符串mName、字符串mDepartment、双mRate）{
超级（mName、mDepartment、mRate）；
}
@凌驾
公共双薪（）{//周薪
返回（this.mRate*40）；
}
@凌驾
公共字符串toString（）{
返回super.toString（）+“\tWeekly Pay:“+this.Pay（）；
}
}

除了年薪，我得到了我想要的所有产出。单步通过调试器，即使从父级调用，它也会返回childs的pay方法。因为它被重写了，所以我对此并不感到惊讶，但我的部分可交付成果是从子类每周获得一次，从超级类每年获得一次

这就引出了我的问题，我怎样才能从父母那里拿到年薪？我是否别无选择，只能将其作为我的系统输出的一部分的员工，还是我缺少了什么

另一方面，我喜欢这个网站的流动性。我去过的地方不多，你打字的时候我会现场展示你的帖子

---

注释：根据我的可交付成果，toString的受薪员工和小时工都必须返还周薪。employee抽象类本身包含返回年薪的方法。

在子类中，您覆盖了pay（）方法。如果希望员工同时拥有年薪和定期工资，则应为子类添加抽象方法periodicPay（），以覆盖并保留pay（）为最终值。

您可以选择从子类调用super。例如，您的

toString

在

Salaried

中可能如下所示：

return super.toString() + "\tWeekly Pay: " + this.pay()+ "\tAnnual Pay: " + super.pay());

是的，在

Employee

中调用

pay（）

确实会在

Salaried

对象的上下文中调用

Salaried.pay（）

。这就是多态性的要点——派生类可以重写行为

---

现在我突然想到，如果你对

getAnnualPay（）

和

getWeeklyPay（）

有单独的方法，那么你的类会更清晰——可能只有

getAnnualPay（）

在基类中，并且在

Salaried

中引入

getWeeklyPay（）

，是的，我觉得没有想到这一点很傻，这就是我一直在寻找的解决方案，谢谢你：）是的，我同意它会更清晰。不幸的是，这是一个家庭作业，每当我尝试添加更多功能时，我的教授都喜欢从我身上拿走分数。针对散户的业务规则：（那么实际指定了多少？对我来说，重要的是你理解为什么调用重写的pay方法，这似乎让你感到惊讶。是的，我现在理解了，但最初我感到惊讶，因为我是从父级而不是超级级调用pay。我想重写的那部分我直到刚才。有人把super.pay作为从家长那里得到它的方式，它有点点击。我已经从孩子那里给super类打电话了，所以我觉得不想用同样的电话来获得报酬有点傻。