*caractéristiques :

orienté objet, indépendant de la plate-forme, simple, sécurisé, portable, robuste,

multithread, haute performance

*Modificateurs d'accès :
- Modificateurs d'accès - default, public, protected, private
- Modificateurs de non-accès - final, abstract, static, synchronized

*Variables :
- Variables locales
- Variables de classe (variables statiques)
- Variables d'instance (variables non statiques)

Les énumérations limitent une variable à l'une des quelques valeurs prédéfinies

*OOP
- Polymorphism
- Inheritance
- Encapsulation
- Abstraction
- Classes
- Objects
- Instance
- Method
- Message Passing

The object of the wrapper class contains or wraps its respective primitive data
type

*Integer x = 5; // boxes int to an Integer object : boxing

x = x + 10; // unboxes the Integer to a int : unboxing

int -> Integer, short -> Short, long -> Long....

xxxValue(), compareTo(), equals(), valueOf(), toString(), parseXxx(), asb(),
ceil(), floor(), min(), max(), pow(), sqrt()

*char -> object : Character : isLetter(), isDigit(), isWhitespace(), isUpperCase(),

isLowerCase(), toUpperCase(), toLowerCase(), toString()

* La classe String est immuable, de sorte qu'une fois créée, un objet String ne
peut pas être modifié.
S'il est nécessaire d'apporter de nombreuses modifications aux chaînes de
caractères,
vous devez utiliser les classes String Buffer et String Builder
The StringBuffer et StringBuilder si on a besoin de faire plusieurs modification
StringBuffer vs StringBuilder :
- StringBuilders ne sont pas thread-safe (non synchronisées)
- Il est recommandé d'utiliser StringBuilder autant que possible car il est plus
rapide que StringBuffer.
Cependant, si la sécurité des threads est nécessaire, la meilleure option est les
objets StringBuffer
public StringBuffer append(String s), public StringBuffer reverse(), public
delete(int start, int end), public insert(int offset, int i), replace(int start,
int end, String str)

*Date( ), Date(long millisec)

Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
System.out.println("Current Date: " + ft.format(dNow));
*expression regulière : java.util.regex
Pattern Class : Un objet Pattern est une représentation compilée d'une expression
régulière.
Matcher Class : Un objet Matcher est le moteur qui interprète le modèle et effectue
des opérations de correspondance sur une chaîne d'entrée.
Comme la classe Pattern, Matcher ne définit aucun constructeur
public. Vous obtenez un objet Matcher en appelant la méthode matcher() sur un objet
Pattern.
PatternSyntaxException :
String line = "This order was placed for QT3000! OK?";
String pattern = "(.*)(\\d+)(.*)";
// Create a Pattern object
Pattern r = Pattern.compile(pattern);
// Now create matcher object.
Matcher m = r.matcher(line);
if(m.find()) .. else ..

this -> fait reference au variable d'instance, methodes d'instance, constrtuteur

type ...nom_du_parametre
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
public static void printMax( double... numbers) {}

protected void finalize( ) {

// finalization code here
}
Il est possible de définir une méthode qui sera appelée juste avant la destruction
finale d'un objet par le garbadge collector.
Par exemple, vous pouvez utiliser finalize( ) pour vous assurer qu'un fichier
ouvert appartenant à cet objet est fermé.

*Le package java.io contient presque toutes les classes dont vous pourriez avoir
besoin pour effectuer des entrées et des sorties (E/S) en Java
Un flux peut être défini comme une séquence de données. Il existe deux types de
flux -
InPutStream - Le InputStream est utilisé pour lire des données à partir d'une
source.
OutPutStream - Le OutputStream est utilisé pour écrire des données vers une
destination.

Flux d'octets (byte stream)

Les flux d'octets Java sont utilisés pour effectuer l'entrée et la sortie d'octets
8 bits.

FileInputStream in = null;
FileOutputStream out = null;

try {
in = new FileInputStream("input.txt");
out = new FileOutputStream("output.txt");

int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
 in.close();
}
if (out != null) {
out.close();
}
}

Flux de charactere (character stream)

les flux Java Character sont utilisés pour effectuer l'entrée et la sortie pour
l'unicode 16 bits.

FileReader in = null;
FileWriter out = null;

try {
in = new FileReader("input.txt");
out = new FileWriter("output.txt");

int c;
while ((c = in.read()) != -1) {
out.write(c);
}
}finally {
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}

Flux standards (streams standars)

prennent en charge les E/S standard où le programme de l'utilisateur peut prendre
une entrée à partir d'un clavier, puis produire une sortie sur l'écran de
l'ordinateur.
STDIN : Standard Input : System.in
STDOUT : Standard Output : System.out
STDERR : Standard Error

InputStreamReader cin = null;

