Java non-objet

Vue d'en haut

Vue d'en bas

Unités syntaxiques

Unicode

\u0020 à \u007E         code ASCII, Latin-1
\u00AE                  ©
\u00BD                  / la barre de fraction ...
\u0000 à \u1FFF         zone alphabets
\u0370 à \u03FFF        alphabet grec
...

Espaces, casse et commentaires

    //          simple ligne
    /*  */      multilignes

    /**  */     javadoc, voir la page officielle.

Identifiants, mots réservés, valeurs littérales

    i
    theCurrentTime
    the_current_time
    θ
    $18

abstract    continue    for         new         switch
assert      default     if          package     synchronized
boolean     do          goto        private     this
break       double      implements  protected   throw
byte        else        import      public      throws
case        enum        instanceof  return      transient
catch       extends     int         short       try
char        final       interface   static      void
class       finally     long        strictfp    volatile
const       float       native      super       while

1           // int
1.0         // double
1d          // double
1.0f        // float
1f          // float
'1'         // character
"one"       // String
true        // boolean
null        

Types primitifs et types références

• Les variables de type primitif ; il y en a 8 :
  • void
  • bool
  • 5 types représentant des entiers (byte, char, short, int, long)
  • 2 types représentant des nombres réels (float, double)
  - Les types primitifs sont définis par le langage, et on ne peut pas en définir de nouveaux.
  - Les types primitifs représentent des valeurs simples.
  - Les types primitifs utilisent entre 1 et 8 octets ; lorsqu'un type primitif est stocké, dupliqué dans une autre variable ou passé en paramètre, ses octets sont recopiés.
