Types primitives:

• Boolean type: boolean
  
• Character type: char
  
• Integer types: byte, short, int, long
  
• Floating-Point types: float, double
  

The following are the possible conversions between numeric types without information loss:

• byte → short → int → long
• char → int
• int → double
• float → double

The following are the possible conversions between numeric types with possibility of information loss (precision):

• int → float
• long → float
• long → double

When the conversion between two numeric types can be done without information loss, then automatic conversion is possible: long value = intValue;
Otherwise you need to manually cast the value of a specific type to another:
int value = (int) longValue;
Note that the value might be truncated if it's larger than the supported range of numeric values of the target type:
byte value = (byte) 128; gives the value: -128.

When applying a binary operator on operands of distinct types, then the following should be considered:

• If an operand is of type double, then the other operand will be converted to a double
• If an operand is of type float, then the other operand will be converted to a float
• If an operand is of type long, then the other operand will be converted to a long
• Otherwise, the operands will be converted to a int

Une variable de type boolean peut contenir les valeurs true ou false.

Une variable de type char peut contenir des caractères.
La valeur de la variable est représentée par 16 bits.
char c1 = 'a';
Une variable de type char peut aussi contenir des nombres entiers positifs.
Une variable de type char peut contenir les valeurs suivantes : [0, 65535]
Un cast est nécessaire pour affecter une valeur entière a une variable de type char.
char c2 = (char) 65535;
A character can be expressed as a hexadecimal value using the suffix \u
char c3 = '\u005B';
Escape Characters: escape character | unicode value | name \" | \u0022 | Double quote \' | \u0027 | Single quote \\ | \u005c | Backslash \t | \u0009 | Tab \n | \u000a | Line feed \r | \u000d | Carriage return \b | \u0008 | Backspace
Unicode escape characters are interpreted before the code get parsed.

• For example "\u0022 + \u0022" is equivalent to "" + ""
  System.out.println("\u0022 + \u0022"); System.out.println("" + "");
  
• \u0061 is the unicode value of the character 'a' char c\u0061 = 'x'; System.out.println(ca);
  

Some cases may cause the compiler to complain about a syntax error:

• The following will be interpreted as if you have typed System.out.println("" "");:
  System.out.println("\u0022 \u0022");
  
• Line feed within a comment:
  // the line feed \u000a will cause multiple compiler errors
  
• Invalid unicode character prefix within a comment:
  // invalid unicode: missing the 4 hex digits after \u: \unicode
  

Please note that the type char can hold any 16 bit (basic) unicode character. For the supplementary unicode characters, each unicode character has a code value (code point) which is represented as pairs of 16 bit code units. When working with strings that might hold supplementary unicode characters, you should be aware that a char value might actually hold the code units that represent the supplementary unicode character. For example, the smiley symbol "🙂" is represented with 2 code units: String smiley = "🙂"; System.out.println(smiley.length()); // code units count: 2 System.out.println(smiley.codePointCount(0, smiley.length())); // code points count: 1 System.out.println(String.format("%X", (int) smiley.charAt(0))); // first code unit D83D of the smiley character System.out.println(String.format("%X", (int) smiley.charAt(1))); // second code unit DE42 of the smiley character System.out.println(String.format("%X", smiley.codePointAt(0))); // code point 1F642 of the smiley character
If you need to print all characters of a string, use the codePoints method of the String class: "mti🙂tek".codePoints().forEach(cp -> System.out.println(new String(Character.toChars(cp)))); m t i 🙂 t e k
See the Java docs API for the usage of Character.toChars method: public static char[] toChars(int codePoint) //Converts the specified character (Unicode code point) to its UTF-16 representation stored in a char array. //If the specified code point is a BMP (Basic Multilingual Plane or Plane 0) value, the resulting char array has the same value as codePoint. //If the specified code point is a supplementary code point, the resulting char array has the corresponding surrogate pair. //Parameters: //codePoint - a Unicode code point //Returns: //a char array having codePoint's UTF-16 representation.

Une variable de type byte peut contenir à la fois des valeurs positives et négatives.
La valeur de la variable est représentée par 8 bits.
Le premier bit sert comme flag pour décider si la valeur est positive ou négative : 1 pour le signe négatif et 0 pour le signe positif.
Les 7 autres bits restants sont utilisés pour représenter la valeur de la variable.
Une variable de type byte peut contenir les valeurs suivantes : [-128, 127].

Une variable de type short peut contenir à la fois des valeurs positives et négatives.
La valeur de la variable est représentée par 16 bits.
Le premier bit sert comme flag pour décider si la valeur est positive ou négative : 1 pour le signe négatif et 0 pour le signe positif.
Les 15 autres bits restants sont utilisés pour représenter la valeur de la variable.
Une variable de type short peut contenir les valeurs suivantes : [-32768, 32767].

