Java - Modificateurs sans accès

Java fournit un certain nombre de modificateurs sans accès pour obtenir de nombreuses autres fonctionnalités.

  • Le modificateur statique pour créer des méthodes de classe et des variables.

  • Le modificateur final pour finaliser les implémentations de classes, méthodes et variables.

  • Le modificateur abstrait pour créer des classes et des méthodes abstraites.

  • Les modificateurs synchronisés et volatils , qui sont utilisés pour les threads.

Le modificateur statique

Variables statiques

Le mot-clé static est utilisé pour créer des variables qui existeront indépendamment de toute instance créée pour la classe. Une seule copie de la variable statique existe quel que soit le nombre d'instances de la classe.

Les variables statiques sont également appelées variables de classe. Les variables locales ne peuvent pas être déclarées statiques.

Méthodes statiques

Le mot clé static est utilisé pour créer des méthodes qui existeront indépendamment de toute instance créée pour la classe.

Les méthodes statiques n'utilisent aucune variable d'instance d'un objet de la classe dans laquelle elles sont définies. Les méthodes statiques prennent toutes les données des paramètres et calculent quelque chose à partir de ces paramètres, sans référence aux variables.

Les variables et méthodes de classe sont accessibles en utilisant le nom de classe suivi d'un point et du nom de la variable ou de la méthode.

Example

Le modificateur static est utilisé pour créer des méthodes de classe et des variables, comme dans l'exemple suivant -

public class InstanceCounter {

   private static int numInstances = 0;

   protected static int getCount() {
      return numInstances;
   }

   private static void addInstance() {
      numInstances++;
   }

   InstanceCounter() {
      InstanceCounter.addInstance();
   }

   public static void main(String[] arguments) {
      System.out.println("Starting with " + InstanceCounter.getCount() + " instances");

      for (int i = 0; i < 500; ++i) {
         new InstanceCounter();
      }
      System.out.println("Created " + InstanceCounter.getCount() + " instances");
   }
}

Cela produira le résultat suivant -

Output

Started with 0 instances
Created 500 instances

Le modificateur final

Variables finales

Une dernière variable ne peut être explicitement initialisée qu'une seule fois. Une variable de référence déclarée finale ne peut jamais être réaffectée pour faire référence à un objet différent.

Cependant, les données de l'objet peuvent être modifiées. Ainsi, l'état de l'objet peut être modifié mais pas la référence.

Avec les variables, le modificateur final est souvent utilisé avec static pour faire de la constante une variable de classe.

Example

public class Test {
   final int value = 10;

   // The following are examples of declaring constants:
   public static final int BOXWIDTH = 6;
   static final String TITLE = "Manager";

   public void changeValue() {
      value = 12;   // will give an error
   }
}

Méthodes finales

Une méthode finale ne peut être remplacée par aucune sous-classe. Comme mentionné précédemment, le modificateur final empêche une méthode d'être modifiée dans une sous-classe.

L'intention principale de rendre une méthode définitive serait que le contenu de la méthode ne soit modifié par aucun étranger.

Example

Vous déclarez des méthodes en utilisant le modificateur final dans la déclaration de classe, comme dans l'exemple suivant -

public class Test {
   public final void changeName() {
      // body of method
   }
}

Classes finales

Le but principal de l'utilisation d'une classe déclarée comme finale est d'empêcher la classe d'être sous- classée . Si une classe est marquée comme finale, aucune classe ne peut hériter d'une fonctionnalité de la classe finale.

Example

public final class Test {
   // body of class
}

Le modificateur abstrait

Classe abstraite

Une classe abstraite ne peut jamais être instanciée. Si une classe est déclarée comme abstraite, le seul but est que la classe soit étendue.

Une classe ne peut pas être à la fois abstraite et finale (puisqu'une classe finale ne peut pas être étendue). Si une classe contient des méthodes abstraites, la classe doit être déclarée abstraite. Sinon, une erreur de compilation sera générée.

Une classe abstraite peut contenir à la fois des méthodes abstraites et des méthodes normales.

Example

abstract class Caravan {
   private double price;
   private String model;
   private String year;
   public abstract void goFast();   // an abstract method
   public abstract void changeColor();
}

Méthodes abstraites

Une méthode abstraite est une méthode déclarée sans aucune implémentation. Le corps des méthodes (implémentation) est fourni par la sous-classe. Les méthodes abstraites ne peuvent jamais être définitives ou strictes.

Toute classe qui étend une classe abstraite doit implémenter toutes les méthodes abstraites de la super classe, sauf si la sous-classe est également une classe abstraite.

Si une classe contient une ou plusieurs méthodes abstraites, alors la classe doit être déclarée abstraite. Une classe abstraite n'a pas besoin de contenir des méthodes abstraites.

La méthode abstraite se termine par un point-virgule. Exemple: échantillon de résumé public ();

Example

public abstract class SuperClass {
   abstract void m();   // abstract method
}

class SubClass extends SuperClass {
   // implements the abstract method
   void m() {
      .........
   }
}

Le modificateur synchronisé

Le mot clé synchronized utilisé pour indiquer qu'une méthode n'est accessible que par un seul thread à la fois. Le modificateur synchronisé peut être appliqué avec l'un des quatre modificateurs de niveau d'accès.

Example

public synchronized void showDetails() {
   .......
}

Le modificateur transitoire

Une variable d'instance est marquée comme transitoire pour indiquer à la JVM d'ignorer la variable particulière lors de la sérialisation de l'objet qui la contient.

Ce modificateur est inclus dans l'instruction qui crée la variable, précédant la classe ou le type de données de la variable.

Example

public transient int limit = 55;   // will not persist
public int b;   // will persist

Le modificateur volatil

Le modificateur volatile est utilisé pour indiquer à la JVM qu'un thread accédant à la variable doit toujours fusionner sa propre copie privée de la variable avec la copie principale en mémoire.

L'accès à une variable volatile synchronise toutes les variables copiées en cache dans la mémoire principale. Volatile ne peut être appliqué qu'aux variables d'instance, qui sont de type object ou private. Une référence d'objet volatile peut être nulle.

Example

public class MyRunnable implements Runnable {
   private volatile boolean active;

   public void run() {
      active = true;
      while (active) {   // line 1
         // some code here
      }
   }

   public void stop() {
      active = false;   // line 2
   }
}

Habituellement, run () est appelé dans un thread (celui que vous commencez à utiliser le Runnable), et stop () est appelé à partir d'un autre thread. Si à la ligne 1, la valeur mise en cache active est utilisée, la boucle peut ne pas s'arrêter lorsque vous définissez active sur false à la ligne 2. C'est à ce moment que vous souhaitez utiliser volatile .