• Les variables de type référence ; il y en a 5 : classes, interfaces, tableaux, énumérations et annotations.
  Ils diffèrent des types primitifs de plusieurs manières :
  - On peut définir de nombreux nouveaux types référence ; c'est ce qu'on fait chaque fois qu'on crée une classe.
  - Les types références sont des types composés, qui comportent chacun 0 ou plusieurs valeurs primitives ou objets.
  - Les objets (les instances de n'importe quel type référence, y compris les tableaux) peuvent occuper beaucoup plus de mémoire. Lorsqu'un objet est stocké, dupliqué dans une autre variable ou passé en paramètre, ses octets ne sont pas recopiés, seule sa référence est transmise.

Les types primitifs

boolean

if(!myVar){ ... }

if(myVar != null){ ... }

char

char c = 'r';

char aleph = '\u0500';

char apostrophe = '\'', backslash = '\\';

Les types entiers

int i = 9874;

long myLong = 123L;

int n1 = 0xff;
long n2 = 0xffL;
System.out.println("n1 = " + n1);
System.out.println("n2 = " + n2);

n1 = 255
n2 = 255

byte b1 = 127, b2 = 1; // La valeur max pour un byte est 127
byte sum = b1 + b2; // sum = -128, qui est la plus petite valeur pour un byte

Les types de nombres réels

1.2314
1.0     // attention 1 représente un entier et 1.0 un réel
1d
1D
.01
1.2345e2    // = 123.45 (notation scientifique, le e peut aussi être en majuscule)
1.2345e-2    // = 0.012345

Les chaînes de caractères (strings)

Conversion entre les types

            VERS
DEPUIS      boolean byte    short   char    int     long    float   double
boolean     -       N       N       N       N       N       N       N
byte        N       -       Y       C       Y       Y       Y       Y
short       N       C       -       C       Y       Y       Y       Y
char        N       C       C       -       Y       Y       Y       Y
int         N       C       C       C       -       Y       Y*      Y
long        N       C       C       C       C       -       Y*      Y*
float       N       C       C       C       C       C       -       Y
double      N       C       C       C       C       C       C       -

1 / 2
1.0 / 2
1 / 2.0

Expressions et opérateurs

1.3     // valeur littérale d'un float ou d'un double
false   // valeur littérale d'un booléen
somme   // une variable

somme = 1.3;

somme = 1 + 2 + 3 * 1.2 + (4 + 8)/3.0;

Prio    A   Opérateur   Types opérandes         Description
-------------------------------------------------------------------------------------
16      L   .           object, member          Object member access
            [ ]         array, int              Array element access
            ( args )    method, arglist         Method invocation
            ++, --      variable                Post-increment, post-decrement
15      R   ++, --      variable                Pre-increment, pre-decrement
            +, -        number                  Unary plus, unary minus
            ~           integer                 Bitwise complement
            !           boolean                 Boolean NOT
14      R   new         class, arglist          Object creation
            ( type )    type, any               Cast (type conversion)
13      L   *, /, %     number, number          Multiplication, division, remainder
12      L   +, -        number, number          Addition, subtraction
            +           string, any             String concatenation
11      L   <<          integer, integer        Left shift
            >>          integer, integer        Right shift with sign extension
            >>>         integer, integer        Right shift with zero extension
10      L   <, <=       number, number          Less than, less than or equal
            >, >=       number, number          Greater than, greater than or equal
            instanceof  reference, type         Type comparison
9       L   ==          primitive, primitive    Equal (have identical values)
            !=          primitive, primitive    Not equal (have different values)
            ==          reference, reference    Equal (refer to same object)
            !=          reference, reference    Not equal (refer to different objects)
8       L   &           integer, integer        Bitwise AND
            &           boolean, boolean        Boolean AND
7       L   ^           integer, integer        Bitwise XOR
            ^           boolean, boolean        Boolean XOR
6       L   |           integer, integer        Bitwise OR
            |           boolean, boolean        Boolean OR
5       L   &&          boolean, boolean        Conditional AND
4       L   ||          boolean, boolean        Conditional OR
3       R   ? :         boolean, any            Conditional (ternary) operator
2       R   =           variable, any           Assignment
            *=, /=, %=, variable, any           Assignment with operation
            +=, -=, <<=,
            >>=, >>>=,
            &=, ^=, |=
1       R   ->          arglist, method body    lambda expression

int a = 2;
a++;       // a = a + 1
a+=2;      // a = a + 2

double b = 10;
b/=3;       // b = b / 3
b = (a > 4 ? 10 : 11);      // if a > 4 then b = 10 else b = 11

// pre-increment and post-increment
int i = 1;
int j = ++i; // i = 2 et j = 2
int i = 1;
int j = i++; // i = 2 et j = 1

// modulo
int c = 14 % 12;    // c = 2
// 2h de l'après-midi est la même chose que 14h

Concaténation de chaînes

System.out.println("Quotient : " + 7/3.0f);   // Quotient : 2.3333333
System.out.println("Somme : " + 7 + 3);       // Somme : 73
System.out.println("Somme : " + (7 + 3));     // Somme : 10

Instructions (statements)

jshell> var a = System.out.println("Hello World!");
|  Error:
|  cannot infer type for local variable a
|    (variable initializer is 'void')
|  var a = System.out.println("Hello World!");
|  ^-----------------------------------------^

Les instructions expression (expression statements)

• les assignations
• les incréments et décréments
• les appels de méthode
• la création d'objets

a = 3;          // assignation
x *= 2;         // assignation avec opération
i++; ++i;       // pré et post-incrément
System.out.println("Statement"); // appel d'une méthode

while((line = in.readLine()) != null) { ... }

Les instructions composées (compound statements)

for(int i=0; i < 10; i++){
    a[i]++;     // le corps de cette boucle est une instruction composée
    b[i]++;     // constituée de 2 instructions
}

    // dans une méthode
    {
        int a = 4;
    }
    // ici, a n'est pas défini

L'instruction vide (empty statement)

for(int i=0; i < 10; i++)
    /* empty */;

Les instructions labelisées (labeled statements)

iloop: for(int i=0; i < 10; i++){
    jloop: for(int j=0; j < 10; j++){
        break iloop;
    }
}

Les instructions de déclaration de variable locale

int i;
String s;

int i = 0;
String s = "string";
int[] a = {i+1, i+2, i+3}; // on verra plus loin les tableaux

int i, j, k;
float x = 1.0, y = 3.5;

void méthode(){
    int i = 0;
    while(i < 10){
        int j = 0;
        i++;
    }
    System.out.println(i); // 10
    System.out.println(j); // erreur, car j n'est plus définie hors de son bloc de définition
}

Déclaration de variable avec var

MaClasseAvecUnNomPasPossible maClasseAvecUnNomPasPossible = new MaClasseAvecUnNomPasPossible();
String message = "Hello World";

var maClasseAvecUnNomPasPossible = new MaClasseAvecUnNomPasPossible();
var message = "Hello World";

Instructions conditionnelles

if / else

if(a == null){
    a = 10;
}
else{
    b = 10;
}

int i = 2, j = 2, k = 3;
if(i == j)
    if(i == k)
        System.out.println("i égal k");
else
    System.out.println("i différent de j"); // PAS BON

if(n == 1){
    ...
}
else if(n == 2){
    ...
}
else if(n == 3){
    ...
}
else{
    ...
}
            

if(n == 1){
    ...
}
else{
    if(n == 2){
        ...
    }
    else{
        if(n == 3){
        ...
        }
        else{
            ...
        }
    }
}
            

switch (instruction)

switch(n){
    case 1:
        ...
    break;
    // syntaxe pour faire la même chose dans plusieurs cas possibles
    case 2:
    case 3:
        ...
    break;
    default:
        ...
    break;
}

switch (expression)

        int a = 3;
        String message = "";
        switch(a){
            case 1:
            case 2:
            case 3:
            case 4: message = "a vaut " + Integer.toString(a); break;
            default: message = "a est trop grand pour moi"; break;
        }
        System.out.println("switch traditionnel (statement) : " + message);

        message = switch(a){
            case 1, 2, 3, 4 -> "a vaut " + Integer.toString(a);
            default -> "a est trop grand pour moi";
        };
        System.out.println("switch nouveau : " + message);

        System.out.println("switch nouveau (directement dans le println) : " + switch(a){
            case 1, 2, 3, 4 -> "a vaut " + Integer.toString(a);
            default -> "a est trop grand pour moi";
        });

Boucles

while

while(expression)
    statement
        

int count = 0;
while(count < 10){
    System.out.println("count = " + count);
    count++;
}
        

do

do
    statement
while (expression)
        

int count = 0;
do {
    System.out.println("count = " + count);
    count++;
} while(count < 10);
        

for

for(int i=0; i < 10; i++){
    System.out.println("i = " + i);
}

for(initialize; test; update)
    statement;
        

initialize;
while(test) {
    statement;
    update;
}
        

for(int i=0, j=10; i < 10; i++, j--){
    System.out.println("i = " + i + ", j = " + j);
}

foreach

for( declaration : expression )
    statement

int[] primes = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };
for(int n : primes)
    System.out.println(n); // et les accolades !!!

for(int i = 0; i < primes.length; i++) {
    System.out.print(primes[i]);
}

for(int i = 0; i < words.length; i++) {
    if (i > 0) System.out.print(", "); // et les accolades !!!
    System.out.print(words[i]);
}

break

for(int i = 0; i < data.length; i++) {
    if (data[i] == target) {
        index = i;
        break;
    }
} // l'interpreteur arrive ici après le break

iloop: for(int i=0; i < 10; i++){
    jloop: for(int j=0; j < 10; j++){
        break iloop;
    }
}// java arrive ici après le break

continue

for(int i = 0; i < data.length; i++) {
    if(data[i] == false){
        continue;
    }
    process(data[i]);
}

return

double square(double x) {
    return x * x;
}

void printSquareRoot(double x) {
    if (x < 0){
        return;
    }
    System.out.println(Math.sqrt(x));
}

Autres instructions