Pour créer une application mobile Android sous Android Studio, vous utiliserez principalement les

fonctionnalités fournies par le kit de développement Android (Android SDK) ainsi que les
bibliothèques et les composants fournis par Google. Voici quelques-unes des classes et des
fonctionnalités clés que vous utiliserez :

1. Activity : Les activités représentent les écrans avec lesquels les utilisateurs interagissent dans
votre application. Chaque écran de votre application est généralement représenté par une
activité.

2. Fragment : Les fragments sont des composants d'interface utilisateur réutilisables au sein
d'une activité. Ils permettent de diviser l'interface utilisateur en modules plus petits et plus
faciles à gérer.

3. Intent : Les intentions sont des objets utilisés pour démarrer des composants dans votre
application ou dans d'autres applications Android. Par exemple, vous pouvez utiliser une
intention pour démarrer une nouvelle activité ou pour envoyer des données à une autre
application.

4. RecyclerView : Le RecyclerView est une vue de liste avancée qui permet d'afficher de grandes
quantités de données de manière efficace en recyclant les éléments de la liste qui ne sont
plus visibles à l'écran.

5. Adapters : Les adaptateurs sont utilisés pour fournir des données au RecyclerView ou à
d'autres vues de liste. Ils permettent de convertir les données en éléments de vue pouvant
être affichés à l'écran.

6. Layouts : Les mises en page définissent la structure de l'interface utilisateur de votre

application. Vous pouvez utiliser des mises en page XML pour définir la disposition des
éléments d'interface utilisateur tels que les boutons, les champs de texte et les images.

7. Services : Les services sont des composants de l'application qui s'exécutent en arrière-plan
pour effectuer des opérations longues ou en continu, comme la lecture de musique en
continu ou la synchronisation de données.

8. BroadcastReceiver : Les récepteurs de diffusion sont des composants de l'application qui

répondent à des diffusions système ou personnalisées. Ils peuvent être utilisés pour écouter
des événements système tels que le démarrage du périphérique ou la réception de messages
texte.

9. Permissions : Les autorisations sont des mécanismes de sécurité qui permettent à votre
application d'accéder à des fonctionnalités sensibles du périphérique, telles que la caméra, le
stockage ou la localisation.

10. [Link] : Le fichier [Link] contient des informations sur votre

application, telles que le nom du package, les permissions requises, les composants de
l'application (activités, services, récepteurs de diffusion) et d'autres métadonnées
importantes.

Ce ne sont là que quelques-unes des classes et des fonctionnalités que vous utiliserez lors de la
création d'une application Android sous Android Studio. Il existe de nombreuses autres classes et
fonctionnalités disponibles dans le kit de développement Android pour vous aider à créer des
applications puissantes et riches en fonctionnalités.
La classe MainActivity dans une application Android est généralement responsable de gérer le cycle
de vie de l'activité principale de votre application et de gérer les interactions utilisateur. Voici
quelques-unes des méthodes couramment utilisées dans la classe MainActivity :

1. onCreate() : Cette méthode est appelée lorsque l'activité est créée pour la première fois.
C'est généralement l'endroit où vous initialisez vos variables, configurez l'interface utilisateur
et effectuez d'autres opérations d'initialisation.

2. onStart() : Cette méthode est appelée lorsque l'activité devient visible à l'utilisateur. C'est
généralement l'endroit où vous commencez à effectuer des opérations que vous souhaitez
effectuer lorsque l'activité est visible mais pas encore en premier plan.

3. onResume() : Cette méthode est appelée lorsque l'activité entre en premier plan et devient
interactive. C'est généralement l'endroit où vous initialisez les ressources qui doivent être
libérées lorsque l'activité n'est plus visible.

4. onPause() : Cette méthode est appelée lorsque l'activité perd le focus mais reste visible à
l'utilisateur. C'est généralement l'endroit où vous enregistrez des données ou effectuez
d'autres opérations pour préparer l'activité à entrer en arrière-plan ou à être arrêtée.

5. onStop() : Cette méthode est appelée lorsque l'activité n'est plus visible à l'utilisateur. C'est
généralement l'endroit où vous libérez des ressources qui ne sont plus nécessaires lorsque
l'activité n'est pas visible.

6. onDestroy() : Cette méthode est appelée lorsque l'activité est détruite. C'est généralement
l'endroit où vous effectuez le nettoyage final, tel que la libération de toutes les ressources qui
ont été allouées à l'activité.

7. onBackPressed() : Cette méthode est appelée lorsque l'utilisateur appuie sur le bouton de
retour matériel de l'appareil. Vous pouvez l'utiliser pour gérer le comportement de retour
personnalisé de votre application.

8. onActivityResult() : Cette méthode est appelée lorsque vous attendez une réponse à une
activité que vous avez lancée à l'aide de startActivityForResult(). Vous pouvez l'utiliser pour
traiter le résultat de cette activité.

9. onRequestPermissionsResult() : Cette méthode est appelée lorsque vous demandez des

autorisations à l'utilisateur et qu'il répond. Vous pouvez l'utiliser pour traiter la réponse de
l'utilisateur concernant les autorisations demandées.

