De JavaScipt à Java

JavaScript ≠ Java

Principales différences:


 JavaScript Java
environnement d'exécution usuel
 Exécuté par un navigateur Web,
inséré dans une page .html
 Programmes "stand-alone"  exécutés  par  la machine virtuelle Java (JVM).
(interpréteur de bytecode)
compilation?
 Pas d'étape de compilation
 Nécessite compilation explicite en bytecode:
javac MonPrg.java
produit le bytecode: MonPrg.class
types peu de types de base
1 type numérique:  Number
 nombreux types de base
types numériques: int, long, short, byte, double, float
typage dynamique
une variable peut tour à tour contenir un nombre, un booléen, une chaîne de caractères, un tableau

Ex: var a = 1;

statique

  • le type d'une variable est spécifié lors de sa déclaration et ne peut pas changer.
  • obligation de déclarer les types des variables et des paramètres.


Ex: int a = 1;
paradigme de
programmation
 Multiple: impératif, fonctionnel, orienté-objet

Objets très différents de Java (à base de prototypes, plutôt que de classes)

Orienté Objet
  • Obligation de déclarer des classes
  • Pas de fonctions toutes seules
  • Une variable ne peut pas contenir une fonction.
Verbosité
 Peu verbeux
 Très verbeux
Tolérance
 Tolérant aux déviations de syntaxe
 strict sur la syntaxe
Rapidité d'exécution
des programmes
 Plutôt lents
 Plutôt rapides

Remarque sur l'existence d'environnement d'exécution moins usuels:

Similarité de syntaxe (superficielle)

Premier programme: afficher "Hello World!"



 JavaScript
 Java
Fichiers source
nécessaires
 Fichier hello.js contenant:
alert("Hello World!")

Fichier: hello.html contenant:

<html>

<head>
<title>Exemple JavaScript</title>
<script type="text/javascript" src="hello.js">
</script>
</head>
<body>
</body>

</html>

 Fichier: Hello.java contenant:

public class Hello
{
    public static void main(String[] args)
    {
        System.out.println("Hello World!");
    }
}
Étape de compilation
 Pas de compilation
 Dans un shell, allez à l'endroit où se trouve votre fichier source, et tapez
javac Hello.java

  • Ceci va compiler (traduire) le code source Java en bytecode  Java.
  • Si il n'y a pas d'erreurs de syntaxe, la traduction en bytecode est écrite dans le fichier Hello.class
  • Si il y a des erreurs de syntaxe, le compilateur vous les signale, et n'écrit pas dans le fichier Hello.class
Exécution
 Ouvrir hello.html dans un navigateur Web (ex: en double-cliquant dessus dans le gestionnaire de fichier).
Cela va afficher une boîte de message indiquant Hello world!

Ces fichiers peuvent aussi être hébergés sur un serveur Web distant. Se rendre à l'URL (adresse Web) pointant sur le fichier hello.html avec un navigateur va (télé)charger le programme dans le navigateur et l'exécuter.
 Dans le shell, taper
java Hello

Notez que pour cette commande il ne faut pas écrire d'extension (ni .java ni .class). Ceci va exécuter le bytecode  qui se trouve dans Hello.class et résulter en l'affichage:

Hello World!

Types de données (data types) et opérations de base

Les langages de programmation servent à effectuer des opérations sur des données. Tout ce qui est manipulé par un ordinateur (nombres, textes, images, sons, programmes) n'est, au plus bas niveau, qu'une squence de bits (valant 1 ou 0, on ou off). La manière spécifique d'interpréter un groupe de bits (représente-t-il un nombre, un texte ou une image) correspond à la notion de type et établit aussi quelles opérations sont possibles.

On distingue les types élémentaires des types composés ou complexes.

Types de base (élémentaires, primitifs)



 JavaScript
 Java

Type
 Description
 Ex de valeur littérale
Type
 Description
 Ex de valeur littérale
Nombres number
  • un seul type numérique pour entiers et réels
  • stocké comme nombre à virgule flottante double présicion 64bits.
  • correpsond au double de Java
  • 3248
  • -727
  • 0.0003
  • 12.5
  • 13.5e3
  • 1.35E-13
  • 0x3FB2 (hexadecimal)
 Nombres
