Finta ereditarietà

[gennysennin]

Ciao, sto creando un giochino sul poker, ma essendo all'inizio dello studio Java mi accontento di far si che il programma mi crei le carte in mano e quelle a terra. Per chi non conoscesse il texas holdem, il gioco prevede la consegna di 2 carte a ogni giocatore e poi il posizionamento di 3 carte a terra scoperte, seguita da un'altra e poi un'altra ancora. Sto cercando di usare la programmazione ad oggetti quindi ho deciso di creare delle classi. Il fatto è che non si tratta di ereditarietà in quanto le classi non rispondono mai "si" alla domanda "is a?". Posto tutto il codice, chi ha 5 minuti da perdere mi dirà se non c'ho capito niente finora.

import java.util.*;

public class Carta {
    private String carta, seme, cartaCompleta;
    private Random caso=new Random();
    private String [] arrayCarte = new String[13];
    private String [] arraySemi = new String[4];
    
    public Carta()
    {
        for (byte i=0;i<13;i++)
        {
            if (i+1==11)
                arrayCarte[i]="J";
            else if (i+1==12)
                    arrayCarte[i]="Q";
            else if (i+1==13)
                arrayCarte[i]="K";
            else if (i+1==1)
                arrayCarte[i]="A";
            else if (i+1==10)
                arrayCarte[i]="T";
            else
                arrayCarte[i]=String.valueOf(i+1);
        }
        arraySemi[0]="h";
        arraySemi[1]="d";
        arraySemi[2]="s";
        arraySemi[3]="c";
    }
    
    public void generaCartaCasuale()
    {
        int caso=this.caso.nextInt(7);
        this.carta=arrayCarte[caso];
        
        caso=this.caso.nextInt(1);
        this.seme=arraySemi[caso];
        cartaCompleta=carta+seme;
    }
    
    public String getCartaCompleta()
    {    return cartaCompleta;    }
}

Con questo ho creato la singola carta, tipo Ac per Asso di fiori (c sta per clubs).

public class HoleCards extends Carta{    
    private Carta carta1=new Carta();
    private Carta carta2=new Carta();
    static String carta1Static, carta2Static;
    
    public HoleCards()
    {
        carta1.generaCartaCasuale();
                
                while (0<1)
                {
                    carta2.generaCartaCasuale();
                    
                    if (!carta2.getCartaCompleta().equals(carta1.getCartaCompleta()))
                        break;
                }
                carta1Static=carta1.getCartaCompleta();
                carta2Static=carta2.getCartaCompleta();
    }
    
    public String getCarta1Static()
    {    return carta1Static;    }
    
    public String getCarta2Static()
    {    return carta2Static;    }
    
    public String getCarta1()
    {    return carta1.getCartaCompleta();    }
    
    public String getCarta2()
    {    return carta2.getCartaCompleta();    }
    
    public String getHoleCards()
    {    return carta1.getCartaCompleta()+" "+carta2.getCartaCompleta();    }
    
    public void stampaCarte()
    {    System.out.print(carta1.getCartaCompleta()+" "+carta2.getCartaCompleta());    }
}

Adesso ho creato 2 oggetti di tipo Carta per avere 2 carte diverse tra loro.

public class Flop extends HoleCards{
    private Carta carta1Flop=new Carta();
    private Carta carta2Flop=new Carta();
    private Carta carta3Flop=new Carta();
    static String carta1FlopStatic, carta2FlopStatic, carta3FlopStatic;
    
    public Flop()
    {
        while (0<1)
        {
            carta1Flop.generaCartaCasuale();
            if((!carta1Flop.getCartaCompleta().equals(carta1Static))&&(!carta1Flop.getCartaCompleta().equals(carta2Static)))
                    break;
        }
        while (0<1)
        {    
            carta2Flop.generaCartaCasuale();
                if((!carta2Flop.getCartaCompleta().equals(carta1Static))&&(!carta2Flop.getCartaCompleta().equals(carta2Static))&&
                        (!carta2Flop.getCartaCompleta().equals(carta1Flop.getCartaCompleta())))
                        break;
        }
        while (0<1)
        {
            carta3Flop.generaCartaCasuale();
                if((!carta3Flop.getCartaCompleta().equals(carta1Static))&&(!carta3Flop.getCartaCompleta().equals(carta2Static))&&
                        (!carta3Flop.getCartaCompleta().equals(carta1Flop.getCartaCompleta()))&&(!carta3Flop.getCartaCompleta().equals(carta2Flop.getCartaCompleta())))
                        break;
        }
        carta1FlopStatic=carta1Flop.getCartaCompleta();
        carta2FlopStatic=carta2Flop.getCartaCompleta();
        carta3FlopStatic=carta3Flop.getCartaCompleta();
    }
    
    public void stampaCarte()
    {
        super.stampaCarte();
        System.out.print(" --- "+carta1Flop.getCartaCompleta()+" "+carta2Flop.getCartaCompleta()+" "+carta3Flop.getCartaCompleta());
    }
}

Con questa creo le 3 carte a terra e per far si che siano diverse dalle carte in mano ho usato le variabili statiche in cui ci sono segnate le carte create prima (anche se non serviva farle static visto che non vengono più modificate).

Ho fatto poi altre 2 classi, Turn e River che fanno in pratica quello che fa Flop.

Alcune domande:
è giusto forzare così l'ereditarietà per poter avere un ordine? in pratica sto ricreando la programmazione strutturata, ogni classe ne eredita un'altra.
Ho notato che mi basta creare solo un oggetto della classe nata per ultima per avere tutto. Qua abbiamo, super classe, poi figlia, nipote, e così via, quindi se creo un oggetto dell'ultima automaticamente sto creando l'istanza di tutte le altre? Ho pensato che dipende semplicemente dal fatto che automaticamente eredito il costruttore vuoto (l'unico che ho) della classe madre, giusto?