Programmation Java

⇑les extensions

les fichiers contenant le code source .java
les fichiers pré-compilés class

⇑les types

types entiers :
bytes (1 octet) de -128 à +127
short (2 octets) de -32768 à +32767.
int (4 octet) de à -2*10⁹ à 2*10⁹
long (8 octet) de -9*10¹⁸ à 9*10¹⁸
bytes (1 octet) de -128 à +127

types réels
float (4 octets ) avec 6 chiffres significatifs
double (8 octets ) avec 15 chiffres significatifs

caractères et chaines
char
String avec majuscule est une classe

⇑Opérations

+ pour la somme ou la concaténation

/ division, ou division euclidienne sur les entiers : 4/3 == 1
% reste de la division euclidienne

conversion de type : (float)3==3.0

⇑entrées sorties

System.out.print("salut !");

Entrées :
Il faut d'abord déclarer Scanner sc = new Scanner(System.in); de la classe Scanner qui est dans le paquet java.util.Scanner; d'où un import java.util.Scanner; en tête de fichier.
str = sc.nextLine(); pour dsaisir une ligne (de texte)
i = sc.nextInt(); pour saisir un entier

⇑Conditions

if (condition)
{
	actions;
}
else
{
	actions;
}

ou plusieurs d'affilée : if (...) {...} else if (...) {...}

le switch

switch (variable)
{
	case valeur1 :
		actions;
   	break;

    	case valeur2 :
		actions;
    	break;

    	default:
	   	actions;
}

opérations : && (et) || (ou) égalité ==

⇑Boucles

while
do { ... } while()
for (int i ; i<10 ;i++ ) { ...} on peut incrémenter comme on le veut i*=2

⇑Tableaux

⇑Définition

En plaçant des [] après le nom de la variable, on déclare un tableau de variables de ce type :

int monTableau[]=new int[3]; déclare un tableau vide de 3 éléments.

int monTableau[]={1,2,4}; définit d'un coup
monTableau[0]=1
monTableau[1]=2
monTableau[3]=4

Tableau à plusieurs indices :
int monTableau[][]={{1,2,3},{4,5,6}} définit
monTableau[0]={1,2,3} et
monTableau[1]={4,5,6} et donc
monTableau[0][2]=3

⇑Opérations

montableau.length la longueur

for (int elt : monTableau){...} parcours avec elt le contenu des cases du tableau.

⇑Chaines de caractères

Pour String chaine="Coucou" on a des méthodes (fonctions)

toUpperCase() passe tout en majuscule chaine2 = chaine.toUpperCase();

toLowerCase(); passe tout en minuscule

concat(...); concatèren chaine2 = chaine.concat("caca"); donne Coucoucaca

length(); sa longueur

charAt(4); caractère d'indice 4 (en partant de 0)

equals(...); compare chaine.equals("caca"); est false

substring(a,b); sous-chaine de l'indice a inclus à l'indice b exclus

indexOf("texte") ou .lastIndexOf(...) donne la position du premier "texte" dans la chaine .

⇑Fonctions mathématiques

Elles sont dans l'objet Math

Math.random(); au hasard dans l'intervalle [0,1]

Math.exp(x);

Math.pow(x,y); le résultat est un double

⇑Les méthodes

(fonctions ou procédures.)
Elles se définisssent à l'interieur d'une classe.

⇑Définir

int somme(int a,b)
{
	return a+b;
}

On peut "surcharger" la méthode (donner au même nom une signification différente suivant le type et le nombre d'arguments)

int somme(int a,b)
{
	return a+b;
}
int somme(int a, int b)
{
	return a+b;
}
float somme(float a, float b)
{
	return a+b;
}

⇑Les classes

⇑Programmation Orientée Objet

explication générale

Une classe est un ensemble d'objets qui ont une structure commune et un comportement commun.

Un objet est une instance d'une classe.
Il est créé par un constructeur (méthode portant le nom de la classe, chargée d'initialiser)
laVariable=new laClasse();

les attributs sont les propriétés de l'objet

Les méthodes permettent de modifier (setter ou muttateur) d'accèder (accesseur ou getter) ou d'opérer sur les attributs d'un objet.

Qui a accès à la méthode (ou la classe)public ou private ou protected
Le mot-clé public signifie que la méthode peut être utilisée par n'importe quelle autre classe Java ou par Java lui-même.
private limite l'accès à l'objet lui même.
protected limite l'accès à l'objet lui même et à ses héritiers.

Comment utiliser static.
Le mot-clé static signifie que l'instance (variable) sera permanente.
Ce sera la même instance qui sera utilisée pour tous les objets de cette classe.
typiquement, on peut ainsi créer un compteur global.

Comment utiliser final
Une méthode déclarée final ne pourra pas ête modifiée par un héritié.

Comment utiliser abstract
Une classe abstract ne peut être utilisée que pour définir des classes filles.
On ne peut pas déclarer d'objet de cette classe.
On peut y défnir des méthodes sans corps, qui seront précisées dans les classes filles.

Comment utiliser interface
Pour créer une super-classe abstraite.
Une classe pourra implémenter (et nonplus hériter de) plusieurs interfaces.

⇑Syntaxe

Les classes doivent être définies dans leurs propres fichier.
Elles définissent la structure d'nu type d'objet ainsi que les méthodes (accesseur...) permettant de travailler avec.

public class Case
{
	private boolean cochee;
	private boolean croixRond;

	// constructeur //
	public Case()
	{
		cochee=false;
		croixRond=false;
	}

	// constructeur surchargé //
	public Case(boolean c,boolean cr)
	{
		cochee=c;
		croixRond=cr;
	}

	// muttateur //
	public void coche()
	{
		cochee=true;
	}
	public void decoche()
	{
		cochee=false;
	}

	// accesseur //
	public boolean estCochee()
	{
		return cochee;
	}
}

Dans les méthodes, on peut accéder à l'objet lui même par this
this.cochee===cochee

⇑Extension de classes

Une extension de classe hérite des attributs de la classe mère.
L'appel au constructeur de la mère se fait par super qui désigne la classe mère.
super() est le constructeur de la classe mère.

class CaseColoree extends Case
{
	private int couleur;

	// constructeur //
	void CaseColoree()
	{
		super(); // constructeur de la mère.
		couleur=0;
	}

	// accesseur //
	public int couleur()
	{
		return couleur;
	}

	// muttateur //
	public void couleur(int c)
	{
		couleur=c;
	}
}

⇑Interface

On déclare les interface et leurs méthodes

public interface I
{
	public void A();
}

public interface I2
{
	public void B();
}

et on l'implémente dans les classes. (ses méthodes doivent être redéfinies) L'extension doit êter spécifiée avant l'implémentation.

public class X extends Y implements I,I2
{
	public void X()
	{
		super();	// constructeur de Y
		....; 	// suite du constructeur de X
	}
	public void A(){...;}
	public void B(){...;}
}

⇑Les exceptions

Les exceptions sont des erreurs. (erreurs de type pour les entrées sorties, divisions par 0 dans les opérations ...)

Quand on pense qu'une telle erreur peut se produite, on essaie (try {....}) puis on capture et on traite l'erreur éventuelle (catch {...}).

int i=0;
while (i==0){
	try{
		i=sc.nextInt();
	}
	catch(java.util.InputMismatchException ie){
		String c=sc.next(); // vide la ligne tampon
		System.out.println("un vrai entier!");
     }
}

⇑Graphisme

Traité à présent dans une page propre : Swing