1. Contrôles d'accès: public, package
   Une classe peut avoir deux niveaux d'accès : public et package.
   

   • L'accès public permet à une classe d'être visible dans tout le code sans aucune restriction.
     Partout dans le code, il est possible de référencer une classe public, de l'instancier, et de la spécialiser (héritage).
     public class MyPublicClass {}
     
   • L'accès package permet à une classe d'être visible à l'intérieur de son package uniquement.
     Il n'y a pas de modificateur explicite pour cet accès, en fait, en absence de modificateur dans la déclaration de la classe, elle obtient par défaut l'accès package.
     package com.mtitek.modifiers; class MyDefaultClass {}
2. Autres modificateurs: abstract, final
   • Le modificateur abstract :
     Une classe abstraite est une classe template qui déclare des méthodes (peuvent être abstraites à leurs tours) ; elle permet ainsi à d'autres classes de s'en servir (en héritant de cette classe) pour définir un comportement spécialisé.
     Une classe abstraite ne peut être instanciée directement.
     Une classe abstraite ne peut pas utiliser le modificateur final.
     public abstract class MyAbstractClass {}
     
   • Le modificateur final :
     Le mot clé final empêche une classe d'être héritée, ce qui veut dire que son comportement ne peut être modifié.
     Une classe final ne peut pas utiliser le modificateur abstract.
     public final class MyFinalClass {}

Les classes ne peuvent pas être private.
Vous obtiendrez une erreur de compilation si vous marquez une classe private.

1. Contrôles d'accès: public, package
   Une interface peut avoir deux niveaux d'accès : public et package.
   

   • L'accès public permet à une interface d'être visible dans tout le code sans aucune restriction.
     Partout dans le code, il est possible de référencer une interface public et de la spécialiser (héritage).
     public interface MyPublicInterface {}
     
   • L'accès package permet à une interface d'être visible à l'intérieur de son package uniquement.
     Il n'y a pas de modificateur explicite pour cet accès, en fait, en absence de modificateur dans la déclaration de la interface, elle obtient par défaut l'accès package.
     package com.mtitek.modifiers; interface MyDefaultInterface { }
2. Autres modificateurs: abstract
   • Le modificateur abstract :
     Les interfaces sont implicitement abstract.
     Ce qui veut dire, qu'il n'est pas nécessaire d'utiliser ce modificateur pour la déclaration des interfaces.
     public abstract interface MyAbstractPublicInterface {}

Les interfaces ne peuvent pas être private.
Vous obtiendrez une erreur de compilation si vous marquez une interface private.

Les interfaces ne peuvent pas être final.
Vous obtiendrez une erreur de compilation si vous marquez une interface final.

Les variables des interfaces sont implicitement public, static, et final.
Ce qui veut dire, qu'il n'est pas nécessaire d'utiliser ces modificateurs pour la déclaration des variables des interfaces.
Mais il est interdit d'utiliser un autre modificateur.

Les méthodes des interfaces sont implicitement public et abstract.
Ce qui veut dire, qu'il n'est pas nécessaire d'utiliser ces modificateurs pour la déclaration des méthodes des interfaces.
Mais il est interdit d'utiliser un autre modificateur.

