Après avoir vu des exemples de code (cf. exercices précédents), précisons quelques points.

Les méthodes (non static) sont toujours lancées sur des objets.
Même si la syntaxe est trompeuse, le code :
class MaClasse {
   void foo() {
      bar();
   }
   void bar() {
      . . .
   }
}
indique que la méthode foo() devra être lancée sur un objet de la classe MaClasse par exemple par :
MaClasse ref;
ref = new MaClasse();
ref.foo();
et que l'appel de la méthode bar() dans foo() se fera sur le même objet. On le précise parfois en écrivant this.bar();

Il y a 2 sortes de types de données en Java :
les types de données "primitifs" et les types de données "référence".

Ces types (dits "primitifs") sont les suivants est ont une taille fixe quelle que soit l'architecture de la machine. Ce sont :
 

Les variables de ces types ont une valeur nulle (0 ou 0.0) par défaut et false pour les boolean.

exemple :
MaClasseBouton a, b;
a et b ne sont pas des objets mais des références sur de futurs objets.
a = new MaClasseBouton("A"); // a refere un boutton appelé A
b = new MaClasseBouton("B"); // b refere un boutton appelé B
a = b; // a et b referencent le meme bouton B.
Il n'y a pas eu de recopie d'objets.
Le bouton A n'est plus référencé et son emplacement sera libéré par le ramasse-miettes (garbage collector).

Le mode de passage des paramêtres en Java est toujours le passage par valeur. Autrement dit lorsqu'une méthode est appelée il y a création d'un emplacement pour le paramêtre formel et le paramêtre effectif passe sa valeur à ce paramêtre formel.

Comme les objets en Java sont manipulés par des références, dans la méthode appelée on peut de nouveau utiliser l'objet référencé dans l'appelant. De ce fait on dit parfois que "les objets passent par référence".

En Java toute classe doit être utilisée en précisant le paquetage auquel elle appartient. Par exemple il faudrait écrire pour utiliser la classe Date, java.util.Date. Afin de simplifier cette syntaxe on utilise le mot import.

Ce mot ne signifie pas que quelque chose est disponible ou a été chargé. Il évite de taper du code : c'est un raccourci lexical.

Les instructions import doivent apparaître au début du fichier, après l'instruction package facultative et avant la définition de toute classe ou interface.

Il y a 2 sortes d'instructions import :
import monpaquetage.MaClasse; // 1
import monpaquetage.*; // 2

La forme 1 permet d'utiliser le nom d'une classe du paquetage sans mettre le nom du paquetage. Par exemple
import java.util.Hashtable;
permet d'écrire Hashtable à la place de java.util.Hashtable.

La forme 2 permet d'utiliser toutes les classes du paquetage en n'indiquant que le nom de la classe. Par exemple
import java.util.*;
permet d'écrire
Date now = new Date();
au lieu de
java.util.Date now = new java.util.Date();

Remarque
import java.lang.*;
est implicite dans tout programme Java.

Ce sont les mots suivants : public, protected, "par défaut" (i.e. pas de modifieur), private, ainsi que abstract, final, native, static, synchronized.

On ne les traitera pas tous.

Ils peuvent agir sur les classes, les méthodes ou les variables (i.e. les champs de données d'une instance). Ils n'agissent pas tous dans ces 4 domaines. Ils apparaissent au début de déclarations.

On a :
 

Dans un fichier .java, il ne peut y avoir qu'une seule classe public. Cette classe donne alors le nom au fichier (qui a pour extension .java)
 

Une classe contenant une méthode abstract doit être abstract.

Une constante de classe est une variable static final.

Une classe peut être : public, "par défaut", abstract, final.

Une méthode peut être : public, protected, "par défaut", private, abstract, final, native, static, synchronized.

Une variable (i.e. une donnée membre) peut être : public, protected, "par défaut", private, final, static.