Java - Introduction & Rappels Eric Blaudez (eric.blaudez@u-psud.fr)| 01

Description Ce cours est un bref rappel sur le langage Java. Les objets Héritage, classe abstraire & interface API Java – le kit de survie Java - Introcution & Rappels

Agenda Le langage Java Les objets Java Héritage, classe abstraite & interface API Java - le kit de survie Java - Introcution & Rappels

Le langage Java Un langage interprété Un code Java n'est pas directement exécuté par le processeur Le code Java est compilé en Byte Code qui est exécuté par une machine virtuelle, la JVM (Java Virtual Machine) Java - Introcution & Rappels

Le langage Java Un langage interprété Généralement, en Java les codes compilés sont des fichiers .class qui sont ensuite archivés / packagés en fichier .jar. Ces .class ne sont pas lisibles avec un éditeur standard Java - Introcution & Rappels

Le langage Java Un langage interprété Il existe beaucoup de machines virtuelles Java Les plateformes Android ont leur propre JVM (Dalvik), en natif. Linux utilise GIT ou OpenJDK, Microsoft et Apple ont également développé leur propre JVM. La plus connue est sans doute celle d'Oracle. Java - Introcution & Rappels

Le langage Java Un langage portable Le Byte Code de Java est portable, c'est à dire qu'il peut être exécuté sur n'importe quel système d'exploitation. Par exemple, il est possible de compiler un programme Java sous Linux est l'exécuter sous Windows. Java - Introcution & Rappels

Le langage Java Un langage portable Java offre un API complète Il y a tout de même une limite : si un programme utilise un module externe (une DLL par exemple), au travers de la JNI (Java Native Interface) cette portabilité sera rompue. Dès lors il faudra compiler ce module sur chaque plateforme afin d'assurer le portage de l'application Java. Java - Introcution & Rappels

Le langage Java Une API riche Un langage multi-tâches L'API de Java est très riche; elle couvre des opérations de gestion de fichiers, d'affichage, d'interface graphique, de gestion du son, ... Java - Introcution & Rappels

Le langage Java Une API riche Les principaux packages java.awt : création d'interfaces graphiques java.io : entrées/sorties, sérialisation et système de fichiers java.lang : package de base pour la programmation en Java java.math : gestion des opérations mathématiques java.net : gestion du réseau java.util : contient les Collections, internationalisation, expression régulière, ... Java - Introcution & Rappels

Le langage Java Une API riche java.rmi : Exécution de méthodes distantes - au travers du réseau (Remote Method Invocation) java.security : gestion de la sécurité java.sql : gestion (interrogation) de base de données java.text : gestion du texte, des dates ... javax.imageio : gestion des images javax.net : applications réseaux javax.rmi : gestion avancée des RMI javax.swing : interface graphique unifiée pour toutes les plateformes Java - Introcution & Rappels

Le langage Java Un langage multitâches En java le multitâche se caractérise par l'exécution de threads. Ce sont des objets disposant d'une méthode pouvant être exécuter en parallèle de l'application principale sans blocage du flots d'instructions. Naturellement il est possible d'exécuter plusieurs threads au même instant. Java - Introcution & Rappels

Le langage Java Un langage multitâches Les threads partagent le même espace d'adressage mémoire et registre que l' application principale. Dans un programme multitâches il est donc nécessaire de prêter une attention particulière à l'accès des ressources. Java - Introcution & Rappels

Agenda Le langage Java Les objets Java Héritage, classe abstraite & interface API Java - le kit de survie Java - Introcution & Rappels

Les objets Java La création d'un objet en Java est faite à l'aide du mot clé class. Cet objet encapsulera des données et des méthodes. En java tous les objets dérivent implicitement de la classe Object. Java - Introcution & Rappels

