Quelque chose d'utile

1. Héritage

Pour travailler avec le moteur de jeu CodeGym, vous devrez utiliser l'héritage . Mais que faire si vous ne savez pas ce que c'est ? D'une part, vous devez comprendre et étudier ce sujet. D'autre part, le moteur est spécialement conçu pour être très simple, vous pouvez donc vous débrouiller avec une connaissance superficielle de l'héritage.

Qu'est-ce donc que l'héritage ? En termes simples, l'héritage est une relation entre deux classes. L'un d'eux agit comme la classe parente et l'autre devient la classe enfant (descendante). De plus, une classe parent peut même ne pas savoir qu'elle a des classes descendantes. En d'autres termes, le parent ne tire pas grand avantage d'avoir des classes descendantes.

Mais l'héritage donne de nombreux avantages à la classe enfant. Le plus important d'entre eux est que toutes les variables et méthodes de la classe parent apparaissent dans la classe enfant, comme si le code de la classe parent était copié directement dans la classe enfant. Ce n'est pas tout à fait exact, mais cela suffira pour une compréhension de base de l'héritage.

Voici quelques exemples pour vous aider à mieux comprendre l'héritage.

Exemple 1 - voici l'exemple le plus simple

public class Parent
{
}

public class Child extends Parent
{
}

Exemple 2 — utilisation des variables de la classe parent

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

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

Exemple 3 — utilisation des méthodes de la classe parent

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);
   }
}

En omettant quelques détails, nous pouvons dire que du point de vue du compilateur Java, nous avons simplement copié le code de la classe parent dans le code de la classe enfant :

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. Remplacer la méthode

Parfois, il y a des situations où nous faisons hériter notre Childclasse d'une classe très utile Parent, ce qui fait que l'enfant hérite de toutes les variables et méthodes du parent. Mais certaines de ces méthodes peuvent ne pas fonctionner tout à fait comme nous le souhaitons ou pas du tout comme nous le souhaitons.

Que faites-vous dans ce cas ? Nous pouvons surcharger une méthode dont l'implémentation ne nous plaît pas . C'est une chose simple à faire : dans notre Childclasse, nous déclarons simplement une méthode avec la même signature que la méthode de la Parentclasse, puis nous y écrivons notre propre code.

Exemple 1 — remplacement de méthode

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());
   }
}

Pour simplifier un peu la situation, l'héritage entraîne la copie du code de la classe parent dans la classe enfant. Mais si une classe descendante est déjà une méthode qui existe dans une classe ancêtre, alors cette méthode n'est pas copiée de la classe ancêtre. Ici, nous disons que la méthode de la classe enfant remplace la méthode de la classe parent. Regardez l'exemple ci-dessous. Peut-être que cela aidera à rendre les choses un peu plus claires :

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());
   }
}

Exemple 2 - un peu de magie d'héritage (et de remplacement de méthode)

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";
   }
}

Si la printInfo()méthode est appelée sur un Parenttype, elle appelle à son tour la getName()méthode de la Parentclasse.

Si la printInfo()méthode est appelée sur un Childobjet, elle appelle à son tour la getName()méthode de la Childclasse.

En d'autres termes, la printInfo()méthode est déclarée uniquement dans la Parentclasse, mais elle appelle la getName()méthode de la Childclasse si la printInfo()méthode est appelée sur un Childobjet.

Exemple:

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

Luke

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

Luke, I am your father

Et tout cela parce que du point de vue du compilateur (une version très simplifiée de celui-ci), le code de la Childclasse ressemble à ceci :

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

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

3. Listes

Voici un bref rappel sur les listes ( List). Les listes ont beaucoup en commun avec les tableaux :

• Ils peuvent stocker beaucoup de données d'un type spécifique.
• Ils vous permettent d'obtenir des éléments par leur index.
• Les indices des éléments commencent à 0.

Avantages des listes :

Contrairement aux tableaux, les listes peuvent changer dynamiquement de taille. Immédiatement après sa création, la taille d'une liste est de 0. Au fur et à mesure que des éléments sont ajoutés à la liste, sa taille augmente. Exemple de création d'une liste :

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

La valeur indiquée entre crochets correspond au type de données que la liste peut stocker.

Voici quelques méthodes pour travailler avec une liste :

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);

Pour plus d'informations sur les listes, vous pouvez lire les articles suivants :

• ArrayList en images
• Classe ArrayListArrayList class
• Supprimer un élément d'une ArrayList

4. Numéros aléatoires

Le moteur de jeu CodeGym a deux méthodes qui peuvent être utilisées pour générer des nombres aléatoires. Ces méthodes sont :

int getRandomNumber(int max)

int getRandomNumber(int min, int max)

La première méthode — getRandomNumber(int max)— renvoie un nombre aléatoire dans la plage 0, 1, 2, ... max-1. Sous le capot, il utilise la Randomclasse du java.utilpackage, mais cela ne change pas la façon dont vous utilisez un nombre aléatoire.

getRandomNumber(int)accepte un entier comme argument. Ce nombre sera la limite supérieure des nombres que le générateur de nombres aléatoires peut renvoyer. La borne inférieure est 0. Attention ! Le générateur de nombres aléatoires ne renverra JAMAIS la valeur de la borne supérieure. Par exemple, si vous appelez getRandomNumber(3), il renverra aléatoirement 0, 1 ou 2. Comme vous pouvez le voir, il ne renverra pas 3. Utiliser un générateur de nombres aléatoires de cette manière est plutôt simple, mais convient à de nombreux cas.

La deuxième méthode — getRandomNumber(int min, int max)— renvoie un entier aléatoire dans la plage [min, max-1]. Il ne renverra jamais un nombre inférieur à min, et il ne renverra jamais un nombre supérieur à max-1.

Comment ces méthodes peuvent-elles être utilisées en pratique ?

1. Dés

Supposons que vous vouliez simuler le lancer d'un dé et obtenir un nombre aléatoire dans la plage 1-6. Comment feriez-vous ? Cela peut être fait avec un code comme celui-ci :

int dice = getRandomNumber(1, 7);

Cette méthode renverra un entier aléatoire dans la plage 1-6.

2. Entraînement à la cible

Supposons que vous vouliez simuler un tir sur une cible et que la précision d'un tir comprenne une composante aléatoire qui varie dans la plage de -10à +10inclus. Cela peut être fait avec un code comme celui-ci :

int dx = getRandomNumber(-10, 11);

Cette méthode renverra un entier aléatoire dans la plage -10de +10.

Il existe de nombreuses façons d'utiliser des nombres aléatoires dans les jeux. Vous n'êtes limité que par votre imagination. Écrivez vos propres jeux, affinez-les et profitez du processus.

Tout le monde peut jouer à des jeux, mais seuls les programmeurs peuvent les créer.