java - 如何说服 Java 构造函数接受包含其类实现特定接口(interface)的对象的列表

Question

我目前正在对一个软件应用程序进行一些更改，该应用程序大量使用了委托(delegate)设计模式。因此我想相应地编写我的代码。目前，我似乎无法找到解决让我忙碌了一段时间的问题的方法。

我当前的任务是创建某种通用的“操作类”，所有实现特定接口(interface)的对象都将使用该类来对这些对象执行操作。为了实现这一点，处理类将为任何需要更改的对象实例化该操作类的对象，并通过该操作类的对象来执行其更改。

我的问题是，我无法使用接受其类实现特定接口(interface)的对象列表的构造函数来实例化“操作类”对象。

“操作类”的构造函数如下所示(请在下面找到完整的代码示例):

public OperationClass(List<InterfaceName> listOfObjects) {
    super();
    listedObjects = listOfObjects;
}

它将被这样调用:

operationObject = new OperationClass(object.getSubObjectsList());

Eclipse 会提示

"The constructor OperationClass(List<SubObjects>) is undefined."

这对我来说有点奇怪，因为提供列表的类实现了构造函数定义中提到的接口(interface)。有趣的是，使用接受此类单个对象的构造函数将可以正常工作。 我的问题是:

1. 是否可以使用接受接口(interface)列表的构造函数？
2. 如何使我的代码正常工作，同时又不丧失将代码用于实现该接口(interface)的所有类的能力？

注意:根据您的反馈编辑了代码。诀窍是将列表的数据类型更改为 Interface 类型，并确保 Getter 方法相应更改。

---

完整代码示例

界面

package test02_interfaceList;

import java.util.List;

public interface PersonI {

    public abstract String getFirstName();

    public abstract void setFirstName(String firstName);

    public abstract String getLastName();

    public abstract void setLastName(String lastName);

    public abstract List<PersonI> getSiblings();

    public abstract void setSiblings(List<PersonI> siblings);

}

实现接口(interface)的类

package test02_interfaceList;

import java.util.List;

public class Member implements PersonI {

    private int memberId;
    private String firstName;
    private String lastName;
    private List<PersonI> siblings;

    public int getMemberId() {
        return memberId;
    }

    public void setMemberId(int memberId) {
        this.memberId = memberId;
    }

    /*
     * (non-Javadoc)
     * 
     * @see test02_interfaceList.PersonI#getFirstName()
     */
    @Override
    public String getFirstName() {
        return firstName;
    }

    /*
     * (non-Javadoc)
     * 
     * @see test02_interfaceList.PersonI#setFirstName(java.lang.String)
     */
    @Override
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    /*
     * (non-Javadoc)
     * 
     * @see test02_interfaceList.PersonI#getLastName()
     */
    @Override
    public String getLastName() {
        return lastName;
    }

    /*
     * (non-Javadoc)
     * 
     * @see test02_interfaceList.PersonI#setLastName(java.lang.String)
     */
    @Override
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    /*
     * (non-Javadoc)
     * 
     * @see test02_interfaceList.PersonI#getSiblings()
     */
    @Override
    public List<PersonI> getSiblings() {
        return siblings;
    }

    @Override
    public void setSiblings(List<PersonI> siblings) {
        this.siblings = siblings;

    }
}

通用“操作”类

package test02_interfaceList;

import java.util.List;

public class Delegate {

    private Member currentMember;
    private List<PersonI> associatedPeople;
    private PersonI associatedPerson;

    /**
     * Standard Constructor, takes list of objects which implements the PersonI
     * interface.
     * 
     * @param listOfPeople
     */
    public Delegate(List<PersonI> listOfPeople) {
        super();
        associatedPeople = listOfPeople;
    }

    /**
     * Alternative Constructor, takes one object implementing the PersonI
     * interface.
     * 
     * @param listOfPeople
     */
    public Delegate(PersonI person) {
        super();
        associatedPerson = person;
    }

    public void addToAssocPeopleList(PersonI person) {
        System.out.println("Adding " + person.getFirstName() + " to list of associated people.");
        associatedPeople.add(person);
    }

    public void removeFromAssocPeopleList(PersonI person) {
        System.out.println("Removing " + person.getFirstName() + " from list of associated people.");
        associatedPeople.remove(person);
    }

    public Member getCurrentMember() {
        return currentMember;
    }

    public void setCurrentMember(Member currentMember) {
        this.currentMember = currentMember;
    }

    public List<PersonI> getAssociatedPeople() {
        return associatedPeople;
    }

    public void setAssociatedPeople(List<PersonI> associatedPeople) {
        this.associatedPeople = associatedPeople;
    }

    public PersonI getAssociatedPerson() {
        return associatedPerson;
    }

    public void setAssociatedPerson(PersonI associatedPerson) {
        this.associatedPerson = associatedPerson;
    }

}

带有 main() 方法的类

import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        // Main Method

        Delegate member01Operations;
        List<PersonI> siblings = new ArrayList<PersonI>();

        Member member01 = new Member();
        member01.setMemberId(42);
        member01.setFirstName("John");
        member01.setLastName("Doe");
        member01.setSiblings(siblings);

        Member member02 = new Member();
        member02.setMemberId(43);
        member02.setFirstName("Joanna");
        member02.setLastName("Doe");

        Member member03 = new Member();
        member03.setMemberId(43);
        member03.setFirstName("James");
        member03.setLastName("Doe");

        // The constructor now accepts the returned list as it contains the
        // PersonI interface datatype
        member01Operations = new Delegate(member01.getSiblings());

        member01Operations.addToAssocPeopleList(member02);
        member01Operations.addToAssocPeopleList(member03);

        for (PersonI person : member01Operations.getAssociatedPeople()) {
            System.out.println(person.getFirstName());
        }
    }
}

Answer 1

你应该明白List<SubObjects>不是 List<InterfaceName> 的子类，所以你不能传递 List<SubObjects>其中 List<InterfaceName>是期待。

您应该更改getSubObjectsList()返回 List<InterfaceName>而不是List<SubObjects> 。无论如何，通常最好在变量和方法参数中使用接口(interface)类型而不是类类型。