entiers

(signés, représentation en complément à 2)
 byte
 entier signé 8 bits
(de -128 à 127)
  • -13
  • 10
  • 010 (octal attention, ça vaut 8 en décimal!)
  • 0x10 (hexadécimal ça vaut 16 en décimal!)
  • 0xFE
short
 entier signé 16 bits
(de --32768 à 32767)
  • 200
  • 0x0FE3
int
(le plus utilisé)
 entier signé 32 bits
(de -2147483648 à 2147483647)
  • -32500
  • 0xABCDEF12
long
 entier signé 64 bits
  • 32L
  • -3768L
  • 0xABCDEF12ABCDEF12L
Nombres
à virgule

(représentation virgule flottante standard IEEE 754)
 float
 nombre à virgule flottante 32 bits
  • 13.3f
  • 9.35e-6f
  • -7E-3f
  • 3.0f
  • 3f
  • 0.5f
  • .5f
double
(le plus utilisé)
 nombre à virgule flottante 64 bits
  • 13.3
  • 9.35e-6
  • -7E-3
  • 3.0
  • 3d
  • 0.5
  • .5
Booléen
 boolean
 Booléen, ne peut prendre que la valeur vrai (true) ou faux (false).
  • true
  • false
boolean Booléen, ne peut prendre que la valeur vrai (true) ou faux (false).
  • true
  • false
Caractère pas de type caractère en JavaScript
 on manipule toujours des chaînes de caractères ( string ).
Voir plus bas.

char 16 bits. Unité d'encodage UTF16.

