Variable statique Java. Méthodes statiques en Java, surcharge de méthodes, récursion. Ce que tout programmeur devrait savoir sur le modificateur Static en Java
Qu'est-ce qui est statique
Dans certains cas, il est souhaitable de définir un membre d'une classe qui sera utilisé indépendamment de tout objet de cette classe. En règle générale, un membre de classe ne doit être accessible qu'en conjonction avec un objet de sa classe. Toutefois, vous pouvez créer un membre de classe pouvant être utilisé seul sans référence à une instance spécifique. Pour créer un tel membre, vous devez placer au début de sa déclaration mot-clé statique. Lorsqu'un membre de classe est déclaré statique, il est accessible avant la création des objets de sa classe et sans référence à aucun objet. Les méthodes et les variables peuvent être déclarées statiques. L’exemple le plus courant de membre statique est la méthode main(). Cette méthode est déclarée statique car elle doit être déclarée avant la création d'un objet.
Les variables d'instance déclarées comme statiques sont essentiellement des variables globales. Lors de la déclaration des objets de leur classe, le programme ne crée aucune copie de la variable statique. Au lieu de cela, toutes les instances d'une classe partagent la même variable statique.
Les méthodes déclarées comme statiques sont soumises à un certain nombre de restrictions.
- Ils ne peuvent appeler que d’autres méthodes statiques.
- Ils ne doivent accéder qu'aux variables statiques.
- Ils ne peuvent en aucun cas faire référence à des membres de type this ou super. (Le super mot-clé est lié à l'héritage et est traité dans le chapitre suivant.)
Si vous devez effectuer des calculs pour initialiser des variables statiques, vous pouvez déclarer un bloc statique qui ne sera exécuté qu'une seule fois lors du premier chargement de la classe. L'exemple suivant montre une classe qui contient une méthode statique, plusieurs variables statiques et un bloc d'initialisation statique :
// Démonstration de variables, méthodes et blocs statiques.
classe UseStatic(
statique int a = 3 ;
int statique b ;
static void meth(int x) (
System.out.println("x = " + x) ;
System.out.println("a = " + a);
System.out.println("b = " + b) ;
}
statique (
System.out.println("Bloc statique initialisé.");
b = une * 4 ;
}
méthamphétamine (42);
}
}
Immédiatement après le chargement de la classe UseStatic, le programme exécute toutes les instructions statiques. Tout d'abord, la valeur de a est définie sur 3, puis le programme exécute un bloc statique qui imprime un message, puis initialise la variable b avec la valeur de a*4, ou 12. Le programme appelle ensuite la méthode main(), qui appelle la méthode meth(), en passant la valeur x 42. Trois instructions println() font référence à deux variables statiques a et b à une variable locale x.
Le résultat de ce programme ressemble à ceci :
Bloc statique initialisé, x = 42 a = 3 b = 12
En dehors de la classe dans laquelle elles sont définies, les méthodes et variables statiques peuvent être utilisées indépendamment de tout objet. Pour ce faire, précisez simplement le nom de leur classe, suivi de l'opération point. Par exemple, si une méthode de type static doit être appelée depuis l’extérieur de sa classe, cela peut être fait en utilisant la forme générale suivante :
nom_classe.method()
Ici class_name est le nom de la classe dans laquelle la méthode de type static est déclarée. Comme vous pouvez le constater, ce format est similaire à celui utilisé pour appeler des méthodes non statiques via des variables de référence d'objet. Une variable statique est accessible de la même manière : via l'opérateur point suivant le nom de la classe. C'est ainsi que Java implémente les versions gérées des méthodes et variables globales.
Donnons un exemple. Dans la méthode main(), la méthode statique callme() et la variable statique b sont accessibles par leur nom de classe StaticDemo.
classe StaticDemo (
statique int a = 42 ;
int statique b = 99 ;
appel vide statique() (
System.out.println("a = " + a);
}
}
classe StaticByName (
public static void main (arguments de chaîne) (
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}
La sortie de ce programme ressemble à ceci.
9 réponses
Java a des classes imbriquées statiques, mais il semble que vous recherchiez une classe statique niveau supérieur. Java ne permet pas de rendre statique une classe de niveau supérieur, mais vous pouvez simuler une classe statique comme ceci :
- Déclarez votre classe finale - Empêche l'extension de la classe car l'extension d'une classe statique n'a aucun sens
- Rendre le constructeur privé - empêche l'instanciation par le code client, car il ne sert à rien de créer une classe statique
- Créer Touséléments et fonctions de la classe statique. Étant donné que la classe ne peut pas être instanciée, les méthodes d'instance ne peuvent pas être appelées ou les champs d'instance sont accessibles
- Notez que le compilateur ne vous empêchera pas de déclarer une instance (non statique). Le problème n'apparaîtra que si vous essayez d'appeler un membre de l'instance
Un exemple simple tiré des phrases ci-dessus :
Classe publique TestMyStaticClass ( public static void main(String args)( MyStaticClass.setMyStaticMember(5); System.out.println("Valeur statique : " + MyStaticClass.getMyStaticMember()); System.out.println("Valeur au carré : " + MyStaticClass.squareMyStaticMember()); // MyStaticClass x = new MyStaticClass(); // entraîne une erreur de compilation ) ) // Un niveau supérieur Classe Java imitant le comportement de la classe statique public final class MyStaticClass ( private MyStaticClass () ( // constructeur privé myStaticMember = 1; ) private static int myStaticMember; public static void setMyStaticMember(int val) ( myStaticMember = val; ) public static int getMyStaticMember() ( return monStaticMember; ) public static int squareMyStaticMember() ( return myStaticMember * myStaticMember; ) )
Qu'est-ce qui est bien avec les cours statiques ? Bon usage La classe statique consiste à définir des classes jetables, utilitaires et/ou bibliothèque où l'instanciation n'a pas de sens. Un excellent exemple est Cours de mathématiques, qui contient des constantes mathématiques telles que PI et E et fournit simplement calculs mathématiques. Exiger une instanciation dans un tel cas serait inutile et déroutant. Voir Cours de mathématiques Java. Veuillez noter qu'il est définitif et que tous ses membres sont statiques. Si Java permettait de déclarer les classes de niveau supérieur statiques, alors la classe Math serait effectivement statique.
Eh bien, Java a des "classes imbriquées statiques", mais elles ne sont pas du tout identiques aux classes statiques C#, si c'est de là que vous venez. Une classe imbriquée statique est simplement une classe qui n'implique pas de référence à une instance de la classe externe.
Les classes imbriquées statiques peuvent avoir des méthodes d'instance et des méthodes statiques.
Il n’existe pas de classe statique de niveau supérieur en Java.
Oui, il existe une classe imbriquée statique en Java. Lorsque vous déclarez une classe imbriquée static, elle devient automatiquement une classe à part entière qui peut être instanciée sans avoir à instancier la classe externe à laquelle elle appartient.
Exemple:
Classe publique A ( classe statique publique B ( ) )
Puisque la classe B est déclarée statique, vous pouvez l'instancier explicitement comme :
Bb = nouveau B();
Notez que si la classe B n'était pas déclarée statique pour la rendre autonome, l'appel de l'objet instance ressemblerait à ceci :
UNE a= nouveau A(); B b = a.nouveau B();
Que se passe-t-il lorsque les membres d'une classe sont déclarés comme statiques... ? Ces éléments sont accessibles sans créer d’instance de la classe. Par conséquent, rendre la classe externe (classe de niveau supérieur) statique n’a pas de sens. Ceci n’est donc pas autorisé.
Mais vous pouvez définir les classes internes pour qu'elles soient statiques (puisqu'elles sont membres de la classe de niveau supérieur). Cette classe peut alors être obtenue sans créer de classe de niveau supérieur. Considérez l'exemple suivant.
Classe publique A ( classe statique publique B ( ) )
Désormais, dans une autre classe C, il est possible d'accéder à la classe B sans créer d'instance de classe A.
Classe publique C ( A.B ab = new A.B(); )
les classes statiques peuvent avoir des membres non statiques. Seule la classe devient statique.
Mais si le mot-clé static est supprimé de la classe B , il n'est pas accessible directement sans créer une instance de A .
Classe publique C ( A a = new A(); A.B ab = a. new B(); )
Mais nous ne pouvons pas avoir de membres statiques dans une classe interne non statique.
Voir ce que c'est meilleur résultat Google pour "classe statique Java" et il n'y a pas de meilleure réponse ici, j'ai pensé que je l'ajouterais. J'interprète la question du PO comme concernant les classes statiques en C#, appelées singletons en Le monde Java. Pour ceux qui ne le savent pas, en C#, le mot-clé « static » peut être appliqué à une déclaration de classe, ce qui signifie que la classe résultante ne peut jamais être instanciée.
Extrait de "Effective Java - Second Edition" de Joshua Bloch (largement connu comme l'un des meilleurs guides en style Java) :
Depuis la version 1.5, il existe une troisième approche pour implémenter des singletons. Introduisez simplement un type enum avec un élément :
// Enum singleton - l'approche préférée public enum Elvis ( INSTANCE; public void LeaveTheBuilding() ( ... ) )
Cette approche est fonctionnellement équivalente à l'approche du domaine public, sauf qu'elle est plus concise, fournit une technique de sérialisation gratuite et offre une excellente garantie contre les instances multiples, même face à des attaques complexes de sérialisation ou de réflexion. Bien que cette approche ne soit pas encore largement utilisée, Le type enum singleton est le meilleur moyen d’implémenter singleton.(auteur de l'article)
Le modificateur static en Java est directement lié à la classe ; si le champ est statique, alors il appartient à la classe, si la méthode est statique, de la même manière, il appartient à la classe. Sur cette base, vous pouvez accéder à une méthode ou un champ statique en utilisant le nom de la classe. Par exemple, si le champ count est statique dans la classe Counter, alors vous pouvez accéder à la variable avec une requête telle que : Counter.count. Bien entendu, les modificateurs d’accès doivent être pris en compte. Par exemple, les champs privés ne sont disponibles qu'au sein de la classe dans laquelle ils sont déclarés. Les champs protégés sont disponibles pour toutes les classes du package ( emballer), ainsi que toutes les classes descendantes en dehors du package. Pour plus informations détaillées lisez l’article « privé vs protégé vs public ». Supposons qu'il existe une méthode statique incrément() dans la classe Counter dont le travail consiste à incrémenter le compteur count . Pour appeler cette méthode vous pouvez utiliser un appel comme Counter.increment() . Il n'est pas nécessaire d'instancier la classe Counter pour accéder à un champ ou une méthode statique. C'est la différence fondamentale entre les objets statiques et NON statiques (membres de classe). Remarque importante. N'oubliez pas que les membres de classe statiques appartiennent directement à la classe et non à son instance. Autrement dit, la valeur de la variable statique count sera la même pour tous les objets de type Counter. Dans cet article, nous examinerons les aspects fondamentaux de l'utilisation du modificateur statique en Java, ainsi que certaines fonctionnalités qui vous aideront à comprendre les concepts clés de la programmation.
Ce que tout programmeur devrait savoir sur le modificateur Static en Java.
Dans cette section, nous examinerons les bases de l'utilisation des méthodes, des champs et des classes statiques. Commençons par les variables.Vous ne pouvez PAS accéder aux membres non statiques d'une classe dans un contexte statique, tel qu'une méthode ou un bloc. La compilation du code ci-dessous entraînera une erreur :
public class Counter ( private int count ; public static void main (String args) ( System. out. println (count) ; // erreur de compilation ) )C'est l'une des erreurs les plus courantes commises Programmeurs Java, surtout pour les débutants. Étant donné que la méthode principale est statique et que la variable count ne l'est pas, dans ce cas, la méthode println à l'intérieur de la méthode principale générera une « erreur de compilation ».
Contrairement aux variables locales, les champs et méthodes statiques ne sont PAS thread-safe en Java. En pratique, c’est l’une des causes les plus courantes de problèmes liés à la sécurité de la programmation multithread. Étant donné que chaque instance d'une classe possède la même copie d'une variable statique, une telle variable a besoin d'une protection - "verrouillage" par la classe. Par conséquent, lorsque vous utilisez des variables statiques, assurez-vous qu'elles sont correctement synchronisées pour éviter des problèmes tels que des conditions de concurrence.
Les méthodes statiques ont un avantage à utiliser car... il n'est pas nécessaire de créer un nouvel objet à chaque fois pour accéder à ces méthodes. Une méthode statique peut être appelée en utilisant le type de la classe dans laquelle les méthodes sont définies. C'est pourquoi ces méthodes conviennent parfaitement comme méthodes d'usine et méthodes utilitaires. La classe java.lang.Math est un excellent exemple dans lequel presque toutes les méthodes sont statiques, ce qui explique pourquoi les classes utilitaires en Java sont définitives.
Un autre point important est que vous ne pouvez pas remplacer les méthodes statiques. Si vous déclarez la même méthode dans une sous-classe, c'est-à-dire méthode avec le même nom et la même signature, vous « masquerez » uniquement la méthode de superclasse au lieu de la remplacer. Ce phénomène est connu sous le nom de méthodes de dissimulation. Cela signifie que lors de l'appel d'une méthode statique déclarée à la fois dans le parent et classe d'enfant, lors de la compilation, la méthode sera toujours appelée en fonction du type de la variable. Contrairement au remplacement, ces méthodes ne seront pas exécutées pendant l'exécution du programme. Regardons un exemple :
classe Véhicule ( public static void kmToMiles (int km) ( System. out. println ( "À l'intérieur de la classe parent/méthode statique") ; ) ) classe Car extends Vehicle ( public static void kmToMiles (int km) ( System. out. println ("À l'intérieur d'une classe enfant/méthode statique") ;
) ) Démo de classe publique ( public static void main ( String args ) ( Vehicle v = new Car () ; v. kmToMiles ( 10 ) ; ) )
Sortie de la console :
Vous pouvez également déclarer une classe statique, à l'exception des classes de niveau supérieur. Ces classes sont appelées classes statiques imbriquées. Ils sont utiles pour représenter des connexions améliorées. Un excellent exemple de classe statique imbriquée est HashMap.Entry, qui fournit une structure de données à l'intérieur d'un HashMap. Il convient de noter que, comme toute autre classe interne, les classes imbriquées se trouvent dans un fichier .class distinct. Ainsi, si vous déclarez cinq classes imbriquées dans votre classe principale, vous auriez 6 fichiers avec une extension .class. Un autre exemple d'utilisation consiste à déclarer votre propre Comparator, par exemple AgeComparator dans la classe Employee.
Le modificateur statique peut également être déclaré dans un bloc statique, mieux connu sous le nom de bloc d'initialisation statique, qui sera exécuté lors du chargement de la classe. Si vous ne déclarez pas un tel bloc, Java rassemblera tous les champs statiques dans une seule liste et l'exécutera lorsque la classe sera chargée. Cependant, un bloc statique ne peut pas lancer d'exceptions interceptées, mais il peut en lancer des non interceptées. Dans ce cas, une « erreur d’initialisation d’exception » se produira. En pratique, toute exception levée lors de l'exécution et de l'initialisation des champs statiques sera enveloppée dans cette erreur par Java. C'est également la cause la plus courante de l'erreur « Aucune définition de classe trouvée » car... la classe n'était pas en mémoire lors de l'accès.
Il est utile de savoir que les méthodes statiques sont liées au moment de la compilation, par opposition aux méthodes virtuelles ou non statiques, qui sont liées au moment de l'exécution sur l'objet réel. Par conséquent, les méthodes statiques ne peuvent pas être remplacées en Java car le polymorphisme d'exécution ne s'applique pas à eux. Il s'agit d'une limitation importante à prendre en compte lors de la déclaration d'une méthode statique. Cela n'a de sens que lorsqu'il n'y a aucune possibilité ou nécessité de remplacer une telle méthode par des classes héritières. Les méthodes d'usine et les méthodes utilitaires sont de bons exemples d'utilisation du modificateur statique. Joshua Bloch a souligné plusieurs avantages de l'utilisation d'une méthode de fabrique statique par rapport à un constructeur dans son livre Effective Java, dont la lecture est obligatoire pour tout programmeur du langage.
Une propriété importante d'un bloc statique est l'initialisation. Les champs ou variables statiques sont initialisés après le chargement de la classe en mémoire. Ordre d'initialisation de haut en bas, dans le même ordre dans lequel ils sont décrits dans la source Fichier Java classe. Étant donné que les champs statiques sont initialisés de manière thread-safe, cette propriété est également utilisée pour implémenter le modèle Singleton. Si vous n'utilisez pas de liste Enum comme Singleton, pour une raison ou une autre, alors il existe une bonne alternative pour vous. Mais dans ce cas, il faut garder à l’esprit qu’il ne s’agit pas d’une initialisation « paresseuse ». Cela signifie que le champ statique sera initialisé AVANT que quiconque ne le « demande ». Si l'objet est gourmand en ressources ou rarement utilisé, son initialisation dans un bloc statique ne jouera pas en votre faveur.
Lors de la sérialisation, tout comme les variables transitoires, les champs statiques ne sont pas sérialisés. En effet, si vous enregistrez des données dans un champ statique, alors après désérialisation le nouvel objet contiendra sa valeur primaire (par défaut), par exemple si le champ statique était une variable tapez int, alors sa valeur après désérialisation sera égale à zéro si type flotteur– 0,0 si le type d'objet est null . Honnêtement, c'est l'une des questions les plus fréquemment posées concernant la sérialisation dans les entretiens Java. Ne stockez pas les données les plus importantes sur un objet dans un champ statique !
Et enfin, parlons de l'importation statique . Ce modificateur a beaucoup en commun avec l'instruction d'importation standard, mais contrairement à lui, il vous permet d'importer un ou tous les membres statiques d'une classe. Lors de l'importation de méthodes statiques, elles sont accessibles comme si elles étaient définies dans la même classe, de même lors de l'importation de champs, nous pouvons y accéder sans spécifier le nom de la classe. Cette opportunité est apparu dans Versions Java 1.5, et lorsqu'il est utilisé correctement, il améliore la lisibilité du code. Cette conception se retrouve le plus souvent dans les tests JUnit, parce que Presque tous les développeurs de tests utilisent des importations statiques pour les méthodes assert, telles que assertEquals() et leurs doublons surchargés. Si rien n’est clair, bienvenue pour plus d’informations.
C'est tout. Tous les points ci-dessus concernant le modificateur statique Chaque programmeur doit connaître Java. Cet article couvre des informations de base sur les variables statiques, les champs, les méthodes, les blocs d'initialisation et les importations. Y compris certains propriétés importantes, dont la connaissance est essentielle pour écrire et comprendre des programmes Java. J'espère que chaque développeur perfectionnera ses compétences dans l'utilisation de concepts statiques car... C'est très important pour une programmation sérieuse."
Dernière mise à jour : 19/04/2018
Sauf méthodes conventionnelles et des champs, une classe peut avoir des champs, des méthodes, des constantes et des initialiseurs statiques. Par exemple, la classe principale du programme a une méthode main, qui est statique :
Main vide statique publique (arguments de chaîne) ( )
Pour déclarer des variables statiques, des constantes, des méthodes et des initialiseurs, utilisez le mot clé static avant de les déclarer.
Champs statiques
Lorsque des objets de classe sont créés, chaque objet possède sa propre copie de champs réguliers non statiques. Et les champs statiques sont communs à toute la classe. Ils peuvent donc être utilisés sans créer d’objets de classe.
Par exemple, créons une variable statique :
Programme de classe publique ( public static void main (String args) ( Person tom = new Person (); Person bob = new Person (); tom.displayId (); // Id = 1 bob.displayId (); // Id = 2 System.out.println(Person.counter); // 3 // change Person.counter Person.counter = 8; Person sam = new Person(); // classe Personne (identifiant int privé; int statique); counter=1; Person())( id = counter++; ) public void displayId())( System.out.printf("Id: %d \n", id); ) )
La classe Person contient un compteur de variable statique, qui est incrémenté dans le constructeur et sa valeur est affectée à la variable id. Autrement dit, lors de la création de chaque nouvel objet Person, cette variable augmentera, de sorte que chaque nouvel objet Person aura une valeur de champ d'identification supérieure de 1 à la précédente.
Puisque la variable compteur est statique, nous pouvons y faire référence dans le programme par son nom de classe :
System.out.println(Personne.counter); // récupère la valeur Person.counter = 8 ; // change la valeur
Sortie console du programme :
Id = 1 Id = 2 3 Id = 8
Constantes statiques
Les constantes statiques sont également communes à toute la classe.
Programme de classe publique (public static void main(String args) ( double radius = 60; System.out.printf("Radisu: %f \n", radius); // 60 System.out.printf("Area: %f \n", Math.PI * rayon); // 188.4 ) ) classe Math( public finale statique double IP = 3,14 ; )
Il convient de noter que tout au long sujets précédents Les constantes statiques ont déjà été activement utilisées. Notamment dans l'expression :
System.out.println("bonjour");
out représente simplement une constante statique de la classe System. Par conséquent, on y accède sans créer d’objet de la classe System.
Initialiseurs statiques
Les initialiseurs statiques sont conçus pour initialiser des variables statiques ou pour effectuer des actions effectuées lors de la création du tout premier objet. Par exemple, définissons un initialiseur statique :
Programme de classe publique ( public static void main (String args) ( Person tom = new Person (); Person bob = new Person (); tom.displayId (); // Id = 105 bob.displayId (); // Id = 106 ) ) class Person( private int id; static int counter; static( counter = 105; System.out.println("Static initializer"); ) Person())( id=counter++; System.out.println("Constructor " ); ) public void displayId())( System.out.printf("Id: %d \n", id); ) )
Un initialiseur statique est défini comme un initialiseur régulier, seulement il est précédé du mot-clé static . DANS dans ce cas dans l'initialiseur statique, nous définissons la valeur initiale du compteur de champ statique et imprimons un message sur la console.
Dans le programme lui-même, deux objets de la classe Person sont créés. Par conséquent, la sortie de la console ressemblera à ceci :
Initialiseur statique Constructeur ID du constructeur : 105 Id : 106
Il convient de considérer que l'initialiseur statique n'est appelé qu'avant la création du tout premier objet de classe.
Méthodes statiques
Les méthodes statiques s’appliquent également à l’ensemble de la classe. Par exemple, dans l'exemple ci-dessus, le compteur de variable statique était accessible de l'extérieur et nous pouvions modifier sa valeur en dehors de la classe Person. Rendons-le immuable de l'extérieur, mais lisible. Pour ce faire, nous utilisons une méthode statique :
Programme de classe publique ( public static void main (String args) ( Person.displayCounter (); // Compteur : 1 Personne tom = new Person (); Person bob = new Person (); Person.displayCounter (); // Compteur : 3 ) ) class Person( private int id; private static int counter = 1; Person())( id = counter++; ) // méthode statique public static void displayCounter())( System.out.printf("Counter: %d \n ", compteur); ) public void displayId())( System.out.printf("Id: %d \n", id); ) )
Désormais la variable statique n’est plus accessible de l’extérieur, elle est privée. Et sa valeur est affichée à l'aide de la méthode statique displayCounter. Pour accéder à une méthode statique, utilisez le nom de classe : Person.displayCounter() .
Lors de l'utilisation de méthodes statiques, nous devons prendre en compte les limitations : dans les méthodes statiques, nous ne pouvons appeler que d'autres méthodes statiques et utiliser uniquement des variables statiques.
En général, les méthodes sont définies comme statiques lorsqu'elles n'affecteront pas l'état de l'objet, c'est-à-dire ses champs et constantes non statiques, et qu'il ne sert à rien de créer une instance de la classe pour appeler la méthode. Par exemple:
Programme de classe publique( public static void main(String args) ( System.out.println(Operation.sum(45, 23)); // 68 System.out.println(Operation.subtract(45, 23)); // 22 System.out.println(Operation.multiply(4, 23)); // 92 ) classe Operation( static int sum(int x, int y)( return x + y; ) static int soustract(int x, int y )( return x - y; ) static int multiplier (int x, int y)( return x * y; ) )
Dans ce cas, pour les méthodes somme, soustraction, multiplication, peu importe l'instance de la classe Operation utilisée. Ces méthodes fonctionnent uniquement avec des paramètres, sans affecter l'état de la classe. On peut donc les définir comme statiques.
Une méthode statique est un fragment de programme auquel est attribuée une certaine nom unique, et qui peut être appelé par ce nom depuis d'autres parties du programme. Au moment où l'appel se produit, les actions répertoriées à l'intérieur de la méthode (dans sa description ou son corps) sont effectuées.
En programmation orientée objet, la tâche principale des méthodes est de modifier l'état actuel d'un objet, mais tant que les objets ne sont pas encore utilisés dans le programme, des méthodes peuvent déjà être introduites. Une méthode définie dans une classe mais appelée sans être appliquée à un objet spécifique de cette classe est appelée statique.
En plus du nom et de la description mentionnés ci-dessus, la méthode présente un certain nombre d'autres caractéristiques :
- Un ensemble de modificateurs.
- Type de valeur de retour.
- Un ensemble d'arguments (paramètres).
Modificateurs de méthode
Afin de créer une méthode statique, vous devez spécifier le modificateur static avant son nom. Si cela n'est pas fait, alors la méthode ne peut être appelée que dans une application sur un objet spécifique. de cette classe(sera non statique).
Le modificateur public est responsable du niveau d'accès à la méthode décrite. Au lieu de public, les niveaux d'accès privé ou protégé peuvent être spécifiés, ou rien ne peut être spécifié, auquel cas le niveau d'accès par défaut s'appliquera.
Nous nous familiariserons plus en détail avec les niveaux d'accès lorsque nous créerons nos propres classes, mais pour l'instant, notons que l'accès par défaut permet d'accéder à une méthode depuis n'importe quelle partie du package dans lequel la méthode est décrite. Et le niveau public permet d’accéder à la méthode depuis n’importe où. Y compris à partir d'autres packages et programmes.
La méthode principale doit avoir un niveau accès public précisément parce qu'il est accessible par un virtuel machine Java, ne fait partie d’aucun package.
De plus, il existe d'autres modificateurs qui permettent, par exemple, de réguler le fonctionnement des méthodes lors de calculs parallèles (multithread).
Type de retour
Les méthodes en Java peuvent être divisées en deux groupes : les fonctions et les procédures. Le premier groupe comprend des méthodes très similaires aux fonctions au sens mathématique. À la suite de leur travail, ces méthodes retournent à l'endroit du programme à partir duquel elles ont été appelées un résultat spécifique d'un type existant, c'est-à-dire qu'il peut s'agir d'un nombre entier ou nombre réel ou valeur logique (int, double, booléen), tableau (référence à celui-ci), objet (référence à celui-ci). La valeur de retour doit être affectée à une variable du type approprié ou transmise à une autre méthode en tant qu'argument.
Contrairement aux fonctions, les méthodes de type procédural produisent une sorte de actions utiles, mais ne donne pas un résultat complet qui pourrait être exprimé en un seul signification spécifique ou un objet.
Double r = Math.random(); /* random fait référence aux fonctions */ System.out.println(r); /* println fait référence aux procédures */
Si nous créions une méthode qui, comme println, imprimerait le texte à l'écran, mais en même temps compterait le nombre d'espaces dans le texte et renverrait ce résultat, nous obtiendrions une fonction. Dans ce cas, la fonction continuerait à effectuer des actions utiles caractéristiques de la procédure println. En conséquence, une fonction est plus universelle qu’une procédure, mais elle n’est pas toujours nécessaire.
Lors de la création d’une méthode, la première étape consiste à déterminer s’il s’agira d’une fonction ou d’une procédure. Pour les calculs intermédiaires, des fonctions sont généralement utilisées. Les procédures peuvent également convenir pour raccourcir des fragments de code similaires.
Après les modificateurs, mais aussi à gauche du nom de la méthode, est indiqué le type de la valeur qu'elle renvoie (si la méthode est une fonction, par exemple : int ou double) ou le mot void (si la méthode est une procédure) .
Si une méthode est une fonction, alors elle doit contenir une commande de retour, après quoi, séparée par un espace, est indiquée l'expression dont la valeur doit être renvoyée comme résultat de la méthode.
Toutes les commandes spécifiées dans la description de la méthode après le retour ne seront plus exécutées ; le retour sans argument peut être utilisé dans les procédures. Il mettra simplement fin à la procédure plus tôt que prévu (un peu comme pour interrompre une boucle).
Arguments (paramètres)
Lors de l'appel d'une méthode, un ensemble de certaines valeurs peut lui être transmis à partir du programme principal. Afin d'apprendre à une méthode à les accepter (et à les traiter à l'intérieur de la méthode), les paires du formulaire doivent être listées entre parenthèses après le nom de la méthode : type_argument nom_argument séparé par des virgules.
Ensuite, lors de l’appel d’une méthode, il sera possible de spécifier un ensemble de valeurs correspondant aux types décrits par les arguments.
Les valeurs transmises à la méthode au moment de l'appel sont appelées paramètres réels, et les noms des arguments qui apparaissent dans la description de la méthode sont appelés paramètres formels.
Chaque paramètre formel est une variable locale à l'intérieur de la méthode, c'est-à-dire qu'il n'est pas disponible en dehors de la méthode (en dehors de son bloc de description). Lorsque la méthode est appelée, la valeur réelle est copiée dans le paramètre formel.
En particulier, cela signifie qu'en passant n'importe quelle variable type de base en paramètre d'une méthode lors de son appel, nous ne pourrons pas changer la valeur de cette variable dans programme principal. Si un objet ou un tableau est transmis à une méthode via un argument, alors seule une référence à l'objet ou au tableau (c'est-à-dire son adresse en mémoire) est copiée dans la méthode. Les actions que nous effectuons sur un tableau ou un objet à l'intérieur d'une méthode affecteront l'état de ce tableau ou de cet objet dans le programme principal même une fois que la méthode a terminé son travail. Dans la méthode, nous avons accédé à la même adresse et travaillé avec les mêmes données en mémoire que celles disponibles dans le programme principal.
Si le nom du paramètre réel correspond au nom du paramètre formel, cela ne pose aucun problème : à l'intérieur de la méthode se trouve une variable locale dans laquelle la valeur de la variable globale du même nom est copiée lors de son appel. En accédant à ce nom dans la méthode, nous nous retrouverons avec une variable locale et ne pourrons pas accéder à la variable globale.
Description de la méthode
La méthode doit être décrite à l'intérieur de la classe, mais une méthode n'est pas décrite à l'intérieur de l'autre, c'est-à-dire que la méthode doit être imbriquée directement dans le bloc de classe.
Schéma général de description de la méthode :
Modificateurs return_value_type nom_méthode (arguments formels) ( // actions effectuées par la méthode // éventuellement, return )
Traditionnellement, le nom de la méthode doit commencer par une petite lettre. S'il est composé de plusieurs mots, chaque mot suivant commence par lettre majuscule. Le nom de la méthode est choisi de manière à ce qu'il soit clair ce qu'elle fait.
Regardons quelques exemples :
Double kvadk statique public (double) ( double t; t = Math.pow(a, 0.5); return t; )
Maintenant, dans la méthode principale, nous pouvons utiliser notre méthode. Par exemple, comme ceci :
Int a = 25 ; System.out.println(kvadk(a)); // 5.0 System.out.println(a) // 25
Lors de la transmission de paramètres réels à une méthode, une diffusion automatique se produit. Si l'argument réel ne correspond pas au type formel, Java essaie de convertir l'argument réel en un type plus générique (dans ce cas, int a été converti en double).
Surcharge de méthode
La signature d'une méthode est la combinaison de son nom et d'un ensemble de paramètres formels.
Java vous permet de créer plusieurs méthodes avec mêmes noms, mais avec des signatures différentes. La création d’une méthode portant le même nom mais avec un ensemble de paramètres différent est appelée surcharge. Java détermine quelle méthode surchargée doit être exécutée lorsqu'elle est appelée en fonction des paramètres réels.
Void pr(double a) ( System.out.println(a); ) void pr (String a) ( System.out.println(a); ) void pr(int a) ( for (int i=0; i Un exemple d'utilisation de la méthode. Int a = 5 ; int m = (1, 2, 8, 3) Chaîne s = "Monde" ; pr (a) //la méthode originale fonctionne pr (a+s); // Monde 5, la première surcharge exécute pr (m); // 1 2 8 3 pr (m+a); // erreur La variable a n'est pas de type double, mais elle est traitée par la méthode d'origine, car la conversion automatique de int en double est possible. C'est impossible dans le sens inverse. Si la méthode avait un argument de type int, elle ne serait pas en mesure de générer des nombres réels. La surcharge de méthodes implémente une propriété aussi importante en programmation que le polymorphisme. Polymorphique est un code logiciel associé à un nom commun, mais qui a des implémentations différentes. L'implémentation qui fonctionnera est choisie en fonction du contexte dans lequel le nom a été mentionné. Spécifiquement pour les méthodes, leurs surcharges sont polymorphes, et la sélection de la surcharge exécutable se fait en fonction des paramètres. Polymorphisme : un nom, plusieurs formes. Le programme suivant recherche et affiche tous les diviseurs premiers non triviaux d'un nombre saisi par l'utilisateur à partir du clavier, en commençant par le plus grand diviseur, ou signale que le nombre saisi est premier. Importer java.util.Scanner ; public class Main ( public static boolean isPrime(int n) ( for(int i = 2; i<= Math.sqrt(n) ; i++) {
if(n%i == 0) {
return false;
}
}
return true;
}
public static void main(String args) {
Scanner sc = new Scanner(System.in);
System.out.print("Введите натуральное число: ");
if(sc.hasNextInt()) {
int u = sc.nextInt();
if(u >0) ( if(isPrime(u)) ( System.out.println("Vous avez saisi un nombre premier"); ) else ( System.out.print("Facteurs premiers du nombre : "); for(int i = (int) Math.sqrt(u); i >= 2 ; i--) ( if(u%i == 0 && isPrime(i)) ( System.out.print(i+" "); ) ) Système. out.println (); ) ) else ( System.out.println("Vous n'avez pas entré de nombre positif"); ) ) else ( System.out.println("Vous n'avez pas entré de nombre entier"); ) ) ) Dans l'exemple suivant, plusieurs méthodes du même nom seront créées en raison d'une surcharge. La première version de la méthode traduira simplement la chaîne, c'est-à-dire qu'elle sera en fait un synonyme plus court de la méthode intégrée System.out.println(). Cette option n'aura aucun paramètre. La deuxième variante de la méthode (sa première surcharge), vérifie si l'argument numérique a partie fractionnaire, s'il n'y est pas, alors l'argument est converti en nombres entiers et affiché à l'écran sans partie fractionnaire nulle (3 au lieu de 3,0). Cette méthode pourra passer non seulement taper des variables double, mais aussi des variables de tout autre type pour lesquelles une conversion automatique en double est possible (par exemple, n'importe quelle variable entière). La troisième méthode avec un paramètre appelle simplement la quatrième méthode, en passant le tableau résultant en paramètres, ainsi qu'un espace en tant que deuxième paramètre. Veuillez noter que nous appelons une méthode qui sera décrite plus loin dans le programme, cela est tout à fait acceptable. La quatrième méthode génère un tableau numérique, traitant déjà chaque élément méthode existante. Après chaque élément affiché, le séparateur passé en paramètre est ajouté. Classe publique Main ( public static void pr() ( System.out.println(); ) public static void pr(double d) ( if((int)d == d) ( System.out.print((int)d ); ) else ( System.out.print(d); ) ) public static void pr(double m) ( pr(m, " "); ) public static void pr(double m, String s) ( for(int i = 0 ;< m.length; i++) {
pr(m[i]);
System.out.print(s);
}
}
public static void main(String args) {
double arrn = {1, 2.71, 3.14, 15, -5, 92, 0.5};
double p = 3.0;
int k = 13;
pr(p); // вывод числа, без дробной части при возможности
pr(); // переводит строку
pr(arrn); // вывод числового массива в строку
pr(); // переводит строку
pr(arrn,", "); // вывод числового массива в строку через запятую
pr(); // переводит строку
pr(k); // вывод целого числа через автоприведение
}
}
À la suite de l'exécution du programme, les éléments suivants seront affichés à l'écran : 3
1 2.71 3.14 15 -5 92 0.5
1, 2.71, 3.14, 15, -5, 92, 0.5,
1
Le programme doit afficher : Yesenin Lermontov Nekrasov Paustovsky Pouchkine Tolstoï A. N. Tolstoï L. N. Astuce : Tout d'abord, vous devez créer une méthode qui définit la relation d'ordre pour les deux chaînes transmises à la méthode en tant qu'arguments. La récursivité est une méthode (fonction) qui s'appelle elle-même dans son corps. Prenons un exemple : le calcul factoriel. Pour calculer n!, il suffit de connaître et de multiplier (n-1) ! et n. Créons une méthode qui implémente la méthode décrite. Fait int statique (int n) ( if (n==1) ( return 1; ) else if (n==2) ( return 2; ) else ( return fact(n-1) * n; ) ) La méthode spécifiée calcule la factorielle d'un nombre naturel. Considérons un exemple qui calcule le nième nombre de Fibonacci par récursion. Rappelons à quoi ressemblent les premiers éléments de cette série : 1 1 2 3 5 8 13... Statique int fib (int n) ( if (n==1 || n == 2) ( return 1; ) return fib (n-2) + fib (n-1); ) Notez que dans cette méthode, le deuxième retour n'est pas placé dans le bloc else pour le premier. opérateur conditionnel. Ceci est permis, car si la condition est remplie et que le premier retour est déclenché, alors l'exécution du programme n'atteindra le deuxième retour que si la condition n'est pas remplie. Les calculs récursifs entraînent souvent la nécessité de répéter les mêmes actions, ce qui ralentit considérablement le programme. DANS cas général V moment actuel Une seule méthode de l’ensemble du programme peut être exécutée à la fois. Cela signifie que si la méthode UN est conçu de telle manière que dans son corps il appelle une méthode b, et lui-même UN appelé principal, puis lorsque le programme démarre, le contrôle sera d'abord transféré à la méthode principal, puis méthode UN, puis méthode b. Méthode b renverra le résultat et le contrôle à UN, UN renverra le résultat du contrôle à principal, et alors seulement ils seront exécutés commandes de base spécifié dans la méthode principal sur les lignes restantes après l'appel un. L'ensemble de la hiérarchie (qui a appelé qui) est stocké dans une zone mémoire spéciale appelée pile d'appels. Des éléments sont ajoutés à ce fragment mémoire selon le principe suivant : le dernier élément ajouté doit être récupéré en premier. Quand la méthode fonctionne-t-elle ? b, il s'avère qu'en dessous de la pile se trouve une méthode un et méthode principal. Pour cette raison, il existe un risque de débordement de la pile d'appels pendant le processus de récursion. Il existe une récursion dite complexe, dans laquelle la méthode UN appelle une méthode b, b causes Avec, UN Avec causes UN. 2010, Alexeï Nikolaïevitch Kostin. Département de TIDM Faculté de Mathématiques MPGU.Exemples d'utilisation de méthodes
Tâches
Pouchkine Lermontov Nekrassov Tolstoï L. N. Tolstoï A. N. Yesenin Paustovsky Récursion
Tâches
Pile d'appels