Mots-clés statiques Java et variables statiques Java et méthodes statiques
Le modificateur statique peut être utilisé avec des variables et des méthodes pour indiquer qu'il est "statique".
Les variables statiques et les méthodes statiques sont accessibles via des noms de classe, et il n'est pas nécessaire de créer un objet d'une classe pour accéder aux membres statiques de la classe, donc les membres modifiés par statique sont également appelés variables de classe et méthodes de classe. Les variables statiques sont différentes des variables d'instance et les variables d'instance sont toujours accessibles via des objets car leurs valeurs varient entre les objets.
Veuillez consulter l'exemple suivant:
classe publique Demo {statique int i = 10; i); Demo obj = new Demo (); Résultats en cours:
Variable de classe i = 10 variable d'instance J = 20
allocation de mémoire statique
Les variables statiques appartiennent aux classes et n'appartiennent à aucun objet indépendant, vous pouvez donc accéder aux variables statiques sans créer des instances de la classe. Ce résultat est dû au fait que le compilateur ne crée qu'une copie des variables statiques pour la classe entière, c'est-à-dire, n'alloue qu'un seul espace mémoire. Les variables d'instance sont différentes.
Veuillez consulter le code suivant:
classe publique Demo {statique int i; int j; public statique vide (String [] args) {démo obj1 = new Demo (); ; obj2 .j = "+ obj2.j);}} Résultats en cours:
obj1.i = 10, obj1.j = 20obj2.i = 10, obj2.j = 0
Remarque: Bien que les variables statiques soient également accessibles via des objets, ils ne sont pas recommandés et le compilateur générera également des avertissements.
Dans le code ci-dessus, I est une variable statique. En effet
Remarque: la variable statique sera initialisée lorsque la classe sera chargée. Autrement dit, tant que la classe est chargée, elle sera initialisée, que vous utilisiez ou non cette variable statique.
Résumé: les variables de classe sont modifiées avec le mot-clé statique. Les modifications des variables affecteront d'autres objets. Il existe deux façons d'accéder à l'extérieur: l'accès via des objets ou l'accès via des noms de classe.
Méthode statique
Une méthode statique est une méthode qui ne peut pas effectuer d'opérations sur un objet. Par exemple, la méthode POW () de la classe de mathématiques est une méthode statique avec une syntaxe de math.pow (x, a), qui est utilisée pour calculer la puissance de A de x, et il n'est pas nécessaire de créer des mathématiques objets lorsqu'ils sont utilisés.
Parce que les méthodes statiques ne peuvent pas fonctionner d'objets, les variables d'instance ne peuvent pas être accessibles dans des méthodes statiques et ne peuvent accéder qu'à des variables statiques de leur propre classe.
La méthode statique peut être utilisée dans les situations suivantes:
Une méthode n'a pas besoin d'accéder à l'état d'objet et ses paramètres requis sont fournis par des paramètres explicites (par exemple, math.pow ()).
Une méthode n'a besoin que d'accéder aux variables statiques de la classe.
Les lecteurs doivent avoir remarqué que Main () est également une méthode statique qui ne fonctionne pas sur des objets. En fait, il n'y a pas d'objets au moment du démarrage du programme, la méthode principale () est l'entrée du programme et sera exécutée et les objets requis par le programme sont créés.
Résumé des variables statiques et des méthodes statiques:
Une méthode statique d'une classe ne peut accéder qu'à des variables statiques;
Une méthode statique d'une classe ne peut pas appeler directement des méthodes non statiques;
Si l'autorisation de contrôle d'accès le permet, les variables statiques et les méthodes statiques sont également accessibles via des objets, mais ne sont pas recommandés;
L'objet actuel n'existe pas dans la méthode statique, donc cela ne peut pas être utilisé, et bien sûr, Super ne peut pas être utilisé;
Les méthodes statiques ne peuvent pas être écrasées par des méthodes non statiques;
Le constructeur n'autorise pas la déclaration de statique;
Les variables locales ne peuvent pas être modifiées avec statique.
Exemples de méthodes statiques:
classe publique Demo {static int sum (int x, int y) {return x + y;} public static void main (String [] args) {int sum = demo.sum (10, 10); "10 + 10 =" + sum); Résultats en cours:
10 + 10 = 20
La méthode statique ne nécessite aucune instance de la classe à laquelle il appartient sera appelée, donc il n'y a aucune valeur de cela et la variable d'instance n'est pas accessible, sinon elle entraînera une erreur de compilation.
Remarque: les variables d'instance ne sont accessibles que via des objets et ne sont pas accessibles via des classes.
Initialiseur statique (bloc statique)
Un bloc est un morceau de code entouré de bretelles. Un initialiseur statique est un bloc statique qui existe dans une classe et en dehors d'une méthode. Les initialiseurs statiques ne sont exécutés qu'une fois que lorsque la classe est chargée (lorsque la classe est utilisée pour la première fois) et sont souvent utilisées pour initialiser les variables statiques.
Exemple de code:
classe publique Demo {public static int i; "+ i);} public static void main (String [] args) {System.out.println (" Demo.i = "+ Demo.i); new Demo (). Test ();}} Le résultat de l'opération est:
Maintenant dans Static Block.demo.i = 10test Méthode: i = 10
Importation statique
L'importation statique est une nouvelle caractéristique de Java 5, utilisée pour importer des variables statiques et des méthodes statiques de classes.
Généralement, nous écrivons ceci dans les classes d'importation:
importer packageName.className;
ou
Importer PackageName. *;
Et l'importation statique peut être écrite comme ceci:
Importer Static PackageName.ClassName.MethonName;
ou
importer statique packagename.classname. *;
Après l'importation, vous pouvez appeler directement la méthode statique avec le nom de la méthode dans la classe actuelle, et vous n'avez plus besoin d'utiliser className.MethodName pour y accéder.
Pour les variables statiques fréquemment utilisées et les méthodes statiques, elles peuvent être importées statiquement. L'avantage de l'importation statique est qu'il peut simplifier certaines opérations, telles que le système de sortie.out.println (); et directement la prochaine fois.
Veuillez consulter le code suivant:
import static java.lang.system. *; import static java.lang.math.random; public class Demo {public static void main (String [] args) {out.println ("produit par le numéro aléatoire:" + random () )); Résultats en cours:
Un nombre aléatoire généré: 0,05800891549018705
Java Mot-clé final: Bloquer l'héritage et le polymorphisme <Br /> en Java, lors de la déclaration des classes, des variables et des méthodes, le mot-clé final peut être utilisé pour le modifier. Les données modifiées par final ont les caractéristiques de "l'état final" et signifie "final". Les réglementations spécifiques sont les suivantes:
La classe modifiée par final ne peut pas être héritée.
La méthode de modification finale ne peut pas être réécrite par les sous-classes.
La variable modifiée par final (variable membre ou variable locale) devient une constante et ne peut être attribuée qu'une seule fois.
La variable membre modifiée par final doit être attribuée en même temps que la déclaration. utilisé.
La variable locale modifiée par final ne peut déclarer qu'elle n'attribue pas, puis être attribuée en même temps.
Final est généralement utilisé pour modifier des données qui ne peuvent pas être modifiées à volonté pour éviter une mauvaise utilisation, telles que des méthodes pour mettre en œuvre des méthodes de triangle mathématique, des opérations d'exponentiation et d'autres fonctions, ainsi qu'une constante mathématique π = 3,141593, E = 2,71828 et al.
En fait, pour assurer l'État final, la classe java.lang.math qui fournit les méthodes et les constantes ci-dessus a également été définie comme finale.
Il convient de noter que si une variable qui fait référence à un type (le type de classe) est marquée comme finale, la variable ne peut pointer vers aucun autre objet. Mais le contenu de l'objet peut être modifié, car seule la référence elle-même est finale.
Si la variable est marquée finale, le résultat est d'en faire une constante. Le désir de modifier la valeur de la variable finale entraînera une erreur de compilation. Voici un exemple de définition correcte des variables finales:
public final int max_array_size = 25;
Les constantes ne peuvent pas être héritées car elles ont une modification finale.
Veuillez consulter le code suivant:
Demo de classe finale publique {public static final int total_number = 5; public int id; = ++ Total_Number;} Public Static Void Main (String [] Args) {Demo final T = Demo (); Effectuer une affectation secondaire}}Final peut également être utilisé pour modifier les classes (avant le mot-clé de classe) pour empêcher la classe de dériver des sous-classes. Cela est fait pour des raisons de sécurité, car il est nécessaire de s'assurer qu'une fois qu'une chaîne est référencée, ce doit être une chaîne de la chaîne de classe, pas une chaîne d'une autre classe (la classe de chaîne peut être héritée et falsifiés de manière malicieusement).
Les méthodes peuvent également être modifiées par Final et les méthodes modifiées par Final ne peuvent pas être écrasées; Une fois qu'une classe est déclarée définitive, les méthodes contenues dans cette classe seront également déclarées implicitement comme finales, mais la variable ne l'est pas.
La méthode modifiée par Final est une liaison statique et ne produira pas de polymorphisme (liaison dynamique). Dans Java, les méthodes modifiées par statique ou privée seront implicitement déclarées comme finales car la liaison dynamique n'a aucun sens.
Étant donné que la liaison dynamique consomme des ressources et n'est souvent pas nécessaire, certains programmeurs pensent qu'à moins qu'il n'y ait suffisamment de raisons d'utiliser le polymorphisme, toutes les méthodes doivent être modifiées avec Final.
Cette compréhension est un peu extrême, car le compilateur instantané dans le JVM peut surveiller les informations de fonctionnement du programme en temps réel et peut connaître avec précision la relation d'héritage entre les classes. Si une méthode n'est pas écrasée et courte, le compilateur peut l'optimiser, ce qui est appelé indicateur. Par exemple, un appel en ligne à e.getName () sera remplacé par l'accès à la variable E.Name. Il s'agit d'une amélioration significative, car le transfert de branche utilisé par le processeur lors du traitement des instructions qui appellent les méthodes perturber la politique de l'instruction de préfetch, ce qui est considéré comme impopulaire. Cependant, si getName () est écrasé dans une autre classe, le compilateur ne peut pas savoir ce que le code écrasé fera, il ne peut donc pas être incliné.