• Types primitifs

  • Type numérique (byte 1 octet, short 2 octets, int 4 octets, long 8 octets, float 4 octets, double 8 octets, char 2 octets)

  //java.lang.Byte  
  //java.lang.Short  
  //java.lang.Integer  
  //java.lang.Long  
  //java.lang.Float  
  //java.lang.Double
  //java.lang.Character
  public class TestEtude {
      public static void main(String[] args) {
          System.out.println("Type primitif : byte, bits binaires : " + Byte.SIZE);
          System.out.println("Classe enveloppante : java.lang.Byte");
          System.out.println("Valeur minimale : Byte.MIN_VALUE=" + Byte.MIN_VALUE);
          System.out.println("Valeur maximale : Byte.MAX_VALUE=" + Byte.MAX_VALUE);
      }
  }
  
  

• Type booléen (true, false, 1 bit)

• Types de référence (tous 4 octets)

  • Classes
  • Interfaces
  • Tableaux

Conversion de types

faible  ------------------------------------>  élevé
byte,short,char—> int —> long—> float —> double

1. Conversion automatique (conversion implicite) : les types de données à plus petite capacité peuvent être convertis automatiquement vers des types à plus grande capacité
2. Conversion forcée (conversion explicite) : conversion effectuée dans les cas où des informations peuvent être perdues Format : (type de données)variable

Règles de nommage des variables

1. Toutes les variables, méthodes et classes : nommage clair et explicite
2. Variables membres de classe : première lettre minuscule et notation camelCase : salaryMonth
3. Variables locales : première lettre minuscule et notation camelCase
4. Constantes : lettres majuscules et underscore : MAX_VALUE
5. Noms de classes : première lettre majuscule et notation camelCase : Man, GoodMan
6. Noms de méthodes : première lettre minuscule et notation camelCase : run(), runRun()

Opérateurs

Opérateurs bit à bit, décaler à droite d'une position équivaut à diviser par 2, décaler à gauche d'une position équivaut à multiplier par 2

Question fréquente aux entretiens : Comment calculer efficacement 2*8 ?

public static void main(String[] args) {
    System.out.println(2 << 3);
}

Contrôle de flux

Interaction avec Scanner

Scanner scanner = new Scanner(System.in);
// Toute classe IO ne doit pas être fermée, sinon elle consommera des ressources. Il faut fermer les scanners après utilisation.
scanner.close();

Structure séquentielle

Structure conditionnelle

if...else if...else
switch...case

Boucles

while
do...while		// Le corps de la boucle s'exécute au moins une fois
for(attention aux boucles for améliorées)

break && continue

break est principalement utilisé dans les boucles ou les instructions switch pour sortir complètement du bloc d'instructions.
continue est utilisé dans n'importe quelle structure de boucle. Il permet de passer immédiatement à l'itération suivante de la boucle.

Méthodes

Définition de méthode

modificateur type_retour nom_methode(paramètres){
    ...
    corps de la méthode
    ...
    return valeur_retour;
}

En Java, seul le passage par valeur est supporté !

Surchage de méthode

1. Le nom de la méthode doit être identique
2. La liste des paramètres doit être différente (nombre différent, ou type différent, ou ordre différent)

Paramètres variables

