JAVA

1) Les différents types de données en JAVA :

Les types primitifs

byte 1 octet short 2 octets int 4 octets long 8 octets

float 4 octets double 8 octets char unicode 2 octets boolean 1 octet

Les types enveloppes :

Un type enveloppe est un type objet qui encapsule un type primitif. Grâce aux classes enveloppes (wrappers)
vous pourrez manipuler les types primitifs à l'aide de méthodes inclues spécialement pour ces types
enveloppes.
Byte Short Integer Long

Float Double Character Boolean

Les types objets :

Il existe un type objet "transparent" : le type String. Ce type de données pourra contenir une chaîne de
caractères. Comme il s'agit d'un type objet, le type String dispose de méthodes propres, comme par exemple
la méthode equals() qui permet de savoir si une chaîne contient la valeur désirée.

2) Les différentes méthodes de déclaration de tableau en JAVA :

La déclaration :
int tableau[] = new int[50]; // declaration et allocation
int[] tableau = new int[50];

int tab[]; // declaration

tab = new int[50]; //allocation

float tableau[][] = new float[10][10];

L’initialisation explicite :
int tableau[5] = {10,20,30,40,50};
int tableau[3][2] = {{5,1},{6,2},{7,3}};
int tableau[] = {1,6,0,4,100};

3) La conversion entre les types de données en JAVA :

int x = 292;

float f = (float) x; // int --> float

byte b = (byte) x; // int --> byte
char c = (char) b; // byte --> char

4) Les droits d’accès (Visibilité) :

Les droits d'accès à un attribut peuvent être de trois types :

❖ private : seules les méthodes de la classe dans laquelle est définit l'attribut peuvent y accéder et le modifier
❖ protected : seules les méthodes de la classe et des éventuelles classes héritées peuvent accéder à l'attribut
et le modifier
❖ public : tout le monde peut accéder à l'attribut en question.
 5) Les attributs statiques (static) et constantes (final) :

Static :
Le mot clé static s'applique aux variables et aux méthodes.

Les variables d'instance sont des variables propres à un objet. Il est possible de définir une variable de classe
qui est partagée entre toutes les instances d'une même classe : elle n'existe donc qu'une seule fois en
mémoire. public static float pi = 3.1416f;

Final :
Le mot clé final s'applique aux variables de classe, méthodes ou variable. Il permet de rendre l'entité sur
laquelle il s'applique non modifiable une fois qu'elle est déclarée pour une méthode ou une classe et initialisée
pour une variable.

Une variable qualifiée de final signifie que la valeur de la variable ne peut plus être modifiée une fois que
celle-ci est initialisée. public final int constante;

6) Définition d’accesseur (getter) et de mutateur (setter) :

Un accesseur est une méthode publique qui permet de récupérer la valeur d’un attribut privée.
Un mutateur est une méthode void qui permet de modifier la valeur d’attribut privée.

7) Définition de constructeur et de destructeur :

Un constructeur donne des valeurs de départ aux attributs de la classe. Il n’est invoqué que lors de la création
d'un objet. public MaClasse() {}

Un destructeur est une méthode spéciale qui sera appelée (si elle est redéfinie dans la classe) lorsque l'objet
sera nettoyé de la mémoire. Pour utiliser le destructeur il est nécessaire de redéfinir une méthode appelée
finalize(). public void finalize(){ }

8) Les différentes boucles de contrôle en JAVA : 9) Les différentes structures conditionnelles en JAVA:

La boucle while : La structure if… else :

while (a < b) //Condition
{ if(//condition) {}
//Instructions a repeter else {}
}
La structure switch :
La boucle do… while :
do{ switch (/*Variable*/)
//Instructions a repeter {
}while(a < b); //Condition case /*Argument*/:
/*Action*/;
break;
La boucle For : default:
for(int i = 1; i <= 10; i++) /*Action*/;
{ }
//Instructions a repeter
}

10) Définition de l’héritage et le polymorphisme :

L'héritage est un mécanisme qui facilite la réutilisation du code et la gestion de son évolution. Elle définit une
relation entre deux classes : une classe mère et une classe fille. class Fille extends Mere { ... }
 Le polymorphisme est la capacité, pour un même message de correspondre à plusieurs formes de traitements
selon l'objet auquel ce message est adressé. La gestion du polymorphisme est assurée par la machine virtuelle
dynamiquement à l'exécution.

Remarque : On parle de polymorphisme d’héritage chaque fois qu’une ou plusieurs classes filles possèdent des
méthodes avec des noms identiques et des traitements différents.

11) Définition de polymorphisme de méthode (Surcharge) :

La surcharge consiste à définir plusieurs méthodes qui portent le même nom avec des paramètres de type
différent. public int min(int X,int Y){ }

public float min(float X,float Y){ }

12) Méthodes associées à la classe String :

String Text_1 = new String("Bonjour !!!") ;

String Text_2 = new String("... Au REVOIR !") ;

String T_1 = Text_1.toUpperCase(); System.out.println(T_1); //Change les lettres en majuscules

String T_2 = Text_2.toLowerCase(); System.out.println(T_2); //Change les lettres en minuscules

String T_3 = Text_1.concat(Text_2); System.out.println(T_3); //Concatene les 2 chaines de carac

int L = Text_1.length(); System.out.println(L); //Renvoie le nombre de caracters dans la chaine de carac

char C = Text_1.charAt(5); System.out.println(C);//Renvoie le caracter en position index

if (Text_1.equals(Text_1)) // Compare les 2 chaines de carac

System.out.println("C la meme phrase ! ");
else
System.out.println("Ce n'est pas la meme phrase ! ");

13) L’utilisation de la classe Scanner et la lecture des entrées clavier :

Scanner sc = new Scanner(System.in);

int i = sc.nextInt(); // Type int

double d = sc.nextDouble(); // Type double
long l = sc.nextLong(); // Type long
byte b = sc.nextByte(); // Type byte
String str = sc.nextLine(); // Type char se fait
char carac = str.charAt(0); // en deux instructions

14) La déclaration de la méthode main :

public static void main(String[] args) { }
 15) Exemple de classe :

public class book_tp{

private String titre, auteur;

private int Nbpages;
public book_tp(String unauteur , String untitre ) {
auteur = unauteur;
titre = untitre;
}
public String getauteur() {
return auteur;
}
public String gettitre() {
return titre;
}
public int getNbpages() {
return Nbpages;
}
public void setauteur(String unauteur) {
auteur = unauteur;
}
public void settitre(String untitre) {
titre = untitre;
}
public void setNbpages(int n) {
if (n>0) {
Nbpages = n;
}
else
{
System.err.println("erreur : nbr de pages negative");
}
}
public String toString(){
return "book [titre="+titre+" , Nbpages="+Nbpages+" , auteur="+auteur+"]";
}
public void afficheToi(){
System.out.print(toString());
}
}

public static void main (String[] args) {

book_tp i1 = new book_tp ("charle kitel" , "physique 1");

i1.setNbpages(150);

System.out.println("livre de " + i1.getauteur());

System.out.println("livre de " + i1.getNbpages() + "pages.");
}