java - 多态，查找get的类型

Question

我有一个关于多态性的问题。

我有一个父对象案例:

public class Case {

//a constructor
//some attributes
//some getters and setters

}

然后是一个子类:

public class CaseNorm extends Case {
public CaseNorm(//some attributes) {
        super(//some attributes);
    }
}

在我的父类 Object 中，我有一个属性:

private Case nextCase;

但下一个案例可以有类型、caseNorm 或 Case 的其他子类。

然后在主类中，我必须获取案例并将其设置在具有正确类型的变量中。例如

 public class Labyrinthe {

    public static void main(String[] args) {
        Case case1 = new Case(//some attributes);
//set Next Case, who can be a type of caseNorm, caseHyp, caseHym, etc.
    }

}

我现在想要获取 case1，但类型正确。我怎样才能做到这一点？

编辑:

我尝试解释我的概念，以更好地理解我的问题。

我有一个案例类，即父案例。这个类模型是一个正方形。然后它有专门这个广场的 child 。 CaseNorm(对于普通正方形，无颜色等)，另一个可以是 caseHyp(对于带边框的红色正方形)等。

每个案例都有一个编号和位置。我想得到下一个案例，如果实际案例是 1，那么 nextCase 将是案例 2(可以是 CaseNorm，或 CaseHyp 等)。我需要知道在我的应用程序中，nextCase 是哪种类型。

编辑2:

看来我又没说清楚了。我努力做到更多。

public class Case {

    private int numeroCase;
    private int posX;
    private int posY;
    private int taille;
    private int ligne;
    private int colonne;

    public Case(int numeroCase, int posX, int posY, int taille, int nbLignes, int nbColonnes) {
        this.numeroCase = numeroCase;
        this.posX = posX;
        this.posY = posY;
        this.taille = taille;
        this.ligne = numeroCase / nbColonnes+1;
        this.colonne = numeroCase % nbColonnes+1;
    }

    public int getNumeroCase() {
        return numeroCase;
    }

    public void setNumeroCase(int numeroCase) {
        this.numeroCase = numeroCase;
    }

    public int getPosX() {
        return posX;
    }

    public void setPosX(int posX) {
        this.posX = posX;
    }

    public int getPosY() {
        return posY;
    }

    public void setPosY(int posY) {
        this.posY = posY;
    }

    public int getTaille() {
        return taille;
    }

    public void setTaille(int taille) {
        this.taille = taille;
    }

    public int getLigne() {
        return ligne;
    }

    public void setLigne(int ligne) {
        this.ligne = ligne;
    }

    public int getColonne() {
        return colonne;
    }

    public void setColonne(int colonne) {
        this.colonne = colonne;
    }
}

子类:

public class CaseMur extends Case {
    private Color color = Color.BLACK;
     private Color BorderColor = Color.WHITE;

    public CaseMur(int numeroCase, int posX, int posY, int taille) {
        super(numeroCase, posX, posY, taille);
    }

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public Color getBorderColor() {
        return BorderColor;
    }

    public void setBorderColor(Color BorderColor) {
        this.BorderColor = BorderColor;
    }

}

类到屏幕:

public class Terrain {

    private int nbColonnes;
    private int nbLignes;
    private int largeurCarre;
    private ArrayList<Case> cases = new ArrayList<Case>();
    private Case caseActuelle;
    private Object caseSuivanteDroite; //next right case
    private Object caseSuivanteGauche; //next left case
    private Object caseSuivanteHaut; //next up case
    private Object caseSuivanteBas; //next bottom case

    public Terrain() {
        constructionStatiqueTerrain();
    }

    private void constructionStatiqueTerrain() {
        this.nbColonnes = 7;
        this.nbLignes = 5;
        this.largeurCarre = 40;

        construitCases();
        caseDebut(1);
        caseFin(24);
        caseMur(12);
//        caseMur(17);caseActuelle.getColonne()
        caseMur(22);
    }

    public Object getCaseSuivanteDroite() {
        return caseSuivanteDroite;
    }

    public void setCaseSuivanteDroite(Case caseActuelle) {
        if (caseActuelle.getColonne() < nbColonnes && !cases.get(caseActuelle.getNumeroCase() + 1).getClass().equals(CaseMur.class)) {
            this.caseSuivanteDroite = cases.get(caseActuelle.getNumeroCase() + 1);
        } else {
            this.caseSuivanteDroite = null;
        }
    }

    public Object getCaseSuivanteGauche() {
        return caseSuivanteGauche;
    }

