Pourquoi ma classe Parent polymorphe appelle-t-elle la méthode de sous-classe à l'intérieur de lui-même?

Question

Voici le code que j'ai créé jusqu'à maintenant. C'est complètement fonctionnel et le seul reproche que je reçois est que ma production hebdomadaire et hebdomadaire est toujours hebdomadaire ... Je ne sais pas comment obtenir cela de l'intérieur de la méthode toString.

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(); 
    } 
} 

Je reçois toute la sortie que je veux sauf pour le salaire annuel. En passant par le débogueur, il retourne à la méthode de paiement childs même en appelant de l'intérieur du parent. Puisqu'il est ignoré, je ne suis pas vraiment surpris par cela, mais une partie de mon livrable est d'obtenir chaque semaine de la sous-classe et annuelle de la super.

Donc, cela soulève ma question, comment puis-je obtenir un salaire annuel du parent? Est-ce que je n'ai pas d'autre choix que de le faire en tant qu'employé dans le cadre de la sortie de mon système ou y a-t-il quelque chose qui me manque?

Et sur une note de côté, j'adore la fluidité de ce site. Il n'y a pas beaucoup d'endroits où je suis allé montrer votre message en direct pendant que vous le tapez.

NOTE SUR COMMENTAIRE: Selon mes livrables, les salariés et les employés horaires deString doivent retourner le salaire hebdomadaire. La classe abstraite d'employé elle-même contient la méthode pour retourner le salaire annuel.

Answer 1

Vous avez la possibilité d'appeler le super de la sous-classe. Votre toString en Salaried, par exemple, pourrait ressembler à ceci:

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

Answer 2

Dans vos sous-classes, vous surchargez la méthode pay(). Si vous voulez que les employés aient à la fois un salaire annuel et un salaire périodique, vous devez ajouter la méthode abstraite periodicPay() pour les sous-classes à remplacer et laisser pay() comme final.

Answer 3

Oui, appelant à pay()Employee se fait appeler Salaried.pay() dans le contexte d'un objet Salaried. C'est le point de polymorphisme - que les classes dérivées peuvent remplacer le comportement.

Maintenant, il me semble que vos classes seraient beaucoup plus clair si vous aviez des méthodes distinctes pour getAnnualPay() et getWeeklyPay() - peut-être seulement d'avoir getAnnualPay() dans la classe de base, et l'introduction d'getWeeklyPay() dans Salaried.