À mettre entre apostrophes (single quote)

  • 'A'
  • '3'
  • 'é'  (attention à l'encodage du fichier...)
  • '\n' (retour à la ligne)
  • '\r' (retour charriot)
  • '\t' (tab)
  • '\\'  ( backslash )
  • '\"'  (double quote, guillemet)
  • '\''  (single quote, apostrophe)
  • '\u0001'  (caractère unicode hexadecimal)

Le type chaîne de caractère (String) n'est pas un type primitif en Java, il sera discutté plus bas.

Opérateurs de base

Opérateurs arithmétiques: +, -, *, /, %

Opérateurs bit-à-bit: ~, &, |, ^, >>, <<, >>>

Opérateurs de comparaison: ==, !=, <, >, <=, >=

Opérateurs logiques: &&, ||, !

Déclaration de variable

Remarque, dans les notations de syntaxe:


 JavaScript
 Java
Syntaxe

 var <nom_de_variable> = <valeur>;

ou bien

var <nom1> = <valeur1>, <nom2> = <valeur2>, ... ;

À l'intérieur d'une fonction, le mot-clé var déclare une variable locale à a fonction.
<type> <nom_de_variable> = <valeur>;

ou bien

<type> <nom_de_variable>;
(déclaration sans valeur initiale, recevront la valeur par défaut).

ou bien

<type> <nom1> = <valeur1>, <nom2> = <valeur2>, ... ;
Toutes les variables d'une même instruction de déclaraiton multiple auront le même type.
Exemples
 
var a = 36;
var pi = 3.14159, allume=true;
var s="allo";
 
int a = 36;
double pi = 3.14159;
boolean allume = true;
char c = 'a';
String s = "allo";
long n1=32L, n2=-25L, n3=128;

Expressions

Dans les 2 langages, les expressions sont composées en combinant
Ex: "Voici"+(3+2*(rayon-1)*Math.pow(Math.sin(angle*Math.PI), 2*p))

Opérateurs d'affectation

Syntaxe:

<lvalue> = <rvalue>;


Ex:
message = "Voici"+(3+2*(rayon-1)*Math.pow(Math.sin(angle*Math.PI), 2*p));

Attention:

Opérateurs arithmétique et affectation combinée

Plusieurs opérateurs op, ont un opérateur d'affectation combiné op=.

Écrire 
<lvalue> op= <rvalue>;                    est un raccourci pour écrire
<lvalue> = <lvalue> op <rvalue>;

Exemples

Instructions équivalentes (toutes les colonnes d'une ligne)
Opérateur d'affectaiton =
 Opérateur arithmétiqe et affectation combinés: +=, -=, *=, /=, %=
Opérateur de post-incrément ++ et post-décrément --
 Opérateur de pré-incrément ++ et pré-décrément --
a = a+1;
 a += 1;
 a++;
 ++a;
a = a-1;
 a -= 1;
 a--;
 --a;
a = a+3;
 a += 3;


a = a-(2*b+7);
 a -= 2*b+7;


a = a*4;
 a *= 4;


a = a/4;
 a /= 4;



Il y a aussi %=, &=, ^=, |=, <<=, >>=, >>>=


Type chaîne de caractère (String en Java, string en JavaScript)

Voir la page

Type tableau

Tableau Java à une dimension

Syntaxe
 Exemple
déclaration
 <type>[] <nom>; 
int[]  t;
Déclare t (au départ vaut null).

Le type de t est int[] c.a.d. "tableau à une dimension d'int". Il ne pourra plus changer.
création
 new <type>[<nbélem>]

  • réserve un espace contigu en mémoire pour stocker nbélem éléments du type spécifié.
  • Retourne une référence à cet espace.
 

t = new int[10];
  • t doit avoir préalablement été déclaré.
  • on peut utiliser une expression plus complexe pour le nombre d'éléments entre crochets.
déclaration et création simultanés
 <type>[] <nom> = new <type>[<nbélem>]; 

char[] tab = new char[100];
 Réserve de la place pour 100 char. Cet espace ne pourra pas être modifiée (ni agrandi, ni raccourci).
taille réservée pour un tableau
 <nom>.length
 
System.out.println(tab.length);
 affichera 100. Attention, pas .length()
accès à un élément en lecture/écriture
 <nom>[position]

Les positions ou indices vont de 0 à taille-1.
 
tab[0] = 'A';
t[3] = 27;
int i=4;
t[i] = t[i-1]+27;
  • tab est de type char[]
  • tab[3] es tde type char
Libération (éventuelle) de l'espace mémoire occupé par un tableau
 <nom_de_tableau> = null;
 
tab = null;
Déclaration et initialisation en ligne
 <type>[] <nom> = {<elem0>, <elem1>, <elem2>, ...};

OU

<type>[] <nom> = new <type>[] {<elem0>, <elem1>, <elem2>, ...};
 int[] tt = {10,20,30};

OU

int[] tt = new int[]{10,20,30};

Tableau Java à 2 dimensions:


Ex: 
// Déclare un tableau 2D de double de 3 "lignes" par 5 "colonnes"

double[][] t = new double[3][5];

// Met à 10, l'élément de la première ligne, dernière colonne
t[0][4] = 10;

// Affiche nombre de lignes, et de colonnes
System.out.println(t.length + " lignes");
System.out.println(t[0].length + " colonnes");

// t[0] est la première ligne de t, c'est un tableau 1D
double[] ligne;
ligne = t[0];   // ligne pointe sur les mêmes éléments que t[0] 
t[0][3] = 33;
System.out.println(ligne[3]); // affichera 33.0


Entrées-sorties


Les  sorties (affichages) Java se font le plus simplement vers la console/terminal/shell (sortie standard), avec les instrucitons suivantes:
Ex:
    int a = 5;
    Systam.out.print("Bonjour ");
    System.out.print("2*"+a+"=");
    System.out.println(2*a);
Affichera:
Bonjour 2*5=10

Les entrées (au clavier) en Java (touches du clavier depuis la fenêtre de terminal actif).
Deux manières de base:

Arguments passés sur la ligne de commande lors du lancement du programme:

Lecture depuis l'entrée standard (stdin, en Java: System.in):

Voir la page "Entrée d'information par l'utilisateur" pour plus de détails et exemples.

Structures de contrôle

Les if / else; while; do ... while; for; switch
sont essentiellement les mêmes dans les deux langages.

Ex: if/else et switch équivalents:

if / else if / else
 switch 
int num = scan.nextInt();
String texte = "";

if (num==10)
{
    texte = "dix";
}
else if (num==100)
{
    texte = "cent";
}
else if (num==1000)
{
    texte = "mille";
}
else
{
    texte = "ni dix, ni cent, ni mille";   
}




 
int num = scan.nextInt();
String texte = "";

switch(num)
{
case 10:
    texte = "dix";
    break;
case 100:
    texte = "cent";
    break;
case 1000:
    texte = "mille";
    break;
default:
    texte = "ni dix, ni cent, ni mille";   
}

Remarque: Java <= 6 ne supporte pas des String dans les switch/case, il faut donc utiliser les if/else/if/else pour les String (en utilisant pour comparer des String, la méthode .equals, ou .equalsIgnoreCase, pas des ==). Java >= 7 supporte les String dans les switch/case.

Java et JavaScript ont aussi les for à 3 sections hérités du C:
Boucle for
 Boucle while équivalente
for(<initialisation de variables>; <condition de continuation>; <modification de variables>)
{
<corps de la boucle>;
}		 <initialisation de variables>;
while(<condition de continuation>)
{
<corps de la boucle>;
<modification de variables>;
}
// pour résumer

for(<A>; <B>; <C>)
{
<D>;
}
// équivaut à

<A>;
while(<B>)
{
<D>;
<C>;
}

Remarques importantes:
Java et JavaScript ont aussi des boucles de style "foreach" qui permettent plus facilement de boucler sur les éléments d'un tableau ou d'une liste, avec une syntaxe de for un peu différente.


JavaScript (boucle de style foreach)
 Java (boucle de style foreach) Java (équivalent for classique)
 
var tab = ["un","deux","trois"];
var txt = "";

for (x in tab)
{
   txt = txt+x+" ";
}
 
String[] tab = {"un","deux","trois"};
String txt = "";

for (String x : tab)
{
   txt = txt+x+" ";
}
 
String[] tab = {"un","deux","trois"};
String txt = "";

for (int i=0; i<tab.length; i++)
{
   txt = txt+tab[i]+" ";
}

 

Définition de fonctions simples (static)


Exemple:
JavaScript
 Java (méthode static d'une classe)
 

function divisible(a,b)
{
    return (a%b == 0);
}

// ... autres fonctions

Autre syntaxe possible:

var divisible = function(a,b)
{
    return (a%b == 0);
}
 
public class MaClasse
{

    public static boolean divisible(int a, int b)
    {
        return (a%b == 0);
    }

    // ... autres fonctions ...
}
  • Les fonctions sont toujours déclarées et définies dans une classe
  • La ligne de déclaration (public static ... ) est appelée la signature de la fonciton.
  • a et b sont appelés paramètres formels
  • On doit déclarer le type de chaque paramètre (ici des int)
  • On doit déclarer le type de la valeur qui sera retournée (ici boolean)
  • Si la fonction ne retourne pas de valeur, il faut indiquer void là où dans l'exemple on a mis boolean.
Syntaxe (plus formel) fonction ne retournant rien:

public static void <nom> ( <type param1> <nom param 1>, <type param2> <nom param 2>, ... )
{
  // corps de la fonction
  // ...
}

Fonction retournant une valeur:

public static <type de retour> <nom> ( <type param1> <nom param 1>, <type param2> <nom param 2>, ... )
{
  // corps de la fonction
  // ...
  return <expression donnant la valeur de retour>;
}

Les paramètre formels déclarés dans la signature d'une fonction (a et b dans l'exemple), sont similaires à des variables locales déclarées dans le corps de la fonction. Ils n'existent que pendant l'appel à la fonction, et ne sont accessibles que depuis le corps de la fonction.

Appel de fonctions simples (static)

Lors d'un appel à une fonction:
Remarques importantes sur le passage de paramètres:

Visibilité/accessibilité des fonctions et propriétés d'une classe oud'un objet:

L'accessibilité d'une fonction/méthode/propriété (à savoir si on peut l'appeler/y accéder) depuis d'autres classes varie selon que l'on spécifie:

Méthodes static v.s. non static

Il y a deux sortes de fonctions (plus communément appelées méthodes en Java)