數組列表 <superclass> 但是使用ArrayList <subclass> .methodofsubclass

Question

我有一個Woning類（房屋）和一個KoopWoning類（可負擔房屋）和一個HuurWoning類（可出租房屋）。 KoopWoning和Huurwoning擴展了Woning。 HuurWoning只是Woning，而KoopWoning具有額外的可變能級。 KoopWoning還具有函數getEnergylevel，該函數返回KoopWoning的能量級別。 我也有一個Portefeuille類，其中包含Woningen的數組列表。

我從文本文件中讀取Portefeuille中的所有Woningen。 在第5課中，我希望能夠對Portefeuille的Woningen的ArrayList進行排序（來自文本文件）。 我有一個函數woningenTot（int maxprijs）返回具有滿足需求的所有Woningen的ArrayList（價格低於maxprijs）。 這些Woningen我想在屏幕上打印。

問題如下：文件中可能還有一個KoopWoning。 在這種情況下，我還希望能夠按能級排序。 但是，我無法對能量水平進行排序。 我不能調用函數getEnergylevel，因為它是一個ArrayList，而Woning不包含函數getEnergylevel。

那么我該如何解決呢？ 如果太模糊，我可以包含代碼，但是它很大：O

任何幫助表示贊賞； 我已經在這個程序上花費了幾個小時，其中至少有1.5個小時僅用於解決這個問題:(

編輯：這是類KoopWoning的代碼

public class KoopWoning extends Woning implements EnergiepeilWoning {
private char energiepeil;

public KoopWoning (Adres adres, int kamers, int vraagPrijs, char energiepeil) {
    super(adres, kamers, vraagPrijs);
    this.energiepeil = energiepeil; 
}

public char getEnergiepeil () {
    return energiepeil;
}

public boolean compareEnergiepeil (Object other) {
    boolean res = false;
    if (other instanceof KoopWoning) {
        KoopWoning that = (KoopWoning) other;
        res = (this.getEnergiepeil() == that.getEnergiepeil());
    }
    return res; 
}

public String toString () {
    String res = adres + ", " + kamers + " kamers, prijs " + prijs + ", energiepeil " + energiepeil;
    return res;
}

這是Woning類的代碼

public class Woning {
protected int kamers;
protected int prijs;
protected Adres adres;
protected String tag;

public Woning (Adres adres, int kamers, int prijs) {
    this.adres = adres;
    this.kamers = kamers;
    this.prijs = prijs;     
}

public String toString () {
    String res = adres + ", " + kamers + " kamers, prijs " + prijs;
    return res;
}

public void setTag (String tag) {
    this.tag = tag;
}

public String getTag () {
    return tag;
}

public boolean kostHooguit (int maxprijs) {
    return (prijs <= maxprijs);
}

public boolean equals (Object other) {
    boolean res = false;
    if (other instanceof Woning) {
        Woning that = (Woning) other;
        if (this.adres.equals(that.adres))
            res = true;
    }
    return res;
}

public static Woning read (Scanner sc) {
    try {
        Adres adress = Adres.read(sc);
        int kamer = sc.nextInt();
        sc.next();
        sc.next();
        int prijs = sc.nextInt();
        String check = sc.next();
        if (check.equals("energiepeil")) {
            char peil = sc.next().charAt(0);
            KoopWoning kwoning = new KoopWoning (adress, kamer, prijs, peil);
            return kwoning;
        }
        else {
            Woning woning = new Woning (adress, kamer, prijs);
            return woning;
        }
    }
    catch (Exception e) {
        System.out.println("Woning: Exception is caught");
        System.out.println(e.getMessage());
        Adres adress = new Adres ("", "", "", "");
        Woning woning = new Woning (adress, 0, 0);
        return woning;
    }
}
}

最后，Portefeuille類的代碼

public class Portefeuille {

private ArrayList<Woning> woninglijst;

public Portefeuille () {
    woninglijst = new ArrayList<Woning>();
}

public void voegToe (Woning woning) {
    if (!woninglijst.contains(woning))
        woninglijst.add(woning);
}

public ArrayList<Woning> woningenTot (int maxprijs) {
    ArrayList<Woning> woninglijst2 = new ArrayList<Woning>();
    for (int i = 0; i < woninglijst.size(); i++) {
        if(woninglijst.get(i).kostHooguit(maxprijs))
            woninglijst2.add(woninglijst.get(i));
    }
    return woninglijst2;
}

public String toStringExt () {
    String res = "[";
    for (int i = 0; i < woninglijst.size(); i++)
        res = res + woninglijst.get(i).toString() + "; ";
    if (woninglijst.size() != 0)
        res = res.substring (0, res.length() - 2);
    res = res + "]";
    return res;
}

public String toString () {
    String res = "";
    for (int i = 0; i < woninglijst.size(); i++)
        res = woninglijst.get(i).toString2();
    return res;
}

public boolean equals (Object other) {
    boolean res = false;
    if (other instanceof Portefeuille) {
        Portefeuille that = (Portefeuille) other;
        if (this.woninglijst.size() == that.woninglijst.size()) {
            int i = 0;
            while (i < this.woninglijst.size() && this.woninglijst.get(i).equals(that.woninglijst.get(i)))
                i = i + 1;
            res = (i == this.woninglijst.size());
        }
    }
    return res;
}

public static Portefeuille read (String infile) {
    try {
        Scanner sc = new Scanner (new File(infile));
        ArrayList<Woning> wlijst = new ArrayList<Woning>();
        Portefeuille p = new Portefeuille();
        int woningen = sc.nextInt();
        int i = 0;
        while (i < woningen) {
            sc.nextLine();
            String tag = sc.nextLine();
            wlijst.add(Woning.read(sc));
            p.voegToe(wlijst.get(i));
            i++;
        }
        sc.close();
        return p;
    }

    catch (Exception e) {
        System.out.println("Portefeuille: Exception is caught");
        Portefeuille p = new Portefeuille();
        return p;
    }   
}
}

編輯

我自己修好了。 感謝您回答所有人：)

Answer 1

您可以在頂級類上定義諸如getSortableValue()類的方法，並將其實現以返回默認字段（您沒有提及需要為Woningen排序的字段）。 在KoopWoning您可以重寫此方法以返回energyLevel 。 然后，您總是對getSortableValue()返回的值進行排序。

Answer 2

您可以在Woning上定義一個Comparator ，該比較器確定兩個Woning的相對順序。 您可以通過以下方法來執行此操作：使該方法查看兩個參數的實際類型，然后適當地執行操作；或者，更好的方法是，使用可重寫的Woning方法返回一些可用於排序目的的值。

例如，如果您確定某個能級高的東西應該排在沒有任何高能級的東西之后，那么您可以讓KoopWoning返回某個能量級在long的高位的東西，這樣它總是比沒有能級的東西高。一個（基本上，您將默認能量級別設置為零）。

然后，您可以使用

Collections.sort(arrayList, myComparator);

根據您創建的Comparator對列表進行排序。

Guava庫中有一些不錯的類可幫助Comparator構建多個鍵，但是如果您的情況很簡單，則可能不需要它們。

Answer 3

您可以讓它們實現Comparable ，就像Woning implements Comparable<Woning> 。 這將使您實現（必需）方法：

@override
public int compareTo(Woning other) {
    int result = Integer.compareto(maxPrijs, other.maxPrijs);
    if (result != 0) return result;
    result = Integer.compareto(someField, other.someField);
    if (result != 0) return result;
    // etc...
    return 0;
}

子類KoopWoning extends Woning implements Comparable<KoopWoning>可以具有如下方法：

@override
public int compareTo(KoopWoning other) {
    int result = Integer.compareto(energylevel, other.energylevel);
    if (result != 0) return result;
    return super.compareTo(other);
}

然后，您要做的就是將所有Woning實例加載到列表中並執行

Collections.sort(list);

有子類都繼承Comparable是可選的，所以HuurWoning將剛剛有點像Woning 。