Java 多态性的使用？

雇员阶级

public class Employee {
protected String name;
protected String jobsheetnumber;

public Employee(String n,String j){
this.name = n;
this.jobsheetnumber = j;
}
public Employee(String name)
{
this.name = name;
}

public String getName() {
    return name;
}

public String getJobsheetnumber() {
    return jobsheetnumber;
}

public void setName(String name) {
    this.name = name;
}

public void setJobsheetnumber(String jobsheetnumber) {
    this.jobsheetnumber = jobsheetnumber;
}



}

技工班

public class Mechanic extends Employee{


public Mechanic(String name,String jobsheetnumber){
super(name,jobsheetnumber);
}
}

主管班

public class Supervisor extends Employee{


public Supervisor(String name){
super(name);
}
}

公司类[代码段]

public class Company {
private String companyname;
private String companyaddress;
private String postalcode;
private String city;
private String country;
private String telephonenumber;
private String faxnumber;
private String province;
private Employee supervisor;
private Employee mechanic;




public Company(String companyname,String companyaddress,String postalcode,String city,String country,String telephonenumber,String faxnumber,String province,String supervisorname,String jobsheetnumber,String mechanicname)
{
 this.companyname = companyname;
 this.companyaddress=companyaddress;
 this.postalcode = postalcode;
 this.city=city;
 this.country=country;
 this.telephonenumber=telephonenumber;
this.faxnumber=faxnumber;
this.province=province;
supervisor = new Supervisor(supervisorname);
mechanic = new Mechanic(mechanicname,jobsheetnumber);




}

Employee类是Mechanical类和Supervisor类的超类。。现在我在Mechanical和Supervisor子类中使用Employee的属性，即name和jobsheetnumber

public class Supervisor extends Employee{


public Supervisor(String name){
super(name);
}
}

代码运行良好。。但如果我想在Mechanical和Supervisor中添加扩展功能，该怎么办？然后我无法访问这些变量，因为引用是对Employee类型对象的

这是多态性的正确用法吗？每次创建Supervisor/Mechanical对象的引用时都必须使用super（）作为构造函数？

---

我们不能在Supervisor和Mechanical类中使用扩展功能吗？

如果您想调用超类非零参数构造函数，那么是的，您必须显式调用它。如果超类构造函数没有参数，那么将为您插入调用

多态性的要点是，对象可以自行处理，而不必让程序的其余部分对其进行微观管理，因此外部程序通过引用接口或超类的类型来引用它们，而不必知道确切的具体类型。例如，所有员工可能都有一种工作方法，其中主管的工作形式与技工的不同；工作方法将被特定的子类覆盖，并可能调用子类上的特定方法。因此，公司可以迭代所有员工，并对每个员工调用work，而work的定义对于员工的不同子类是不同的

---

（在实践中，使用子类来描述角色太不灵活了，因为员工可能有多个角色，或者这些角色会随着时间的推移而变化。通常最好使用组合，这里将角色对象分配给员工。）

对于不同的实现，更好地使用多态性将是相同的接口（方法）。所以您可以决定在运行时使用哪个实现

为了解释我的观点，我将给出一个使用您的类的示例

public class Employee{
    public void work(int hours){ doNothing();}      
}
public class Supervisor extends Employee{
    private Object pen; 
    private Object note;
    @Override
    public void work(int hours){
        observations = superviseWorkers();
        note.write(observations, pen);

    } 

}
public class Mechanic extends Employee{
    private Tool tool;
    private TaskBoard taskBoard;
    @Override
    public void work(int hours){ 
        task = taskBoard.getPendent()
        if(task.canSolveWithTool(tool))
        {
            solveTask(task, tool)
        }
    } 
}

使用示例：

employees = new List<Employee>();
employees.add(new Supervisor("foo"));
employees.add(new Mechanic("bar"));

foreach(employee in employees){
   //you don't need to know which kind of employee you are treating here because you are only calling a behavior that all employees have.
   employee.work(8);
}

employees=newlist（）；
添加（新主管（“foo”）；
添加（新技工（“律师”））；
foreach（员工中的员工）{
//你不需要知道你在这里对待的是哪种员工，因为你只是在说所有员工都有的行为。
员工工作（8）；
}

如果在代码中的许多地方，您试图找出您正在处理的对象，那么可能是您做错了

---

我在示例中使用了您的类来帮助您理解，但正如Nathan Hughes在本例中建议的那样，最好使用组合而不是继承。

我将用两种方式处理上述场景

解决方案1：（作为角色的接口）

您可以在

Employee

对象中使用“state”，并且可以实现角色作为接口

Employee

将具有所有通用属性和方法。您可以在各自的Employee实现中重写基类方法，如

doWork（）

您可以使用接口添加

机械

，

Supvervisor

的特定行为

public interface ISupervise{
     public void doSupervise();
}

public class Supervisor extends Employee implements ISupervise{
    public void doSupervise(){

    }
} 

public interface IMechanic{
    public void doMechanicWork();
}

public class Mechanic extends Employee implements IMechanic{
    public void doMechanicWork(){

    }
}

解决方案2：（装饰角色）

实施员工扮演多个角色的模式<代码>技工和主管将装饰员工的行为。请参阅此示例以更好地理解装饰器模式

可以找到示例代码@

---

您可以强制转换引用，例如：Supervisor superRef=（Supervisor）company.Supervisor；然后访问SuperRef上的专用属性这不是多态性，这只是继承。多态性就是在员工中有一个抽象的方法，并为技工和主管以不同的方式实现它。您无法通过公司实例访问主管和机械师属性，这只是因为您将成员声明为雇员。你应该分别声明他们是主管和技工。