Modificateurs de non-accès en Java

Les modificateurs de non-accès sont les mots-clés introduits dans Java 7 pour informer la JVM du comportement, des méthodes ou des variables d'une classe, etc. Cela permet d'introduire des fonctionnalités supplémentaires, telles que le mot-clé final utilisé pour indiquer que la variable ne peut pas être initialisée deux fois. Il y a un total de 7 modificateurs de non-accès introduits.

1. Statique
2. Finale
3. Résumé
4. Synchronisé
5. transitoire
6. strictfp
7. natif

Types de modificateurs de non-accès en Java

Vous trouverez ci-dessous les types de modificateurs de non-accès en Java :

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

1. Modificateurs finaux de non-accès

Ce modificateur peut être appliqué avec :

1. Classe
2. Méthode
3. Variable d'instance
4. Variable locale
5. Arguments de méthode

• Final Class : Le mot-clé final est utilisé avec une classe lorsque nous voulons restreindre son héritage par toute autre classe. Par exemple, si nous avons une classe finale Honda, alors toute tentative d'étendre cette classe peut entraîner une erreur de compilation.

Code :

final class Honda{
public void myFun1(){
System.out.println("Honda Class");
}
}
class Bike extends Honda{
public void myFun1(){
System.out.println("Bike Class");
}
}

Sortie :

• Méthode Final : Le mot-clé Final est utilisé pour indiquer à Java Runtime Environment que cette méthode n'est pas destinée à être remplacée dans aucune de ses sous-classes.

Code :

class Honda{
public final void myFun1(){
System.out.println("Honda Class");
}
}
class Bike extends Honda{
public void myFun1(){
System.out.println("Bike Class");
}
}

Sortie :

• Variable finale : Le mot-clé final est utilisé avec une variable pour restreindre toute modification de la valeur de la variable, indiquant ainsi à JVM de la traiter comme une constante. Cela signifie que les variables finales ne peuvent être initialisées qu'une seule fois.

2. Modificateur abstrait de non-accès

• Classe abstraite : Une classe est déclarée comme abstraite pour indiquer que cette classe ne peut pas être instanciée, ce qui signifie qu'aucun objet ne peut être formé pour cette classe mais peut être hérité. Néanmoins, cette classe possède un constructeur qui sera appelé à l'intérieur du constructeur de sa sous-classe. Il peut contenir des méthodes abstraites ainsi que des méthodes finales, où les méthodes abstraites seront remplacées dans la sous-classe.

Code :

public abstract class MyActivity{
public MyActivity(){
}
public final String myFun1(){
}
}

• Méthode abstraite : Les méthodes abstraites sont des méthodes sans aucune définition. Il contient uniquement la signature de la méthode et vise à indiquer que celles-ci doivent être remplacées dans la sous-classe.

Exemple : public abstract void fun1();

Code :

abstract class Electronics
{
abstract void display();
abstract void display(String msg);
}
class Computers extends Electronics
{
@Override
void display() {
System.out.println("Abstract method is called");
}
@Override
void display(String txt) {
System.out.println(txt);
}
}
public class AbstractDemo {
public static void main(String[] args) {
Computers obj=new Computers();
obj.display();
obj.display("Method with arguments");
}
}

Sortie :

3. Modificateur de non-accès synchronisé

Ce mot-clé permet d'empêcher l'accès d'une méthode par plusieurs threads simultanément, synchronisant ainsi le flux d'un programme et faisant ressortir les résultats souhaités à l'aide de la fonctionnalité multithreading.

Code :

class Person1
{
public synchronized void sendFun(String txt)
{
System.out.println("Sending message\t" + txt );
try
{
Thread.sleep(1000);
}
catch (Exception e)
{
System.out.println("Thread interrupted.");
}
System.out.println("\n" + txt + "Sent");
}
}
class DemoThread extends Thread
{
private String txt;
Person1  person;
DemoThread(String m,  Person1 obj)
{
txt = m;
person = obj;
}
public void run()
{
synchronized(person)
{
person.sendFun(txt);
}
}
}
public class HelloWorld
{
public static void main(String args[])
{
Person1 snd = new Person1();
DemoThread S1 =
new DemoThread( " Hi " , snd );
DemoThread S2 =
new DemoThread( " Bye " , snd );
S1.start();
S2.start();
// wait for threads to end
try
{
S1.join();
S2.join();
}
catch(Exception e)
{
System.out.println("Interrupted");
}
}
}