Ces méthodes sont des exemples courants utilisés dans la classe MainActivity d'une application
Android, mais il en existe d'autres que vous pouvez également utiliser en fonction des besoins de
votre application.
Pour créer une interface graphique en Java, vous pouvez utiliser la bibliothèque Swing, qui fait partie
de la plateforme Java Standard Edition (Java SE). Voici quelques-unes des méthodes couramment
utilisées pour créer et gérer une interface graphique en Java Swing :

1. JFrame() : Le constructeur de la classe JFrame est utilisé pour créer une fenêtre principale qui
contiendra tous les éléments de votre interface graphique.

2. setLayout() : Cette méthode est utilisée pour définir le gestionnaire de disposition (layout
manager) de la fenêtre, qui détermine comment les composants sont disposés à l'intérieur de
la fenêtre (par exemple, BorderLayout, FlowLayout, etc.).

3. add() : Cette méthode est utilisée pour ajouter des composants (comme des boutons, des
zones de texte, des étiquettes, etc.) à la fenêtre.

4. setVisible() : Cette méthode est utilisée pour rendre la fenêtre visible à l'utilisateur.

5. setSize() : Cette méthode est utilisée pour définir la taille initiale de la fenêtre.

6. setDefaultCloseOperation() : Cette méthode est utilisée pour définir le comportement par

défaut de la fenêtre lorsque l'utilisateur la ferme.

7. JButton() : Le constructeur de la classe JButton est utilisé pour créer un bouton.

8. JLabel() : Le constructeur de la classe JLabel est utilisé pour créer une étiquette de texte.

9. JTextField() : Le constructeur de la classe JTextField est utilisé pour créer une zone de texte.

10. JTextArea() : Le constructeur de la classe JTextArea est utilisé pour créer une zone de texte
multiligne.

11. JCheckBox() : Le constructeur de la classe JCheckBox est utilisé pour créer une case à cocher.

12. JRadioButton() : Le constructeur de la classe JRadioButton est utilisé pour créer un bouton
radio.

13. setLayout() : Cette méthode est utilisée pour définir le gestionnaire de disposition des
composants à l'intérieur d'un conteneur (comme un panneau).

14. addActionListener() : Cette méthode est utilisée pour ajouter un écouteur d'événements à
un composant, ce qui permet de réagir aux actions de l'utilisateur (par exemple, cliquer sur
un bouton).

15. repaint() : Cette méthode est utilisée pour redessiner la fenêtre et ses composants.

Ce ne sont là que quelques-unes des méthodes couramment utilisées pour créer une interface
graphique en Java à l'aide de la bibliothèque Swing. Il existe de nombreuses autres méthodes et
classes disponibles dans Swing pour créer des interfaces graphiques riches et interactives.

Voici quelques autres méthodes couramment utilisées pour créer une interface graphique en Java
avec Swing :

16. JPanel() : Le constructeur de la classe JPanel est utilisé pour créer un panneau, qui est un
conteneur léger pouvant être utilisé pour organiser des composants à l'intérieur d'une
fenêtre.
 17. setLayout() : Cette méthode est utilisée pour définir le gestionnaire de disposition des
composants à l'intérieur d'un panneau.

18. setBorder() : Cette méthode est utilisée pour définir la bordure d'un composant, ce qui peut
aider à le distinguer visuellement des autres composants.

19. setBackground() : Cette méthode est utilisée pour définir la couleur d'arrière-plan d'un
composant, comme un panneau ou une étiquette.

20. setFont() : Cette méthode est utilisée pour définir la police de caractères d'un composant,
telle que la police, le style et la taille.

21. setForeground() : Cette méthode est utilisée pour définir la couleur de premier plan d'un
composant, telle que la couleur du texte d'une étiquette.

22. setToolTipText() : Cette méthode est utilisée pour définir le texte d'info-bulle qui s'affiche
lorsque l'utilisateur survole un composant avec la souris.

23. setEnabled() : Cette méthode est utilisée pour activer ou désactiver un composant, ce qui
peut empêcher l'utilisateur d'interagir avec lui.

24. setEditable() : Cette méthode est utilisée pour rendre un composant éditable ou non
éditable, comme une zone de texte.

25. setHorizontalAlignment() : Cette méthode est utilisée pour définir l'alignement horizontal du
texte dans un composant, comme une étiquette.

26. setVerticalAlignment() : Cette méthode est utilisée pour définir l'alignement vertical du texte
dans un composant, comme une étiquette.

27. setIcon() : Cette méthode est utilisée pour définir l'icône d'un composant, comme un bouton.

28. setLayout() : Cette méthode est utilisée pour définir le gestionnaire de disposition des
composants à l'intérieur d'un conteneur, comme une fenêtre ou un panneau.

29. setVisible() : Cette méthode est utilisée pour rendre un composant visible ou invisible.

30. dispose() : Cette méthode est utilisée pour libérer les ressources associées à un composant
lorsque vous avez fini de l'utiliser.

Ces méthodes peuvent être utilisées pour personnaliser l'apparence et le comportement des
composants de votre interface graphique en Java avec Swing, en leur donnant la fonctionnalité et
l'apparence souhaitées