Une variable de type int peut contenir à la fois des valeurs positives et négatives.
La valeur de la variable est représentée par 32 bits.
Le premier bit sert comme flag pour décider si la valeur est positive ou négative : 1 pour le signe négatif et 0 pour le signe positif.
Les 31 autres bits restants sont utilisés pour représenter la valeur de la variable.
Une variable de type int peut contenir les valeurs suivantes : [-(2³¹), (2³¹)-1].

Une variable de type long peut contenir à la fois des valeurs positives et négatives.
La valeur de la variable est représentée par 64 bits.
Le premier bit sert comme flag pour décider si la valeur est positive ou négative : 1 pour le signe négatif et 0 pour le signe positif.
Les 63 autres bits restants sont utilisés pour représenter la valeur de la variable.
Une variable de type long peut contenir les valeurs suivantes : [-(2⁶³), (2⁶³)-1].
long l1 = 1l; long l2 = 1L;

Une variable de type float peut contenir des nombres réels.
La valeur de la variable est représentée par 32 bits.

Examples:
float f1 = 1.0; // compiler error: "Type mismatch: cannot convert from double to float" float f2 = (float) 1.0; // OK float f3 = 1.0f; // OK
Constant holding the positive infinity of type float:
/** * A constant holding the positive infinity of type float. * It is equal to the value returned by Float.intBitsToFloat(0x7f800000). */ float POSITIVE_INFINITY = 1.0f / 0.0f;
Constant holding the negative infinity of type float:
/** * A constant holding the negative infinity of type float. * It is equal to the value returned by Float.intBitsToFloat(0xff800000). */ float NEGATIVE_INFINITY = -1.0f / 0.0f;
Constant holding a Not-a-Number (NaN) value of type float:
/** * A constant holding a Not-a-Number (NaN) value of type float. * It is equivalent to the value returned by Float.intBitsToFloat(0x7fc00000). */ float NaN = 0.0f / 0.0f;
Check if a variable is not a number:
if(Float.isNaN(f3))
The following is always false (use Float.isNaN instead):
if(f3 == Float.NaN)
Check if a variable is positive infinity:
if(f3 == Float.POSITIVE_INFINITY)
Check if a variable is negative infinity:
if(f3 == Float.NEGATIVE_INFINITY)
Check if a variable is a finite floating-point value:
if(Float.isFinite(f3))
Check if a variable is either positive infinity or negative infinity:
if(Float.isInfinite(f3))

Une variable de type double peut contenir des nombres réels.
La valeur de la variable est représentée par 64 bits.

Examples:
double d1 = 1.0; // OK double d2 = 1.0d; // OK
Constant holding the positive infinity of type double:
/** * A constant holding the positive infinity of type double. * It is equal to the value returned by Double.longBitsToDouble(0x7ff0000000000000L). */ double POSITIVE_INFINITY = 1.0 / 0.0;
Constant holding the negative infinity of type double:
/** * A constant holding the negative infinity of type double. * It is equal to the value returned by Double.longBitsToDouble(0xfff0000000000000L). */ double NEGATIVE_INFINITY = -1.0 / 0.0;
Constant holding a Not-a-Number (NaN) value of type double:
/** * A constant holding a Not-a-Number (NaN) value of type double. * It is equivalent to the value returned by Double.longBitsToDouble(0x7ff8000000000000L). */ double NaN = 0.0d / 0.0;
Check if a variable is not a number:
if(Double.isNaN(d1))
The following is always false (use Double.isNaN instead):
if(d1 == Double.NaN)
Check if a variable is positive infinity:
if(d1 == Double.POSITIVE_INFINITY)
Check if a variable is negative infinity:
if(d1 == Double.NEGATIVE_INFINITY)
Check if a variable is a finite floating-point value:
if(Double.isFinite(d1))
Check if a variable is either positive infinity or negative infinity:
if(Double.isInfinite(d1))

Quand on parle de référence, il faut distinguer les objets créés en mémoire des variables qui référencent ces objets :

