Visibilité et accessibilité

1. Visibilité et accessibilité hadj Batatia

2. introduction • Une application JAVA est un ensemble de classes • Contrairement à d'autres langages orientés objet (tel que C++) dans Java tout est contenu dans des classes • données, fonctions, constantes… • La classe java joue deux rôles • une structure de données • la classe est le seul moyen de créer des structures de données (non primitives) • un module • la classe est l'élément de base de l'application Java • Les classes sont regroupées dans des paquetages (packages) • un "paquet par défaut" (default package) regroupe toutes les classes qui n'appartiennent à aucun package nominativement H. Batatia

3. structure d'une classe [package paquet]; [{import paquet.classe;}] [visibilité] [modificateur] class Nom [héritage] { déclarations; constructeurs; méthodes; classes; } H. Batatia

4. package • Un ensemble de classes peuvent être regroupées dans un paquet (package) • le paquet est une manière logique de regrouper des classes • un paquet a un nom • qui peut être un identificateur simple • exemples : es, scolarite • pour distinguer les paquets de différents éditeurs le nom est souvent précédé d'un nom de domaine inversé • exemples : com.jackarta.struts, fr.ipst.scolarite H. Batatia

5. déclaration de package • Pour qu'une classe appartienne à un paquet, il faut mettre en première ligne l'instruction package nom_paquet; • Cela ne suffit pas, il faut aussi • créer un répertoire (du nom du paquet) • si le paquet a plusieurs noms séparées par des points • on crée une suite de sous répertoires (un pour chaque partie du nom) • placer le fichier de la classe (nom.class) dans le répertoire H. Batatia

6. Exemple • Nous voulons créer un paquet appelé fr.ipst.paq dans lequel on met A.class et B.class • On crée A.java et B.java • On compile pour créer A.class, B.class • On crée les répertoires (ou dossiers) fr\ipst\paq • On copie A.class et B.class dans le répertoire fr\ipst\paq H. Batatia

7. javac A.java javac B.java A.class B.class la classe fr.ipst.paq.A le paquetfr.ipst.paq la classe fr.ipst.paq.B package fr.ipst.paq; public class B { public static void impr() { System.out.println( "Je suis la classe B" ); } } package fr.ipst.paq; public class A { public static void affiche() { System.out.println( "Je suis la classe A" ); } } Illustration H. Batatia

8. T T public class T { public static void main(String[] s) { A.affiche(); B.impr(); } } public class T { public static void main(String[] s) { fr.ipst.paq.A.affiche();fr.ipst.paq.B.impr(); } } javac T.java T.class Illustration H. Batatia

9. Directives d'importation • Normalement, quand on utilise la classe "nomclasse" qui appartient au paquet "nompaquet", il faut la référencier à chaque fois par nompaquet.nomclasse • exemples es.Clavier, java.util.Radom, fr.ipst.paq.A • Pour éviter d'écrire à chaque fois nompaquet.nomclasse, et à la place écrire seulement "nomclasse", on ajoute l'instruction import nompaquet.nomclasse; • exemples import es.Clavier;import fr.ipst.paq.A; • Si on utilise plusieurs classes d'un paquet ("nompaquet"), on peut soit avoir une instruction import par classe, soit une seule instruction import nompaquet.*; exempleimport es.*;import fr.ipst.paq.*;import java.util.*; H. Batatia

10. Exemple • Pour utiliser les méthodes affiche () de A et impr() de B dans T • on peut soit directement nommer les classes précédées de leurs paquets • soit utiliser l'instruction import pour alléger l'écritureimport fr.ipst.paq.A;import fr.ipst.paq.B; • On peut aussi écrire : • import fr.ipst.paq.*; //* veut dire toutes les classes H. Batatia

11. solution 1 public class T { public static void main(String[] s) { fr.ipst.paq.A.affiche();fr.ipst.paq.B.impr(); } } javac T.java solution 2 import fr.ipst.paq.*; public class T { public static void main(String[] s) { A.affiche(); B.impr(); } } T.class Illustration H. Batatia

12. visibilité • une classe peut être • public • accessible à toute autre classe • protected • visibilité réservée aux classes internes • rend la classe visible dans le package, aux sous-classes, et dans les packages des sous-classes • par défaut • accessible aux classes du même package H. Batatia

13. solution 1 public class T { public static void main(String[] s) { fr.ipst.paq.A.affiche();fr.ipst.paq.B.impr(); } } package fr.ipst.paq; public class B { public static void impr() { System.out.println( "Je suis la classe B" ); A.affiche(); } } package fr.ipst.paq; class A { public static void affiche() { System.out.println( "Je suis la classe A" ); } } Illustration autorisé interdit autorisé H. Batatia