1. Contrôles d'accès: public, private, protected, package
   Une méthode peut avoir quatre niveaux d'accès : public, private, protected, et package.
   
   

   • L'accès public permet à une méthode d'être accessible dans tout le code sans aucune restriction (à condition que la classe qui la déclare est visible elle aussi).
     
     
   • L'accès private permet à une méthode d'être accessible uniquement dans le code de la classe qui la déclare.
     L'accès private n'empêche pas une sous-classe de déclarer une méthode avec exactement la même signature, dans ce cas, on ne parle pas de redéfinition de la méthode (héritage) mais plutôt d'une nouvelle définition de la méthode puisque celle de la superclasse est non visible pour la sous-classe.
     
     
   • L'accès protected permet à une méthode d'être visible à l'intérieur du package de la classe qui la déclare.
     Il permet aussi à la méthode d'être visible dans le code des sous-classes de la classe qui la déclare, même s'elles sont dans d'autres packages.
     
     Mais attention, la méthode de la classe parente est accessible dans le code de la sous classe comme s'elle a été déclarée dans la sous-classe : Il est possible de la redéfinir (override) ou l'invoquer.
     Par contre, il ne sera pas possible pour le code de la sous-classe d'utiliser une référence d'une instance de la classe parente pour invoquer la méthode protégée.
     package com.mtitek.inheritance.package1; public class MyParentClass { protected void doFirstThing() { // ... } protected void doSecondThing() { // ... } }
     package com.mtitek.inheritance.package2; import com.mtitek.inheritance.package1.MyParentClass; public class MySubClass extends MyParentClass { @Override protected void doFirstThing() { super.doFirstThing(); } public void doThirdThing() { doFirstThing(); // OK doSecondThing(); // OK MyParentClass myParentClass = new MyParentClass(); myParentClass.doFirstThing(); // Compiler error : The method doFirstThing() from the type MyParentClass is not visible } }
     
   • L'accès package permet à une méthode d'être visible uniquement à l'intérieur du package de la classe qui la déclare.
     Il n'y a pas de modificateur explicite pour cet accès, en fait, en absence de modificateur dans la déclaration de la méthode, elle obtient par défaut l'accès package.
     
     

   Ci-dessous un tableau qui résume les visibilités de ces méthodes en fonction de leurs modificateurs d'accès et aussi en fonction des contextes desquels elles sont invoquées (considérant une classe T qui déclare des méthodes avec les modificateurs d'accès public, private, protected, et package) :
   
   

   Visibilité des méthodes de la classe T	public	private	protected	package
   Dans le code de la classe T	Oui	Oui	Oui	Oui
   Dans le code de n'importe quelle classe (autre que la classe T) appartenant au même package de la classe T	Oui	Non	Oui	Oui
   Dans le code de n'importe quelle classe (pas sous-classe) appartenant à un package différent de celui de la classe T	Oui	Non	Non	Non
   Dans le code de n'importe quelle sous-classe appartenant au même package de la classe T	Oui	Non	Oui	Oui
   Dans le code de n'importe quelle sous-classe appartenant à un package différent de celui de la classe T	Oui	Non	Oui	Non

2. Autres modificateurs: static, abstract, final, synchronized, strictfp, native
   • Le modificateur static :
     Une méthode statique peut être invoquée sans créer une instance de la classe; une méthode statique est accessible au chargement de la classe en mémoire par la JVM.
     Une méthode statique ne peut pas utiliser des variables d'instance ou invoquer des méthodes d'instance.
     
     
   • Le modificateur abstract :
     Une méthode abstraite est une méthode template qui n'implémente pas un code ; elle permet ainsi à d'autres classes de s'en servir (en héritant de la classe qui définit cette méthode) pour définir un comportement spécialisé.
     Une méthode abstraite peut être définit uniquement dans une classe abstraite.
     Une méthode abstraite peut avoir trois niveaux d'accès : public, protected, et package.
     Une méthode abstraite ne peut pas utiliser les modificateurs final, private, et static.
     Quand une classe non abstraite hérite d'une classe abstraite, elle doit implémenter toutes les méthodes abstraites de cette classe.
     public abstract class MyAbstractClass { public abstract void doSomeThing(); }
     
   • Le modificateur final :
     Le mot clé final empêche une méthode d'être redéfinit ; ce qui veut dire que son comportement ne peut être modifié (héritage).
     public class MyClass { public final void doSomeThing() { // add code here } }
     
   • Le modificateur synchronized :
     Le mot clé synchronized permet à une méthode d'être exécuter par un seul thread à la fois.
     public class MyClass { public synchronized void doSomeThing() { // add code here } }
     
   • Le modificateur strictfp :
     Le mot clé strictfp permet à une méthode d'être conforme avec le standard concernant la gestion des nombres réels.
     
     Some processors might not truncate intermediary results of a computation which can increase the precision of the result of the computation but also can give different results depending on the processor where the computation is executed.
     
     If the portability is an issue, then consider using the keyword strictfp to enforce that all instructions (within a method or a class) use the strict floating point computations.
     
     When using mathematical functions, you might consider using the class StrictMath (instead of Math) if results are expected to be the same regardless of the processor used to execute the mathematical functions (this might have an impact on performance though).
     
     public class MyClass { public strictfp void doSomeThing() { // add code here } }
     
   • Le modificateur native :
     Le mot clé native indique que la méthode est implémenter dans un autre langage (exemple C++).
     public class MyClass { public native void doSomeThing(); }

1. Contrôles d'accès: public, private, protected, package
   Une variable peut avoir quatre niveaux d'accès : public, private, protected, et package.
   Les contrôles d'accès s'appliquent uniquement aux variables d'instances et de classe.
   Les contrôles d'accès n'empêchent pas une sous-classe de re-déclarer une variable de la superclasse, et de lui spécifier un contrôle d'accès différent. L'héritage s'applique uniquement aux méthodes.
   
   

   • L'accès public permet à une variable d'être accessible dans tout le code sans aucune restriction, du moment où la classe qui la déclare est visible elle aussi.
     
     
   • L'accès private permet à une variable d'être accessible uniquement dans le code de la classe qui la déclare.
     
     
   • L'accès protected permet à une variable d'être visible à l'intérieur du package de la classe qui la déclare.
     Il permet aussi à la variable d'être visible dans le code des sous-classes de la classe qui la déclare, même s'elles sont déclarées dans d'autres packages.
     
     Mais attention, la variable de la classe parente est accessible dans le code de la sous classe comme s'elle a été déclarée dans la sous-classe.
     Par contre, il ne sera pas possible pour le code de la sous-classe d'utiliser une référence d'une instance de la classe parente pour référencer la variable protégée.
     package com.mtitek.inheritance.package1; public class MyParentClass { protected Integer var1; }
     package com.mtitek.inheritance.package2; import com.mtitek.inheritance.package1.MyParentClass; public class MySubClass extends MyParentClass { public void doSomeThing() { var1 = 10; // OK MyParentClass myParentClass = new MyParentClass(); myParentClass.var1 = 10; // Compiler error : The field MyParentClass.var1 is not visible } }
     
   • L'accès package permet à une variable d'être visible uniquement à l'intérieur du package de la classe qui la déclare.
     Il n'y a pas de modificateur explicite pour cet accès, en fait, en absence de modificateur dans la déclaration de la variable, elle obtient par défaut l'accès package.
     
2. Autres modificateurs: static, final, transient, volatile
   • Le modificateur static :
     Le mot clé static implique que la variable aura une seule copie (classe copie) qui sera partagée par toutes les instances de la classe.
     Une variable statique veut dire aussi qu'il est possible de l'utiliser sans créer une instance de la classe; une variable statique est accessible après le chargement de la classe en mémoire par la JVM.
     
     
   • Le modificateur final :
     Le mot clé final empêche la modification de la référence contenue dans une variable (s'applique aux variables de classe, variables de d'instance, variables locales des méthodes, et paramètres de méthodes).
     public class MyClass { public final static Integer ADD_OPERATION_ID = 0; }
     
   • Le modificateur transient :
     Le mot clé transient indique que la variable ne doit pas être prise en compte lors de la sérialisation de l'objet qui définit cette variable.
     
     
   • Le modificateur volatile :
     Le mot clé volatile permet aux threads de voir la dernière valeur modifiée de la variable (une sorte de synchronisation sans la charge supplémentaire du verrouillage).
     
     Il y a des cas bien particuliers ou ce mot clé peut fonctionner correctement, particulièrement il ne faut pas utiliser ce mot clé dans les cas où la lecture/modification de la variable doit être une opération atomique (exemple incrémenter la valeur une variable).
     Aussi, il faut faire attention au cas où la variable est utilisée dans une opération impliquant une autre variable (exemple tester si la valeur de la variable est égale ou différente de la valeur d'une autre variable).
     
     Typiquement, la variable marquée par le mot clé doit être initialisée à une seule place et en suite utiliser sa valeur pour effectuer une opération suite au changement de sa valeur.