• Un objet est une instance d'une classe bien particulière qui ne changera plus jamais une fois créée.
  
  
• Une variable, de son cotée, peut référencer n'importe quel objet en mémoire et peut aussi référencer durant sa vie différents objets, si la variable n'est pas déclarée avec le mot clé final.
  
  Les seules conditions qui s'appliquent aux variables concernent le type utilisé lors de leurs déclarations :
  
  
  • Le type de la variable ne peut être modifié une fois la variable est déclarée.
    public class MyClass { void foo() { Integer var1; // La variable var1 va toujours être de type Integer !!! } }
    
  • Si la variable est déclarée avec le mot clé final alors, une fois initialisée, sa valeur ne peut pas être modifiée (autrement dit, la variable ne peut pas référencer un autre objet).
    public class MyClass { void foo() { Integer var1 = Integer.valueOf(0); final Integer var2 = Integer.valueOf(0); var1 = Integer.valueOf(10); // OK var2 = Integer.valueOf(20); // Compiler error : The final local variable var2 cannot be assigned. It must be blank and not using a compound assignment } }
    
  • Le type de la variable décide quels objets il est possible de référencer.
    Cela inclut tous:
    - les objets du même type que celui de la variable,
    - et aussi les objets dont le type est un sous-type de celui de la variable.
    public class MyClass { void foo() { Integer var1 = Integer.valueOf(0); // OK : l'objet référencé est du même type (Integer) que celui de la variable var1 Object var2 = Integer.valueOf(0); // OK : le type de l'objet référencé (Integer) est un sous-type de celui de la variable var2 (Object) String var3 = var1; // Compiler error : Type mismatch: cannot convert from Integer to String String var4 = var2; // Compiler error : Type mismatch: cannot convert from Object to String } }
    
  • Le type de la variable détermine les méthodes de l'objet qu'il est possible d'invoquer.
    Cette contrainte a plus d'importance lorsque le type de l'objet référencé est un sous-type de celui de la variable, car, potentiellement, le type de l'objet peut définir de nouvelles méthodes qui ne sont pas définies par le type de la variable.
    public class MyClass { void foo() { Integer var1 = Integer.valueOf(0); Object var2 = Integer.valueOf(0); var1.intValue(); var2.intValue(); // Compiler error : The method intValue() is undefined for the type Object } }
    

• Règles de déclaration des interfaces :
  public abstract interface MyInterfaceType {}
  
  • La déclaration de l'interface peut utiliser uniquement les modificateurs public et abstract.
    
    
  • La déclaration de l'interface peut omettre le modificateur d'accès public (dans ce cas elle obtiendra l'accès default).
    
    
  • La déclaration de l'interface peut utiliser ou omettre le modificateur abstract ; une interface peut contenir des déclarations de méthodes ainsi que des méthodes ayant le modificateur default.
    
    
  • La déclaration de l'interface ne peut pas utiliser les modificateurs d'accès protected ou private.
    
    
  • La déclaration de l'interface ne peut pas utiliser les modificateurs static ou final.
    
    
• Règles de déclaration des variables des interfaces : public abstract interface MyInterfaceType { public final static Integer ADD_OPERATION_ID = 0; Integer MULTIPLY_OPERATION_ID = 1; }
  
  • La déclaration des variables peut utiliser uniquement les modificateurs public, final, et static.
    
    
  • La déclaration des variables peut omettre les modificateurs public, final, et static ; le compilateur les ajoutent par défaut.
    Les variables déclarées dans les interfaces sont, en fait, des constantes et ne peuvent être être modifiées dans les classes qui implémentent ces interfaces.
    
    
  • La déclaration des variables ne peut pas utiliser les modificateurs d'accès protected ou private.
    
    
• Règles de déclaration des méthodes des interfaces : public abstract interface MyInterfaceType { public abstract Integer addOperation(Integer value1, Integer value2); Integer multiplyOperation(Integer value1, Integer value2); default Integer identity(Integer i) { return i;} }
  
  • La déclaration des méthodes peut utiliser uniquement les modificateurs public et abstract.
    
    
  • La déclaration des méthodes peut omettre les modificateurs public et abstract ; le compilateur les ajoutent par défaut.
    
    
  • La déclaration des méthodes ne peut pas utiliser les modificateurs d'accès protected ou private.
    
    
  • Les méthodes des interfaces ne peuvent pas utiliser les modificateurs final (à cause du mot clé abstract), static, native, ou strictfp.
    
    
  • Les méthodes des interfaces ne peuvent pas définir du code (à cause du mot clé abstract) à moins de les marquées comme default.
    
    
• Règles pour étendre des interfaces :
  • Une interface peut étendre (extend) uniquement d'autres interfaces (elle ne peut pas étendre des classes).
    
  package com.mtitek.inheritance; interface MyInterface1 { public void doAction1(); } interface MyInterface2 { public void doAction2(); } interface MyInterface3 extends MyInterface1, MyInterface2 { public void doAction3(); }
  
• Règles pour implémenter les méthodes des interfaces :
  • Une classe peut implémenter (implements) plusieurs interfaces.
    
    
  • Une classe qui implémente une interface doit implémenter toutes les méthodes de cette interface à moins que cette classe est :
    - abstraite ;
    - ou qu'une de ses superclasse à déjà implémenter les méthodes de cette interface.
    
  package com.mtitek.inheritance; interface MyInterface1 { public void doAction1(); } interface MyInterface2 { public void doAction2(); } interface MyInterface3 { public void doAction3(); }
  /* La classe "SuperClass1" est abstraite, donc elle n'est pas obligée d'implémenter aucune des méthodes des interfaces "MyInterface1" et "MyInterface2". */ abstract class SuperClass1 implements MyInterface1, MyInterface2 { @Override public void doAction1() { } }
  /* La classe "SuperClass2" n'est pas obligée d'implémenter la méthode "doAction1" car elle est déjà implémenter par la classe "SuperClass1". */ class SuperClass2 extends SuperClass1 implements MyInterface3 { @Override public void doAction2() { } @Override public void doAction3() { } }
  /* La classe "SubClass1" n'est pas obligée d'implémenter aucunes des méthodes car elles sont déjà implémentées par ses superclasses */ class SubClass1 extends SuperClass2 implements MyInterface2 { }

• Une classe peut étendre (extend) une seule classe.
  
  
• Une classe peut implémenter (implements) plusieurs interfaces.
  
  
• Une classe peut déclarer plusieurs constructeurs (signatures différentes) qui peuvent être invoqués à l'instanciation de la classe.
  Le constructeur invoqué dépend des arguments utilisés pour l'instanciation de la classe (new).
  Le constructeur invoqué peut lui même invoquer un autre constructeur de la classe en utilisant le mot clé this.
  
  
• Le compilateur ajoute par défaut un constructeur sans paramètres, uniquement, quand aucun constructeur n'a été défini pour la classe.
  
  
• La déclaration du constructeur ne peut pas spécifier une valeur de retour et ne peut pas utiliser les modificateurs final, static, et abstract.
  

class MyClassType implements MyInterfaceType { MyClassType() { // constructor code } @Override public Integer addOperation(Integer value1, Integer value2) { return value1 + value2; } @Override public Integer multiplyOperation(Integer value1, Integer value2) { return value1 * value2; } }

• Un tableau est une structure de type Object qui peut contenir un nombre fixe d'éléments du même type (primitive ou référence).
  
  
• Tous les éléments du tableau doivent être du même type ou des sous-types du type principale défini dans la déclaration du tableau.
  
  
• Le nombre d'éléments maximal que peut contenir un tableau est déterminé à la création du tableau et ne peut être changé par la suite.
  
  
• Les éléments des tableaux sont accessibles par leurs indices dans le tableau ; le premier élément du tableau a l'indice 0, et le deuxième a l'indice 1, ainsi de suite.
  

Declare an array that can hold integers:
int myIntsArray [] = new int[10]; myIntsArray[0] = 3; System.out.println(myIntsArray.length); // 10 System.out.println(myIntsArray[0]); // 3
Declare an array that can hold objects:
Object[] myObjectsArray = new Object[5]; myObjectsArray[0] = Integer.valueOf(7); System.out.println(myObjectsArray.length); // 5 System.out.println(myObjectsArray[0]); // 7
Declare a String array and initialize it with initial values:
String[] myStringsArray = {"value1", "value2"}; // explicit syntax: String[] myStringsArray = new String[] {"value1", "value2"};
Declare an Object array and initialize it with initial values:
Object[] myComplexObjectsArray = { myStringsArray, myObjectsArray, myIntsArray }; // explicit syntax: Object[] myComplexObjectsArray = new Object[] { myStringsArray, myObjectsArray, myIntsArray };
Declare a 2 dimensional array and initialize it with initial values:
String[][] myStringsArray2D = {{"value11", "value12"}, {"value21", "value22"}, {"value31", "value32"}, {"value41", "value42"}}; // explicit syntax: String[][] myStringsArray2D = new String[][] {{"value11", "value12"}, {"value21", "value22"}, {"value31", "value32"}, {"value41", "value42"}}; System.out.println(myStringsArray2D.length); // 4 System.out.println(myStringsArray2D[0].length); // 2
Declare an empty array:
String[] emptyArray1 = new String[0]; String[] emptyArray2 = {}; String[] emptyArray3 = new String[] {}; System.out.println(emptyArray1.length); // 0 System.out.println(emptyArray2.length); // 0 System.out.println(emptyArray3.length); // 0
To iterarte over an array, use "for each" loop: for (type element : array) statement

To copy an array, use the method "copyOf" of the "Arrays" class: Arrays.copyOf(array, array.length)

To sort an array, use the method "sort" of the "Arrays" class: Arrays.sort(array)