14. Autres caractéristiques de classe • Les autres caractéristiques de classes sont les modificateurs et l'héritage • Les modificateurs comme (abstract/final) permettent de définir la manière d'utiliser la classe • L'héritage est un des concepts principaux de la programmation objet H. Batatia

15. java.lang java.util java.io java.net java.awt java.applet Quelques paquets java H. Batatia

16. Boolean Byte Character Class Compiler Double Float Integer Long Math Number Object Package Process Runtime SecurityManager Short String StringBuffer System Thread Throwable Exception Error java.lang H. Batatia

17. ArrayList Arrays BitSet Calendar Collections Currency Date Dictionary HashMap HashSet Hashtable Observable Properties Random Stack Timer TreeMap TreeSet Vector java.util H. Batatia

18. BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter DataInputStream DataOutputStream File FileReader FileWriter InputStream InputStreamReader OutputStream OutputStreamWriter PrintStream PrintWriter Reader Writer java.io H. Batatia

19. Authenticator ContentHandler DatagramPacket DatagramSocket DatagramSocketImpl HttpURLConnection InetAddress Socket SocketAddress URL URLClassLoader URLConnection URLDecoder URLEncoder URLStreamHandler java.net H. Batatia

20. BorderLayout Button Canvas CardLayout Checkbox Choice Color Component Container Cursor Dialog Dimension Event FlowLayout Font Frame Graphics Graphics2D GridLayout Image Label List Menu Panel Point Polygon PopupMenu Rectangle Scrollbar TextArea TextField Window java.awt mercredi 23/3 H. Batatia

