Quels sont les non modificateurs d'accès en Java ?
Modificateurs Java sans accès
Nous avons 7 modificateurs sans accès en Java . Le nom de ces modificateurs de non-accès sont donnés ci-dessous,
- natif
- synchronisé
- transitoire
- volatil
- finale
- abstrait
- statique
Nous apprendrons tous les modificateurs sans accès un par un...
1) natif
- "native" est un mot-clé introduit en Java.
- "native" est le modificateur applicable uniquement aux méthodes, mais il ne s'applique pas aux variables et aux classes.
- Les méthodes natives sont implémentées dans d'autres langages comme C, C++, etc.
- Le but de la méthode native est d'améliorer les performances du système.
- Nous savons que la mise en œuvre des méthodes natives est disponible dans d'autres langages, nous n'avons donc pas à nous soucier de la mise en œuvre.
Exemple :Nous verrons comment écrire des méthodes natives
class Native { static { // Load Native Library System.loadLibrary("native library"); } // Native Method Declaration public native void display(); } class Main { public static void main(String[] args) { Native native = new Native(); native.display(); } }
2) synchronisé
- "synchronisé" est le mot-clé applicable pour les méthodes et le bloc.
- Le mot-clé "synchronized" n'est pas applicable pour les classes et les variables.
- Le mot clé « synchronized » est utile pour le multithreading si nous déclarons une méthode comme synchronisée, alors à la fois, un seul thread est autorisé à opérer sur un objet.
Exemple :
class SynchronizedDisplay { public synchronized void display(String msg) { for (int i = 0; i < 2; ++i) { System.out.println(msg); try { Thread.sleep(500); } catch (Exception ex) { System.out.println(ex.getMessage()); } } } } class MyThread extends Thread { SynchronizedDisplay sd; MyThread(SynchronizedDisplay sd) { this.sd = sd; } public void run() { sd.display("hi"); } } class SynchronizedClass { public static void main(String[] args) { SynchronizedDisplay sd1 = new SynchronizedDisplay(); MyThread mt1 = new MyThread(sd1); mt1.start(); MyThread mt2 = new MyThread(sd1); mt2.start(); } }
Sortie
E:\Programs>javac SynchronizedClass.java E:\Programs>java SynchronizedClass hi hi hi hiPublicité
3) transitoire
- "transient" est un mot-clé introduit en Java.
- "transient" est le modificateur applicable uniquement pour les variables.
- "transient" est le modificateur non applicable pour les classes et les méthodes.
- "transient" est utile pour la sérialisation car au moment de la sérialisation si nous ne voulons pas enregistrer la valeur de la variable pour répondre à certaines contraintes de sécurité.
Exemple :
Supposons que nous ayons une classe nommée Transient dans cette classe, nous avons deux-trois membres de données fname (prénom), lname (nom) et adresse, de sorte que le membre d'adresse déclaré comme transitoire de sorte que ses valeurs ne seront pas sérialisées (c'est-à-dire au cas où de désérialisation d'un objet, nous obtiendrons la valeur par défaut de la variable d'adresse et sa valeur définie sera effacée).
import java.io.*; class Serialization implements Serializable { public String fname, lname; transient String address; public Serialization(String fname, String lname, String address) { this.fname = fname; this.lname = lname; this.address = address; } } public class Deserialization { public static void main(String[] args) { Serialization serialize = new Serialization("Ronit", "Jain", "Mayur vihar 1"); try { FileOutputStream fos = new FileOutputStream("E:\\Programs\\myjava.txt"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(serialize); oos.close(); fos.close(); } catch (IOException ex) { System.out.println(ex.getMessage()); } serialize = null; try { FileInputStream fis = new FileInputStream("E:\\Programs\\myjava.txt"); ObjectInputStream ois = new ObjectInputStream(fis); serialize = (Serialization) ois.readObject(); ois.close(); fis.close(); System.out.println("His full name and address is :" + serialize.fname + " " + serialize.lname + " " + serialize.address); } catch (IOException ex) { System.out.println(ex.getMessage()); } catch (ClassNotFoundException ex) { System.out.println(ex.getMessage()); } } }
Sortie
E:\Programs>javac Deserialization.java E:\Programs>java Deserialization His full name and address is :Ronit Jain null
4) volatile
- "volatile" est un mot clé introduit en Java.
- "volatile" est le modificateur applicable uniquement pour les variables mais pas pour les méthodes et les classes.
- Si la valeur de la variable continue de changer ce type de variable, nous devons déclarer avec le modificateur volatile.
- Toute opération intermédiaire sera effectuée dans la copie locale au lieu de la copie finale.
Exemple :
class VolatileVariable { // volatile keyword here makes sure that // the changes made in one class are // immediately reflect in other class static volatile int volatile_var = 10; } class Main { public static void main(String[] args) { System.out.println("The previous value of volatile variable in one class is " + VolatileVariable.volatile_var); VolatileVariable.volatile_var++; System.out.println("The value changes made to the volatile variable in other class is" + VolatileVariable.volatile_var); } }
Sortie
E:\Programs>javac Main.java E:\Programs>java Main The previous value of volatile variable in one class is 10 The value changes made to the volatile variable in other class is 11Publicité
5) finale
- "final" est un mot-clé introduit en Java.
- "final" est le modificateur applicable aux méthodes, classes et variables.
- Nous ne pouvons pas remplacer la classe enfant.
Exemple :déclarer la classe comme "final" et la variable comme final et la méthode comme final
final class Final { final String str = "we are accessible final variable"; final void printMethod() { System.out.println("we are in final method"); } public static void main(String[] args) { Final f = new Final(); System.out.println("final variable :" + f.str); f.printMethod(); } }
Sortie
E:\Programs>javac Final.java E:\Programs>java Final final variable :we are accessible final variable we are in final method.
6) résumé
- "abstract" est un mot-clé introduit en Java.
- "abstract" est le modificateur applicable aux classes et aux méthodes.
- Si une classe est abstraite, nous devons implémenter toutes les méthodes de la classe abstraite dans notre classe.
Exemple :
abstract class AbstractClass { abstract void printMethod(); } public class AbstractImplementation { public static void main(String[] args) { AbstractClass ac = new AbstractClass() { void printMethod() { System.out.println("Hi, We are in abstract class"); } }; ac.printMethod(); } }
Sortie
E:\Programs>javac AbstractImplementation.java E:\Programs>java AbstractImplementation Hi, We are in abstract class
7) statique
- "static" est un mot clé introduit en Java.
- Le membre "statique" crée une copie de l'ensemble du programme et la partage avec d'autres objets du même programme.
- "static" ne peut accéder qu'aux méthodes statiques.
Exemple :
class StaticClass { public static int div(int a, int b) { return a / b; } } class Main { public static void main(String[] args) { int p = 20, q = 10; int div = StaticClass.div(p, q); System.out.println("The div of p , q is" + div); } }
Sortie
E:\Programs>javac Main.java E:\Programs>java Main The div of p , q is2