Programmation Java/Types de base
Les types de base ou types primitifs de Java sont listés dans le tableau plus bas.
Remarques :
Nombres.
Comme le montre le tableau précédent, Java possède différents types primitifs pour représenter les nombres.
Ces types sont tous signés :
excepté le type codice_18 utilisé pour représenté un point de code Unicode sur 16 bits qui peut aussi être utilisé comme type numérique non signé.
Pour aller au-delà de 64 bits, Java peut gérer des nombres de taille arbitraire, occupant plus de mémoire, via des types non primitifs.
Depuis Java 7, le caractère souligné peut être utilisé pour séparer les chiffres (et uniquement les chiffres) afin de les regrouper.
Exemple :
Il ne peut pas être placé avant le nombre, ou entre un chiffre et le point décimal ou le suffixe :
Booléens.
Comme en Pascal, le langage Java a un type dédié aux résultats de l'évaluation de conditions ou expressions booléennes : le type codice_19.
Les deux valeurs possibles sont codice_20 (vrai) et codice_21 (faux).
boolean en_dehors_de_l_intervalle = (valeur < min) || (valeur > max);
if (en_dehors_de_l_intervalle) // utilisation dans une condition if
 System.out.println("La valeur et en dehors de l'intervalle de validité.");
Ce type est particulièrement utile pour réutiliser le résultat d'une condition plusieurs fois, ou initialiser un état selon une condition.
Les opérateurs sur les booléens sont les suivants :
Les deux opérandes binaires du et et du ou sont évalués de manière paresseuse ("lazy evaluation") : le deuxième opérande n'est pas évalué si la valeur du premier suffit à déterminer le résultat final :
Cela a de l'importance pour l'évaluation d'expression du deuxième opérande, notamment l'appel à une méthode ou l'accès à un membre d'un objet.
Exemple :
boolean non_vide = texte != null && texte.length() > 0;
// Si texte == null, la non évaluation du deuxième opérande empêche un déréférencement
// de la référence null et évite donc une exception de type NullPointerException.
boolean non_vide = texte != null & texte.length() > 0; // <!> Erreur d'opérateur
// Si texte == null, le deuxième opérande est tout de même évalué et un déréférencement
// de la référence null a lieu, provoquant une exception de type NullPointerException !
Pour effectuer un ou exclusif sur les booléens, il est possible d'utiliser l'opérateur de comparaison différent codice_29 ou l'opérateur ou exclusif sur les bits codice_30 qui dans les deux cas évaluent les deux opérandes.
Caractères pour codice_18 et codice_10.
Les caractères spéciaux suivants peuvent être utilisés pour les valeurs littérales des types codice_18 et codice_10 :
String exemple = "Ce texte est la première ligne,\n\tsuivie d'une seconde ligne indentée par une tabulation.";
Variables et classes.
Les classes de base comme String ne sont pas des types primitifs.
Il est aisé de les confondre mais les conventions habituelles d'écriture permettent de distinguer les deux types de données.
Les types de variables primitifs sont toujours écrits en minuscules, par contre les noms des classes ont par convention leur premier caractère en majuscule.
Aussi lorsque vous rencontrez un Boolean, ce n'est pas un type de base mais bien une classe.
En effet les valeurs de type primitif peuvent être encapsulées, et Java fournit d'ailleurs pour tous les types primitifs des classes d'encapsulation appelées "wrappers". 
Ceci peut être utile dans certains cas pour bénéficier de certaines caractéristiques de leur classe mère "Object".
Par exemple, la pose d'un verrou de synchronisation (instruction "synchronized") ne peut se faire que sur un objet.
Les emballages de types primitifs.
Une classe d'emballage ("wrapper" en anglais) permet d'englober une valeur d'un type primitif dans un objet.
La valeur est stockée sous la forme d'un attribut.
Chaque classe permet de manipuler la valeur à travers des méthodes (conversions, ...).
Auto-boxing.
L'auto-boxing permet la conversion d'une valeur de type primitif en objet de la classe englobante correspondante de manière implicite, notamment lors d'une affection ou d'un passage d'arguments en paramètres d'une méthode.
Exemple :
public Integer somme(Integer a, Integer b)
 // <!> a et b sont de type objet et peuvent valoir null.
 // Dans ce cas, pour cette méthode, considérer que null vaut 0 :
 if (a==null) return b;
 if (b==null) return a;
 return a + b;
