Qualcosa di utile

1. Ereditarietà

Per lavorare con il motore di gioco CodeGym, dovrai utilizzare l'ereditarietà . Ma cosa succede se non sai cos'è? Da un lato, devi capire e studiare questo argomento. D'altra parte, il motore è appositamente progettato per essere molto semplice, quindi puoi cavartela con una conoscenza superficiale dell'ereditarietà.

Quindi cos'è l'eredità? In termini semplici, l'ereditarietà è una relazione tra due classi. Uno di loro funge da classe genitore e l'altro diventa la classe figlio (discendente). Inoltre, una classe genitore potrebbe anche non sapere di avere classi discendenti. In altre parole, il genitore non ottiene molti vantaggi dall'avere classi discendenti.

Ma l'ereditarietà offre molti vantaggi alla classe figlio. Il più importante è che tutte le variabili ei metodi della classe genitore appaiono nella classe figlia, come se il codice della classe genitore fosse stato copiato direttamente nella classe figlia. Questo non è del tutto esatto, ma sarà sufficiente per una comprensione di base dell'ereditarietà.

Ecco alcuni esempi per aiutarti a comprendere meglio l'ereditarietà.

Esempio 1 : ecco l'esempio più semplice

public class Parent
{
}

public class Child extends Parent
{
}

Esempio 2 — utilizzo delle variabili della classe genitore

public class Parent
{
  public int age;
  public String name;
}

public class Child extends Parent
{
  public void printInfo()
  {
    System.out.println(name + " " + age);
  }
}

Esempio 3: utilizzo dei metodi della classe genitore

public class Parent
{
   public int age;
   public String name;
   public getName() {
      return name;
   }
}

public class Child extends Parent
{
   public void printInfo()
   {
      System.out.println(getName() + " " + age);
   }
}

Tralasciando alcuni dettagli, possiamo dire che dal punto di vista del compilatore Java, abbiamo semplicemente copiato il codice della classe genitore nel codice della classe figlia:

public class Child extends Parent
{
   public int age; // An inherited variable public String name; // An inherited variable public getName() { // An inherited method return name; } 
   public void printInfo()
   {
      System.out.println(getName() + " " + age);
   }
}

2. Override del metodo

A volte ci sono situazioni in cui facciamo Childereditare alla nostra classe una classe molto utile Parent, facendo sì che il figlio erediti tutte le variabili ei metodi del genitore. Ma alcuni di questi metodi potrebbero non funzionare esattamente come vorremmo o non funzionare affatto come vorremmo.

Cosa fai in questo caso? Possiamo eseguire l'override di un metodo la cui implementazione non ci piace . Questa è una cosa semplice da fare: nella nostra Childclasse dichiariamo semplicemente un metodo con la stessa firma del metodo nella Parentclasse e poi scriviamo il nostro codice al suo interno.

Esempio 1 — override del metodo

public class Parent
{
   public String name;
   public void setName(String nameNew) {
      name = nameNew;
   }

   public getName() {
      return name;
   }
}

Luke, No!!!

public class Child extends Parent
{
   public void setName(String nameNew) {
      name = nameNew + ", No!!!";
   }

   public void printInfo()
   {
      setName("Luke");
      System.out.println(getName());
   }
}

Semplificando in qualche modo la situazione, l'ereditarietà fa sì che il codice della classe genitore venga copiato nella classe figlia. Ma se una classe discendente è già un metodo che esiste in una classe antenata, quel metodo non viene copiato dalla classe antenata. Qui diciamo che il metodo nella classe figlia sovrascrive il metodo nella classe genitore. Guarda l'esempio qui sotto. Forse servirà a rendere le cose un po' più chiare:

public class Child extends Parent
{
   public String name; // An inherited variable

   public void setName(String nameNew)  // The overridden method replaces the inherited one
   {
      name = nameNew + ", No!!!";
   }

   public getName() // An inherited method { return name; }

   public void printInfo()
   {
      setName("Luke");
      System.out.println(getName());
   }
}

Esempio 2: un po' di magia dell'ereditarietà (e override del metodo)

public class Parent
{
   public getName() {
      return "Luke";
   }

   public void printInfo()
   {
      System.out.println( getName() );
   }
}

public class Child extends Parent
{
   public getName() {
      return "Luke, I am your father";
   }
}

