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
|
La Child classe hérite de la Parent classe à l'aide du extends mot clé. |
|
Exemple 2 — utilisation des variables de la classe parent
|
La Child classe peut utiliser les champs age et name de la Parent classe comme s'ils étaient déclarés dans la Child classe elle-même. |
|
Exemple 3 — utilisation des méthodes de la classe parent
|
La Child classe peut utiliser les variables et les méthodes de la classe Parent comme si elles étaient déclarées dans la Child classe. Dans cet exemple, nous utilisons la getName() méthode. |
|
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);
}
}
Child
classe apparaît du point de vue du compilateur
2. Remplacer la méthode
Parfois, il y a des situations où nous faisons hériter notre Child
classe 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 Child
classe, nous déclarons simplement une méthode avec la même signature que la méthode de la Parent
classe, puis nous y écrivons notre propre code.
Exemple 1 — remplacement de méthode
|
La printInfo() méthode affichera la phrase suivante :
|
|
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 :
Voici comment la classe Child apparaît du point de vue du compilateur : |
---|
|
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 Parent
type, elle appelle à son tour la getName()
méthode de la Parent
classe.
Si la printInfo()
méthode est appelée sur un Child
objet, elle appelle à son tour la getName()
méthode de la Child
classe.
En d'autres termes, la printInfo()
méthode est déclarée uniquement dans la Parent
classe, mais elle appelle la getName()
méthode de la Child
classe si la printInfo()
méthode est appelée sur un Child
objet.
Exemple:
|
Ce code affiche le texte suivant à l'écran :
|
|
Ce code affiche le texte suivant à l'écran :
|
Et tout cela parce que du point de vue du compilateur (une version très simplifiée de celui-ci), le code de la Child
classe ressemble à ceci :
public class Child extends Parent
{
public getName() {
return "Luke, I am your father";
}
public void printInfo()
{
System.out.println(getName());
}
}
Child
classe apparaît du point de vue du compilateur
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>();
ArrayList
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 :
Code | Brève description |
---|---|
|
Création d'une nouvelle liste de chaînes |
|
Ajouter un élément à la fin de la liste |
|
Ajouter un élément au début de la liste |
|
Obtenir un élément par son index |
|
Changer un élément par son index |
|
Obtenir le nombre d'éléments dans la liste |
|
Supprimer un élément de la liste |
Pour plus d'informations sur les listes, vous pouvez lire les articles suivants :
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 Random
classe du java.util
package, 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
à +10
inclus. 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 -10
de +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.
GO TO FULL VERSION