Qu'est-ce qui est statique. Méthodes Java - Comment appeler et utiliser

1. Quels éléments du langage de programmation C# peuvent être déclarés statiques ?

Dans le langage de programmation C#, static peut être :

• cours;
• méthodes;
• variables.

Pour qu'une classe (méthode, variable) soit statique, le mot-clé static est placé avant sa déclaration.

2. Le concept de classe statique. Quelles sont les fonctionnalités de l’utilisation de classes statiques dans les programmes C# ? Mot clé statique

En termes de syntaxe C#, une classe statique est une classe déclarée avec le mot clé static.

La forme générale de déclaration d’une classe statique est la suivante :

classe statique NomClasse( // champs et méthodes de la classe // ... }

Où Nom de classe– nom de la classe statique.

3. Propriétés d'une classe statique

L'implémentation du code de programme d'une classe statique n'est pas différente du code de programme d'une classe normale, à l'exception de deux propriétés principales. Par rapport à une classe non statique, une classe statique possède les propriétés (différences) suivantes :

• vous ne pouvez pas créer d'objets d'une classe statique ;
• une classe statique doit contenir uniquement des membres statiques.

4. Exemples illustrant les propriétés d'une classe statique

Exemple 1. Laissez la classe statique MyStaticClass être spécifiée. Cette classe déclare un membre statique nommé d.

// classe statique classe statique MyStaticClass ( public static int d = 0; )

Si vous essayez de créer un objet d'une classe statique

// tentative de créer un objet d'une classe statique MaClasseStatique ms ; // erreur - vous ne pouvez pas créer un objet d'une classe statique

alors une erreur de compilation se produira avec le message :

Impossible de déclarer une variable de type statique

ce qui veut dire :

Impossible de déclarer une variable de type statique

Exemple 2. Cet exemple illustre la règle selon laquelle une classe statique doit contenir uniquement des membres statiques. Laissez la classe statique MyStaticClass être spécifiée. Si dans la classe statique MyStaticClass vous essayez de déclarer non statique membre d de type entier

// classe statique classe statique MyStaticClass ( // membre non statique, sans le mot clé static public int d = 0 ; // erreur - vous ne pouvez pas déclarer une instance non statique dans une classe statique }

puis lors de la compilation, le compilateur produira l'erreur suivante :

Impossible de déclarer les membres d'une instance dans une classe statique

Qu'est-ce que ça veut dire

Vous ne pouvez pas déclarer les membres d'une instance dans une classe statique

5. Exemples de classes statiques

Exemple 1. Cet exemple montre l'utilisation d'une variable statique dans une classe statique. Une classe statique appelée Count est déclarée et contient une variable statique, count . Cette variable statique est un compteur partagé dans les méthodes non statiques Add1(), Add2() d'une autre classe Methods.

Le code des classes Count et Methods est le suivant :

// Nombre de classes statiques compte de classe statique ( public static int count; ) // classe non statique méthodes de classe ( // les méthodes de classe non statiques ont accès // au nombre de variables statiques de la classe statique Count public vide Add1() // méthode non statique { // changer la valeur d'une variable statique Comptez .count++ ; ) public static void Add2()// méthode statique

( Compte .count = Compte .count + 2; ) )

Le code suivant montre l'accès à la variable count de la classe Count et la modification de la valeur de cette variable à partir des méthodes Add1() et Add2(). Méthodes M = new Methods(); // crée un objet de la classe Méthodes// vérifie les valeurs des membres statiques int n = Nombre .count; // n = 0// appelle la méthode non statique Add1() de la classe Methods M.Add1();// augmente Count.count de 1

n = Nombre .count ; // n = 1

Comme le montre l'exemple, le membre de données statique Count.count est commun aux méthodes Add1() et Add2() de la classe Methods. Si le programme devait implémenter d'autres classes avec certaines méthodes, alors ce membre de données serait accessible à partir de ces méthodes.

Si dans cet exemple la classe Count est déclarée non statique (sans le mot clé static)// Nombre de classes - non statique nombre de classes (// le nombre de variables statiques dans la classe Count est une ressource partagée

nombre d'ints statiques publics ; )...

alors le résultat du programme ne changera pas. La variable statique Count.count peut être utilisée comme ressource partagée. Exemple 2

. L'exemple montre l'utilisation d'une méthode statique dans une classe non statique. Une méthode statique agit comme une ressource partagée qui effectue un travail général.

L'exemple déclare une méthode statique AbsComplex() qui trouve le module d'un nombre complexe. La méthode est déclarée dans la classe ComplexLibrary. Nous déclarons également 2 classes qui contiennent des méthodes qui utilisent la méthode AbsComplex() dans leurs calculs.// classe non statique contenant une méthode statique classe ComplexLibrary ( // méthode statique, calcule le module d'un nombre complexe public static double AbsComplex(double a, double b) ( return Math .Sqrt(a * a + b * b); ) ) // classe qui contient une méthode non statique qui utilise la méthode statique AbsComplex classe CalcComplex1 ( // méthode non statique // détermine si les modules de 2 nombres complexes sont égaux // cette méthode utilise la méthode statique ComplexLibrary.AbsComplex() pour les calculs public bool EqualComplex(double a1, double b1, double a2, double b2) ( double valeur1, valeur2; // utilise la méthode statique AbsComplex() valeur1 = ComplexLibrary .AbsComplex(a1, b1); valeur2 = ComplexLibrary .AbsComplex(a2, b2); valeur de retour1 == valeur2; ) )// une autre classe qui utilise la méthode AbsComplex() de la classe ComplexLibrary