System.out.println("Somme 1+2 = "+somme(1,2));
System.out.println("Somme +2 = "+somme(null,2));
Pour plus de détails, voir la section Autoboxing du chapitre Transtypage de ce livre.
Conversions.
Pour convertir une valeur du type indiqué par la ligne vers celui de la colonne :

Programmation Java/Conditions
En Java, les séquences d'instructions "if...else" et "switch..case" permettent de formuler des traitements conditionnels.
Instructions if...else.
L'instruction "if" permet d'exécuter une instruction (ou un bloc d'instructions) si une condition est remplie.
La condition est une expression booléenne dont le résultat est de type codice_1.
if (condition)
 // instruction à exécuter
L'instruction "else" complète l'instruction "if". Elle permet d'exécuter une instruction si la condition indiquée par le "if" n'est pas remplie :
if (condition)
 // instruction à exécuter
else
 // instruction à exécuter si la condition n'est pas remplie
Exemple :
if (a > 10) System.out.println("A est plus grand que 10.");
else System.out.println("A ne dépasse pas 10.");
Pour plusieurs instructions, il faut les regrouper avec des accolades :
if (condition) 
 // instructions à exécuter
else
 // instructions à exécuter si la condition n'est pas remplie
On peut aussi enchaîner les tests conditionnels les uns à la suite des autres :
if (condition1)
 // bloc1
else if (condition2)
 // bloc2
else
 // bloc3
Pour une meilleure compréhension du code, il est recommandé que la condition dans le codice_2 soit positive et simplifiée.
Pareillement, les variables booléennes devraient évaluer une condition positive plutôt que négative.
Instructions switch...case.
La séquence d'instructions "switch" permet d'exécuter différentes instructions (ou blocs d'instructions) en fonction d'une liste de cas. L'instruction "default" permet de définir un cas par défaut. 
switch (expression)
 case constante1:
 // instructions à exécuter
 break;
 case constante2:
 // instructions à exécuter
 break;
 case constante3:
 case constante4:
 // instructions à exécuter pour les deux constantes
 break;
 default:
 // instructions à exécuter
 break;
L'instruction "break" sert à sortir du test.
Dans le cas contraire, les instructions du "case" suivant seraient également exécutées, ce qui est utile pour traiter plusieurs cas de la même façon.
Pour plus de précision, voir la section suivante (itération).
Remarque : le dernier "break" est facultatif (qu'il s'agisse de la clause "default" dans le cas précédent, ou d'une clause "case").
Cependant ajouter ce dernier "break" améliore la maintenabilité du code en cas d'ajout d'un nouveau cas ("case" ou "default") ou de déplacement du dernier cas.

Windows/Lire et écrire le japonais
Windows 95/Windows 98/Windows Me.
Ces versions de Windows ne supportent malheureusement pas Unicode, et seules les éditions japonaises sont capables de gérer du texte japonais. On peut cependant installer Jamondo-IME.EXE qui ajoute la possibilité d'écrire en japonais. 
Cependant, certains logiciels comme Microsoft Internet Explorer ou Microsoft Office sont compatibles Unicode. Pour Internet Explorer, la prise en charge du japonais est possible en téléchargeant et installant un composant optionnel.
Windows 2000/XP.
Les versions européennes ont par défaut le support Unicode. Lire et écrire le japonais est donc une simple question de configuration. 
Procédure à suivre pour pouvoir lire le japonais : 
Afin de pouvoir écrire en japonais, il faut également : 
Note : il est possible qu'il faille redémarrer le système pour que le support soit entièrement installé.