Un extrait de code Java. La syntaxe de Java est l'ensemble des règles définissant la manière dont un programme Java est écrit et interprété. La syntaxe est principalement dérivé...
Worldlex WikiContenu en francaisLecture gratuite
Un extrait de code Java.
La syntaxe de Java est l'ensemble des règles définissant la manière dont un programme Java est écrit et interprété.
La syntaxe est principalement dérivée du C et du C++ . Contrairement au C++, Java ne possède ni fonctions ni variables globales, mais dispose de membres de données qui sont également considérés comme des variables globales . Tout le code appartient à des classes et toutes les valeurs sont des objets . La seule exception concerne les types primitifs , qui ne sont pas considérés comme des objets pour des raisons de performance (bien qu'ils puissent être automatiquement convertis en objets et inversement grâce à l'autoboxing ). Certaines fonctionnalités, comme la surcharge d'opérateurs ou les types de données entiers non signés, sont omises afin de simplifier le langage et d'éviter d'éventuelles erreurs de programmation.
La syntaxe Java a été progressivement étendue au fil des nombreuses mises à jour majeures du JDK et prend désormais en charge des fonctionnalités telles que la programmation générique et les fonctions anonymes (littéraux de fonction, appelés expressions lambda en Java). Depuis 2017, une nouvelle version du JDK est publiée deux fois par an.
« Hello, World ! » est le suivant :
); } }
Depuis Java 25, il est possible d'écrire un programme Hello World simplifié sans classe explicite :
Les variables sont des identifiants associés à des valeurs. Elles sont déclarées en précisant leur type et leur nom, et peuvent être initialisées dans la même instruction en leur attribuant une valeur.
inférer automatiquement les types des variables en utilisant var.
);// Une déclaration équivalente avec un type explicite FileOutputStream stream = new FileOutputStream ( "file.txt" );
blocs de code
Les accolades { et } délimitent un bloc de code et une nouvelle portée. Les membres d'une classe et le corps d'une méthode sont des exemples de ce qui peut se trouver entre ces accolades dans différents contextes.
À l'intérieur du corps d'une méthode, des accolades peuvent être utilisées pour créer de nouvelles portées, comme suit :
commentaires : les commentaires traditionnels , les commentaires de fin de ligne et les commentaires de documentation .
Les commentaires traditionnels, également appelés commentaires de bloc, commencent /*et se terminent par une virgule*/ ; ils peuvent s’étendre sur plusieurs lignes. Ce type de commentaire est dérivé du C et du C++.
Javadoc pour générer la documentation. Ce type de commentaire est identique aux commentaires traditionnels, à ceci près qu'il commence par /**une convention définie par Javadoc et la respecte. Techniquement, il s'agit d'un type particulier de commentaire traditionnel, non défini explicitement dans la spécification du langage.
`int` est le type de niveau supérieur de Java . Il est implicitement la superclasse de toutes les classes qui ne déclarent aucune classe parente (donc toutes les classes en Java héritent de `int` Object). Toutes les valeurs peuvent être converties en ce type, bien que pour les valeurs primitives, cela implique un autoboxing .
java.lang.Record
Tous les enregistrements étendent implicitement la classe java.lang.Record. Ainsi, un record, bien que traité comme un class, ne peut étendre aucune autre classe.
java.lang.Enum<E>
En Java, tous les types énumérésjava.lang.Enum<E> (enums) étendent implicitement la classe `List<T>`. Ainsi, un `List<T>` enum, bien que traité comme un `List<T>` class, ne peut étendre aucune autre classe. Le paramètre de type Eest contraint à `List<T>` .java.lang.Class<T>
java.lang.Class<T>Une classe représente un objet classou interfaceune structure de données dans l'application lors de son exécution. Elle ne peut pas être construite par instanciation directe, mais est créée par la JVM lorsqu'une classe est dérivée des octets d'un .classfichier . Un littéral de classe peut être obtenu à partir X.classde cette classe X. Par exemple, String.classrenvoie `true` Class<String>. Une classe inconnue modélisée peut être représentée par `inconnue` Class<?>(où `<nom_de_la_classe>` ?désigne un caractère générique ).
Bien que X.classl'on semble accéder à un champ nommé « class », il n'existe en réalité aucun champ nommé « class » ; l'instruction exécute en fait l'instruction , qui place une constante du pool de constantes d'exécution de la classe dans la pile des opérandes. immuable . Il n'implémente pas `String` Iterable<Character>, il ne peut donc pas être parcouru dans une boucle `for-each`, mais peut être converti en `string` char[]. Certaines méthodes traitent chaque unité de code UTF-16char comme un `string` , mais des méthodes permettant de le convertir en un ` int[]string` équivalent à UTF-32 sont également disponibles. String`string` implémente `String` java.lang.CharSequence, donc charles `string` de `string` Stringpeuvent être accédés par la méthode `getString() charAt()`.
java.lang.Throwable
java.lang.Throwableest le supertype de tout ce qui peut être levé ou intercepté avec les instructions `run` throwet `intercept` de Java catch. Ses sous-classes directes connues sont java.lang.Error`Exception` (pour les erreurs graves irrécupérables) et java.lang.Exception`Exception` (pour les exceptions pouvant survenir naturellement lors de l'exécution d'un programme).
java.lang.Error
java.lang.Errorest le supertype de toutes les classes d'erreurs et étend Throwable. Il est utilisé pour indiquer des conditions qu'une application raisonnable ne devrait pas intercepter.
java.lang.Exception
java.lang.Exceptionest le supertype de toutes les classes d'exceptions et étend Throwable. Il est utilisé pour indiquer les conditions qu'une application raisonnable pourrait avoir des raisons de capturer.
java.lang.Math
java.lang.Mathest une classe utilitaire contenant des fonctions mathématiques et des constantes mathématiques (telles que Math.sin(), Math.pow(), et Math.PI).
java.lang.IO
java.lang.IOest une classe introduite dans Java 25 (auparavant connue sous le java.ionom de java.io.IO). Elle permet un accès plus simple aux flux d'entrée et de sortie standard via System.inet System.out.
Primitifs
Chaque type primitif possède une classe enveloppe associée (voir types primitifs ).
structure du programme
Les applications Java sont constituées d'ensembles de classes. Les classes existent dans des packages, mais peuvent également être imbriquées dans d'autres classes.
mainméthode
fichier manifeste ). La mainméthode `entry`, ainsi que la classe principale, doivent être déclarées. La méthode `entry` publicdoit être de type `java.get static()` et reçoit des arguments de ligne de commande sous forme de tableau de chaînes de caractères. Contrairement à C++ ou C# , elle ne renvoie jamais de valeur et doit retourner `false` void. Cependant, un code de retour peut être spécifié au système d'exploitation en appelant `return_code()` System.exit().
espace de noms . Les paquetages n'ont pas de hiérarchie, même si les points peuvent le suggérer. L'accessibilité d'un paquetage, en interne ou en externe, au sein d'un projet peut être contrôlée grâce aux modules .
Un paquet est déclaré au début du fichier avec la packagedéclaration suivante :
La programmation modulaire (modules) permet de regrouper les paquets et de contrôler précisément ceux qui font partie de l'API publique. Contrairement aux fichiers JAR , les modules déclarent explicitement leurs dépendances et les paquets qu'ils exportent. Ces déclarations de dépendances explicites améliorent l'intégrité du code en facilitant la compréhension des applications complexes et des dépendances entre les composants logiciels.
La déclaration du module est placée dans un fichier nommé module-info.java à la racine de l'arborescence des fichiers sources du module. Le JDK vérifie les dépendances et les interactions entre les modules à la compilation et à l'exécution.la programmation par réflexion. Dans les versions Java 9 à 16, la permission de cet « accès illégal » dépend de la configuration de la ligne de commande .
Le JDK est devenu modulaire dans Java 9. [ exemple, la majorité de la bibliothèque standard Java est exportée par le module java.base.
déclaration d'importation
Une instruction d'importation permet de résoudre un type appartenant à un autre package (espace de noms). On peut la comparer à celle utilisée usingen C++.
Déclaration d'importation de type
Une déclaration d'importation de type permet de faire référence à un type nommé par son nom simple plutôt que par son nom complet incluant le nom du package. Les déclarations d'importation peuvent concerner un seul type ou être des déclarations d'importation à la demande . Elles doivent être placées en haut du fichier de code, après la déclaration du package.
J2SE 5.0 . Les déclarations d'importation statique permettent d'accéder aux membres statiques définis dans une autre classe, interface, annotation ou énumération, sans avoir à spécifier le nom de la classe.
et aurait été incorrecte sans la déclaration d'importation. */ out . println ( "Bonjour le monde !" ); } }
Les déclarations d'importation à la demande permettent d'importer tous les champs du type :
, "Orange" , "Yellow" , "Green" , "Blue" , "Indigo" , "Violet" ); IO . println ( MessageFormat . format ( "My favourite colour is {0} and today is {1,date,long}" , colours . get ( ThreadLocalRandom . current (). nextInt ( colours . size ())), new Date () )); } }
Opérateurs
Les opérateurs en Java sont similaires à ceux de C++ . Cependant, Java ne possède pas deleted'opérateur `__init__` en raison du mécanisme de ramasse-miettes , et les opérations sur les pointeurs sont impossibles car Java ne les prend pas en charge. Autre différence : Java dispose d'un opérateur de décalage à droite non signé (`__init__` >>>), tandis qu'en C, le signe de l'opérateur de décalage à droite dépend du type. Les opérateurs en Java ne peuvent pas être surchargés . Seul l'opérateur `__init__` operator+de concaténation de chaînes de caractères est surchargé.
Priorité
Opérateur
Description
Associativité
1
()
Appel de méthode
De gauche à droite
[]
Accès au tableau
.
sélection des membres de la classe
2
++--
Incrémentation et décrémentation postfixées
3
++--
Incrémentation et décrémentation du préfixe
De droite à gauche
+-
unaire plus et moins
!~
NON logique et NON bit à bit
(type) val
Type cast
new
création d'instance de classe ou de tableau
4
*/%
Multiplication, division et module (reste)
De gauche à droite
5
+-
Addition et soustraction
+
concaténation de chaînes
6
<<>>>>>
Décalage bit à gauche, décalage signé à droite et décalage non signé à droite
7
<<=
relationnel « inférieur à » et « inférieur ou égal à »
>>=
Les relations « supérieur à » et « supérieur ou égal à »
Affectation par décalage binaire à gauche, décalage signé à droite et décalage non signé à droite
&=^=|=
Affectation par opérations bit à bit ET, OU exclusif (XOR) et OU
structures de contrôle
énoncés conditionnels
ifdéclaration
Les instructions if en Java sont similaires à celles en C et utilisent la même syntaxe :
Les instructions switch en Java peuvent utiliser les types primitifs `int` byte, `string` short, `void` charet ` string` int(mais pas `string` ) ou leurs types wrapper correspondants. À partir de J2SE 5.0, il est possible d'utiliser des types énumérés . À partir de Java SE 7, il est possible d'utiliser des chaînes de caractères. Les autres types référence ne peuvent pas être utilisés dans les instructions switch.longswitch
Les valeurs possibles sont listées à l'aide cased'étiquettes. En Java, ces étiquettes ne peuvent contenir que des constantes (y compris les constantes d'énumération et les constantes de type chaîne de caractères). L'exécution commence après l'étiquette correspondant à l'expression entre crochets. Une defaultétiquette optionnelle peut être présente pour indiquer que le code suivant sera exécuté si aucune autre étiquette ne correspond à l'expression.
Le code de chaque étiquette se termine par le breakmot-clé. Il est possible de l'omettre, ce qui entraîne le passage à l'étiquette suivante ; toutefois, un avertissement sera généralement généré lors de la compilation.
J2SE 5.0 , Java propose quatre formes de ces instructions. La condition doit être de type `True` booleanou java.lang.Boolean`Boolean`. Java ne convertit pas implicitement les entiers ou les types de classe en valeurs booléennes.
Par exemple, le code suivant est valide en C mais provoque une erreur de compilation en Java.
Les boucles foreach sont disponibles depuis J2SE 5.0 . Ce type de boucle utilise des itérateurs intégrés sur les tableaux et les collections pour retourner chaque élément de la collection donnée. Chaque élément est retourné et accessible dans le contexte du bloc de code. Lors de l'exécution du bloc, l'élément suivant est retourné jusqu'à ce qu'il n'y ait plus d'éléments. Cette boucle for, initialement présente en Java, a ensuite été intégrée à C++11 . Contrairement à C# , ce type de boucle n'utilise pas de mot-clé spécifique, mais une notation différente.
type union , il s'agit en réalité du supertype commun le plus spécifique parmi les alternatives.
pile d'appels jusqu'à ce qu'un bloc correspondant catchsoit trouvé dans l'une des méthodes actives. Si l'exception remonte jusqu'à la mainméthode la plus haute sans qu'aucun catchbloc correspondant ne soit trouvé, une description textuelle de l'exception est écrite sur la sortie standard.
Les instructions contenues dans le finallybloc sont toujours exécutées après les blocs try`and` et ` catchor`, qu'une exception ait été levée ou non, et même si une returninstruction `on` a été atteinte. Ces blocs sont utiles pour fournir du code de nettoyage dont l'exécution est garantie.
Les blocs catch« and » et « andfinally » sont facultatifs, mais au moins l’un ou l’autre doit être présent après le trybloc.
try-instructions avec-ressources
tryLes instructions `with-resources` sont un type particulier d' instructions try` catch-` , introduites dans Java SE 7 finallypour implémenter le modèle `Dispose`try . Dans une instruction `with-resources`, le trymot-clé `ressources` est suivi de l'initialisation d'une ou plusieurs ressources qui sont libérées automatiquement à la tryfin de l'exécution du bloc. Les ressources doivent implémenter l' interface `Dispose` java.lang.AutoCloseable. Contrairement aux instructions ` -` classiques, tryles instructions `with-resources` ne nécessitent pas de bloc `dispose` catchou `dispose` .finallytrycatchfinally
); XMLEncoder xEnc = new XMLEncoder ( fos )) { xEnc . writeObject ( object ); } catch ( IOException e ) { Logger . getLogger ( Serializer . class . getName ()). log ( Level . SEVERE , null , e ); }
Depuis Java 9, il est possible d'utiliser des variables déjà déclarées :
Cette throwinstruction permet de lever une exception et de mettre fin à l'exécution du bloc ou de la méthode. L'instance de l'exception levée est affichée après l' throwinstruction.
J2SE 1.4 . Elles permettent de formuler des assertions dans le code source, qui peuvent être activées ou désactivées lors de l'exécution pour des classes ou des packages spécifiques. Pour déclarer une assertion, asserton utilise le mot-clé `assert` suivi d'une expression conditionnelle. Si falsel'expression est vraie lors de l'exécution de l'instruction, une erreur est levée java.lang.AssertionError. Cette instruction peut inclure un deux-points suivi d'une autre expression, qui servira de message d'erreur détaillé.
;
Enfilage
des threads d'exécution via la classe `Thread` java.lang.Thread. Cette classe prend un argument java.lang.Runnable(tel qu'une lambda) et les threads sont démarrés à l'aide de la start()méthode `start`, et mis en pause/bloqués à l'aide de `pause` sleep(). Pour notifier les autres threads, wait()`pause` libère le verrou de l'objet et met le thread en pause jusqu'à ce qu'un autre thread appelle `pause` notify()ou ` pause` notifyAll().
Thread t = new Thread (() -> { System . out . println ( "En cours d'exécution" ); });t.démarrer ( ) ;
Les threads démons sont des threads qui s'exécutent en arrière-plan, par exemple les ramasse-miettes ou les threads de surveillance. La JVM s'arrête lorsqu'il ne reste plus que des threads démons.
Le thread actuel est accessible via cette currentThread()méthode.
Historiquement, une erreur java.lang.ThreadDeathétait levée lors de l'appel stop()à un thread, mais cette stop()exception a été supprimée depuis Java 20 et cette erreur n'est plus levée . La méthode idiomatique pour arrêter un thread consiste désormais à utiliser la interrupt()méthode `stop()`, qui permet au thread de se terminer correctement plutôt que de l'arrêter immédiatement sans nettoyage.
Contrôle de la concurrence des threads
Java intègre des outils pour la programmation multithread. L' instruction `synchronize` est incluse dans le langage Java à des fins de synchronisation des threads.synchronized
Pour synchroniser un bloc de code, on le fait précéder du synchronizedmot-clé `synchronized`, suivi de l'objet verrou entre crochets. Lorsqu'un thread atteint le bloc synchronisé, il acquiert un verrou d'exclusion mutuelle , exécute le bloc, puis libère le verrou. Aucun thread ne peut accéder à ce bloc tant que le verrou n'est pas libéré. Tout type référence non nul peut être utilisé comme verrou.
atomicity features (java.util.concurrent.atomic) and locking features (java.util.concurrent.locks).
Rather than java.lang.Thread, another class java.util.concurrent.CompletableFuture<T> is provided for asynchronous computation; this may be seen as similar to a System.Threading.Tasks.Task<T> in C#, even though Java lacks explicit coroutines like those of C#.
As part of Project Loom in Java 21, virtual threads were introduced, which allow for normal, blocking, synchronous code while scaling to millions of tasks. The classic Java thread is called a "platform thread", corresponding roughly to an OS thread, but Java virtual threads are lightweight and managed by the JVM, scheduled onto a small pool of real OS threads. Virtual threads are still java.lang.Thread, but are created with factory methods like ofVirtual(). Although the code is still synchronous and blocking, the physical OS threads are asynchronous; upon stopping to wait, the JVM detaches the code from the physical thread, running other tasks until the OS sends an asynchronous event notification to pick up the code where it left off to finish.
Primitive types
Primitive types in Java include integer types, floating-point numbers, UTF-16 code units and a Boolean type. Unlike C++ and C#, there are no unsigned types in Java except char type, which is used to represent UTF-16 code units. The lack of unsigned types is offset by introducing unsigned right shift operation (>>>), which is not present in C++, methods such as .toUnsignedInt(). Nevertheless, criticisms have been leveled about the lack of compatibility with C and C++ this causes.
paire de substitution , auquel cas le point de code Unicode est représenté par une séquence de deux charvaleurs.
Les classes enveloppes contiennent des méthodes statiques supplémentaires pour les opérations sur leurs types primitifs, ainsi Integer.parseInt()que des constantes statiques décrivant les informations du type. La classe enveloppe java.lang.Characterelle-même contient des types imbriqués supplémentaires :
java.lang.Character.Subset, représentant un sous-ensemble de l' ensemble de caractères Unicode
java.lang.Character.UnicodeBlock, contenant des constantes représentant un bloc Unicode
java.lang.Character.UnicodeScript, une énumération de scripts en Unicode
Boxer et déballer
Cette fonctionnalité du langage a été introduite dans J2SE 5.0 . L'encapsulation (boxing) consiste à convertir une valeur d'un type primitif en une valeur d'un type référence correspondant, qui sert d'enveloppe à ce type primitif. Le déballage (unboxing) est l'opération inverse, consistant à convertir une valeur d'un type référence (précédemment encapsulée) en une valeur d'un type primitif correspondant. Aucune de ces opérations ne nécessite de conversion explicite.
Exemple:
Les déclarations de tableaux de style C sont également acceptées en Java, mais elles ne sont pas couramment utilisées.
JVM, les tableaux sont représentés par un crochet ouvrant à gauche pour chaque dimension du tableau, avec les lettres suivantes :
Integer.MAX_VALUE
Les classes java.util.Arrayset java.lang.reflect.Arraysont fournies respectivement pour la manipulation de tableaux et les opérations de réflexion sur les tableaux.
Les tableaux semblent posséder un champ `int` length, mais il ne s'agit pas d'un champ réel ; c'est une propriété intégrée évaluée nativement par l' arraylengthinstruction bytecode `int` . Les tableaux ne possèdent aucun membre, méthode ou constructeur déclaré (à l'exception de ceux hérités de `int` java.lang.Object).
Les tableaux héritent de la classe java.lang.Objectet implémentent les interfaces java.lang.Cloneableet java.io.Serializable. Les tableaux sont implicitement de type finalet ne peuvent pas être hérités de . Bien qu'étant des classes, il n'existe pas de fichier .class pour les tableaux car ils sont créés directement en mémoire lors de l'exécution, n'ont pas de représentation physique en bytecode et ne sont pas chargés par un chargeur de classes .
Les tableaux étant des types référence, ils peuvent être utilisés directement dans les paramètres de type générique.
Les classes sont fondamentales dans un langage orienté objet comme Java. Elles contiennent des membres qui stockent et manipulent des données. On distingue les classes de premier niveau et les classes imbriquées . Les classes imbriquées sont des classes placées à l'intérieur d'une autre classe et qui peuvent accéder aux membres privés de cette dernière. Parmi les classes imbriquées, on trouve les classes membres (qui peuvent être définies avec le modificateur `static` pour une imbrication simple ou sans pour les classes internes), les classes locales et les classes anonymes .
Déclaration
Classe de niveau supérieur
classe intérieure
variables d'instance et des méthodes, qui sont liées aux objets créés à partir de cette classe. Pour créer ces objets, la classe doit être instanciée à l'aide de l' newopérateur d'instanciation et en appelant le constructeur de la classe.
; String bar = foo . toUpperCase ();
Pour accéder à un membre statique d'une classe, utilisez le nom de la classe ou un autre type. Il n'est pas nécessaire de créer une instance de la classe. Les membres statiques sont déclarés à l'aide du staticmodificateur `static`.
norme IEEE 754 et interdit l'utilisation d'une précision accrue pour stocker les résultats intermédiaires.
classe abstraite
Dernière classe
classe finale ne peut pas être héritée. Comme cela peut apporter des avantages en matière de sécurité et d'efficacité, de nombreuses classes de la bibliothèque standard Java sont finales, telles que `String` java.lang.Systemet `String` java.lang.String.
Exemple:
Modificateur
Même classe ou classe imbriquée
Autre classe dans le même paquet
Classe étendue à l'intérieur d'un autre package
Non étendu à l'intérieur d'un autre paquet
private
Oui
Non
Non
Non
par défaut (package privé)
Oui
Oui
Non
Non
protected
Oui
Oui
Oui
Non
public
Oui
Oui
Oui
Oui
Cette image décrit la portée des membres de classe au sein des classes et des packages.
Constructeurs et initialiseurs
Un constructeur est un bloc de code spécial, semblable à une méthode, appelé lors de l'initialisation d'un objet. Son rôle est d'initialiser les membres de l'objet. La principale différence entre les constructeurs et les méthodes ordinaires réside dans le fait que les constructeurs ne sont appelés que lors de la création d'une instance de la classe et ne renvoient jamais de valeur. Les constructeurs sont déclarés de manière similaire aux méthodes, mais ils portent le nom de la classe et aucun type de retour n'est spécifié ; pour une classe `Class` X, un constructeur est `Constructor`X(...) ; en particulier, le constructeur par défaut ne prend aucun paramètre X().
C++ , où les constructeurs sont considérés comme des fonctions membres spéciales ). Malgré cela, dans le bytecode de la JVM , un constructeur apparaît sous le nom <init>de « méthode d'initialisation d'instance » et est marqué comme tel void(et par conséquent, aucun objet résultant n'est placé sur la pile d'opérandes de la JVM à la fin de son exécution).
Les initialiseurs sont des blocs de code exécutés lors de la création d'une classe ou d'une instance de classe. Il existe deux types d'initialiseurs : les initialiseurs statiques et les initialiseurs d'instance .
Les initialiseurs statiques initialisent les champs statiques lors de la création de la classe. Ils sont déclarés à l'aide du staticmot-clé :
exception vérifiée (sauf dans quelques cas particuliers). Les initialiseurs d'instance sont déclarés dans un bloc sans aucun mot-clé.
destructeurs~X() ni deleteopérateurs de finalisation. Cependant, chaque objet possède une finalize()méthode appelée avant le passage du ramasse-miettes, qui peut être redéfinie pour implémenter la finalisation. Néanmoins, rien ne garantit quel thread appellera cette finalize()méthode pour un objet donné, ni même qu'elle sera appelée tout court. Les finaliseurs sont non déterministes (contrairement aux destructeurs en C++), et la libération de ressources critiques lors d'un finalize()appel peut entraîner un comportement imprévisible. Une autre classe, java.lang.ref.Cleanerintroduite dans Java 9, est également fournie pour renforcer la sécurité de bas niveau lors de la récupération de ressources autres que la mémoire, telles que les pointeurs natifs, les descripteurs de fichiers ou les sockets.
Méthodes
En Java, toutes les instructions doivent être placées dans des méthodes . Les méthodes sont similaires aux fonctions, à la différence qu'elles appartiennent à des classes. Une méthode possède une valeur de retour, un nom et généralement des paramètres initialisés lors de son appel avec des arguments. Comme en C++, les méthodes ne retournant rien ont un type de retour déclaré comme `null` void. Contrairement au C++, les méthodes en Java ne peuvent pas avoir de valeurs par défaut pour leurs arguments et sont généralement surchargées.
Abstract methods can be present only in abstract classes, such methods have no body and must be overridden in a subclass unless it is abstract itself.
static - Makes the method static and accessible without creation of a class instance. However static methods cannot access non-static members in the same class.
final - Declares that the method cannot be overridden in a subclass.
native - Indicates that this method is implemented through JNI in platform-dependent code. Actual implementation happens outside Java code, and such methods have no body.
strictfp - Declares strict conformance to IEEE 754 in carrying out floating-point operations. Now obsolete.
synchronized - Declares that a thread executing this method must acquire monitor. For synchronized methods the monitor is the class instance or java.lang.Class if the method is static.
Access modifiers - Identical to those used with classes.
Final methods
method cannot be overridden or hidden by subclasses. This is used to prevent unexpected behavior from a subclass altering a method that may be crucial to the function or consistency of the class.
Example:
compiler to directly insert the method wherever it is called (see inline expansion). Because the method is loaded at runtime, compilers are unable to do this. Only the runtime environment and JIT compiler know exactly which classes have been loaded, and so only they are able to make decisions about when to inline, whether or not the method is final.
Machine code compilers that generate directly executable, platform-specific machine code, are an exception. When using static linking, the compiler can safely assume that methods and variables computable at compile-time may be inlined.
Variadic parameters
J2SE 5.0. The last argument of the method may be declared as a variable arity parameter, in which case the method becomes a variable arity method (as opposed to fixed arity methods) or simply variadic method. This allows one to pass a (possibly zero) variable number of values, of the declared type, to the method as parameters. These values will be available inside the method as an array.
,74,83,25,96);
Fields
Fields, or class variables, can be declared inside the class body to store data.
serialization.
volatile - If a field is declared volatile, it is ensured that all threads see a consistent value for the variable.
Inheritance
Classes in Java can only inherit from one class. A class can be derived from any class that is not marked as final. Inheritance is declared using the extends keyword. A class can reference itself using the this keyword and its direct superclass using the super keyword.
virtual and can be overridden by the inheriting classes.
abstract class is a class that is incomplete, or is to be considered incomplete, and cannot be instantiated (directly).
A class X has abstract methods if any of the following is true:
X explicitly contains a declaration of an abstract method.
Any of X's superclasses in the inheritance chain have an abstract method and X neither declares nor inherits a method that implements it.
A direct superinterface of X declares or inherits a method (which is therefore necessarily abstract) and X neither declares nor inherits a method that implements it.
A subclass of an abstract class that is not itself abstract may be instantiated, resulting in the execution of a constructor for the abstract class and, therefore, the execution of the field initializers for instance variables of that class.
,MyAbstractClass.class.getName());hello=String.format("hello from %s",MyAbstractClass.class.getName());}{System.out.printf("%s: instance block runtime%n",MyAbstractClass.class.getName());}publicAbstractClass(){System.out.printf("%s: constructor runtime%n",MyAbstractClass.class.getName());}publicstaticvoidhello(){System.out.println(hello);}}
,MyCustomClass.class.getName());}{System.out.printf("%s: instance block runtime%n",MyCustomClass.class.getName());}publicCustomClass(){System.out.printf("%s: constructor runtime%n",MyCustomClass.class.getName());}publicstaticvoidmain(String[]args){MyCustomClassnc=newMyCustomClass();hello();MyAbstractClass.hello();// also valid}}
Output:
J2SE 5.0. Technically enumerations are a kind of class containing enum constants in its body. Each enum constant defines an instance of the enum type. Enumeration classes cannot be instantiated anywhere except in the enumeration class itself.
Interfaces are types which contain no fields and usually define a number of methods without an actual implementation. They are useful to define a contract with any number of different implementations. Every interface is implicitly abstract. Interface methods are allowed to have a subset of access modifiers depending on the language version, strictfp, which has the same effect as for classes, and also static since Java SE 8.
lambda expression instead of implementing it in a new class, thus greatly simplifying writing code in the functional style. Functional interfaces can optionally be annotated with the java.lang.FunctionalInterface annotation, which will tell the compiler to check whether the interface actually conforms to a definition of a functional interface.
number + otherNumber); // Equivalent code which uses an anonymous class instead runCalculation(new Calculation() { @Override public int calculate(int someNumber, int someOtherNumber) { return someNumber + someOtherNumber; } }) "
// A functional interface@FunctionalInterfaceinterfaceCalculation{intcalculate(intsomeNumber,intsomeOtherNumber);}// A method which accepts this interface as a parameterintrunCalculation(Calculationcalculation){returncalculation.calculate(1,2);}// Using a lambda to call the methodrunCalculation((number,otherNumber)->number+otherNumber);// Equivalent code which uses an anonymous class insteadrunCalculation(newCalculation(){@Overridepublicintcalculate(intsomeNumber,intsomeOtherNumber){returnsomeNumber+someOtherNumber;}})
The parameter types of a lambda do not have to be fully specified and can be inferred from the interface it implements, but there is no place to explicitly specify the lambda's return type (which is inferred). The body of the lambda can be written without a body block and a return statement if it is only an expression. Also, for those interfaces which only have a single parameter in the method, round brackets can be omitted.
{ return number + otherNumber; }); // A functional interface with a method which has only a single parameter interface StringExtender { String extendString(String input); } // Initializing a variable of this type by using a lambda StringExtender extender = input -> input + \" Extended\"; "
// Same call as above, but with fully specified types and a body blockrunCalculation((intnumber,intotherNumber)->{returnnumber+otherNumber;});// A functional interface with a method which has only a single parameterinterfaceStringExtender{StringextendString(Stringinput);}// Initializing a variable of this type by using a lambdaStringExtenderextender=input->input+" Extended";
Lambdas cannot specify throws clauses. Lambdas implement some target functional interface (such as java.lang.Runnable, etc.). Lambdas themselves are not complete expressions of concrete types, but rather poly expressions, whose type are influenced by their surrounding target type rather than entirely by their own content.
x + 1; // Should instead be: Function f = x -> x + 1; "
importjava.util.function.Function;// Invalid, as lambda expressions themselves have no standalone typevarf=(intx)->x+1;// Should instead be:Function<Integer,Integer>f=x->x+1;
If a lambda implements a functional interface which extends java.lang.Serializable, then when the lambda is serialized, it becomes a java.lang.invoke.SerializedLambda, capturing information about the lambda itself, called its "serialized form". This is necessary, because lambda implementation classes are synthetic and JVM-specific, and must therefore be reconstructed exactly in another JVM invocation. Much like in C++, lambda type names are synthetic and compiler-generated with unspecified implementation details.
System.out.println(\"Hello\"); // Could print something like: // class org.wikipedia.examples.Main$$Lambda$1/0x0000000800b00440 System.out.println(r.getClass()); "
Runnabler=()->System.out.println("Hello");// Could print something like:// class org.wikipedia.examples.Main$$Lambda$1/0x0000000800b00440System.out.println(r.getClass());
Lambdas do not generate class files, but rather emit an invokedynamic instruction on the JVM, which the runtime uses to create a suitable implementation class.
Capturing lambdas are typically distinct objects, due to requiring stored captured state, however non-capturing lambdas may potentially be singleton.
{}; Runnable r2 = () -> {}; System.out.println(r1 == r2); // May print true or false; determined by the JVM "
Runnabler1=()->{};Runnabler2=()->{};System.out.println(r1==r2);// May print true or false; determined by the JVM
However, unlike C++, lambda types are not part of the language model; nothing about its runtime class may be depended upon, whereas in C++ the lambda type may still be extracted with decltype to obtain a real unique closure type; a lambda's java.lang.Class<?> cannot be referenced in code.
Method references
Java allows method references using the operator :: (it is not related to the C++ namespace qualifying operator ::). It is not necessary to use lambdas when there already is a named method compatible with the interface. This method can be passed instead of a lambda using a method reference. There are several types of method references:
Private methods were added in the Java 9 release. An interface can have a method with a body marked as private, in which case it will not be visible to inheriting classes. It can be called from default methods for the purposes of code reuse.
metadata into code. This language feature was introduced in J2SE 5.0.
Annotation types
Java has a set of predefined annotation types, but it is allowed to define new ones. An annotation type declaration is a special type of an interface declaration. They are declared in the same way as the interfaces, except the interface keyword is preceded by the @ sign. Java annotations are interfaces and are implicitly extended from java.lang.annotation.Annotation and cannot be extended from anything else. Unlike C++ annotations, which may be any object, Java annotations cannot be instantiated into a real runtime object.
Generic programming (generics), or parameterized types, or parametric polymorphism, is one of the major features introduced in J2SE 5.0. Before generics were introduced, it was required to declare all the types explicitly. With generics, it became possible to work in a similar manner with different types without declaring the exact types. The main purpose of generics is to ensure type safety and to detect runtime errors during compilation. Unlike C++ templates, generics do not instantiate a specialization for each type, and unlike C#, generics are not reified, and information on the used parameters is not available at runtime due to type erasure (while Kotlin, another JVM language, offers reified generics, it achieves this by inlining the type at the call site). This is because historically, Java lacked generics entirely; thus generics are erased at runtime to allow a generic class X<T> to be compatible with X.
For instance, before generics were introduced, the Java collections framework stored everything as java.lang.Object.
);names.add("Bob");Stringfirst=(String)names.get(0);// first = "Alice"names.add(1);// Allowed
At runtime, generics appear as the lower bound of the type parameter (if no lower bound is specified, this is implicitly java.lang.Object). Because generics are erased, it is not possible to construct a generic type (such as checked exceptions entirely, such as in the Project Lombok@SneakyThrows attribute.
intersection type).
Wildcards are expressed by writing ? sign instead of the actual type. It is possible to limit possible types to the subclasses or superclasses of some specific class by writing the extends keyword or the super keyword correspondingly followed by the class name.
Plus d articles de Worldlex Wiki
Revenez a l index pour explorer davantage de pages sur l histoire, la science, la culture, la geographie et la societe en francais.
Worldlex Wiki 