Les objets Java Les modifieurs de classe : public package edu.iut; public class PublicHello { /** * @param name to display */ public void sayHello(String name) { System.err.println("Hello "+name+"."); } La classe est accessible dans toute l'application : elle peut être instanciée partout. Java - Introcution & Rappels

Les objets Java Les modifieurs de classe : private public class PrivateHello { private class ImplPrivateHello { public void sayHelloPrivate(String name) { System.err.println("Hello(private) "+name+"."); } public class ImplPublicHello { public void sayHelloPublic(String name) { System.err.println("Hello(public) "+name+"."); public void sayHello(String name) { ImplPrivateHello realHello = new ImplPrivateHello(); realHello.sayHelloPrivate(name); La classe est une classe imbriquée (inner class) elle n'est accessible que depuis la classe l'encapsulant. Java - Introcution & Rappels

Les objets Java Les modifieurs de classe : abstract Ce modificateur permet la définition d'une classe abstraite. Dans ce type de classes certaines fonctions ne sont pas définies : elles n'ont pas de corps. Dès lors, une classe abstraite ne peut pas être instanciée : il faudra la dériver est implémenter toutes les méthodes non définies. abstract public class AbstractHello { abstract public void sayHello(String name); } public class EnglishHello extends AbstractHello { public void sayHello(String name) { System.err.println("Hello "+name+"."); } Java - Introcution & Rappels public class FrenchHello extends AbstractHello { public void sayHello(String name) { System.err.println("Bonjour "+name+"."); }

Les objets Java Visibilité, modificateurs des attributs & des méthodes de classe public : un attribut ou une méthode marqué comme public sera visible par les objets appelants. Dans les exemples précédant la méthode sayHello était public, elle pouvait être appelée en dehors de son espace de définition. protected : un attribut ou une méthode marqué comme protected n'est accessible que par les classe filles. private : un attribut ou une méthode private n'est accessible que dans le scope de la classe qui le contient. Autrement dit, ni les classes filles ni le programme appelant ne pourra y accéder. abstract : ce modificateur ne peut être utilisé que dans les classe abstraite. Il identifie les méthodes que devront être implémentées dans les classes filles. Java - Introcution & Rappels

Les objets Java Affectations & comparaison En java tous les objets sont instanciés par allocation dynamique. Les comparaisons et les affections directes sont à manipuler avec précaution puisque qu'une copie ou un comparaison est faite sur la référence et non le contenu. Java - Introcution & Rappels

Les objets Java Affectations & comparaison String hello = "hello"; String newHello = new String("hello"); System.err.println("Compare hello & newHello:"+(hello==newHello)); System.err.println("Use .equals method:"+hello.equals(newHello)); Le résultat: Compare hello & newHello:false Use .equals method:true Lorsque l'on compare directement hello et newHello avec l'opérateur == on obtient false : cet opérateur compare les références sur les objets qui, ici, sont différentes. Pour comparer le contenu des objets, nous utiliserons la méthode equals qui compare le contenu des objets. Attention, lorsque vous créez vos propres objets la méthode equals existe (elle dérive de la classe Object); sans surcharge elle effectuera la même opération que l'opérateur ==. Java - Introcution & Rappels

Les objets Java this fait référence à l'objet courant. this & super this fait référence à l'objet courant. super fait référence à l'objet parent. Java - Introcution & Rappels

Les objets Java this & super Function:CTO Name:John Name:Lolita public class ChiefTechnologyOfficer extends Employee { protected double dividends; public ChiefTechnologyOfficer(String name, double salary) { super(name, salary); dividends = 0.0; } public void setDividends(double dividends) { this.dividends = dividends; @Override public double getAnnualSalary() { return super.getAnnualSalary() + dividends; } @Override public String toString() { return "Function:CTO\n"+super.toString(); public class Employee { protected String name; protected double salary; public Employee(String name, double salary) { this.name = name; this.salary = salary; } public double getAnnualSalary() { return salary; @Override public String toString() { return "Name:"+this.name+"\nSalary:" + this.getAnnualSalary(); Java - Introcution & Rappels Function:CTO Name:Lolita Salary:61000.0 Name:John Salary:40000.0

Les objets Java Les énumérations Les énumérations sont une structure de données permettant la définition d'une liste de valeurs. Elles sont définies avec le mot clé enum public enum Language { FRENCH("fr","french"), ENGLISH("en","english"), GERMAN("gr","german"); private String shortName; private String longName; Language(String shortName, String longName) { this.shortName = shortName; this.longName = longName; } public String getLongName() { return longName; public String toString() { return shortName; public class EnumExample { public static void main(String[] args) { Language french = Language.FRENCH; System.err.println(french+" ; long name:"+french.getLongName()); } Java - Introcution & Rappels fr ; long name:french

Agenda Le langage Java Les objets Java Héritage, classe abstraire & interface API Java – le kit de survie Java - Introcution & Rappels

Héritage, classe abstraite & interface Comme la plupart des langages Objet, Java propose un mécanisme d'héritage, de classes abstraites et d'interface. L'héritage et l'implémentation de classe abstraite est faite à l'aide du mot clé extends public class ChiefTechnologyOfficer extends Employee L'implémentation d'interface est faite à l'aide du mot clé implements public class Employee implements Worker Java - Introcution & Rappels

Héritage package edu.iut; public class Position { protected String placeName; public Position() { this.placeName = null; } public Position(String placeName) { this.placeName = placeName; public String getPlaceName() { return placeName; @Override public String toString() { return "Place name:"+placeName; L’annotation @Override indique que la fonction est surchargée. Ici la méthode toString() est surchargée car elle appartient aussi à la classe mère de tous les objets Java : Object Java - Introcution & Rappels

Héritage public class GpsPosition extends Position { protected double longitude; protected double latitude; public GpsPosition() { super(); this .longitude = 0.0; this.latitude = 0.0; } public GpsPosition(String placeName, double longitude, double latitude) { super(placeName); this .longitude = longitude; this.latitude = latitude; public double getLongitude() { return this.longitude; public double getLatitude() { return this.latitude; @Override public String toString() { return super.toString() + "\nGPS: (Long:"+this.longitude+", Lat:"+this.latitude+")"; Lorsque l’on dérive une d’une classe (extends), on peut accéder à toutes les méthodes de la classe mère (à part les membre noté comme private). Ici la class GpsPosition a également la méthode getPlaceName (quand bien même elle n’est écrite). GpsPosition surcharge également la méthode toString(), cette méthode appelle la méthode de la classe mère (super) et ajoute à la chaîne ses propres informations. Java - Introcution & Rappels

Héritage public class InheritanceExample { Affiche: public static void main(String[] args) { Position withGPS = new GpsPosition("Orsay",48.7,2.183333); System.err.println(withGPS); System.err.println(withCell); } Affiche: Place name:Orsay GPS: (Long:48.7, Lat:2.183333) Java - Introcution & Rappels Lorsque nous allouons une classe fille (new GpsPosition) et que l’affectation est faite sur la classe mère (Position) les méthodes surchargées appelées sont celles de la dernière définition : celle de la classe fille. Ainsi lorsque nous affichons la fonction surchargée toString() c’est celle de la classe qui est appelée.

Classe abstraite Une classe abstraite contient des méthodes non implémentées : ces méthodes ont une modifieur abstract. L'implémentation est faite dans les classes filles. Java - Introcution & Rappels

Classe abstraite public abstract class LandVehicle { protected int x,y; public LandVehicle() { x = -1; y = -1; } public abstract boolean withWheel(); public abstract boolean withAir(); public abstract boolean started(); public abstract void stop(); public abstract void start(); public void moveTo(int x, int y) { if (this.started()) { this.x = x; this.y = y; @Override public String toString() { return "LandVehicle at("+x+", "+y+")"; Ici les méthodes withWheel, withAir, started, stop et start sont abstraites : leur implémentation sera faite dans les classes filles. La méthode moveTo est une méthode concrète (avec du code) elle appelle une méthode abstraite (started): cette méthode est celle qui sera définie dans une classe fille. Java - Introcution & Rappels

Classe abstraite public class Car extends LandVehicle { protected boolean isStarted; public Car() { isStarted = false; } @Override public boolean withWheel() { return true; } public boolean withAir() { return false; } public boolean started() { return this.isStarted; } public void stop() { isStarted=false; } public void start() { isStarted=true; } public String toString() { return "Car "+(this.started()?" is started":" is stopped") + "\n"  + super.toString(); } L’ensemble des méthodes abstraites de la classe mère sont implémentées. Comme dans l’héritage ‘simple’, l’annotation @Override indique que la méthode est surchargée. Si une des méthodes abstraites n’avait pas été implémentée, cette classe aurait dû être également abstraite. Java - Introcution & Rappels

Les interfaces Les interfaces peuvent être vues comme des classes complétement abstraites : où aucune méthode n’est implémentée. La différence étant qu'il est possible d'implémenter plusieurs interfaces. Java - Introcution & Rappels

Les interfaces public interface Worker { public void work(); } public interface Vacationer { void haveANap(); } Les classes implémentant une interface, doivent surcharger toutes les méthodes de l’interface public class Student implements Vacationer { @Override public void haveANap() { System.err.println("I sleep\n"); } Java - Introcution & Rappels public class Employee implements Worker { @Override public void work() { System.err.println("I work\n"); }

Les interfaces public class Teacher implements Worker, Vacationer { @Override public void haveANap() { System.err.println("I sleep\n"); } public void work() { System.err.println("I teach\n"); } } Un classe peut implémenter plusieurs interfaces. Les méthodes de chacune des interfaces doivent être implémentées. Java - Introcution & Rappels

Les interfaces public class InterfaceExample { public static void main(String[] args) { Worker employee = new Employee(); Vacationer student = new Student(); Worker teacher = new Teacher(); Vacationer teacher2 = new Teacher(); System.err.println("** Employee"); employee.work(); System.err.println("** Student"); student.haveANap(); System.err.println("** Teacher(worker)"); teacher.work(); System.err.println("** Teacher(vacationer)"); teacher2.haveANap(); } ** Employee I work ** Student I sleep ** Teacher(worker) I teach ** Teacher(vacationer) Java - Introcution & Rappels Il apparaît clairement qu'une classe implémentant deux interfaces (Teacher) peut être 'allouée’ sur ses deux interfaces (Worker & Vactioner). Nous pouvons noter, que, dès lors que nous utilisons une interface comme type alloué (Worker teacher = new Teacher() ) l'objet alloué aura ses fonctionnalités (les méthodes) 'restreintes' aux méthodes de l'interface.

Les interfaces Une interface peut être implémentée 'en ligne' : dans l'exemple suivant l'objet developer est instancié en implémentant sur place les méthodes de interface Worker. Worker developer = new Worker() { public void work() { System.err.println("A dev work"); } }; Java - Introcution & Rappels Notons qu’il est possible d’implémenter en ligne des méthodes abstraites

Agenda Le langage Java Les objets Java Héritage, classe abstraire & interface API Java – le kit de survie Java - Introcution & Rappels

Package java.lang System Ecriture / Lecture : System.err, System.out, System.in Les 'temps' machines : System.currentTimeMillis() & System.nanoTime() Les propriétés systèmes : System.getProperties() Accéder au variables d'environnement : System.getEnv("HOME"), System.getenv() Java - Introcution & Rappels

Package java.lang String Transformer un nombre en chaîne de caractère: String.valueOf(nombre) Supprimer les espaces en début et fin de chaîne: mystring.trim() Changer la casse : mystring.toLowerCase(), mystring.toUpperCase() Découper une chaîne : mystring.split(expression regulière) Extraire une sous chaîne : mystring.substring(index de début, index de fin) Remplacer un morceau de chaîne : mystring.replaceAll(regexp, nouvelle chaîne), mystring.replaceFirst(regexp, nouvelle chaîne) Savoir si un chaîne est vide : mystring.isEmpty() Taille d'une chaîne : mystring.length() Java - Introcution & Rappels

Package java.lang Manipulation des nombres Les objets Short, Integer, Long, Float, Double encapsulent les types primitifs short, int, long, float, double. Ils offrent des fonctionnalités de haut niveau et de transtypage. Récupérer la valeur sous forme de type primitif : shortValue(), intValue(), longValue(),floatValue(), doubleValue() la construction à partir d'une chaîne de caractère : valueOf(mystring) Manipulation des bits Java - Introcution & Rappels

Package java.util Les collections Les collections permettent la manipulation de tableaux, de listes, de queues, de tableaux associatifs et de table de hachage. Elles offrent un ensemble d'interfaces pour manipuler des données tel que les tris, les ajouts ou suppressions d'éléments. Nous pouvons distinguer deux grands types de collections Celles que nous pouvons grossièrement appeler des listes ArrayList LinkedList ArrayDeque Les tableaux associatifs et les tables de hachage HashMap HashSet Java - Introcution & Rappels

Package java.util Les collections Les classes d'une collection disposent de la même interface : public boolean add(Object element) : insert un élément public boolean addAll(collection c) : ajoute les éléments d'une collection public boolean remove(Object element) : efface un élément public boolean removeAll(Collection c) : efface tous éléments égaux à ceux de c public boolean retainAll(Collection c) : efface tous éléments sauf ceux égaux à ceux de c public int size() : donne la taille de la collection public void clear() : efface la collection public boolean contains(object element) : existence d'un élément dans la collection public boolean containsAll(Collection c) : existence de tous les éléments de c dans la collection public Iterator iterator() : obtenir un itérateur sur la collection public Object[] toArray() : convertir une collection en tableau public boolean isEmpty() : vérifier si la collection est vide public boolean equals(Object element) : vérifier l'égalité avec une autre collection Java - Introcution & Rappels

Package java.util Les collections package edu.iut; import java.util.ArrayList; import java.util.LinkedList; public class CollectionExample { public static void main(String[] args) { ArrayList<String> stringTable = new ArrayList<>(); LinkedList<String> stringList = new LinkedList<>(); stringTable.add(new String("New York")); stringTable.add(new String("Chicago")); stringTable.add(new String("Paris")); stringList.add(new String("Paris")); stringList.add(new String("Marseille")); System.err.println("Table:"+stringTable); System.err.println("List:"+stringList); System.err.println("Contains:"+ stringTable.contains(new String("Paris"))); stringList.removeAll(stringTable); } } Table:[New York, Chicago, Paris] List:[Paris, Marseille] Contains:true List:[Marseille] Java - Introcution & Rappels

Package javax.swing Les composants JButton : un bouton JColorChooser : boîte de dialogue pour choisir une couleur JCheckBox : afficher une boîte d'état : vrai ou faux JRadioButton : boîte d'état fonctionnant en groupe JLabel : placer et afficher un texte JList : afficher une liste d'items textuels. JComboBox : menu à choix multiples. JTextField : champs de saisie JPasswordField : champs de saisie pour une mot de passe JTextArea : zone de texte multi-lignes ImageIcon : affichage d'icones JScrollBar : scrolling de composant JOptionPane : boîte de dialogue configurable. JFileChooser : boîte de dialogue pour choisir un fichier JSlider : un slider sur un intervalle borné JSpinner : champs texte pouvant être modifier avec un sélecteur haut/bas Java - Introcution & Rappels

Package javax.swing Les composants public class SwingExample { JFrame mainFrame; JLabel textLabel; JButton fileButton; protected void setupGUI() { mainFrame = new JFrame("Component test"); mainFrame.setSize(400,50); mainFrame.setLayout(new FlowLayout()); textLabel = new JLabel("My Label"); mainFrame.add(textLabel); fileButton = new JButton("File"); fileButton.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { (new JFileChooser()).showOpenDialog(null); } }); mainFrame.add(fileButton); mainFrame.setVisible(true); } public static void main(String[] args) { SwingUtilities.invokeLater(new Runnable() { public void run() { SwingExample swingExample = new SwingExample(); swingExample.setupGUI(); } }); } } Java - Introcution & Rappels

Package javax.swing Les listeners Les listeners sont des objets permettant la gestion de l'interaction avec des composant. Par exemple, il est possible d'ajouter un listeners ActionListener à un JButton : fileButton.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { (new JFileChooser()).showOpenDialog(null); } }); Java - Introcution & Rappels Ici, après un click sur le bouton (fileButton), la méthode actionPerformed sera appelée. Dans notre exemple cela a pour effet d'ouvrir un navigateur de fichier.

Package javax.swing Les listeners Java - Introcution & Rappels

Package javax.swing Layouts Les Layouts permettent de positionner les composants dans une fenêtre (JFrame) ou un panel (JPanel). Java - Introcution & Rappels

Package javax.swing Layouts - FlowLayout Les composants sont centrés. public class FlowLayoutExample extends JFrame { public FlowLayoutExample(String title) { super(title); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setSize(new Dimension(200,200)); this.setPreferredSize(new Dimension(200,200)); JPanel pane = (JPanel) this.getContentPane(); pane.setLayout(new FlowLayout()); pane.add(new JButton("1")); pane.add(new JButton("2")); pane.add(new JButton("3")); pane.add(new JButton("4")); pane.add(new JButton("5")); }} Java - Introcution & Rappels

Package javax.swing Layouts - GridLayout Les composants sont placés sur une grille. public class GridLayoutExample extends JFrame { public GridLayoutExample(String title) { super(title); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setSize(new Dimension(200,200)); this.setPreferredSize(new Dimension(200,200)); JPanel pane = (JPanel) this.getContentPane(); pane.setLayout(new GridLayout(3,2)); pane.add(new JButton("1")); pane.add(new JButton("2")); pane.add(new JButton("3")); pane.add(new JButton("4")); pane.add(new JButton("5")); } } Java - Introcution & Rappels

Package javax.swing Layouts - GridBagLayout Les composants sont placés sur une grille paramétrable (fusion de ligne et/ou de colonnes). public class GridBagLayoutExample extends JFrame { public GridBagLayoutExample(String title) { super(title); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setSize(new Dimension(200,200)); this.setPreferredSize(new Dimension(200,200)); JPanel pane = (JPanel) this.getContentPane(); pane.setLayout(new GridBagLayout()); GridBagConstraints c = new GridBagConstraints(); c.gridx=0;c.gridy=0; c.gridwidth=GridBagConstraints.REMAINDER; c.gridheight=1;c.fill=GridBagConstraints.HORIZONTAL; pane.add(new JButton("1"),c); c.gridy=1;c.gridwidth=2 c.gridheight=1; c.fill = GridBagConstraints.HORIZONTAL; pane.add(new JButton("2"),c); c.gridx=2;c.gridy=1;c.gridwidth=GridBagConstraints.REMAINDER; c.gridheight=1; pane.add(new JButton("3"),c); c.gridx=0;c.gridy=2;c.gridwidth=1;c.gridheight=1; pane.add(new JButton("4"),c); c.gridx=1;c.gridy=2;c.gridwidth=1;c.gridheight=1; pane.add(new JButton("5"),c); c.gridx=2;c.gridy=2;c.gridwidth=1;c.gridheight=1; pane.add(new JButton("6"),c); } } Java - Introcution & Rappels

Package javax.swing Layouts - BorderLayout Les composants sont placés autour d'un composant central. public class BorderLayoutExample extends JFrame { public BorderLayoutExample(String title) { super(title); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setSize(new Dimension(200,200)); this.setPreferredSize(new Dimension(200,200)); JPanel pane = (JPanel) this.getContentPane(); pane.setLayout(new BorderLayout()); pane.add(new JButton("1"), BorderLayout.PAGE_START); pane.add(new JButton("2"), BorderLayout.CENTER); pane.add(new JButton("3"), BorderLayout.LINE_START); pane.add(new JButton("4"), BorderLayout.PAGE_END); pane.add(new JButton("5"), BorderLayout.LINE_END); } } Java - Introcution & Rappels

Package javax.swing Layouts - BoxLayout Les composants sont placés verticalement ou horizontalement. public class BoxLayoutExample extends JFrame { public BoxLayoutExample(String title) { super(title); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setSize(new Dimension(200,200)); this.setPreferredSize(new Dimension(200,200)); JPanel pane = (JPanel) this.getContentPane(); pane.setLayout(new BoxLayout(pane, BoxLayout.Y_AXIS)); pane.add(new JButton("1")); pane.add(new JButton("2")); pane.add(new JButton("3")); pane.add(new JButton("4")); pane.add(new JButton("5")); } } Java - Introcution & Rappels

Package javax.swing Layouts -BoxLayout Les composants sont placés par couches. public class CardLayoutExample extends JFrame { CardLayout layout; JPanel content; public CardLayoutExample(String title) { super(title); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setSize(new Dimension(200,200)); layout = new CardLayout(); content = new JPanel(); JPanel pane = (JPanel) this.getContentPane(); pane.setLayout(new BoxLayout(pane, BoxLayout.Y_AXIS)); JPanel card1 = new JPanel(); card1.setBackground(Color.blue); JPanel card2 = new JPanel(); card2.setBackground(Color.red); JPanel card3 = new JPanel(); card3.setBackground(Color.green); JButton button = new JButton("Next"); button.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent event){ layout.next(content); } }); content.setLayout(layout); content.add(card1, "1"); content.add(card2, "2"); content.add(card3, "3"); pane.add(button); pane.add(content); } } Java - Introcution & Rappels

Package javax.swing JFrame, JDialog, JPanel JFrame permet la création d'une fenêtre. C'est le composant de base lorsque que l'on créé un applique avec un IHM. JDialog permet la création d'une boîte de dialogue. JPanel est un composant graphique permettant l'ajout de composants ou de graphiques. public class JFrameAndPanelExample extends JPanel{ public static void main(String[] a) { JFrame frame = new JFrame(); frame.setSize(200, 200); frame.add(new JFrameAndPanelExample()); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } public void paint(Graphics g) { g.setColor(Color.BLUE); g.fillRect (5, 5, 150, 175); g.setColor(Color.RED); g.fillOval(50, 50, 40, 30); } } Java - Introcution & Rappels