// Ajouter trois points (...) après un type de paramètre spécifique
// Une méthode ne peut avoir qu'un seul paramètre variable, qui doit être le dernier paramètre de la méthode.
public static void afficherMaximum(double... nombres) {
    if (nombres.length == 0) {
        System.out.println("Aucun argument passé");
        return;
    }

Récursion

La récursion consiste à appeler une méthode à partir d'elle-même. Lors de la conception d'un algorithme récursif, il faut impérativement définir quand l'appel ne se fait plus. Sinon, cela entraîne une boucle infinie !

Tableaux

Caractéristiques fondamentales des tableaux :

1. La taille est fixée. Une fois créé, la taille d’un tableau ne peut plus être modifiée.
2. Les éléments doivent être du même type. Les types mélangés ne sont pas autorisés.
3. Les éléments peuvent être de tout type de données, y compris les types primitifs et les types de référence.

Mémoire Java :

1. Pile (heap) : stockage des objets et tableaux créés avec new
2. Stack : stockage des variables primitifs et des références aux objets
3. Zone de méthode : contient toutes les classes et variables statiques

Trois types d'initialisation

// Initialisation statique (allocation et affectation de valeurs lors de la définition du tableau)
int[] a={1,2,3};
// Initialisation dynamique (définition du tableau et allocation de mémoire)
int[] b=new int[2];
// Initialisation par défaut

Plage valide des indices : [0, longueur-1], ArrayIndexOutOfBoundsException : exception d'indice de tableau hors limites !

Classe Arrays

Utilitaire java.util.Arrays
Fonctions courantes :
	Attribuer des valeurs au tableau : via la méthode fill().
	Trier le tableau : via la méthode sort(), en ordre croissant.
	Comparer des tableaux : via la méthode equals() pour vérifier si les éléments sont égaux.
    Rechercher un élément : via la méthode binarySearch() sur un tableau trié.

Programmation orientée objet

Détail de l'OOP

1. La programmation orientée objet consiste à organiser le code sous forme de classes et à organiser les données sous forme d'objets.
2. Le mode de pensée orienté objet peut être décrit comme un mode de pensée par catégories.

Différence entre break et return :

return :
(1) Quitte la méthode courante et retourne à l’instruction qui l’a appelée.
(2) Retourne une valeur à l’appelant, le type de cette valeur doit correspondre au type déclaré dans la méthode.
(3) Peut ne rien retourner, ce qui permet d'interrompre l’exécution de la méthode.

break :
(1) Termine l’exécution de la boucle, saute directement à l'instruction suivant la boucle.
(2) Si utilisé dans un switch, sort uniquement du bloc switch.

!!! Les méthodes statiques ne peuvent pas appeler les méthodes non statiques

Constructeur

Caractéristiques :
1. Doit porter le même nom que la classe
2. Ne possède aucun type de retour, ni void
Rôles :
1. Lorsque l'on utilise new pour créer un objet, le constructeur de la classe doit être utilisé
2. Le code du constructeur permet d'initialiser les attributs de l'objet
Remarque : Un constructeur sans paramètre est automatiquement généré. S'il existe un constructeur avec paramètres, le constructeur sans paramètre doit être défini explicitement.
Raccourci : Alt+Insert

Analyse mémoire de création d'objet

Encapsulation, héritage, polymorphisme

Haut couplage : les détails internes de la classe sont gérés par elle-même, aucune intervention extérieure n’est permise ;

Bas couplage : seule une méthode limitée est exposée à l’extérieur.

// Étapes d'encapsulation
1. Utiliser private pour modifier les variables membres à encapsuler.
2. Fournir une méthode publique pour accéder ou définir les propriétés privées (méthodes get et set).
Raccourci : Alt+Insert

// Étapes d'héritage
Héritage : une classe enfant (dérivée), une classe parent (base). La classe enfant hérite de la classe parent, utilisant le mot-clé extends pour indiquer cela.
public class étudiant extends Personne{
}
Raccourci pour voir l'héritage : Ctrl+H

Chaque classe en Java hérite directement ou indirectement de la classe Object.
Lorsqu’une classe enfant hérite d’une classe parent, elle peut utiliser this pour accéder aux attributs ou méthodes de la classe enfant, et super pour accéder aux attributs et méthodes de la classe parent.
Quel que soit l'appel explicite ou implicite du constructeur parent, la ligne super doit être placée en première ligne du constructeur de la classe enfant.

Syntaxe de redéfinition (les méthodes statiques ne peuvent pas être redéfinies)
1. Le nom de la méthode doit être identique.
2. La liste des paramètres doit être identique.
3. Le niveau d'accès peut être augmenté mais pas réduit : public protected default private.
4. La portée des exceptions levées peut être réduite mais pas agrandie : ClassNotFoundException ---> Exception.
5. Le type de retour peut être identique ou différent, si différent, le type de retour de la méthode redéfinie doit être un sous-type du type de retour de la méthode parent.

// Étapes de polymorphisme
1. Relation d'héritage.
2. La classe enfant redéfinit la méthode de la classe parent.
3. Une référence de classe parent pointe vers un objet de classe enfant.

Modificateur static

    {
        System.out.println("Bloc anonyme");
    }

    static {
        System.out.println("Bloc statique");
    }
    public Personne(){
        System.out.println("Constructeur");
    }
// Ordre d'exécution : Bloc statique - Bloc anonyme - Constructeur (le bloc statique s'exécute une seule fois, le bloc anonyme et le constructeur s'exécutent à chaque création d'objet)
[La classe Student n'a pas encore été chargée]
1. Chargement de la classe, initialisation des attributs statiques
2. Exécution du bloc statique
3. Allocation de l'espace mémoire, initialisation des attributs non statiques (valeur par défaut, 0/false/null)
4. Appel du constructeur de la classe parent de Student
5. Affectation explicite des attributs de Student (s'il y en a)
6. Exécution du bloc anonyme
7. Exécution du constructeur
8. Retour de l'adresse mémoire

Modificateur abstract

public abstract class Action{
    public abstract void faireQuelqueChose();
}
Classe abstraite, ne peut pas être instanciée avec new, elle est destinée à être héritée par ses sous-classes.
Méthode abstraite, déclare seulement la méthode sans implémentation, elle est destinée à être implémentée par les sous-classes.

Interface

Rôles de l'interface :
    1. Contrainte, norme uniquement
    2. Définition de méthodes pour que différentes personnes puissent les implémenter (les sous-classes doivent redéfinir les méthodes)
    3. Mot-clé class pour déclarer une classe, mot-clé interface pour déclarer une interface
    4. Les interfaces ne peuvent pas être instanciées, elles n'ont pas de constructeur
    5. implements peut implémenter plusieurs interfaces
    6. Les variables dans les interfaces sont des constantes statiques

public interface Action{
    public abstract void courir();
    // Par défaut, c'est public abstract
    void test();
}   

Résumé :

1. Les variables membres d'une interface sont par défaut public, static, final (tous peuvent être omis), doivent être initialisées explicitement, donc elles sont des constantes (majuscules, mots séparés par "_")
2. Les méthodes d'une interface sont par défaut public, abstract (tous peuvent être omis), sans corps, ne peuvent pas être instanciées
3. Une interface ne peut contenir que des membres variables de type public, static, final et des méthodes membres de type public, abstract
4. L'interface ne peut pas avoir de constructeur, ne peut pas être instanciée
5. Une interface ne peut pas implémenter une autre interface, mais peut hériter de plusieurs interfaces
6. Une interface doit être implémentée par une classe pour utiliser ses méthodes abstraites
7. Si une classe implémente une interface, elle doit implémenter toutes les méthodes abstraites, sinon la classe doit être déclarée comme abstraite
8. Impossible d'instancier une interface, mais on peut déclarer une variable de type interface qui référence une instance d'une classe implémentant l'interface
9. Une classe ne peut hériter que d'une classe parent directe, mais peut implémenter plusieurs interfaces, réalisant ainsi l'héritage multiple indirect

Classes internes

1. Classe interne membre (création d'une classe B à l'intérieur de la classe A)
2. Classe interne statique (classe interne avec le mot-clé static)
3. Classe interne locale (classe déclarée à l'intérieur d'une méthode)
4. Classe interne anonyme (l'objet créé par new Object().method() n'est pas stocké dans une variable)

Exceptions

Super classe des exceptions : java.lang.Throwable

Error : généré et lancé par la machine virtuelle Java, la plupart des erreurs sont indépendantes des opérations du programmeur.
Exception : représente des situations d'exception que le programme peut capturer ou traiter.
StackOverflowError : erreur générée lorsque la profondeur de la pile dépasse la taille allouée au thread.
OutOfMemoryError : la JVM n'a plus de ressources mémoire pour continuer l'exécution.
ArithmeticException : exception arithmétique
MissingResourceException : ressource manquante
ClassNotFoundException : classe introuvable
NullPointerException : exception de pointeur nul
IllegalArgumentException : paramètre incorrect ou non valide passé à une méthode
ArrayIndexOutOfBoundsException : index de tableau hors limite
UnkownTypeException : exception de type inconnu

Le traitement des exceptions en Java consiste à lever et attraper les exceptions

// Lever une exception
if(etudiant == null){
    throw new NullPointerException();
}
// Attraper une exception
Raccourci de gestion d'exception : Ctrl+Alt+T
    try -- pour écouter
    catch -- pour capturer l'exception
    finally -- le bloc finally s'exécute toujours
    throw -- pour lever une exception
    throws -- utilisé dans la signature de la méthode pour déclarer les exceptions pouvant être levées

Flux d'E/S

Catégories des flux d'entrée/sortie

1. Par direction du flux de données : flux d'entrée et flux de sortie (les deux sont vus du point de vue du programme)
2. Par unité de traitement des données : flux d'octets (8 bits) et flux de caractères (2 octets)
3. Par fonction : flux de nœuds et flux de traitement

Flux d'entrée : InputStream (flux d'octets), Reader (flux de caractères)
Flux de sortie : OutPutStream (flux d'octets), Writer (flux de caractères)
Flux de nœud : lit des données depuis une source spécifique (fichier, mémoire)
Flux de traitement : connecté à un flux existant, fournit des fonctionnalités avancées de lecture/écriture

Types de flux de nœud

Types de flux de traitement

InputStream (flux d'entrée)

// Lit un octet, traite un octet. Retourne -1 lorsque la fin du flux est atteinte
int read() throws IOException
// Lit une série d'octets et les stocke dans un tableau buffer
// Retourne le nombre d'octets effectivement lus, -1 si la fin du flux est atteinte
int read(byte[] buffer) throws IOException
// Lit length octets et les stocke dans un tableau buffer
// Retourne le nombre d'octets effectivement lus, -1 si la fin du flux est atteinte
int read(byte[] buffer,int offset,int length) throws IOException
// Ferme le flux et libère les ressources mémoire
void close() throws IOException

Les flux d'E/S nécessitent une gestion avec try/catch

OutputStream (flux de sortie)

// Écrit un octet dans le flux de sortie, l'octet est constitué des 8 bits de poids faible de b
void write(int b) throws IOException
// Écrit les données d'un tableau d'octets dans le flux de sortie
void write(byte[] b) throws IOException
// Écrit un nombre de bytes spécifié (len) à partir d'une position (off) d'un tableau d'octets dans le flux de sortie
void write(byte[] b,int off,int len) throws IOException
// Ferme le flux et libère les ressources mémoire
void close() throws IOException

Reader et Writer

FileReader et FileWriter sont des flux de caractères, ils traitent les données en unités de caractères, adaptés aux caractères chinois qui prennent deux octets en Java

Programmation réseau

But de la programmation réseau : échanger des données avec d'autres ordinateurs via des protocoles réseau, communication.

Protocoles de communication réseau

1. Modèle OSI (Couche application, Couche représentation, Couche session, Couche transport, Couche réseau, Couche liaison de données, Couche physique)
2. Modèle TCP/IP (Couche application, Couche transport, Couche réseau, Couche liaison de données)

Deux éléments essentiels de la programmation réseau

1. Adresse IP et numéro de port
2. Protocole de communication réseau

IP

// Classe InetAddress, représente une IP, nécessite un try/catch pour gérer l'exception
InetAddress parNom2 = InetAddress.getByName("www.baidu.com");    // Obtenir l'adresse IP

Numéro de port

// TCP et UDP disposent chacun de 65535 ports, les numéros de port ne peuvent pas être en conflit dans un même protocole.
// La combinaison d'IP et de port forme un socket réseau. Certaines programmations réseau sont appelées programmation Socket.
new InetSocketAddress("127.0.0.1",8080);
socketAddress.getHostName()			
socketAddress.getAddress()			// Retourne l'adresse
socketAddress.getPort()				// Retourne le port

Protocole de communication réseau

Protocole TCP/IP :

1. Couche transport :
   • Protocole TCP : handshake en trois phases, déconnexion en quatre phases, connexion établie, stable (appel téléphonique)
   • Protocole UDP : paquets de données, source, destination encapsulés, pas de connexion, non fiable (SMS)
2. Couche réseau : IP

Programmation graphique

Swing et AWT sont des technologies courantes pour développer des interfaces graphiques en Java. AWT dépend du système d'exploitation, les applications AWT peuvent ne pas conserver leur apparence sur d'autres plateformes ; les applications Swing développées en Java conservent leur apparence sur différentes plateformes.

AWT

Les classes utilisées avec AWT se trouvent généralement dans le package java.awt et ses sous-packages.
Container (conteneur) et Component (composant) sont deux classes centrales dans AWT.

Frame

frame.setBackground(Color.blue);	// Définit la couleur de fond de la fenêtre
frame.setVisible(true);				// Définit si la fenêtre est visible
frame.setSize(400,400);				// Définit la taille initiale de la fenêtre
frame.setLocation(200,200);			// Définit la position de la fenêtre
frame.setBounds(x,y,w,h)			// Définit la position et la taille de la fenêtre
frame.setResizable(false);			// Définit si la fenêtre peut être redimensionnée
frame.setLayout();					// Ajoute un paramètre pour définir la disposition
frame.addWindowListener				// Ajoute un écouteur d'événements de fenêtre
frame.pack();						// Redimensionne la fenêtre à la taille optimale
frame() est initialisé avec BorderLayout par défaut, peut aussi spécifier un gestionnaire de mise en page

Panel

Panel() est initialisé avec FlowLayout par défaut, peut aussi spécifier un gestionnaire de mise en page

Gestionnaires de mise en page

frame.setLayout(new FlowLayout(FlowLayout.LEFT));	// FlowLayout : disposition fluide de gauche à droite (centré par défaut)
frame.add(buttonEast,BorderLayout.EAST);			// BorderLayout : nord, sud, est, ouest, centre (centré par défaut)
frame.setLayout(new GridLayout(3,2));				// GridLayout : disposition en grille

Composants

(1).Button button1 = new Button("button1");	// Crée un bouton
(2).ScrollPane scrollPane = new ScrollPane(ScrollPane.SCROLLBARS_ALWAYS);// Crée un conteneur avec barres de défilement
(3).Label label = new Label("Hello JAVA");// Crée un label

Écouteurs d'événements

// Pour devenir un écouteur, une classe doit implémenter l'interface ActionListener
class MonEcouteurAction implements ActionListener{
    // Redéfinition de la méthode actionPerformed(ActionEvent e) de l'interface ActionListener
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Un bouton a été pressé");
    }
}   

Écouteur de champ de texte

// Appuyer sur Entrée dans le champ de texte déclenche un événement Action
// Récupérer le contenu saisi dans le champ de texte
TextField tf=(TextField)e.getSource();
tf.getText()

Classe Graphics

// Dans la méthode main(), paint(Graphics g) n'est pas appelée explicitement, car elle est appelée implicitement lors de la création de la fenêtre Frame

Adaptateur d'événements de souris

Événements de fenêtre

this.addWindowListener(new WindowAdapter() {
   @Override
   public void windowClosing(WindowEvent e) {
       System.exit(0);
    }
});

Événements de touches

// Utiliser getKeyCode() pour obtenir le code virtuel de la touche, NomClasse.constanteStatique
public void keyPressed(KeyEvent e) {
     int keycode = e.getKeyCode();
     if(keycode==KeyEvent.VK_UP){
          System.out.println("Vous avez appuyé sur la flèche haut");
     }
}

Swing

JFrame (fenêtre)

JFrame jf = new JFrame(title);
// Dans le développement, hériter de java.swing.JFrame pour créer une fenêtre, utiliser this pour appeler ses méthodes.
// Après la création de l'objet JFrame, il faut appeler getContentPane() pour convertir la fenêtre en conteneur, puis ajouter des composants ou définir un gestionnaire de mise en page
jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
Les modes de fermeture courants de la fenêtre sont quatre :
"DO_NOTHING_ON_CLOSE" : ne fait rien lorsque la fenêtre est fermée ;
"DISPOSE_ON_CLOSE" : cache et supprime la fenêtre lorsqu'elle est fermée ;
"HIDE_ON_CLOSE" : cache la fenêtre lorsqu'elle est fermée ;
"EXIT_ON_CLOSE" : quitte le programme lorsque la fenêtre est fermée ;

JDialog (boîte de dialogue)

// La boîte de dialogue a un événement de fermeture par défaut, pas besoin de le spécifier
class MaBoiteDialogue1 extends JDialog{
    public MaBoiteDialogue1() {
    }
}

Étiquettes

JLabel jl = new JLabel();
// Obtenir le chemin de l'image
URL resource = ImageIconDemo.class.getResource("tx.jpg");

Plans

Les plans Swing couramment utilisés sont JPanel (plan normal) et JScrollPane (plan avec barre de défilement)

// Si vous voulez placer plusieurs composants dans un JScrollPane, placez ces composants dans un JPanel, puis ajoutez le JPanel comme composant principal dans le JScrollPane

Boutons

1. Bouton standard (JButton)					JButton jb = new JButton();
2. Bouton radio (JRadioButton)			ButtonGroup groupe = new ButtonGroup();
    							  JRadioButton jr1 = new JRadioButton("JRadioButton1");
								  groupe.add(jr1);
// Un bouton radio est une icône circulaire avec du texte. Lorsqu'un bouton radio est sélectionné, les autres boutons du groupe sont désélectionnés. Il faut utiliser ButtonGroup pour gérer les boutons radios, car seul un bouton peut être sélectionné dans un groupe.
3. Case à cocher (JCheckBox)				JCheckBox jrb  = new JCheckBox("abc");
// Une case à cocher est une icône carrée avec du texte. Chaque case peut être cochée ou décochée.

Listes

1. Liste déroulante (JComboBox)				JComboBox jComboBox = new JComboBox();
								   jComboBox.addItem("En cours de projection");
2. Liste (JList)			
								   String[] nom={"1","2","3"};					// Configuration statique
								   Vector nom = new Vector();	nom.add("1");	// Configuration dynamique
								   JList jList = new JList(nom);
// La liste n’a qu’une taille fixe dans la fenêtre. Pour obtenir un effet de défilement, il faut placer la liste dans un panneau de défilement.

Composants de texte

1. Champ de texte
    			JTextField jt = new JTextField("aaa"); 
				jt.setText("");
2. Champ de mot de passe
    			JPasswordField jp = new JPasswordField();
				jp.setEchoChar('#');      // Définir le caractère d’écho
3. Zone de texte
    			JTextArea tArea = new JTextArea(20, 50);
				tArea.setText("Bienvenue à l'ouverture de l'ouest pour étudier Java");

Annotations et réflexion

Qu'est-ce qu'une annotation

Les annotations peuvent commenter le programme, ou être lues par d'autres programmes. Format : "@NomAnnotation", peuvent inclure des valeurs de paramètres

Annotations intégrées

@Override			Défini dans java.lang.Override, redéfinit une méthode d'une classe parent
@Deprecated			Défini dans java.lang.Deprecated, indique qu'il est déconseillé d'utiliser cet élément
@SuppressWarnings		Défini dans java.lang.SuppressWarnings, supprime les avertissements de compilation (masquer les avertissements, nécessite un paramètre)

Méta-annotations

// Les méta-annotations servent à annoter d'autres annotations
@Target : décrit la portée d'utilisation de l'annotation
@Retention : décrit le cycle de vie de l'annotation (SOURCE < CLASS < RUNTIME)
@Documented : indique que l'annotation sera incluse dans le javadoc
@Inherited : indique que les annotations de la classe parent peuvent être héritées par les classes enfants

Annotations personnalisées

// Utiliser @interface pour créer une annotation personnalisée, hérite automatiquement de java.lang.annotation.Annotation
// Format : type_paramètre nom_paramètre();
String valeur();

Réflexion