Commençons par observer le résultat final. L'applet affiche un paysage sur lequel nous faisons apparaître de la neige ou de la pluie. La classe Ovni va représenter un élément susceptible de jouer le rôle de la neige ou de la pluie.
Nous appellerons Objet Volant Non Identifié (Ovni) un objet susceptible de jouer le rôle d'un flocon de neige ou d'une goutte de pluie. Cet objet doit être capable de se dessiner et de bouger, il aura donc une méthode dessine et une méthode bouge. Ces deux méthodes ferons appel à plusieurs variables donnant la position de l'objet, la direction dans laquelle il se déplace et la vitesse avec laquelle il se déplace.
Nous devons commencer par annoncer l'utilisation du package java.awt (pour utiliser la classe Graphics). Puis nous déclarons les variables utilisées.
import java.awt.*;
public class Ovni {
int x,y; //position de l'objet
double angle; //direction de déplacement
int vitesse; //vitesse de déplacement
Nous allons donner deux constructeurs à notre classe: un constructeur générique et un constructeur choisissant une position de départ au hasard dans un rectangle. Une fonction hasard nous fournira des nombres entiers au hasard dans des limites choisies.
public Ovni() {
x=0; y=0; vitesse=0; angle=0;
}
public Ovni(int larg, int haut) {
this();
x=hasard(larg); //rester dans les limites horizontales
y=hasard(haut); //rester dans les limites verticales
vitesse=hasard(4)+1;
}
public int hasard(int n) {
return (int)(Math.floor(Math.random()*n));
}
La méthode dessine est vide, nous ne connaissons pas encore la nature de l'objet volant.
public void dessine(Graphics g) {
}
La méthode bouge peut être écrite, elle consiste simplement à modifier les coordonnées x et y de l'objet en tenant compte des limites dans lesquelles il évolue.
public void bouge(int larg, int haut) {
//nouvelle position
x=(int)(x*1.0+vitesse*Math.cos(angle));
y=(int)(y*1.0+vitesse*Math.sin(angle));
//en cas de sortie du cadre, on remet à 0
if (x>larg) {
x=0;
y=hasard(haut);
}
if (y>haut) {
y=0;
x=hasard(larg);
}
if (x<0) {
x=larg;
y=hasard(haut);
}
if (y<0) {
y=haut;
x=hasard(larg);
}
}
La classe Ovni est terminée. Il reste à lui donner différentes apparences dans des classes dérivées. Celles-ci auront simplement à gérer la méthode dessine.
La classe Flocon va donner un contenu concret à la classe Ovni en dessinant un flocon de neige. Elle utilisera une variable supplémentaire r qui représentera le rayon du flocon. La vitesse d'un flocon dépendra de son rayon. Sa direction sera pi/2 pour qu'il tombe verticalement.
Ceci nous donne le code suivant :
import java.awt.*;
public class Flocon extends Ovni {
int r=0;
//constructeur
public Flocon(int larg, int haut) {
super(larg,haut);
r=hasard(4)+1;
vitesse=r;
angle=Math.PI/2;
}
//méthode de dessin
public void dessine(Graphics g) {
g.setColor(Color.white);
g.fillOval(x,y,r,r);
}
}
La classe Pluie va donner un nouveau contenu concret à la classe Ovni en dessinant une goutte de pluie. Elle utilisera une variable supplémentaire lg qui représentera la longueur du segment représentant cette goutte. La vitesse d'une goutte dépendra de sa longueur. Sa direction sera pi/2+pi/10 pour qu'elle tombe de façon oblique (à cause du vent).
Ceci nous donne le code suivant :
import java.awt.*;
public class Pluie extends Ovni {
int lg=0;
public Pluie(int larg, int haut) {
super(larg,haut);
lg=hasard(6)+6;
vitesse=lg/2;
angle=Math.PI/2+Math.PI/10;
}
public void dessine(Graphics g) {
g.setColor(Color.lightGray);
int x1=(int)(x*1.0+lg*Math.cos(angle));
int y1=(int)(y*1.0+lg*Math.sin(angle));
g.drawLine(x,y,x1,y1);
}
}
Nous disposons de deux types d'objet dérivés de la classe Ovni qui ont toutes les capacités nécessaires pour être utilisés. Nous allons maintenant créer la classe Paysage qui contiendra des Ovnis et les fera bouger.