Sortie :

4. Modificateur statique de non-accès

Cette variable est utilisée pour la gestion de la mémoire et est la première chose référencée lors du chargement d'une classe. Ces membres sont traités au niveau de la classe ; ainsi, ils ne peuvent pas être appelés à l’aide d’un objet ; au lieu de cela, le nom de la classe est utilisé pour y faire référence.

• Static Variable: If a variable is declared as static, then only a single copy of the variable is created and shared among all the objects. Thus any change made to the variable by one object will be reflected in other others. Therefore,  the variables that hold value on the class level is declared as static.
• Static Class: Static keyword can only be used with nested classes.
• Static Methods: Since Static Methods are referenced by class name thus can only access static member variables and other static methods. Also, these methods cannot be referred to using this or super pointer. The main method is the most common example of a static method that always get loaded while its class is being loaded.
• Static Block: This is said to be a block being used to perform certain operations while class is being loaded. Since it is static thus can use only static members of the class.

Code:

public class Demo
{
// static variable
static int x = 10;
static int y;
//static class
public static class DemoInnerClass{
static int z=10;
}
// static block
static {
System.out.println("Static block initialized.");
y = x + 4;
}
//static method
public static void main(String[] args)
{
System.out.println("from main");
System.out.println("Value of x : "+x);
System.out.println("Value of y : "+y);
System.out.println("Value of z : "+DemoInnerClass.z);
}
}

Output:

5. Native Non Access Modifier

The native keyword is used only with the methods to indicate that the particular method is written in platform -dependent. These are used to improve the system’s performance, and the existing legacy code can be easily reused.

Note: Static, as well as abstract methods, cannot be declared as native.

Example: Consider a function myfun1 in class NativeDemo that is written in C++. To use this code, we will create a link library mylib1 and load it using the class’s static block.

public class DateTimeUtils {
public native String getSystemTime();
static {
System.loadLibrary("nativedatetimeutils");
}
}

6. Strictfp Non-Access Modifier

• Strictfp Class / Method: This keyword is used to ensure that results from an operation on floating-point numbers brings out the same results on every platform. This keyword can not be used with abstract methods, variables or constructors as these need not contain operations.

Code:

public class HelloWorld
{
public strictfp double calSum()
{
double n1 = 10e+07;
double n2 = 9e+08;
return (n1+n2);
}
public static strictfp void main(String[] args)
{
HelloWorld t = new HelloWorld ();
System.out.println("Result is -" + t.calSum());
}
}

Output:

7. Transient Non-Access Modifier

While transferring the data from one end to another over a network, it must be serialised for successful receiving of data, which means convert to byte stream before sending and converting it back at receiving end. To tell JVM about the members who need not undergo serialization instead of being lost during transfer, a transient modifier comes into the picture.

Syntax:

private transient member1;

Code:

import java.io.*;
class Demo implements Serializable
{
int x = 10;
transient int y = 30;
transient static int z = 40;
transient final int d = 50;
public static void main(String[] args) throws Exception
{
Demo input = new Demo();
FileOutputStream tos = new FileOutputStream("abc.txt");
ObjectOutputStream tin = new ObjectOutputStream(tos);
tin.writeObject(input);
FileInputStream fis = new FileInputStream("abc.txt");  ObjectInputStream ois = new ObjectInputStream(fis);
Demo output = (Demo)ois.readObject();
System.out.println("x = " + output.x);
System.out.println("y = " + output.y);
System.out.println("z = " + output.z);
System.out.println("d = " + output.d);
}
}

Output:

Conclusion

Non-access modifiers are the type of modifiers that tell JVM about the behavior of classes, methods, or variables defined and prepared accordingly. It also helps in synchronizing the flow as well as displaying similar results from operations being performed irrespective of the platform used for execution.

Recommended Article

This is a guide to Non Access Modifiers in Java. Here we discuss the Types of Non Access Modifiersand their methods and code implementation in Java. You can also go through our other suggested articles to learn more –

1. Layout in Java
2. Java Compilers
3. Merge Sort In Java
4. Java BufferedReader

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!