21. Variables dans les classes • Des variables peuvent être déclarées dans la classe • Ces variables sont un des fondements de la programmation par objet (l'encapsulation) • Leurs déclarations se fait sous la forme [visibilité] [modificateur] type nom [= valeur]; H. Batatia

22. visibilité des variables • une variable déclarée dans une classe est accessible dans toutes les méthodes de cette classe • Sa visibilité dans les méthodes d'autres classes est définie par son attribut de visibilité • public : accessible de n'importe où • protected : accessible des classes du même package, des sous-classes et des classes appartenant aux mêmes packages que les sous-classes • private : accessible uniquement dans la même classe • par défaut : accessible dans le même package H. Batatia

23. package fr.ipst.paq; import fr.ipst.paq.B; class A { public static int m; public static void affiche() { System.out.println( "Je suis la classe A" ); B bar = new B(); bar.n = 200;//correct } } package fr.ipst.paq; public class B { public int n; public static void impr() { System.out.println( "Je suis la classe B" ); B var = new B(); var.n = 10; A.m = 20;//correct } } Illustration import fr.ipst.paq.B; public class T { public static void main(String[] s) { fr.ipst.paq.A.affiche(); //erreur fr.ipst.paq.A.m = 20; //erreur fr.ipst.paq.B.impr(); B tar = new B(); tar.n = 300;//correct } } H. Batatia

24. package fr.ipst.paq; import fr.ipst.paq.B; class A { static int m; public static void affiche() { System.out.println( "Je suis la classe A" ); B bar = new B(); bar.n = 200; //erreur } } package fr.ipst.paq; public class B { private int n; public static void impr() { System.out.println( "Je suis la classe B" ); B var = new B(); var.n = 10; A.m = 20;//correct } } Illustration import fr.ipst.paq.B; public class T { public static void main(String[] s) { fr.ipst.paq.A.affiche(); //erreur fr.ipst.paq.A.m = 20; //erreur fr.ipst.paq.B.impr(); B tar = new B(); tar.n = 300;//erreur } } H. Batatia

25. package fr.ipst.paq; import fr.ipst.paq.B; class A { static int m; public static void affiche() { System.out.println( "Je suis la classe A" ); B bar = new B(); bar.n = 200; } } package fr.ipst.paq; public class B { int n; public static void impr() { System.out.println( "Je suis la classe B" ); B var = new B(); var.n = 10; A.m = 20;//correct } } Illustration import fr.ipst.paq.B; public class T { public static void main(String[] s) { fr.ipst.paq.A.affiche(); //erreur fr.ipst.paq.A.m = 20; //erreur fr.ipst.paq.B.impr(); B tar = new B(); tar.n = 300; } } H. Batatia

26. modificateurs de variable • L'attribut modificateur d'une variable définit la manière de l'utiliser dans le code • static : la variable appartient à la classe (autrement la variable appartient à l'objet instance de la classe) • final : ne peut pas être modifiée • transcient : non persistante • volatile : ne doit pas être optimisée H. Batatia

27. méthodes • Une classe peut disposer de plusieurs méthodes • La déclaration d'une méthode se fait sous la forme [visibilité] [nature] type nom (paramètres) H. Batatia

28. visibilité nature type nom type param Signature d'une méthode • La signature est le moyen de différencier les méthodes • Elle se compose de • visibilité • public, private… • nature • static, final, abstract, native, … • type de la valeur retournée par la méthode • un des 8 types primitifs (int, double, …) ou le nom d'une classe • le nom de la méthode • un identificateur • la liste des types de paramètres • les types peuvent être primitifs ou objets • Exemple • public static void main ( String [] a) H. Batatia

29. visibilité d'une méthode • De la même manière que pour les variables, une méthode peut être • public : accessible de n'importe où • protected : accessible des classes du même package, des sous-classes et des classes appartenant aux mêmes packages que les sous-classes • private : accessible uniquement dans la même classe • par défaut : accessible dans le même package H. Batatia

30. package fr.ipst.paq; import fr.ipst.paq.B; class A { public static void affiche() { System.out.println( "Je suis la classe A" ); B bar = new B(); int x = bar.carre();; } } package fr.ipst.paq; public class B { private int n = 10; public static void impr() { B var = new B(); System.out.println( "carré=" + var.carre()); ); } public int carre (){ return this.n*this.n; } } Illustration import fr.ipst.paq.B; public class T { public static void main(String[] s) {fr.ipst.paq.B.impr(); B tar = new B(); int x = tar.carre(); } } H. Batatia

31. package fr.ipst.paq; import fr.ipst.paq.B; class A { public static void affiche() { System.out.println( "Je suis la classe A" ); B bar = new B(); int x = bar.carre();//erreur } } package fr.ipst.paq; public class B { private int n = 10; public static void impr() { B var = new B(); System.out.println( "carré=" + var.carre()); ); } private float carre (){ return this.n*this.n; } } Illustration import fr.ipst.paq.B; public class T { public static void main(String[] s) { fr.ipst.paq.B.impr(); B tar = new B(); int x = tar.carre();//erreur } } H. Batatia

32. package fr.ipst.paq; import fr.ipst.paq.B; class A { public static void affiche() { System.out.println( "Je suis la classe A" ); B bar = new B(); int x = bar.carre(); } } package fr.ipst.paq; public class B { private int n = 10; public static void impr() { B var = new B(); System.out.println( "carré=" + var.carre()); ); } float carre (){ return this.n*this.n; } } Illustration import fr.ipst.paq.B; public class T { public static void main(String[] s) { fr.ipst.paq.B.impr(); B tar = new B(); int x = tar.carre();//erreur } } H. Batatia

33. nature de la méthode • Une méthode peut être • static : la méthode appartient à la classe et non aux instances • final : ne peut pas être redéfinie dans les classes dérivées • native : écrite dans un langage autre que JAVA • abstract : une signature, implantation dans les classes dérivées H. Batatia

34. type de méthode • définit le type de la valeur retournée par la méthode (primitif ou objet) • si la méthode est une procédure (ne retourne aucune valeur), le type est void H. Batatia

35. Constructeurs • Les classes peuvent disposer de méthodes spéciales appelées constructeurs. • Un constructeur est une méthode dont le nom est le même que le nom de la classe • Il peut prendre un nombre quelconque de paramètres • Il sert généralement à initialiser les variables de l'objet (c'est-à-dire les variables qui ne sont pas précédées de static) H. Batatia

36. classes et fichiers • Dans Java, une classe Nom est enregistré dans un fichier Nom.java • Cette règle est obligatoire si la classe est public • Autrement, plusieurs classes peuvent être enregistrées dans un même fichier .java H. Batatia

37. Structure en blocs • Un programme java est quasi-totalement inclus dans des blocs • chaque bloc est délimité par des { } • les blocs peuvent être imbriqués H. Batatia

38. portée d'une variable • une variable peut être déclarée dans n'importe quel bloc • la portée d'une variable commence à sa déclaration et finit à la fin du bloc où elle a été déclarée • la zone de portée inclus les blocs imbriqués dans le bloc de déclaration H. Batatia

39. schéma class X { int g = 0; { int h; } int i=0; { int j=0; { int k=0; } } { int l=0; } } H. Batatia

40. visibilité • La portée d'une variable n'implique pas son accessibilité (ou sa visibilité) • En effet, une variable peut être masquée par une nouvelle déclaration • la variable originale n'est alors pas visible H. Batatia

41. boolean i double i char i schéma • public class Visibilite { • static char i = 'x'; • public static void main (String[] args) { • System.out.println(i); • boolean i = false; • System.out.println(i); • test(); • System.out.println(i); • System.out.println(Visibilite.i); • } • public static void test() { • System.out.println(i); • double i = 5.0; • System.out.println(i); • System.out.println(Visibilite.i); • } • } visibilité portée H. Batatia

42. Masquage d'une variable • Une variable ne peut être masquée que • par une variable déclarée dans une méthode différente H. Batatia

43. Appel de méthode • Soit m() une méthode déclarée dans la classe A • L'appel à la méthode m() peut se faire de la manière suivante : • SI m() n'est pas static • soit obj une variable de type A [A obj = new A();] • l'appel peut se faire par • obj.m (…); • m (..); //si l'appel se fait depuis le même objet • this.m (…); //si l'appel se fait depuis le même objet • Si m() est static [static … m(…)] • A.m (…); • m (…); //si l'appel se fait depuis la même classe A • soit obj une variable de type A [A obj = new A();] • l'appel peut aussi se faire par • obj.m (…); • m (..); //si l'appel se fait depuis le même objet • this.m (…); //si l'appel se fait depuis le même objet H. Batatia

44. Passage de paramètres • Les paramètres de type primitif sont passés par valeur • Les paramètres de type objet sont passés par référence H. Batatia

45. class Voiture { private static String état; private static float avg, avd, arg, ard; public static void modifPressionAvg(float diff) { avg += diff; } static void setEtat(String s) { état = s; } } class Test { public static void main (String [] s) { float f; f = 0.5f; String c; c = "Normal"; Voiture.modifPressionAvg(f); Voiture.setEtat(c); } } c f état avg avd arg ard null 0.0 null 0.0 0.0 0.0 0.0 diff diff 0.5 0.0 Exemple : passage de paramètres @ 0.5 @ 0.5 Normal …. @ s H. Batatia

46. Exemple • On se propose d'écrire une classe qui décrit un segment en utilisant les coordonnées de ses deux sommets. Cette classe contiendra une méthode qui calcule la longueur du segment. • On écrira aussi une classe Test avec main() qui lit les valeurs des coordonnées, calcule et imprime la longueur du segment. H. Batatia

47. Sommet class Sommet { private double x, y; public Sommet( double x, double y){ this.x = x; this.y = y; } public double getX(){return this.x;} public double getY(){return this.y;} public void setX(double x){this.x = x;} public void setY(double y){this.y = y;} } H. Batatia

48. Segment class Segment { private Sommet s1, s2; public Segment(Sommet s1, Sommet s2){ this.s1 = s1; this.s2 = s2; } public double longueur () { double a = Math.pow(this.s2.getX() – this.s1.getX(), 2.0); double b = Math.pow(this.s2.getY() – this.s1.getY(), 2.0); double m = Math.sqrt(a+ b); return m; } } H. Batatia

49. Classe Tests import es.*; class TestSegment { public static void main (String [] argv) { Ecran.ecrire("Donner l'abscisse (x) du 1er sommet : "); double x = Clavier.lireDouble(); Ecran.ecrire("Donner l'ordonnée (y) du 1er sommet : "); double y = Clavier.lireDouble(); Sommet p1 = new Sommet(x, y); Ecran.ecrire("Donner l'abscisse (x) du 2eme sommet : "); x = Clavier.lireDouble(); Ecran.ecrire("Donner l'ordonnée (y) du 2eme sommet : "); y = Clavier.lireDouble(); Sommet p2 = new Sommet(x, y); Segment s = new Segment(p1, p2); double d = s.longueur(); Ecran.ecrireLigne("Longueur = " + d); } } H. Batatia

50. Exercices • Ecrire une classe Equation qui contient • trois réels (public double) • un constructeur • une méthode résoudre (public void) qui résout l'équation (calcule les racines sans imprimer les solutions) • Ecrire une classe Parité qui contient • un entier (int) • une méthode estPair (public boolean) qui retourne true seulement si le nombre est pair • Les deux classes doivent être dans le paquet fr.ipst.maths • Ecrire une classe Test_maths dont le main • génère aléatoirement trois réels, crée une équation, résout l'équation puis imprime les résultats • génère un nombre entier aléatoire, crée un objet Parité, imprime la parité du nombre H. Batatia