classe CalcComplex2 (

// méthode qui détermine si la longueur d'un nombre complexe est égale à 0 public bool ZeroComplex(double a, double b) ( double valeur = ComplexLibrary .AbsComplex(a, b); valeur de retour == 0.0; ) ) L'utilisation des méthodes des classes CalcComplex1, CalcComplex2 peut être la suivante :

CalcComplex1 c1 = nouveau CalcComplex1();

// crée une instance (objet) de la classe

• CalcComplex2 c2 = nouveau CalcComplex2(); bool f; f = c1.EqualComplex(3, 4, 2, 5); // f = Faux f = c1.EqualComplex(1, 2, 2, 1); // f = Vrai f = c1.EqualComplex(-1, 2, -2, 1); // f = Vrai f = c2.ZeroComplex(0, 0); // f = Vrai f = c2.ZeroComplex(1, -5); // f = Faux
• 6. Quels sont les avantages de l’utilisation de classes, méthodes et variables statiques dans les programmes C# ?
• Les classes, méthodes et variables statiques sont efficaces dans les cas suivants :
• si vous devez créer des méthodes dites d'extension. Les méthodes d'extension sont utilisées pour étendre les fonctionnalités d'une classe. Ces méthodes sont statiques ;

si le programme dispose d'une ressource partagée accessible par les méthodes de différentes classes qui traitent cette ressource (lire ou modifier sa valeur). Cette ressource partagée est déclarée comme variable statique. Par exemple, une telle ressource pourrait être un compteur d'appels, une méthode qui implémente un traitement unique, une variable de fichier unique (ressource), etc. ;

Dans n'importe quelle classe non statique, les méthodes statiques et non statiques peuvent être déclarées. La différence entre appeler une méthode de classe statique et non statique est la suivante :

• Pour appeler une méthode non statique d'une classe, vous devez créer une instance (objet) de cette classe. Une méthode statique est appelée sans créer d'objet de classe - le nom de la méthode est précédé du nom de la classe dans laquelle cette méthode statique est déclarée.

Par exemple. Une classe Sqr non statique est définie et contient les deux méthodes suivantes qui renvoient le carré d'une valeur entière :

• GetSqr() – méthode non statique ;
• GetSqrStatic() est une méthode statique.

classe Sqr ( // méthode non statique public int GetSqr(int x) ( return x * x; ) // méthode statique public static int GetSqrStatic(int x) ( return x * x; ) )

Ce qui suit montre l'appel et l'utilisation de ces méthodes :

// Démonstration de l'appel de méthodes de classe statiques et non statiques int t; // 1. Appel d'une méthode non statique de la classe Sqr // Nous devons créer un objet de classe Sqr sc = nouveau Sqr(); t = sc.GetSqr(7); // t = 49 // 2. Appel d'une méthode statique de la classe Sqr t = Carré .GetSqrStatic(7); // t = 49

Comme vous pouvez le voir dans le code ci-dessus, pour appeler une méthode statique d'une classe, vous devez faire précéder son nom du nom de cette classe.

8. Est-il possible de déclarer un membre statique caché (privé) dans une certaine classe ?

Oui, vous pouvez. Dans ce cas, ce membre statique de la classe ne sera accessible que dans les limites de cette classe, c'est-à-dire depuis les méthodes de cette classe. L'accès à partir des méthodes d'autres classes ne sera pas possible.

9. Est-il possible de déclarer un membre de classe statique avec le modificateur d'accès protégé ?

Oui, vous pouvez. Dans ce cas, les méthodes de classe héritées de cette classe auront accès au membre statique de la classe.

Par exemple. Une classe A est donnée, contenant un membre statique a déclaré protégé. La classe B est également donnée, qui hérite (étend) de la classe A. A partir de la méthode SomeMethod() de la classe B, on accède à la variable protégée de la classe A.

// classe non statique contenant des méthodes non statiques et statiques classe A ( protected static int a; ) // la classe B hérite (étend) de la classe A classe B : A ( void SomeMethod() ( a = 10; // accès à la variable protégée de classe A } }

10. Une classe non statique peut-elle contenir des variables statiques et des méthodes statiques ?

Oui, c'est possible. Des exemples d'utilisation de méthodes statiques dans une classe non statique sont donnés aux paragraphes 5 et 7.

11. Est-il possible de combiner des méthodes statiques et non statiques dans une seule classe ?

Oui, vous pouvez. Mais seulement dans une classe non statique. Si une classe est déclarée statique, alors toutes les méthodes et variables de la classe doivent également être statiques (voir paragraphe 4 - Exemple 2).

Par exemple. L'exemple montre la combinaison de méthodes de classe statiques et non statiques pour accéder à une variable statique cachée t dans la classe. Une classe non statique CMyClass est déclarée, contenant une variable statique, des méthodes d'accès statiques et non statiques.

// classe non statique classe CMyClass( // variable statique déclarée privée int statique privé t ; // méthode statique qui change la valeur de la variable statique t public static void Set(int _t) ( t = _t; ) // méthode non statique qui lit la valeur de la variable statique t public int Get() (retour t;))

Le code suivant montre l'accès à la variable statique cachée t de la classe CMyClass

// démonstration de la combinaison de membres de classe statiques et non statiques entier x ; // 1. Accès à une variable statique cachée (privée) via la méthode static Set CMyClass.Set(777); // variable statique t = 777 // 2. Lire la valeur de la variable statique cachée (privée) t // 2.1. Créer un objet de classe CMyClass mc = new CMyClass(); // 2.2. Appeler une méthode Get() non statique via une instance d'une classe x = mc.Get(); // x = 777 - valeur actuelle de la variable statique

Cet exemple montre bien comment vous pouvez organiser le travail avec des données de classe générales et cachées.

12. Est-il possible de créer un objet d'une classe non statique dans une méthode statique d'une classe statique ?

Oui, vous pouvez. Un exemple classique de ceci est la fonction Main() pour les applications console. Cette fonction est déclarée comme statique. Cependant, vous pouvez créer des instances de n'importe quelle classe non statique dans cette fonction.

13. Que sont les constructeurs statiques ? Exemple

Les constructeurs statiques vous permettent d'initialiser des variables de classe statiques.

Exemple. La déclaration d'un constructeur statique dans une classe est démontrée.

// classe qui contient un constructeur statique classe CCount ( nombre d'ints statiques privés ; statique CCount() ( nombre = 7 ; // initialisation du nombre de variables statiques } // accès au nombre de variables statiques internes public static int Get() ( return count; ) )

Démonstration du fonctionnement de la classe CCount dans une certaine méthode

entier x ; x = CCount .Get(); //x = 7

14. Quelles sont les règles (fonctionnalités) d'utilisation des constructeurs statiques ?

Lorsque vous utilisez des constructeurs statiques, vous devez faire attention aux règles suivantes :

• Un constructeur statique peut être précédé du mot clé static ;
• les constructeurs statiques sont appelés automatiquement lorsque la classe est chargée pour la première fois ;
• Les constructeurs statiques ne peuvent pas avoir de modificateurs d'accès (public, privé). Autrement dit, les constructeurs statiques ont un accès par défaut. Cela est dû au fait que les constructeurs statiques sont appelés en premier dans une classe – avant que la première instance de la classe ne soit créée dans le programme ;
• un constructeur statique ne peut pas avoir de paramètres. Si vous essayez de créer un constructeur statique paramétré dans une classe, une erreur de compilation se produira.

15. Est-il possible d'initialiser des variables de classe non statiques à partir de constructeurs statiques ?

Non, tu ne peux pas. Parmi les constructeurs statiques, seules les variables statiques de la même classe peuvent être initialisées. Si cette classe déclare également des variables non statiques, les constructeurs statiques n'y ont pas accès.

Par exemple.

class CFileName ( chaîne statique privée fname ; // variable statique cachée dossier de chaîne privé ; // variable non statique cachée // constructeur statique static CFileName(string _fname) ( fname = _fname; // accès uniquement aux variables de classe statiques // dossier = ""; // erreur, le dossier est une variable non statique } }

Sujets connexes

• La notion de classe. Forme générale de déclaration de classe. Objet Entrée suivante Reliure tardive. Appel de méthode. Exemple. Classe System.Activator. Méthode Invoke()

En programmation orientée objet, une méthode est un bloc de code nommé déclaré dans une classe et pouvant être réutilisé. Si vous êtes familier avec la programmation procédurale (Pascal, Basic), rappelez-vous ce qu'est une fonction - en termes de principe de fonctionnement, elle et la méthode ont beaucoup en commun.

Une méthode bien écrite résout un problème pratique : trouve la racine carrée d'un nombre (comme la méthode standard sqrt() en Java), convertit un nombre en chaîne (méthode toString()), attribue des valeurs aux champs d'objet, et ainsi de suite.

Une nouvelle méthode est d'abord déclarée et définie, puis appelée sur l'objet ou la classe souhaitée.

Les méthodes de langage standard - intégrées - fonctionnent avec des objets de service. Par exemple, la méthode print en Java imprime les valeurs sur la console. Appelez-le comme ceci :

Système. dehors. print("Bonjour tout le monde !" );

Faites attention à la structure : la classe System a un champ out - un flux d'entrée/sortie. Le champ est également un objet et il possède une méthode print() que nous appelons.

Il existe également une méthode println(), qui déplace automatiquement le chariot vers la ligne suivante lors de la sortie des valeurs. Cela élimine le besoin de mettre « \n » au niveau du saut de ligne.

Pour qu'une application Java fonctionne, elle doit déclarer une méthode principale dans sa classe de base.

public static void main (arguments de chaîne) ( // voici le code principal et les appels aux autres méthodes }

Comme vous pouvez le voir, main prend un tableau de chaînes comme paramètre, dans ce cas les paramètres de lancement.

Déclarer et définir une méthode en Java

Les méthodes peuvent ou non renvoyer des valeurs et peuvent être appelées avec ou sans paramètres. Le type de données renvoyées est indiqué lors de la déclaration d'une méthode - avant son nom.

Dans l'exemple ci-dessous, la méthode doit trouver le plus grand de deux entiers, le type de retour est donc int :

public static int maxFinder(int a, int b) ( //en-tête de méthode //ci-dessous le corps de la méthode int max ;< b) max = b; else max = a; return max; }

si (un

L'en-tête de la méthode contient d'abord des modificateurs qui déterminent dans quelles conditions elle est disponible pour l'appel. Plus d’informations à ce sujet ci-dessous. Revenons au titre : int - type de retour, maxFinder - nom de la méthode, paramètres entre parenthèses.

Dans le corps de la méthode, on crée une variable max, où on écrira ensuite un nombre plus grand. Ensuite, nous comparons les valeurs, fixons la plus grande au maximum et la renvoyons.

Veuillez noter que return peut fonctionner non seulement avec une variable, mais également avec une expression. Si nous ne comparions pas les valeurs, mais les ajoutions, le résultat pourrait être renvoyé sans variable interne supplémentaire. Le corps de la méthode n’aurait qu’une seule ligne :

retourner a+ b ;

Lorsqu'une méthode ne doit rien renvoyer, le type de retour est spécifié comme void. Et si la méthode n'a pas besoin de paramètres d'entrée pour fonctionner, les parenthèses restent vides : static void theWarning() ( System. out. println(); }

"Je n'ai besoin de rien et tu n'obtiendras rien de moi."

Comment appeler une méthode en Java

Une méthode avec le modificateur public peut être appelée depuis n'importe quelle classe, y compris celles situées dans un fichier externe. Si vous souhaitez qu'une méthode soit accessible exclusivement au sein de sa classe, utilisez le modificateur private. Il existe également une version plus douce de la restriction d'accès : les méthodes avec le modificateur protected sont disponibles pour les sous-classes de leur classe et pour les autres classes du même package. Plus il est difficile d’accéder à une méthode de l’extérieur, plus elle est sûre – moins le risque d’erreurs est faible.

Une méthode statique en Java appartient à la classe, pas aux objets (et instances) de la classe. Il est donc appelé sans créer d’instance.

Les méthodes sont appelées de deux manières : selon qu'elles renvoient quelque chose ou non. Si oui, nous substituons la valeur là où nous en avons besoin :

public static void main(String args) ( Système . out . print(maxFinder(3 ,8 )); )

Nous avons appelé maxFinder et avons immédiatement affiché le résultat de son travail à l'écran. Pour cet exemple, les nombres sont définis manuellement en tant que constantes sans nom, mais dans les applications réelles, ils comparent généralement les valeurs des variables.

Après l'appel, la méthode contrôle le programme jusqu'à la fin de son travail : jusqu'à ce que l'opérateur de retour ou d'interruption soit déclenché dans son corps, ou jusqu'à ce que toutes les instructions qu'il contient soient exécutées.

Appelons theWarning, qui ne renvoie rien :

public static void main(String args) ( theWarning(); System . out. print("theWarning a terminé son travail. Passons à autre chose."); )

Cette méthode se passe d'assistants - elle fait ce qu'elle doit et passe le contrôle au code suivant.

Appeler une méthode depuis une autre classe

Et si maxFinder était dans une classe distincte et n'était pas statique ? Ensuite, pour l'appeler, il faudra d'abord créer un objet de la classe dans laquelle il réside. Disons que la méthode se trouve dans la classe SampleClass. Nous appelons :

public void main(String args) ( SampleClass sc= new SampleClass (); System. out. print(sc. maxFinder(5,8)); )

Une méthode statique est appelée via un point sur le nom de la classe - comme ceci :

Système. dehors. print(SomeClass . maxFinder(5 ,8 ));

Surcharge de méthode en Java

Et si nous devions comparer non seulement des nombres entiers, mais également des nombres à virgule flottante ? La surcharge de méthode aidera à implémenter cela. Copiez-collez la méthode maxFinder dans la même classe, remplacez les types de toutes les valeurs impliquées par double :

public statique double maxFinder(double a, double b) ( double max; //laisse le reste du corps de la méthode inchangé }

Nous ne changeons pas le nom de la méthode ! Il s'agit d'une surcharge : le compilateur choisira lui-même quelle version de la méthode utiliser, en fonction du type de valeurs que nous comparons.

Le mot-clé this dans les méthodes Java

Le mot-clé this permet de faire référence aux instances d'une classe : leurs variables, méthodes et constructeurs. Utilisez-le uniquement dans un constructeur de méthode ou d’instance. Par exemple, voici comment associer les paramètres d’entrée d’une méthode aux mêmes paramètres d’une instance spécifique de la classe :

classe UserData ( int id, age, phone; void setProfileData ( int id , int age , int phone ) ( this . id= id; this . age= age; this . phone= phone; ) )

Un autre exemple consiste à appeler un constructeur à partir d'un autre :

classe ProfileData (int id; ProfileData () ( this (100); ) ProfileData (int id) ( this . id = id; ) )

C'est ce qu'on appelle un « appel explicite du constructeur ».

Méthodes abstraites en Java

Une méthode abstraite est une méthode déclarée sans implémentation - elle n'a ni corps ni même accolades. Le nom d'une telle méthode est précédé du modificateur abstrait :

nom de méthode vide abstrait ();

Pourquoi est-il nécessaire comme ça ? Comme modèle pour d'autres méthodes d'autres classes. Ici, nous avons une classe abstraite « Building », et elle contient une méthode abstraite « build ». Ces abstractions doivent être implémentées via plusieurs classes dérivées non abstraites et leurs méthodes. Exemple : classe « Hut » - méthode « buildHut », classe « Bridge » - méthode « buildBridge », etc.

package ru.vos.classes ; classe abstraite Construction ( abstract void build_it (String msg1 ); abstract void sell_it (String msg2 ); ) public class Hut extends Construction ( // classe non abstraite@Outrepasser // remplace la méthode void build_it (String msg1) ( Système . out . println ( "La cabane est construite !"); ) @Override void sell_it (String msg2) ( Système . out . println ("La cabane a été vendue." ); ) ) classe abstraite publique Bridge extends Construction ( @Override void build_it (String msg1 ) ( System . out . println ( "Le pont est construit!" ); ) // Disons que les objets de la classe Bridge ne sont pas censés être vendus.// Nous n'avons alors pas besoin de redéfinir sell_it.

// Mais nous allons certainement créer une méthode enfant abstraite :

résumé void sell_it (String msg2); ) Puisqu’une classe abstraite n’a pas d’implémentation concrète, ses instances ne peuvent pas être créées. Il s'agit d'un modèle qui définit la structure des autres classes et contient des déclarations de méthodes. Modificateur

statique

- de l'anglais "statique", "permanent" - rend la variable ou la méthode "indépendante" de l'objet. Voyons comment le modificateur est appliqué aux méthodes.

modificateur statique pour les méthodes

1. La méthode est appelée sans créer d’objet de classe.

Comme pour les champs, les méthodes statiques peuvent être appelées sans créer d’objet. Par exemple, imaginez que nous ayons une classe MyClass - et qu'à l'intérieur il y a deux méthodes, statique et « normale » : class MyClass( public static void firstMethod ()( System.out.println("Ceci est une méthode statique!"); ) public void secondMethod ()( System.out.println("Ceci n'est PAS une méthode statique!"); ) ) classe MaClasse ( public static void firstMethod() () ; Système. dehors . println( classe MaClasse ( "C'est une méthode statique !") ;

Nous pouvons appeler les deux méthodes en créant un objet MyClass :

test de classe ( public static void main (String args)( MyClass c1 = new MyClass(); c1.firstMethod(); c1.secondMethod(); ) )

Test de classe ( MaClasse c1 = new MaClasse(); c1. premièreMéthode(); c1. secondeMéthode();

Cependant, essayons d'écrire la même chose sans créer d'objet - comme ceci :

test de classe ( public static void main (String args)( MyClass.firstMethod(); MyClass.secondMethod(); ) )

Test de classe ( public static void main (arguments de chaîne) ( MaClasse. premièreMéthode(); MaClasse. secondeMéthode();

Ici, nous avons remplacé le nom de l'objet - c1- au nom de la classe (après tout, nous n'avons plus un seul objet maintenant ! :)).

Selon vous, que va-t-il se passer ?

Naturellement, un tel code ne fonctionnera pas. Le fait est que vous ne pouvez accéder qu'à une seule de ces méthodes de cette manière - la méthode statique :

test de classe ( public static void main (String args)( MyClass.firstMethod(); ) )

Test de classe ( public static void main (arguments de chaîne) ( MaClasse. premièreMéthode();

Si nous avons besoin d'une deuxième méthode non statique, nous devrons créer un objet de classe MaClasse. Comme vous pouvez le constater, si vous vous tournez vers méthodes statiquesà la fois via le nom de l'objet et le nom de la classe, le code fonctionnera. Les méthodes non statiques doivent être accessibles exclusivement via le nom des objets de classe.

2. Les méthodes statiques ne peuvent pas être remplacées.

Comme vous vous en souvenez, l’un des principes fondamentaux est « l’héritage ». Le fait est que dans les cas où nous devons créer une nouvelle classe qui a de nombreuses propriétés communes avec une classe existante, au lieu de tout écrire à nouveau, nous pouvons créer un « successeur » de la classe existante. Cet "enfant" aura la même méthode et les mêmes variables que le "parent".

Cependant, dans une classe descendante, vous pouvez généralement redéfinir méthodes existantes. Cela signifie que vous pouvez créer une méthode avec le même nom, en remplaçant simplement ses éléments internes. Donc, statique la méthode ne peut pas être remplacée. Par analogie avec les variables, on peut dire que cette méthode est « une pour la classe et ses descendants » - tout comme une variable statique est « une pour la classe et tous ses objets ».

3. Les méthodes statiques nécessitent un « contexte statique ».

Il existe une telle règle : une méthode statique ne peut pas référencer une variable non statique. Qu'est-ce que ça veut dire?

Imaginez que nous ayons une méthode statique dans une classe. Autrement dit, c'est une méthode à laquelle, comme vous le savez, accessible sans créer d'objet de classe. Cela signifie que si une méthode statique accède à des variables non statiques (qui "n'existeront tout simplement pas" car l'objet n'est pas déclaré), une erreur se produira. C'est pourquoi, les méthodes statiques ne peuvent référencer que des variables statiques . Cela garantit que lorsque notre méthode s'exécutera, tous les éléments seront initialisés et fonctionneront. C'est ce qu'on appelle un « contexte statique ».

Le résultat de deux parties - pourquoi le modificateur statique est utilisé

Ainsi, vous comprenez en termes généraux quel est le principe de fonctionnement du modificateur statique. Résumons : comment est-il utilisé ?

1. Si vous devez déclarer des constante- par exemple, = 3,14 - vous devez utiliser du statique. Ils sont déclarés à l'aide de la combinaison "static final" :classe publique Test (

public statique final double pi = 3.14159265359 ;

2. Si vous avez besoin d'avoir accéder à une variable ou une méthode sans créer d'instance de la classe. Par exemple, imaginons que nous ayons une classe appelée Cat. Logiquement, cela n'a aucun sens de rendre la variable « nom du chat » statique - après tout, elle sera individuelle pour chaque instance de la classe - c'est-à-dire pour chaque chat. Et cela n'a aucun sens de rendre la méthode "miaou" statique - après tout, sans chat (sans créer d'objet de classe), il ne semble y avoir personne pour miauler :)

Mais si nous imaginons que nous avons un cours de mathématiques, qui aura une méthode « trouver la racine carrée ». Nous pouvons rendre cette méthode statique - après tout, elle nous sera évidemment très utile et sera souvent utilisée. Pourquoi écrire deux lignes de code (créer une instance de classe + appeler une méthode) si vous pouvez vous en sortir avec une seule (appeler une méthode) ? En même temps, la classe Math ne porte aucune charge logique, contrairement aux classes Cat, Dog ou Car, et nous n'avons pas du tout besoin d'un objet Math pour trouver des racines carrées :)

3. Les variables et méthodes statiques ont une autre propriété utile : elles commun à toutes les instances de la classe.

D'une part, cela fait écho au réglage des constantes - point 1. Par exemple, imaginez que nous ayons une classe Cat, qui a deux champs - "number_of_paws" et "number_of_tails". Il est clair que pour toutes les instances de cette classe la variable "number_of_legs" sera égale à 4, et "number_of_tails" sera égale à 1. Nous pouvons rendre ces champs statiques car ils seront partagés. De plus, cela nous aidera à économiser de la mémoire car ces variables ne seront pas « recréées » pour chaque instance. Au contraire, toutes ces instances feront référence à la même variable – statique.

Le fait qu’une variable statique soit commune à toutes les classes peut être utilisé d’autres manières. Par exemple, imaginez que nous ayons une classe appelée Dog. Dans cette classe, nous aurons une variable statique "number_of_dogs" et nous la ferons incrémenter de 1 à chaque fois que nous créerons un objet de la classe Dog. De cette façon, nous pourrons compter le nombre d'objets que nous avons créés ! Ou bien, ce chiffre peut être utilisé pour attribuer un numéro d’identification unique à chaque chien.

Vous connaissez maintenant les méthodes de base pour utiliser le modificateur statique. Il y en a d'autres, mais nous les examinerons plus tard.

Méthodes de type statique est un outil de cadre de langage implémenté pour fonctionner avec des données membres statiques. Ces méthodes peuvent être divisées en deux types :

méthodes statiques dans les classes statiques ;

méthodes statiques dans les classes non statiques.

Si un programmeur déclare une classe statique, alors tous les membres de cette classe deviennent statiques, y compris les méthodes. Ce sont des méthodes de classes - des conteneurs d'instructions ; elles acceptent des objets d'autres types pour le traitement et produisent la valeur de type dont le programmeur a besoin.

Un cas plus courant est celui où le programmeur doit implémenter un bloc d’instructions indépendant du type d’objet. Ce bloc d'instructions est une méthode statique, puisqu'il est appelé avant la création d'une instance du type.

Déclarer et appeler une méthode statique

Une méthode est déclarée statique en utilisant le mot-clé static avant le type de retour dans la définition de la méthode au niveau de la classe :

Classe publique Somenonstaticclass ( // Déclarez les champs statiques. static int firststaticfield; static string secondstaticfield; // Déclarez les champs non statiques. double firstnonstaticfield; float secondnonstaticfield; // Déclarez une méthode statique. static void FirstStaticMethod() ( // Implémentation d'un méthode statique. Console WriteLine (premier champ statique); Console.WriteLine (second champ statique);

Un programmeur peut appeler une méthode statique via le nom du type dans lequel elle est définie :

Classe UseStaticMethods ( static void Main() ( // Appel d'une méthode statique via le nom du type. Somenonstaticclass.FirstStaticMethod(); ) )

Restrictions d'utilisation

Les méthodes statiques ne participent pas à l'héritage. Ils sont scellés. Ils ne peuvent qu’être surchargés, mais pas redéfinis. La limitation s'exprime dans le fait que les méthodes statiques appartiennent à la classe dans laquelle elles sont définies, les méthodes non statiques – à l'objet de la classe.

Classe publique Somenonstaticclass ( // Déclare les champs statiques de la classe. static int firststaticfield; static string secondstaticfield; double firstnonstaticfield; float secondnonstaticfield; // Déclare une méthode statique. static void FirstStaticMethod() ( // Implémentation de la méthode statique. Console .WriteLine(firststaticfield); Console.WriteLine(secondstaticfield); // Surcharger la méthode FirstStaticMethod() static int FirstStaticMethod(string a) ( Console.WriteLine("L'argument de méthode que vous avez entré est imprimé : "+a); ) )

Les méthodes statiques d'une classe non statique dans le bloc d'implémentation n'ont accès qu'aux membres statiques. Vous ne pouvez pas utiliser de membres non statiques dans les méthodes statiques :

Classe publique Somenonstaticclass ( // Déclare les champs statiques de la classe. static int firststaticfield; static string secondstaticfield; double firstnonstaticfield; float secondnonstaticfield; // Déclare une méthode statique. static void FirstStaticMethod() ( // Implémentation de la méthode statique. Console .WriteLine(firststaticfield); Console.WriteLine(secondstaticfield); Console.WriteLine(firstnonstaticfield); // La ligne provoquera une erreur de compilation car un membre non statique est utilisé à l'intérieur d'un membre statique.

21 réponses

Une règle générale : demandez-vous : "Est-il judicieux d'appeler cette méthode même si l'Obj n'a pas encore été construit ?" Si tel est le cas, ce sera définitivement statique.

Ainsi, dans la classe Car, vous pourriez avoir une méthode double convertMpgToKpl(double mpg) qui serait statique car vous pourriez savoir en quoi 35mpg est converti même si personne n'a jamais construit de voiture. Mais void setMileage(double mpg) (qui définit l'efficacité d'une voiture spécifique) ne peut pas être statique, car il est impensable d'appeler la méthode avant qu'une voiture n'ait été construite.

(Au fait, l'inverse n'est pas toujours vrai : parfois, vous pouvez avoir une méthode qui inclut deux objets Car et vouloir toujours qu'elle soit statique. Par exemple Car theMoreEfficientOf(Car c1, Car c2). Bien que cela puisse être converti en not - static version, certains soutiennent que puisqu'il n'y a pas de choix "privilégié" pour savoir quelle voiture est la plus importante, vous ne devriez pas forcer l'appelant à choisir une voiture comme objet que vous référencerez, une partie assez petite de toutes les méthodes statiques.)

Définissez des méthodes statiques uniquement dans les scénarios suivants :

Il existe plusieurs bonnes raisons d’utiliser des méthodes statiques :

Performance: Si vous souhaitez exécuter du code et que vous ne souhaitez pas instancier un objet supplémentaire pour le faire, placez-le dans une méthode statique. La JVM peut également beaucoup optimiser les méthodes statiques (je pense avoir lu une fois James Gosling déclarant que vous n'avez pas besoin d'instructions spéciales dans la JVM car les méthodes statiques seront tout aussi rapides, mais je ne trouve pas la source - donc cela peut être complètement faux). Oui, il s'agit d'une micro-optimisation et probablement inutile. Et nous, les programmeurs, ne faisons jamais de choses inutiles simplement parce que c'est cool, n'est-ce pas ?

Praticité: Au lieu d'appeler new Util().method(arg), appelez Util.method(arg) ou method(arg) avec importation statique. Plus facile, plus court.

Ajout de méthodes: vous vouliez vraiment que la classe String ait une méthode d'instance removeSpecialChars(), mais elle n'existe pas (et elle ne devrait pas, car les caractères spéciaux de votre projet peuvent être différents de ceux d'un autre projet), et vous ne pouvez pas l'ajouter ( puisque Java est tout à fait normal), vous créez donc une classe utilitaire et appelez removeSpecialChars(s) au lieu de s.removeSpecialChars() . Doux.

Pureté: En prenant quelques précautions, votre méthode statique sera une fonction pure. La seule chose dont elle dépend, ce sont ses paramètres. Des données, des données. Il est plus facile à lire et à déboguer puisque vous n’avez pas à vous soucier de l’héritage. Vous pouvez également le faire avec les méthodes d'instance, mais le compilateur vous aidera un peu plus avec les méthodes statiques (ne vous permettant pas de référencer les attributs d'instance, de remplacer les méthodes, etc.).

Vous devrez également créer une méthode statique si vous souhaitez créer un singleton, mais... ne faites pas ça. Je veux dire, réfléchis à deux fois.

Maintenant, plus important encore, pourquoi ne voudriez-vous pas créer une méthode statique ? En principe, le polymorphisme passe par la fenêtre. Vous ne pourrez pas surcharger une méthode et vous ne pourrez pas la déclarer dans une interface (pré-Java 8). Cela nécessite beaucoup de flexibilité de la part de votre conception. Aussi, si vous avez besoin État, tu en auras beaucoup erreurs de concurrence et/ou des goulots d'étranglement si vous ne faites pas attention.

Après avoir lu les articles de Misko, je pense que les méthodes statiques sont mauvaises du point de vue des tests. Au lieu de cela, vous auriez dû (peut-être en utilisant un outil d'imbrication par injection comme Guice).

comment puis-je m'assurer que je n'en ai qu'un seul

il n'y a qu'un seul problème "comment puis-je m'assurer que je n'ai qu'un seul des "bien" éludé. Vous n'instancierez qu'une seule ApplicationFactory dans votre main et, par conséquent, vous n'instancierez que l'instance entière de vos singlets.

Le principal problème des méthodes statiques est le code procédural

Le principal problème des méthodes statiques : ce sont du code procédural. Je n'ai pas d'idée de procédure de test unitaire. Les tests unitaires supposent que je puisse instancier une partie de mon application de manière isolée. Lors de la création, j'inclus des dépendances à l'aide de mocks/friendly qui remplacent les vraies dépendances. Avec la programmation procédurale, il n'y a rien sur quoi « s'appuyer » car il n'y a pas d'objets, le code et les données sont séparés.

Une méthode statique est un type de méthode qui ne nécessite pas l’initialisation d’un objet pour l’appeler. Avez-vous remarqué que static est utilisé dans la fonction principale en Java ? L'exécution du programme commence à partir de là sans créer d'objet.

Prenons l'exemple suivant :

Langages de classe ( public static void main(String args) ( display(); ) static void display() ( System.out.println("Java est mon langage de programmation préféré."); ) )

Les méthodes statiques en Java sont spécifiques à une classe (et non à une instance). Ils n'utilisent pas de variables d'instance et prennent généralement les entrées des paramètres, effectuent des actions dessus, puis renvoient un résultat. Les méthodes d'instance sont associées à des objets et, comme leur nom l'indique, peuvent utiliser des variables d'instance.

Si vous appliquez un mot-clé statique avec n’importe quelle méthode, on parle de méthode statique.

• Une méthode statique fait référence à une classe et non à un objet de la classe.
• Méthode statique appelée sans qu'il soit nécessaire de créer une instance de la classe.
• une méthode statique peut accéder à une donnée membre statique et modifier sa valeur.

//Programme pour changer une propriété commune à tous les objets (champ statique).

Classe Étudiant9( int rollno; Nom de la chaîne; static String college = "ITS"; static void change())( college = "BBDIT"; ) Student9(int r, String n)( rollno = r; name = n; ) void display ()(System.out.println(rollno+" "+name+" "+college);) public static void main(String args)( Student9.change(); Student9 s1 = new Student9 (111,"Indian"); Student9 s2 = new Student9 (222, "Américain"); s3 = new Student9 (333, "Chine");

O/P : 111 BBDIT indien 222 BBDIT américain 333 BBDIT chinois

Les méthodes statiques ne sont pas instanciées et ne peuvent donc pas accéder aux champs non statiques de la classe.

Vous utiliserez une méthode statique si la méthode n’utilise aucun champ (ou uniquement des champs statiques) de la classe.

Si des champs de classe non statiques sont utilisés, vous devez utiliser une méthode non statique.

En fait, nous utilisons des propriétés et des méthodes statiques dans une classe lorsque nous voulons qu'une partie de notre programme y existe jusqu'à ce que notre programme soit exécuté. Et nous savons que pour manipuler les propriétés statiques, nous avons besoin de méthodes statiques puisqu'elles ne font pas partie de la variable d'instance. Et sans méthodes statiques, la gestion des propriétés statiques prend beaucoup de temps.

Les méthodes et variables statiques sont la version gérée des fonctions et variables « globales » en Java. Quelles méthodes sont accessibles en tant que classname.methodName() ou classInstanceName.methodName() , c'est-à-dire que les méthodes et variables statiques sont accessibles en utilisant le nom de la classe ainsi que les instances de la classe.

Une classe ne peut pas être déclarée statique (car cela n'a aucun sens. Si une classe est déclarée publique, elle est accessible de n'importe où), les classes internes peuvent être déclarées statiques.

Les méthodes statiques peuvent être utilisées si

Pas besoin d'effectuer une action sur l'instance (méthodes utilitaires)

Comme mentionné dans plusieurs des réponses ci-dessus dans cet article, convertir des miles en kilomètres ou calculer la température de Fahrenheit en Celsius et vice versa. Dans ces exemples, en utilisant une méthode statique, il n'est pas nécessaire d'instancier un tout nouvel objet sur le tas. Jetons un coup d'oeil ci-dessous

1. nouveau ABCClass (double farenheit).convertFarenheitToCelcium() 2. ABCClass.convertFarenheitToCelcium (double farenheit)

le premier crée une nouvelle classe pour chaque méthode, Performance, pratique. Les exemples sont la classe Math et Apache-Commons StringUtils ci-dessous :

Math.random() Math.sqrt(double) Math.min(int, int) StringUtils.isEmpty(String) StringUtils.isBlank(String)

• On veut être utilisé comme une simple fonction. Les entrées sont explicitement transmises et reçoivent les données de résultat comme valeur de retour. L'héritage, l'installation d'objet ne se produit pas. Concis, lisible.

Note: Peu de gens s'opposent au test des méthodes statiques, mais les méthodes statiques peuvent également être testées ! Avec jMockit, vous pouvez vous moquer des méthodes statiques. Testabilité. Exemple ci-dessous :

Nouvelle maquette () ( @Mock public int doSomething(Input input1, Input input2)( return returnValue; ) );

Je me demande quand utiliser des méthodes statiques ?

• Une manière courante d’utiliser les méthodes statiques consiste à accéder aux champs statiques.

Mais vous pouvez avoir des méthodes statiques sans référencer des variables statiques. Des méthodes d'assistance sans référence de variable statique peuvent être trouvées dans certaines classes Java telles que

Public statique int min(int a, int b) ( return (a<= b) ? a: b; }

Une autre façon de penser à ces méthodes en combinaison avec la méthode synchronisée consiste à implémenter le verrouillage au niveau de la classe dans un environnement multithread.

Disons que si j'ai une classe avec plusieurs getters et setters, une méthode ou deux, et que je souhaite que ces méthodes ne soient invocables que sur l'objet instance de classe. Cela signifie-t-il que je dois utiliser une méthode statique ?