我对多态性有疑问。
我有一个父对象案例：
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，但使用的是正确的类型。我怎么能这样做？
编辑：
我试着解释我的观念，以便更好地理解我的问题。
我有一个案例类，即父案例。这个类模型一个正方形。然后它有专门这个广场的孩子。 CaseNorm（普通方形，无颜色等），另一个可以是caseHyp（带边框的红色方块）等。
每个案例都有一个数字和一个位置。我想得到下一个案例，如果实际案例是1，则nextCase将是案例2（可以是CaseNorm，或CaseHyp等）。我需要在我的应用程序中知道哪种类型是nextCase。
EDIT2：
似乎我又不清楚了。我试着做更多。
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;
}
}
CLASS TO SCREEN：
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();
但是如果我逐个更改Object，则getCaseSuivantBas返回一个Object或一个Case，然后我就无法捕获CaseNormal方法。
答案 0 :(得分：1)
Case已经是“正确”类型。
创建像new CaseNorm(attribute1, attribute2, attribute3)这样的对象时，需要使用所需的具体类型的构造函数。使用该对象后，您不需要知道类型CaseNorm。因此，您可以将对象分配给类型为Case的变量，并且可以将对象传递给不知道对象是什么类型Case的代码。这就是多态性的含义。有一种使用Case的常用方法，它们的实际实现可能会有所不同（通过覆盖具体方法或实现抽象方法）。
答案 1 :(得分：0)
你的问题并不是很清楚。
鉴于以下课程：
class Case {
// some variables
private Case nextCase;
public Case(constructorarg1, arg2, arg3, Case theNextCase) {
// assign arguments to variables
nextCase = Case;
}
Case（SpecialCase，CoolCase，CaseInARedDress）有多种子类型。
你的构造函数应该分配nextCase ......或者应该有一些setter。
正在使用的实际类型并不重要，只要它是Case的子类型即可。此子类型允许您在不知道其实际类型的情况下处理任何子类型。
你问的是不同的东西吗？如果是这样，请澄清和/或说出你得到的错误/出错的地方。