Se il printInfo()metodo viene chiamato su un Parenttipo, a sua volta chiama il getName()metodo della Parentclasse.

Se il printInfo()metodo viene chiamato su un Childoggetto, a sua volta chiama il getName()metodo della Childclasse.

In altre parole, il printInfo()metodo viene dichiarato solo nella Parentclasse, ma chiama il getName()metodo della Childclasse se il printInfo()metodo viene chiamato su un Childoggetto.

Esempio:

Parent parent = new Parent();
parent.printnInfo();

Luke

Child child = new Child();
child.printnInfo();

Luke, I am your father

E tutto perché dal punto di vista del compilatore (una versione molto semplificata di esso), il codice della Childclasse si presenta così:

public class Child extends Parent
{
   public getName() {
      return "Luke, I am your father";
   }

   public void printInfo() { System.out.println(getName()); }
}

3. Liste

Ecco un breve promemoria sugli elenchi ( List). Le liste hanno molto in comune con gli array:

• Possono memorizzare molti dati di un tipo specifico.
• Ti consentono di ottenere elementi in base al loro indice.
• Gli indici degli elementi iniziano da 0.

Vantaggi delle liste:

A differenza degli array, gli elenchi possono cambiare dimensione in modo dinamico. Subito dopo la creazione, la dimensione di un elenco è 0. Man mano che gli elementi vengono aggiunti all'elenco, la sua dimensione aumenta. Esempio di creazione di un elenco:

ArrayList<String> myList = new ArrayList<String>();

Il valore indicato tra parentesi angolari è il tipo di dati che l'elenco può memorizzare.

Ecco alcuni metodi per lavorare con un elenco:

ArrayList<String> list = new ArrayList<String>();

list.add("name");

list.add(0, "name");

String name = list.get(5);

list.set(5, "new name");

int count = list.size();

list.remove(4);

Per ulteriori informazioni sugli elenchi, puoi leggere i seguenti articoli:

• ArrayList nelle immagini
• Classe ArrayList
• Rimozione di un elemento da un ArrayList

4. Numeri casuali

Il motore di gioco CodeGym ha due metodi che possono essere utilizzati per generare numeri casuali. Questi metodi sono:

int getRandomNumber(int max)

int getRandomNumber(int min, int max)

Il primo metodo — getRandomNumber(int max)— restituisce un numero casuale nell'intervallo 0, 1, 2, ... max-1. Sotto il cofano, usa la Randomclasse del java.utilpacchetto, ma ciò non cambia il modo in cui usi un numero casuale.

getRandomNumber(int)accetta un numero intero come argomento. Questo numero sarà il limite superiore dei numeri che il generatore di numeri casuali può restituire. Il limite inferiore è 0. Attenzione! Il generatore di numeri casuali non restituirà MAI il valore del limite superiore. Ad esempio, se chiami getRandomNumber(3), restituirà casualmente 0, 1 o 2. Come puoi vedere, non restituirà 3. Usare un generatore di numeri casuali in questo modo è piuttosto semplice, ma è adatto a molti casi.

Il secondo metodo — getRandomNumber(int min, int max)— restituisce un numero intero casuale nell'intervallo [min, max-1]. Non restituirà mai un numero inferiore a mine non restituirà mai un numero maggiore di max-1.

Come si possono utilizzare questi metodi nella pratica?

1. Dadi

Supponiamo di voler simulare il lancio di un dado e ottenere un numero casuale compreso nell'intervallo 1-6. Come lo faresti? Questo può essere fatto con un codice come questo:

int dice = getRandomNumber(1, 7);

Questo metodo restituirà un numero intero casuale nell'intervallo 1-6.

2. Tiro al bersaglio

Supponiamo di voler simulare il tiro a un bersaglio e che la precisione di un tiro includa una componente casuale che varia nell'intervallo da -10a +10compreso. Questo può essere fatto con un codice come questo:

int dx = getRandomNumber(-10, 11);

Questo metodo restituirà un numero intero casuale nell'intervallo -10a +10.

Esistono molti modi per utilizzare i numeri casuali nei giochi. Sei limitato solo dalla tua immaginazione. Scrivi i tuoi giochi, perfezionali e goditi il ​​processo.

Tutti possono giocare, ma solo i programmatori possono crearli.