Java >> Tutoriel Java >  >> Java

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,

  1. natif
  2. synchronisé
  3. transitoire
  4. volatil
  5. finale
  6. abstrait
  7. 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
hi
Publicité

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 11
Publicité

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

Balise Java