處理多個異構對象時如何在Java中使用generics？

Question

比方說，我有兩個看起來像這樣的類：

public class classA {
    private Boolean is_started;

    public classA(Boolean is_started) {
        this.is_started = started;
    }
    public Boolean getIs_started(){
        return this.is_started;
    }
}

public class classB {
    private String token;

    public classA(String token) {
        this.token = token;
    }
    public String get_token(){
        return this.token;
    }
}

我從另一個 class 調用這兩個類，如下所示：

public class CallingClass {

    public void function1() {
        ClassA stepA = new ClassA(<some boolean>);
        commonFunction(stepA);
}
    public void function2() {
        ClassB stepB = new ClassB(<some string>);
        commonFunction(stepB);
}
    public <T> void commonFunction(Class<T> dataObject) {
        //An if statement that has a condition that only calls a function in classB {
            String token = dataObject.get_token();
        }
        //An if statement that has a condition that only calls a function in classA {
        Boolean is_started = dataObject.getIS_started();
        }
//It returns error : The method [get_token()/getIS_started()] is undefined for the type Class<T>

我想確保我可以調用不同的對象，而無需在 function 中指定它們。 例如，我想提供ClassA和ClassB作為commonFunction的參數，如上例所示。 如何使用 generics 實現它？

Answer 1

您需要某種方法將類聯系在一起，上面寫着“此實例實現了一個名為getToken的方法，該方法返回某種結果”

最簡單的起點是interface ，例如...

public interface Tokenable<T> {
    public T getToken();
}

那么ClassA和ClassB都需要根據需要實現這個interface ，例如......

public class ClassA implements Tokenable<Boolean> {

    private Boolean started;

    public ClassA(Boolean started) {
        this.started = started;
    }

    @Override
    public Boolean getToken() {
        return started;
    }

}

public class ClassB implements Tokenable<String> {

    private String token;

    public ClassB(String token) {
        this.token = token;
    }

    @Override
    public String getToken() {
        return token;
    }

}

然后你可以將回電公用化......

public class CallingClass {

    public void function1() {
        ClassA stepA = new ClassA(false);
        commonFunction(stepA);
    }

    public void function2() {
        ClassB stepB = new ClassB("hello");
        commonFunction(stepB);
    }

    public <T> void commonFunction(Tokenable<T> dataObject) {
        T token = dataObject.getToken();
    }

}

如果不提供某種共同祖先，您將無法真正使其工作 - Class沒有定義getToken方法，因此您需要某種共同祖先才能調用它（有一個“ hacky”的方法，但你真的，真的，真的不想 go 掉進那個兔子洞）

Answer 2

可能是我對您的問題有所遺漏，因為尚不完全清楚您要達到的目標，但是您嘗試執行此操作的方式似乎不太正確。

如果參數是一種類型，則commonFunction中的邏輯以一種方式運行，如果參數是另一種類型，則以另一種方式運行。 看來您真正應該做的是在 ClassA 和 ClassB 中擁有該邏輯。 所以他們都應該實現一些方法，在 ClassA 內部以一種方式在 ClassB 內部以另一種方式運行。 那么commonFunction就可以對所有的arguments一視同仁了。

一般來說，如果您正在測試參數的類型並在不同的情況下觸發不同的行為，那么這很好地表明該行為確實屬於這些類本身，前提是您是在這種情況下定義您所在的類的人。

Answer 3

您的字面問題的直接答案是classA和classB的唯一超類型是Object ，因此您的參數類型必須是Object ，您可以使用instanceof來測試它是否是特定類型的實例，如果是，則強制轉換為那種類型來做只能用那種類型做的事情：

public void commonFunction(Object dataObject) {
    if (dataObject instanceof classB) {
        String token = ((classB)dataObject).get_token();
    }
    if (dataObject instanceof classA) {
        Boolean is_started = ((classA)dataObject).getIS_started();
    }
}

然而，像這樣使用instanceof是糟糕設計的證據。 如果兩種不同類型的邏輯是分開的，那為什么要把它們放在同一個 function 中呢？ 如果“token”和“is_started”應該代表相同類型的信息，那么將它們重構為接口中提供的相同方法，就像建議的其他答案一樣，更有意義。