    public void setCaseSuivanteGauche(Case caseSuivanteGauche) {
        if (caseActuelle.getColonne() != 1 && !cases.get(caseActuelle.getNumeroCase() - 1).getClass().equals(CaseMur.class)) {
            this.caseSuivanteGauche = cases.get(caseActuelle.getNumeroCase() - 1);
        } else {
            this.caseSuivanteGauche = null;
        }
    }

    public Object getCaseSuivanteHaut() {
        return caseSuivanteHaut;
    }

    public void setCaseSuivanteHaut(Case caseSuivanteHaut) {
        if (caseActuelle.getLigne() != 1 && !cases.get(caseActuelle.getNumeroCase() - nbColonnes).getClass().equals(CaseMur.class)) {
            this.caseSuivanteHaut = cases.get(caseActuelle.getNumeroCase() - nbColonnes);
        } else {
            this.caseSuivanteHaut = null;
        }
    }

    public Object getCaseSuivanteBas() {
        return caseSuivanteBas;
    }

    public void setCaseSuivanteBas(Case caseSuivanteBas) {
        if (caseActuelle.getLigne() < nbLignes && !cases.get(caseActuelle.getNumeroCase() + nbColonnes).getClass().equals(CaseMur.class)) {
            this.caseSuivanteBas = cases.get(caseActuelle.getNumeroCase() + nbColonnes);
        } else {
            this.caseSuivanteBas = null;
        }
    }

    public void setCaseActuelle(int numCase) {
        this.caseActuelle = new Case(numCase, cases.get(numCase).getPosX(), cases.get(numCase).getPosY(), largeurCarre, nbLignes, nbColonnes);
        setCaseSuivanteDroite(caseActuelle);
        setCaseSuivanteGauche(caseActuelle);
        setCaseSuivanteHaut(caseActuelle);
        setCaseSuivanteBas(caseActuelle);
    }

    public Case getCaseActuelle() {
        return this.caseActuelle;
    }

    public void caseNormale(int numCase) {
        numCase--;
        cases.set(numCase, new CaseNormale(numCase, cases.get(numCase).getPosX(), cases.get(numCase).getPosY(), largeurCarre));
    }

    private void caseMur(int numCase) {
        numCase--;
        cases.set(numCase, new CaseMur(numCase, cases.get(numCase).getPosX(), cases.get(numCase).getPosY(), largeurCarre));
    }

    public void caseDebut(int numCase) {
        numCase--;
        cases.set(numCase, new CaseDebut(numCase, cases.get(numCase).getPosX(), cases.get(numCase).getPosY(), largeurCarre));
        this.caseActuelle = new Case(numCase, cases.get(numCase).getPosX(), cases.get(numCase).getPosY(), largeurCarre, nbLignes, nbColonnes);
        this.caseSuivanteDroite = cases.get(numCase + 1);
    }

    private void caseFin(int numCase) {
        numCase--;
        cases.set(numCase, new CaseFin(numCase, cases.get(numCase).getPosX(), cases.get(numCase).getPosY(), largeurCarre));
    }

    private void construitCases() {
        int numeroCase = 1;
        for (int i = 0; i < nbLignes; i++) {
            for (int j = 0; j < nbColonnes; j++) {
                addCase(new CaseNormale(numeroCase, j * largeurCarre, i * largeurCarre, largeurCarre));
                numeroCase++;
            }
        }
    }

    public ArrayList<Case> getCases() {
        return cases;
    }

    public void addCase(Case case1) {
        cases.add(case1);
    }

    public int getNbColonnes() {
        return nbColonnes;
    }

    public void setNbColonnes(int nbColonnes) {
        this.nbColonnes = nbColonnes;
    }

    public int getNbLignes() {
        return nbLignes;
    }

    public void setNbLignes(int nbLignes) {
        this.nbLignes = nbLignes;
    }

    public int getLargeurCarre() {
        return largeurCarre;
    }

    public void setLargeurCarre(int largeurCarre) {
        this.largeurCarre = largeurCarre;
    }

}

在getCaseSuivanteGauche方法中，我必须返回一个Object case，我想返回一个case并使用so:

主类:

Terrain terrain = new Terrain();
terrain.getCaseSuivanteBas().getColor();

但是如果我逐个更改对象，则 getCaseSuivantBas 返回一个对象或一个案例，然后我无法捕获 CaseNormal 方法。

Answer 1

Case 已经是“正确”类型。

创建对象时，您需要使用所需的具体类型的构造函数，例如 new CaseNorm(attribute1, attribute2, attribute3)。稍后使用该对象时不需要知道类型 CaseNorm。因此，您可以将该对象分配给 Case 类型的变量，并且可以将该对象传递给不知道该对象是什么类型的 Case 的代码。这就是多态性的意义所在。使用 Case 有一种常见的方法，它们的实际实现可能会有所不同(通过覆盖具体方法或实现抽象方法)。