Modificateurs Java
Le langage Java propose de nombreux modificateurs, qui se répartissent principalement dans les deux catégories suivantes :
Modificateurs d'accès
Non -access Modificateurs Les modificateurs
sont utilisés pour définir des classes, des méthodes ou des variables, et sont généralement placés au début de l'instruction. Nous illustrons avec l'exemple suivant :
public class className {
// ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
// 方法体
}Modificateur de contrôle d'accès
En Java, les modificateurs de contrôle d'accès peuvent être utilisés pour protéger l'accès aux classes, variables, méthodes et constructeurs. Java prend en charge 4 droits d'accès différents.
La valeur par défaut, également appelée default, est visible dans le même package sans aucun modificateur.
Privé, spécifié avec le modificateur privé, visible au sein de la même classe.
Public, spécifié avec le modificateur public, visible par toutes les classes.
Protégé, spécifié avec le modificateur protected, visible par les classes et toutes les sous-classes du même package.
Modificateur d'accès par défaut - n'utilisez aucun mot-clé
Les variables et méthodes déclarées à l'aide du modificateur d'accès par défaut sont visibles par les classes du même package. Les variables de l'interface sont implicitement déclarées comme public static final, et les droits d'accès des méthodes de l'interface sont publics par défaut.
Exemple :
Comme le montre l'exemple suivant, les variables et les méthodes peuvent être déclarées sans aucun modificateur.
String version = "1.5.1";
boolean processOrder() {
return true;
}Modificateur d'accès privé-privé
Le modificateur d'accès privé est le niveau d'accès le plus restrictif, donc les méthodes, variables et constructeurs déclarés comme privés ne sont accessibles que par la classe à laquelle ils appartiennent, et Les classes et interfaces ne peuvent pas être déclarées privées.
Les variables déclarées comme types d'accès privés ne sont accessibles qu'aux classes externes via les méthodes getter publiques de la classe.
L'utilisation du modificateur d'accès privé est principalement utilisée pour masquer les détails d'implémentation de la classe et protéger les données de la classe.
Les classes suivantes utilisent le modificateur d'accès privé :
public class Logger {
private String format;
public String getFormat() {
return this.format;
}
public void setFormat(String format) {
this.format = format;
}
}Dans l'exemple, la variable de format dans la classe Logger est une variable privée, donc les autres classes ne peuvent pas directement obtenir et définir la valeur du variable. Afin de permettre à d'autres classes d'exploiter cette variable, deux méthodes publiques sont définies : getFormat() (renvoie la valeur du format) et setFormat(String) (définit la valeur du format)
Modificateur d'accès public-public
Les classes, méthodes, constructeurs et interfaces déclarés publics sont accessibles par n'importe quelle autre classe.
Si plusieurs classes publiques qui accèdent les unes aux autres sont distribuées dans des packages différents, vous devez importer le package où se trouve la classe publique correspondante. En raison de l'héritage de classe, toutes les méthodes et variables publiques d'une classe peuvent être héritées par ses sous-classes.
Les fonctions suivantes utilisent le contrôle d'accès public :
public static void main(String[] arguments) {
// ...
}La méthode main() du programme Java doit être définie sur public, sinon l'interpréteur Java ne pourra pas exécuter la classe.
Modificateur d'accès protégé - protégé
Les variables, méthodes et constructeurs déclarés comme protégés sont accessibles par toute autre classe du même package, ou par les classes d'accès aux sous-classes de différents packages.
Le modificateur d'accès protégé ne peut pas modifier les classes et les interfaces. Les méthodes et les variables membres peuvent être déclarées comme protégées, mais les variables membres et les méthodes membres des interfaces ne peuvent pas être déclarées comme protégées.
Les sous-classes peuvent accéder aux méthodes et variables déclarées avec le modificateur Protected, protégeant ainsi les classes non liées de l'utilisation de ces méthodes et variables.
La classe parent suivante utilise le modificateur d'accès protégé et la sous-classe surcharge la méthode openSpeaker() de la classe parent.
class AudioPlayer {
protected boolean openSpeaker(Speaker sp) {
// 实现细节
}
}
class StreamingAudioPlayer {
boolean openSpeaker(Speaker sp) {
// 实现细节
}
}Si la méthode openSpeaker() est déclarée privée, les classes autres qu'AudioPlayer ne pourront pas accéder à cette méthode. Si openSpeaker() est déclaré public, toutes les classes peuvent accéder à cette méthode. Si nous voulons que la méthode soit visible uniquement par les sous-classes de sa classe, déclarez la méthode comme protégée.
Contrôle d'accès et héritage
Veuillez noter les règles suivantes pour l'héritage des méthodes :
Les méthodes déclarées comme publiques dans la classe parent doivent également l'être dans la classe enfant.
Les méthodes déclarées comme protégées dans la classe parent sont soit déclarées comme protégées, soit publiques dans la sous-classe. Ne peut pas être déclaré privé.
Les méthodes déclarées comme privées dans la classe parent ne peuvent pas être héritées.
Modificateurs de non-accès
Afin d'implémenter d'autres fonctions, Java fournit également de nombreux modificateurs de non-accès.
modificateur statique, utilisé pour créer des méthodes de classe et des variables de classe.
Le modificateur Final est utilisé pour modifier les classes, les méthodes et les variables. Les classes modifiées par final ne peuvent pas être héritées, les méthodes modifiées ne peuvent pas être redéfinies par les classes héritées et les variables modifiées sont des constantes et ne peuvent pas être modifiées.
Modificateur abstrait, utilisé pour créer des classes abstraites et des méthodes abstraites.
Les modificateurs synchronisés et volatils sont principalement utilisés pour la programmation des threads.
Modificateur statique
Variable statique :
Le mot-clé statique est utilisé pour déclarer des variables statiques indépendantes des objets, quel que soit le Non quel que soit le nombre d’objets qu’une classe instancie, il n’existe qu’une seule copie de ses variables statiques. Les variables statiques sont également appelées variables de classe. Les variables locales ne peuvent pas être déclarées comme variables statiques.
Méthode statique :
Le mot clé Static est utilisé pour déclarer des méthodes statiques indépendantes de l'objet. Les méthodes statiques ne peuvent pas utiliser de variables non statiques de la classe. Les méthodes statiques récupèrent les données d'une liste de paramètres, puis calculent les données.
L'accès aux variables et méthodes de classe est directement accessible en utilisant classname.variablename et classname.methodname.
Comme le montre l'exemple suivant, le modificateur static est utilisé pour créer des méthodes de classe et des variables de classe.
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");
}
}L'exemple ci-dessus d'exécution et de modification des résultats est le suivant :
Started with 0 instances Created 500 instances
Modificateur final
Variable finale :
Variable finale peut être affiché Initialisé formellement et une seule fois. Les références aux objets déclarés final ne peuvent pas pointer vers des objets différents. Mais les données de l'objet final peuvent être modifiées. En d’autres termes, la référence de l’objet final ne peut pas être modifiée, mais la valeur à l’intérieur peut être modifiée.
Le modificateur final est généralement utilisé avec le modificateur statique pour créer des constantes de classe.
Instance :
public class Test{
final int value = 10;
// 下面是声明常量的实例
public static final int BOXWIDTH = 6;
static final String TITLE = "Manager";
public void changeValue(){
value = 12; //将输出一个错误
}
}Méthode Final
La méthode Final d'une classe peut être héritée par les sous-classes, mais ne peut pas être modifiée par les sous-classes.
Le but principal de la déclaration d'une méthode finale est d'empêcher la modification du contenu de la méthode.
Comme indiqué ci-dessous, utilisez le modificateur final pour déclarer la méthode.
public class Test{
public final void changeName(){
// 方法体
}
}Classe finale
La classe Final ne peut pas être héritée et aucune classe ne peut hériter des caractéristiques de la classe finale.
Instance :
public final class Test {
// 类体
}Modificateur abstrait
Classe abstraite :
La classe abstraite ne peut pas être utilisée pour instancier des objets, déclarer abstrait. le seul but d’une classe est de faciliter les extensions futures de la classe.
Une classe ne peut pas être modifiée par abstract et final en même temps. Si une classe contient des méthodes abstraites, elle doit être déclarée comme classe abstraite, sinon une erreur de compilation se produira.
Les classes abstraites peuvent contenir des méthodes abstraites et des méthodes non abstraites.
Instance :
abstract class Caravan{
private double price;
private String model;
private String year;
public abstract void goFast(); //抽象方法
public abstract void changeColor();
}Méthode abstraite
La méthode abstraite est une méthode sans aucune implémentation. L'implémentation spécifique de la méthode est fournie par la sous-classe. Les méthodes abstraites ne peuvent pas être déclarées définitives et strictes.
Toute sous-classe qui hérite d'une classe abstraite doit implémenter toutes les méthodes abstraites de la classe parent, sauf si la sous-classe est également une classe abstraite.
Si une classe contient plusieurs méthodes abstraites, alors la classe doit être déclarée comme classe abstraite. Une classe abstraite n'a pas besoin de contenir des méthodes abstraites.
La déclaration d'une méthode abstraite se termine par un point-virgule, par exemple : public abstract sample();
Exemple :
public abstract class SuperClass{
abstract void m(); //抽象方法
}
class SubClass extends SuperClass{
//实现抽象方法
void m(){
.........
}
}Modificateur synchronisé
Synchronisé mot-clé La méthode déclarée n'est accessible que par un seul thread à la fois. Le modificateur Synchronisé peut être appliqué à quatre modificateurs d'accès.
Instance :
public synchronized void showDetails(){
.......
}Modificateur transitoire
Lorsque l'objet sérialisé contient une variable d'instance modifiée par transitoire, la machine virtuelle Java (JVM) ignore cette variable spécifique.
Ce modificateur est inclus dans l'instruction qui définit la variable et est utilisé pour prétraiter le type de données de la classe et de la variable.
Exemple :
public transient int limit = 55; // will not persist public int b; // will persist
Modificateur volatile
La variable membre modifiée volatile est forcée d'être relue à partir de la mémoire partagée à chaque fois qu'une valeur de thread y accède. De plus, lorsqu'une variable membre change, le thread est obligé de réécrire la valeur modifiée dans la mémoire partagée. De cette façon, à tout moment, deux threads différents voient toujours la même valeur d'une variable membre.
Une référence d'objet volatile peut être nulle.
Exemple :
public class MyRunnable implements Runnable
{
private volatile boolean active;
public void run()
{
active = true;
while (active) // 第一行
{
// 代码
}
}
public void stop()
{
active = false; // 第二行
}
}Normalement, la méthode run() est appelée sur un thread (le thread démarré par Runnable), et la méthode stop() est appelée sur un autre thread. Si la valeur active du tampon dans la première ligne de est utilisée, alors la boucle ne bouclera pas lorsque la valeur active de la deuxième ligne de est faux.
Mais dans le code ci-dessus, nous avons utilisé volatile pour modifier active, donc la boucle s'arrêtera.
