📘 Cours Java complet
1. Introduction à Java
Java est :
Un langage orienté objet
Très utilisé en :
o Applications Android 📱
o Logiciels
o Backend web
👉 Avantage :
Portable → “Write once, run anywhere”
2. Premier programme
public class Main {
public static void main(String[] args) {
[Link]("Hello World");
}
}
3. Variables
int age = 17;
double prix = 9.99;
String nom = "Hama";
boolean actif = true;
4. Les types
int → entier
double → décimal
String → texte
boolean → vrai/faux
5. Conditions
if (age >= 18) {
[Link]("Majeur");
} else {
[Link]("Mineur");
}
6. Boucles
FOR :
for (int i = 0; i < 5; i++) {
[Link](i);
}
WHILE :
int i = 0;
while (i < 5) {
[Link](i);
i++;
}
7. Tableaux
int[] nums = {1, 2, 3};
[Link](nums[0]);
8. Les méthodes
static void bonjour() {
[Link]("Hello");
}
9. Classes et objets
class Personne {
String nom;
void parler() {
[Link]("Je suis " + nom);
}
}
Utilisation :
Personne p = new Personne();
[Link] = "Hama";
[Link]();
10. Constructeur
class Personne {
String nom;
Personne(String n) {
nom = n;
}
}
🔥 Niveau intermédiaire
11. Encapsulation
class User {
private String nom;
public String getNom() {
return nom;
}
public void setNom(String n) {
nom = n;
}
}
12. Héritage
class Animal {
void parler() {
[Link]("Son");
}
}
class Chien extends Animal {
}
13. Polymorphisme
Animal a = new Chien();
[Link]();
14. Interfaces
interface Animal {
void parler();
}
15. Abstract
abstract class Animal {
abstract void parler();
}
16. Exceptions
try {
int x = 5 / 0;
} catch (Exception e) {
[Link]("Erreur");
}
17. ArrayList
import [Link];
ArrayList<String> list = new ArrayList<>();
[Link]("Hello");
18. HashMap
import [Link];
HashMap<String, Integer> map = new HashMap<>();
[Link]("age", 17);
19. Scanner (entrée utilisateur)
import [Link];
Scanner sc = new Scanner([Link]);
String nom = [Link]();
20. Fichiers
import [Link];
File f = new File("[Link]");
🚀 Niveau avancé
21. Streams
[Link]()
.filter(x -> [Link]("H"))
.forEach([Link]::println);
22. Lambda
(x) -> x + 1
23. Threads
class MyThread extends Thread {
public void run() {
[Link]("Thread");
}
}
24. Runnable
new Thread(() -> {
[Link]("Hello");
}).start();
25. Synchronisation
synchronized void test() {
}
26. Enum
enum Couleur {
ROUGE, BLEU
}
27. Packages
package monprojet;
28. Gestion mémoire
👉 Java utilise un Garbage Collector
29. JVM
👉 Java fonctionne grâce à la Java Virtual Machine
30. Compilation
javac [Link]
java Main
🔥 Niveau pro
31. Architecture MVC
Model → données
View → interface
Controller → logique
32. Maven / Gradle
Outils de gestion de projet :
<dependency>
33. Spring Boot (très important)
Framework backend :
@RestController
class Test {
@GetMapping("/")
public String hello() {
return "Hello";
}
}
34. API REST
GET
POST
PUT
DELETE
35. JSON en Java
import [Link];
36. JDBC (base de données)
Connection conn = [Link](...);
37. Sécurité
👉 Ne jamais faire confiance aux inputs utilisateur
38. Logging
import [Link];
39. Tests (JUnit)
@Test
void test() {
}
40. Bonnes pratiques
✔ Code propre
✔ Classes bien séparées
✔ Nom clair
✔ Respect OOP
🚀 Mini projet Java
import [Link];
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
[Link]("Nom : ");
String nom = [Link]();
[Link]("Bonjour " + nom);
}
}
📘 Java — Niveau avancé / expert
41. Génériques (Generics)
Permettent de rendre ton code flexible et typé :
List<String> noms = new ArrayList<>();
Créer ta propre classe générique :
class Boite<T> {
T valeur;
void set(T v) {
valeur = v;
}
T get() {
return valeur;
}
}
42. Wildcards (?)
List<? extends Number> liste;
👉 Permet d’accepter plusieurs types
43. Comparable vs Comparator
Comparable :
class User implements Comparable<User> {
public int compareTo(User u) {
return [Link] - [Link];
}
}
Comparator :
[Link](list, (a, b) -> [Link] - [Link]);
44. Optional (éviter les null)
Optional<String> nom = [Link]("Hama");
[Link]([Link]::println);
👉 Évite les NullPointerException
45. Stream API avancée
[Link]()
.filter(x -> x > 10)
.map(x -> x * 2)
.sorted()
.forEach([Link]::println);
46. Parallel Stream (performance)
[Link]()
.forEach([Link]::println);
👉 Utilise plusieurs threads
47. Immutable Objects
Créer des objets non modifiables :
final class User {
private final String nom;
public User(String nom) {
[Link] = nom;
}
public String getNom() {
return nom;
}
}
48. Builder Pattern (très utilisé)
class User {
private String nom;
static class Builder {
private String nom;
Builder setNom(String nom) {
[Link] = nom;
return this;
}
User build() {
User u = new User();
[Link] = [Link];
return u;
}
}
}
49. Singleton Pattern
class Singleton {
private static Singleton instance;
private Singleton() {}
static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
50. Factory Pattern
class AnimalFactory {
static Animal create(String type) {
if ([Link]("chien")) return new Chien();
return null;
}
}
🚀 Backend Java (très important)
51. Spring Boot complet
Exemple API :
@RestController
@RequestMapping("/api")
class UserController {
@GetMapping("/users")
public List<String> getUsers() {
return [Link]("Hama", "Ali");
}
}
52. Injection de dépendances
@Service
class UserService {}
@RestController
class Controller {
private final UserService service;
public Controller(UserService service) {
[Link] = service;
}
}
53. Base de données (JPA)
@Entity
class User {
@Id
@GeneratedValue
Long id;
String nom;
}
54. Repository
interface UserRepo extends JpaRepository<User, Long> {}
55. CRUD complet
Create → POST
Read → GET
Update → PUT
Delete → DELETE
56. Sécurité (Spring Security)
@Configuration
class SecurityConfig {
}
👉 Login / auth / JWT
57. JSON (Jackson)
ObjectMapper mapper = new ObjectMapper();
58. Logs pro
private static final Logger log = [Link]([Link]);
59. Tests avancés (JUnit + Mockito)
@Mock
UserService service;