try {
cin = new InputStreamReader(System.in);
System.out.println("Enter characters, 'q' to quit.");
char c;
do {
c = (char) cin.read();
System.out.print(c);
} while(c != 'q');
}finally {
if (cin != null) {
cin.close();
}

try {
byte bWrite [] = {11,21,3,40,5};
OutputStream os = new FileOutputStream("test.txt");
for(int x = 0; x < bWrite.length ; x++) {
os.write( bWrite[x] ); // writes the bytes
 }
os.close();

InputStream is = new FileInputStream("test.txt");

int size = is.available();

for(int i = 0; i < size; i++) {

System.out.print((char)is.read() + " ");
}
is.close();
} catch (IOException e) {
System.err.print("Exception");
}

*La classe Java File représente les fichiers et les noms de chemin de répertoire de
manière abstraite
Cette classe est utilisée pour la création de fichiers et de répertoires, la
recherche de fichiers, la suppression de fichiers, etc..

*Une exception est un problème qui survient lors de l'exécution d'un programme. le
déroulement normal
du programme est interrompu et le programme/l'application se termine anormalement
par une erreur de l'utilisateur, d'autres par une erreur du programmeur et
d'autres par des ressources physiques qui ont échoué d'une manière ou d'une autre.

Exceptions vérifiées : Une exception vérifiée est une exception qui est vérifiée
(notifiée) par le compilateur au moment de la compilation,
elles sont également appelées exceptions au moment de la compilation. Ces
exceptions ne peuvent pas simplement être ignorées,
le programmeur doit prendre soin de (gérer) ces exceptions. (exemple :
FileNotFoundException)

Exceptions non contrôlées : Une exception non contrôlée est une exception qui se
produit au moment de l'exécution. Celles-ci sont également appelées exceptions
d'exécution .
Ceux-ci incluent des bogues de programmation, tels que des erreurs de logique ou
une mauvaise utilisation d'une API.
Les exceptions d'exécution sont ignorées au moment de la compilation. (exemple :
ArrayIndexOutOfBoundsException)

Erreurs - Ce ne sont pas du tout des exceptions, mais des problèmes qui surgissent
au-delà du contrôle de l'utilisateur ou du programmeur.
Les erreurs sont généralement ignorées dans votre code car vous pouvez rarement
faire quoi que ce soit à propos d'une erreur.
Par exemple, si un débordement de pile se produit, une erreur se produira. Ils sont
également ignorés au moment de la compilation.

gestion automatique des ressources

try(FileReader fr = new FileReader("file path")) {
// use the resource
} catch () {
// body of catch
}
}

Exceptions définies par l'utilisateur

Si vous souhaitez écrire une exception d'exécution, vous devez étendre la classe
RuntimeException.
class MyException extends Exception {
}

Exceptions JVM - Ce sont des exceptions/erreurs qui sont exclusivement ou

logiquement levées par la JVM.
Exemples : NullPointerException, ArrayIndexOutOfBoundsException,
ClassCastException.

Exceptions programmatiques - Ces exceptions sont lancées explicitement par

l'application ou les programmeurs de l'API.
Exemples : IllegalArgumentException, IllegalStateException.

*Classes imbriquées (nested class)

Classes imbriquées non statiques (inner classes) - Ce sont les membres non
statiques d'une classe :
- inner classes (classe intérieru), Method-local Inner Class (Classe interne
locale à la méthode), Anonymous Inner Class (Classe intérieure anonyme)
Classes imbriquées statiques (static nested classes) - Ce sont les membres
statiques d'une classe.

*Super
Il est utilisé pour différencier les membres de la superclasse des membres de la
sous-classe, s'ils ont les mêmes noms.
Il est utilisé pour invoquer le constructeur de la superclasse à partir de la sous-
classe.

*inheritance (heritage)
single inheritance
multi level inheritance
hierarchical inheritance
multiple inheritance
is-a
has-a ( permet d'eviter la reecriture du code : un objet est une variable dinstance
d'une autre class)

Une interface sans méthode est appelée interface de balisage . Il existe deux
objectifs de conception de base pour le balisage des interfaces :

*Crée un parent commun - Comme avec l'interface EventListener, qui est étendue par
des dizaines d'autres interfaces dans l'API Java,
vous pouvez utiliser une interface de balisage pour créer un parent commun parmi un
groupe d'interfaces. Par exemple,
lorsqu'une interface étend EventListener, la JVM sait que cette interface
particulière va être utilisée dans un scénario de délégation d'événement.
*Ajoute un type de données à une classe - Cette situation est d'où vient le terme,
tagging. Une classe qui implémente une interface de marquage n'a pas
besoin de définir de méthodes (puisque l'interface n'en a pas), mais la classe
devient un type d'interface par polymorphisme.

*Les packages sont utilisés en Java afin d'éviter les conflits de noms, de
contrôler l'accès,
de faciliter la recherche/localisation et l'utilisation des classes, des
interfaces, des énumérations et des annotations, etc.

Un package peut être défini comme un regroupement de types connexes (classes,

interfaces, énumérations et annotations) fournissant une protection
d'accès et une gestion des espaces de noms.

- La structure de données en Java est définie comme la collection d'éléments de

données
 qui offre un moyen efficace de stocker et d'organiser les données dans un
ordinateur

classification 1 )
- Il existe deux types de structures de données :
*Structures de données primitives ou types de données primitifs : byte,
short, int, float, char, boolean, long et double
*Structures de données non primitives : deux types :
- Structures de données linéaires : chaque élément est connecté à un
seul autre élément :
- arrays ( single dimentional array, multidimentional array),
stack, queue, linked List (singly linked list, doubly linked list, circular linked
list)
- Structures de données non linéaires : chaque élément est connecté à
n-autres éléments
- Trees ( binary tree, binary search tri, AVL tri, red-black tree
), graph, heap (maxheap, minheap), hash (hashSet, hashMap)reuiti

- avanatges : efficacité, abstraction, reutilisabilité, vitesse de traitement,

recherche de données

classification 2 )
- Il existe deux types de structures de données :
*Les structures de données statiques sont les structures de données dont la
taille est déclarée et fixée au moment
de la compilation et ne peuvent pas être modifiées ultérieurement (example:
arrays)
*Les structures de données dynamiques sont les structures de données dont la
taille n'est pas fixée au moment de la
compilation et peut être décidée au moment de l'exécution en fonction des
besoins sont appelées structures de données dynamiques.