1. Premier programme
2. Types primitifs
3. Conversions de type
4. Instruction d'affectation
5. Instruction composée
6. Instruction conditionnelle
7. Calcul de la date de Pâques

import java.io.*;

class PremierProg {
    public static void main (String args[ ]){
        System.out.println ("Bonjour");
        System.out.println ("les débutants!");
    }
}

javac PremierProg.java

java PremierProg

• Le nom est une séquence de lettres ou chiffres commençant par une lettre.
  
  
• Le type décrit l'ensemble de valeurs que peut prendre la variable.
  
  
• On doit toujours déclarer une variable.
  
  
• Le type d'une variable est donné à sa déclaration.

int x1;
String phrase;
float pi;

1. Octets (8 bits) byte
2. Entiers courts (16 bits) short
3. Entiers (32 bits) int
4. Entiers longs (64 bits) long
5. Réels (32 bits) float
6. Réels longs (64 bits) double
7. Caractères (16 bits) char
8. Booléens boolean

• Une variable doit toujours être initialisée
  
  

  
  int x1 = -155;
  String phrase = "Bonjour";
  float pi = 3.14159;
  

• Une variable peut être affectée, c'est à dire que sa valeur est modifiée.
  
  
• Une variable peut être évaluée, le résultat de l'évaluation est alors la dernière valeur qui lui a été affectée.
  
  
• Une variable peut faire partie d'une expression
  
  

  
  float r = 4.5;
  float surface = 4 * pi * r * r ;
  

• Toute variable a un type qu'il faut déclarer.
  
  
• Toute variable a une valeur par défaut.
  
  
• On peut initialiser cette valeur à la déclaration.

long u, v;
int x = 1, y = 3, z = -9;
boolean a = true, b = false;
float r = 4.5;
double surface = 4 * pi * r * r ;

• Conversions implicites:
  byte ® short ® int ® long ® float ® double
  
  On a aussi:
  char ® int

short i = 23;
int j = i;
long u = j;
float v = u;

• u = e;
  
  
• u est une variable, e est une expression
  
  
• Les deux ont même type
  
  
• L'expression e est évaluée
  
  
• La valeur de u devient la valeur de l'expression e.

s = 4 * pi * r * r ;
s = s / 2;
i = i + 1;

• (t) e
• t est un type, e est une expression
• la valeur de e est convertie dans le type t
• une telle conversion peut faire perdre de la précision
• dans le cas où e est réel et t est entier, on prend la partie entière.

long i = 23;
int j = (int) i;
short u = (short) j;

float pi = 3.14159;
int x = (int) pi;

int a = 5;
float r = 2.75;
float pi = 3.14159;
float delta = pi * r * r - a * a;
System.out.println (delta);

int a = 3125 % 713;
System.out.println (a);

• Fortement typé. Toute expression a un type.
  
  
• Orienté objet.
  
  
• Tout programme contient au moins une classe, contenant une fonction main
  
  
• Pour afficher sur l'écran

  
  System.out.println ("Coucou!!");
  

• { inst₁ inst₂ ... inst_n } où inst₁, inst₂, ...inst_n sont des instructions quelconques (n ³ 0).
  
  
• if (e) instruction
• if (e) instruction₁ else instruction₂

if (x > 110) 
  x = x - 10;
else {
  x = x + 11;
  z = x * z;
}

• valeurs true ou false
  
  
• Opérations de comparaison
  x > 8
  x == 7
  x != 9
  
  
• Expressions booléennes composites
  (a > 8) && (b < 16)
  !(a == 9)
  (c != 0) && (b/c == 1)
  (b/c == 1) || (a = 8)

• = pour l'affectation, == pour la comparaison
  
  
• les expressions booléennes sont évaluées de gauche à droite

class Additionneur {
  public static void main (String[ ] args) {
    if (args.length != 2)
      System.out.println ("Mauvais nombre d'arguments.");
    else {
      int n1 = Integer.parseInt (args[0]);
      int n2 = Integer.parseInt (args[1]);
      System.out.println (n1 + n2);
    }
  }
}

• Jusqu'à présent, on n'a vu que des programmes sans boucles (straight line programs)
  
  Théorème 1 Les programmes sans boucles terminent toujours.
  
  
• Si on a des instructions d'itérations (cf prochain cours), il faut plus réfléchir. Par exemple, un programme itératif simple peut calculer la suite:
  
  

  un+1 =

  ì í î

  3 un + 1    si   un  impair un / 2    si   un  pair

  
  à partir d'un u₀ quelconque, et personne ne sait si on termine toujours par 1.

• 4, 2, 1
• 5, 16, 8, 4, 2, 1
• 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1

class Syracuse {
  public static void main (String[ ] args) {
    int a = Integer.parseInt (args[0]);
    System.out.println (a);
    while (a != 1) {
      if (a % 2 == 0)
        a = a / 2;
      else
        a = 3 * a + 1;
      System.out.println (a);
    }
  }
}

This document was translated from L^AT_EX by H^EV^EA.