java basics
1.0.0
Cliquez si vous aimez le projet. Vos contributions sont les bienvenues.
Multithreading
Collections
Connectivité de base de données Java (JDBC)
Programmes Java
Méthodes de chaîne Java
Pages du serveur Jakarta (JSP)
Servlets
Questions à choix multiples Java
Modèle de conception Java
Hiberner
Bases du framework Spring
Introduction
Architecture Java
Types de données Java
Méthodes Java
Programmation fonctionnelle Java
Expressions Java Lambda
Cours Java
Constructeurs Java
Tableau Java
Chaînes Java
Réflexion Java
Flux Java
Expressions régulières Java
Gestion des fichiers Java
Exceptions Java
Héritage Java
Remplacement de la méthode Java
Polymorphisme Java
Abstraction Java
Interfaces Java
Encapsulation Java
Génériques Java
Divers
Méthodes d'interface par défaut ;
Expressions lambda ;
Interfaces fonctionnelles ;
Références aux méthodes et aux constructeurs ;
Annotations répétables
Annotations sur les types de données ;
Réflexion sur les paramètres de la méthode ;
API Stream pour travailler avec des collections ;
Tri parallèle des tableaux ;
Nouvelle API pour travailler avec les dates et les heures ;
Nouveau moteur JavaScript Nashorn ;
Ajout de plusieurs nouvelles classes pour un fonctionnement thread-safe ;
Ajout d'une nouvelle API pour Calendar et Locale ;
Ajout de la prise en charge d'Unicode 6.2.0 ;
Ajout d'une classe standard pour travailler avec Base64 ;
Ajout de la prise en charge de l'arithmétique non signée ;
Constructeur java.lang.String(byte[], *) et performances de la méthode améliorés java.lang.String.getBytes() ;
Une nouvelle implémentation AccessController.doPrivileged qui vous permet de définir un sous-ensemble de privilèges sans avoir à vérifier tous les * autres niveaux d'accès ;
Les algorithmes basés sur des mots de passe sont devenus plus robustes ;
Ajout de la prise en charge de l'indication de nom de serveur SSL/TLS (NSI) dans le serveur JSSE ;
Magasin de clés amélioré (KeyStore) ;
Ajout de l'algorithme SHA-224 ;
Suppression du pont JDBC - ODBC ;
PermGen est supprimé , la méthode de stockage des métadonnées des classes est modifiée ;
Possibilité de créer des profils pour la plateforme Java SE, qui n'incluent pas l'intégralité de la plateforme, mais une partie de celle-ci ;
Outils
Ajout de l'utilitaire jjs pour utiliser JavaScript Nashorn ;
La commande java peut exécuter des applications JavaFX ;
Ajout de l'utilitaire jdeps pour analyser les fichiers .class.
↥ retour en haut
Nashorn est un moteur JavaScript développé en Java par Oracle. Conçu pour offrir la possibilité d'intégrer du code JavaScript dans des applications Java. Par rapport à Rhino, qui est pris en charge par la Fondation Mozilla, Nashorn offre des performances 2 à 10 fois supérieures, car il compile le code et transfère le bytecode à la machine virtuelle Java directement en mémoire. Nashorn peut compiler du code JavaScript et générer des classes Java chargées avec un chargeur spécial. Il est également possible d'appeler du code Java directement depuis JavaScript.
↥ retour en haut
jjs - Il s'agit d'un utilitaire de ligne de commande qui vous permet d'exécuter des programmes JavaScript directement dans la console.
↥ retour en haut
En Java, il existe trois manières différentes de lire les entrées de l'utilisateur dans l'environnement de ligne de commande ( console ).
1. Utilisation de la classe Buffered Reader :
Cette méthode est utilisée en encapsulant le System.in (flux d'entrée standard) dans un InputStreamReader qui est enveloppé dans un BufferedReader, nous pouvons lire l'entrée de l'utilisateur dans la ligne de commande.
/** * Classe de lecteur tamponné */import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class Test { public static void main(String[] args) throws IOException { // Entrée données utilisant BufferReader BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); // Lecture de données à l'aide de readLine String name = reader.readLine(); // Impression de la ligne de lecture System.out.println(name);
}
}2. Utilisation de la classe Scanner :
L'objectif principal de la classe Scanner est d'analyser les types primitifs et les chaînes à l'aide d'expressions régulières, mais elle peut également être utilisée pour lire les entrées de l'utilisateur dans la ligne de commande.
/** * Classe Scanner */import java.util.Scanner;class GetInputFromUser { public static void main(String args[]) { // Utilisation du scanner pour obtenir les entrées de l'utilisateur Scanner in = new Scanner(System.in); Chaîne s = in.nextLine(); System.out.println("Vous avez entré la chaîne " + s); int a = in.nextInt(); System.out.println("Vous avez entré un entier " + a); float b = in.nextFloat(); System.out.println("Vous avez entré float " + b);
}
}3. Utilisation de la classe console :
C'est devenu un moyen privilégié pour lire les entrées de l'utilisateur à partir de la ligne de commande. De plus, il peut être utilisé pour lire une entrée de type mot de passe sans faire écho aux caractères saisis par l'utilisateur ; la syntaxe de chaîne de format peut également être utilisée (comme System.out.printf() ).
/** * Classe console */public class Sample { public static void main(String[] args) { // Utilisation de la console pour saisir les données de l'utilisateur String name = System.console().readLine(); System.out.println(nom);
}
}↥ retour en haut
La commande javap affiche des informations sur les champs, constructeurs et méthodes présents dans un fichier de classe. La commande javap (également connue sous le nom de Java Disassembler) désassemble un ou plusieurs fichiers de classe.
/** * Désassembleur Java */class Simple { public static void main(String args[]) { System.out.println("Hello World");
}
}cmd> javap Simple.class
Sortir
Compilé à partir de la classe ".java" Simple {
Simple();
public static void main(java.lang.String[]);
}↥ retour en haut
System.out::println ? L'expression spécifiée illustre le passage d'une référence à une méthode statique d'une classe println() System.out .
↥ retour en haut
Les flux peuvent être séquentiels et parallèles. Les opérations sur les flux séquentiels sont effectuées dans un seul thread de processeur, sur des flux parallèles - en utilisant plusieurs threads de processeur. Les flux parallèles utilisent le flux partagé ForkJoinPool via la méthode statique ForkJoinPool.commonPool() . Dans ce cas, si l’environnement n’est pas multicœur, alors le flux sera exécuté de manière séquentielle. En fait, l'utilisation de flux parallèles se réduit au fait que les données dans les flux seront divisées en parties, chaque partie est traitée sur un cœur de processeur distinct, et à la fin ces parties sont connectées et les opérations finales sont effectuées sur eux.
Vous pouvez également utiliser la méthode d'interface parallelStream() pour créer un flux parallèle à partir de la Collection Collection .
Pour rendre parallèle un flux séquentiel régulier, vous devez appeler la méthode Stream sur l'objet parallel() . La méthode isParallel() permet de savoir si le flux est parallèle.
En utilisant les méthodes parallel() et sequential() il est possible de déterminer quelles opérations peuvent être parallèles et lesquelles uniquement séquentielles. Vous pouvez également créer un flux parallèle à partir de n’importe quel flux séquentiel et vice versa :
collection .flux () .peek ( ... ) // l'opération est séquentielle .parallèle () .map ( ... ) // l'opération peut être effectuée en parallèle, .séquentiel () .reduce ( ... ) // l'opération est à nouveau séquentielle
En règle générale, les éléments sont transférés vers le flux dans le même ordre dans lequel ils sont définis dans la source de données. Lorsque vous travaillez avec des flux parallèles, le système préserve la séquence des éléments. Une exception est une méthode forEach() qui peut générer des éléments dans un ordre aléatoire. Et pour maintenir l'ordre, il faut appliquer la méthode forEachOrdered() .
Critères pouvant affecter les performances dans les flux parallèles :
Taille des données : plus il y a de données, plus il est difficile de d'abord les séparer, puis de les combiner.
Le nombre de cœurs de processeur. Théoriquement, plus un ordinateur a de cœurs, plus le programme fonctionnera rapidement. Si la machine n'a qu'un seul cœur, cela n'a aucun sens d'utiliser des threads parallèles.
Plus la structure de données avec laquelle le flux fonctionne est simple, plus les opérations seront rapides. Par exemple, les données d' ArrayList sont faciles à utiliser, puisque la structure de cette collection suppose une séquence de données sans rapport. Mais une collection de types LinkedList n'est pas la meilleure option, puisque dans une liste séquentielle tous les éléments sont connectés avec précédent/suivant. Et de telles données sont difficiles à paralléliser.
Les opérations avec les types primitifs seront plus rapides qu'avec les objets de classe.
Il est fortement recommandé de ne pas utiliser de flux parallèles pour des opérations longues (par exemple, des connexions réseau), car tous les flux parallèles fonctionnent avec un seul ForkJoinPool , de telles opérations longues peuvent arrêter tous les flux parallèles dans la JVM en raison du manque de threads disponibles. dans la piscine, etc. e. les flux parallèles ne doivent être utilisés que pour des opérations courtes où le décompte s'étend sur des millisecondes, mais pas pour celles où le décompte peut s'étendre sur des secondes et des minutes ;
La sauvegarde de l'ordre dans des flux parallèles augmente les coûts d'exécution, et si l'ordre n'est pas important, il est possible de désactiver sa sauvegarde et ainsi d'augmenter la productivité en utilisant une opération intermédiaire unordered() :
collection.parallelStream ()
.trié ()
.non ordonné ()
.collect (Collecteurs . toList());↥ retour en haut
Java Virtual Machine (JVM) est une spécification qui fournit un environnement d'exécution dans lequel le bytecode Java (fichiers .class) peut être exécuté. La JVM est la plateforme. La JVM agit comme une machine ou un processeur « virtuel ». L'indépendance de la plate-forme Java réside principalement dans sa machine virtuelle Java (JVM). JVM rend cela possible car elle connaît les longueurs d'instructions spécifiques et d'autres particularités de la plateforme (système d'exploitation).
La JVM n'est pas indépendante de la plate-forme. La machine virtuelle Java (JVM) fournit l'environnement pour exécuter le fichier Java (fichier .Class). Donc, à la fin, cela dépend du noyau et le noyau diffère d'un système d'exploitation (système d'exploitation) à un autre. La JVM est utilisée à la fois pour traduire le bytecode dans le langage machine d'un ordinateur particulier et pour exécuter également les instructions correspondantes en langage machine.
↥ retour en haut
Le compilateur Just-In-Time (JIT) est un composant de l'environnement d'exécution qui améliore les performances des applications Java en compilant les bytecodes en code machine natif au moment de l'exécution.
Les programmes Java se composent de classes contenant des bytecodes indépendants de la plate-forme qui peuvent être interprétés par une JVM sur de nombreuses architectures informatiques différentes. Au moment de l'exécution, la JVM charge les fichiers de classe, détermine la sémantique de chaque bytecode individuel et effectue le calcul approprié. L'utilisation supplémentaire du processeur et de la mémoire lors de l'interprétation signifie qu'une application Java s'exécute plus lentement qu'une application native. Le compilateur JIT permet d'améliorer les performances des programmes Java en compilant les bytecodes en code machine natif au moment de l'exécution. Le compilateur JIT est activé par défaut. Lorsqu'une méthode a été compilée, la JVM appelle directement le code compilé de cette méthode au lieu de l'interpréter.
↥ retour en haut
Le Java ClassLoader fait partie de Java Runtime Environment qui charge dynamiquement les classes Java dans la machine virtuelle Java. Le code Java est compilé dans un fichier de classe par le compilateur javac et JVM exécute le programme Java en exécutant les codes d'octet écrits dans le fichier de classe. ClassLoader est responsable du chargement des fichiers de classe à partir du système de fichiers, du réseau ou de toute autre source.
Types de chargeur de classe :
1. Chargeur de classe Bootstrap :
Il charge les fichiers de classe JDK standard à partir de rt.jar et d'autres classes principales. Il charge les fichiers de classe depuis jre/lib/rt.jar. Par exemple, classe de package java.lang.
2. Chargeur de classe d'extensions :
Il charge directement les classes des extensions JDK, généralement le répertoire JAVA_HOME/lib/ext ou tout autre répertoire tel que java.ext.dirs.
3. Chargeur de classe système :
Il charge les classes spécifiques à l'application à partir de la variable d'environnement CLASSPATH. Il peut être défini lors de l'appel du programme à l'aide des options de ligne de commande -cp ou classpath.
↥ retour en haut
1. JDK :
Le kit de développement Java est le composant principal de l'environnement Java et fournit tous les outils, exécutables et binaires nécessaires pour compiler, déboguer et exécuter un programme Java.
2. JVM :
JVM est responsable de la conversion du code octet en code spécifique à la machine. JVM dépend également de la plate-forme et fournit des fonctions Java de base telles que la gestion de la mémoire, le garbage collection, la sécurité, etc. La JVM est personnalisable et nous pouvons utiliser les options Java pour la personnaliser, par exemple en allouant de la mémoire minimale et maximale à la JVM. La JVM est appelée virtuelle car elle fournit une interface qui ne dépend pas du système d'exploitation sous-jacent ni du matériel de la machine.
2. JRE :
Java Runtime Environment fournit une plate-forme pour exécuter des programmes Java. JRE se compose de binaires JVM et Java et d'autres classes pour exécuter n'importe quel programme avec succès.
↥ retour en haut
1. Espace de tas Java :
L'espace Java Heap est utilisé par le runtime Java pour allouer de la mémoire aux classes Objects et JRE . Chaque fois que nous créons un objet, il est toujours créé dans l'espace Heap.
Garbage Collection s'exécute sur la mémoire tas pour libérer la mémoire utilisée par les objets qui n'ont aucune référence. Tout objet créé dans l'espace du tas dispose d'un accès global et peut être référencé depuis n'importe où dans l'application.
2. Mémoire de pile Java :
La pile en Java est une section de mémoire qui contient des méthodes , des variables locales et des variables de référence . Les variables locales sont créées dans la pile.
La mémoire de pile est toujours référencée dans l'ordre LIFO (Last-In-First-Out). Chaque fois qu'une méthode est invoquée, un nouveau bloc est créé dans la mémoire de pile pour que la méthode contienne les valeurs primitives locales et les références à d'autres objets de la méthode.
Dès que la méthode se termine, le bloc devient inutilisé et devient disponible pour la méthode suivante. La taille de la mémoire de pile est très inférieure à celle de la mémoire Heap.
Différence:
| Paramètre | Mémoire de pile | Espace de tas |
|---|---|---|
| Application | La pile est utilisée par parties, une à la fois lors de l'exécution d'un thread | L'ensemble de l'application utilise l'espace Heap pendant l'exécution |
| Taille | La pile a des limites de taille en fonction du système d'exploitation et est généralement plus petite que le tas | Il n'y a pas de limite de taille sur le tas |
| Stockage | Stocke uniquement les variables primitives et les références aux objets créés dans l'espace de tas | Tous les objets nouvellement créés sont stockés ici |
| Commande | On y accède à l'aide du système d'allocation de mémoire Last-in, First-out (LIFO). | Cette mémoire est accessible via des techniques complexes de gestion de la mémoire qui incluent la jeune génération, la génération ancienne ou titulaire et la génération permanente. |
| Vie | La mémoire de pile n'existe que tant que la méthode actuelle est en cours d'exécution | L'espace de mémoire existe tant que l'application s'exécute |
| Efficacité | Comparativement beaucoup plus rapide à allouer par rapport au tas | Plus lent à allouer par rapport à la pile |
| Allocation/Désallocation | Cette mémoire est automatiquement allouée et désallouée lorsqu'une méthode est appelée et renvoyée respectivement | L'espace de tas est alloué lorsque de nouveaux objets sont créés et désalloué par Gargabe Collector lorsqu'ils ne sont plus référencés |
↥ retour en haut
JVM est un programme qui prend le bytecode Java et convertit le bytecode (ligne par ligne) en code compréhensible par machine. La JVM effectue certains types d'opérations particuliers :
Chargement du code
Vérification du code
Exécuter le code
Il fournit un environnement d'exécution aux utilisateurs
Types de zones mémoire allouées par la JVM :
1. Classloader : Classloader est un sous-système de JVM utilisé pour charger des fichiers de classe.
2. Zone de classe (méthode) : La zone de classe (méthode) stocke les structures par classe telles que le pool de constantes d'exécution, les données de champ et de méthode, le code des méthodes.
3. Heap : C'est la zone de données d'exécution dans laquelle les objets sont alloués.
4. Stack : Java Stack stocke les frames. Il contient des variables locales et des résultats partiels, et joue un rôle dans l'invocation et le retour de la méthode. Chaque thread possède une pile JVM privée, créée en même temps que le thread.
5. Registre du compteur de programme : registre PC (compteur de programme). Il contient l'adresse de l'instruction de machine virtuelle Java en cours d'exécution.
6. Native Method Stack : Elle contient toutes les méthodes natives utilisées dans l’application.
↥ retour en haut
La conversion automatique des types de données primitifs en son type Wrapper équivalent est connue sous le nom de boxing et l'opération inverse est connue sous le nom de unboxing.
Exemple : Autoboxing
/** * Autoboxing */class BoxingExample { public static void main(String args[]) { int a = 50; Entier a2 = nouveau Entier(a); // Boxe Entier a3 = 5; // Boxe System.out.println(a2 + " " + a3);
}
}Exemple : déballage
/** * Unboxing */class UnboxingExample { public static void main(String args[]) { Integer i = new Integer(50); int a = je; System.out.println(a);
}
}↥ retour en haut
1. Transitoire :
Le modificateur transitoire indique au sous-système de sérialisation d'objets Java d'exclure le champ lors de la sérialisation d'une instance de la classe. Lorsque l'objet est ensuite désérialisé, le champ sera initialisé à la valeur par défaut ; c'est-à-dire null pour un type référence et zéro ou false pour un type primitif.
Exemple:
/** * Transitoire */limite int transitoire publique = 55 ; // ne persistera paspublic int b; // persistera
2. Volatil :
Le modificateur volatile indique à la JVM que les écritures dans le champ doivent toujours être vidées de manière synchrone dans la mémoire et que les lectures du champ doivent toujours être lues à partir de la mémoire. Cela signifie que les champs marqués comme volatils peuvent être consultés et mis à jour en toute sécurité dans une application multithread sans utiliser de synchronisation native ou basée sur une bibliothèque standard.
Exemple:
/** * Volatile */classe publique MyRunnable implémente Runnable { private volatile boolean active; public void run() { actif = vrai ; pendant que (actif) {
}
} public void stop() { actif = faux ;
}
}↥ retour en haut
Une assertion permet de tester l'exactitude de toutes les hypothèses formulées dans le programme. L'assertion est obtenue à l'aide de l'instruction assert en Java.
Lors de l'exécution de l'assertion, on pense qu'elle est vraie. En cas d'échec, la JVM renvoie une erreur nommée AssertionError . Il est principalement utilisé à des fins de tests lors du développement.
L'instruction assert est utilisée avec une expression booléenne et peut être écrite de deux manières différentes.
// Première façon d'affirmer l'expression; // Deuxième façon d'affirmer l'expression1 : expression2;
Exemple:
/** * Assertions */public class Exemple { public static void main(String[] args) { int age = 14; affirmer un âge <= 18 : « Impossible de voter » ; System.out.println("L'âge de l'électeur est " + age);
}
}↥ retour en haut
1. Variable finale :
Les variables finales ne sont que des constantes. Nous ne pouvons pas changer la valeur d'une variable finale une fois qu'elle est initialisée.
Exemple:
/** * Variable finale */class Démo { final int MAX_VALUE = 99; void maMéthode() { MAX_VALUE = 101;
} public static void main(String args[]) { Démo obj = new Demo(); obj.myMethod();
}
}Sortir
Exception dans le thread « principal » java.lang.Erreur : problème de compilation non résolu : Le champ final Demo.MAX_VALUE ne peut pas être attribué sur Beginnersbook.com.Demo.myMethod (Details.java: 6) sur Beginnersbook.com.Demo.main (Details.java: 10)
2. Variable finale vide :
Une variable finale qui n'est pas initialisée au moment de la déclaration est appelée variable finale vide. Nous devons initialiser la variable finale vide dans le constructeur de la classe, sinon cela générera une erreur de compilation (Erreur : variable MAX_VALUE might not have been initialized ).
Exemple:
/** * Variable finale vide */class Demo { // Variable finale vide final int MAX_VALUE; Demo() { // Il doit être initialisé dans le constructeur MAX_VALUE = 100 ;
} void maMéthode() { System.out.println(MAX_VALUE);
} public static void main(String args[]) { Démo obj = new Demo(); obj.myMethod();
}
}Sortir
100
3. Méthode finale :
Une méthode finale ne peut pas être remplacée. Ce qui signifie que même si une sous-classe peut appeler la méthode finale de la classe parent sans aucun problème, elle ne peut pas la remplacer.
Exemple:
/** * Méthode finale */class XYZ { final void demo() { System.out.println("Méthode de classe XYZ");
}
}la classe ABC étend XYZ { void demo() { System.out.println("Méthode de classe ABC");
} public static void main(String args[]) { ABC obj = new ABC(); obj.demo();
}
}↥ retour en haut
Si un type primitif ou une chaîne est défini comme constante et que la valeur est connue au moment de la compilation, le compilateur remplace le nom de la constante partout dans le code par sa valeur. C'est ce qu'on appelle une constante de compilation.
La constante de temps de compilation doit être :
Déclaré final
Primitive ou chaîne
Initialisé dans la déclaration
Initialisé avec une expression constante
Elles sont remplacées par les valeurs réelles au moment de la compilation, car le compilateur connaît leur valeur à l'avance et sait également qu'elle ne peut pas être modifiée pendant l'exécution.
int final privé x = 10 ;
↥ retour en haut
Les spécificateurs/modificateurs d'accès permettent de restreindre la portée d'une classe, d'un constructeur, d'une variable, d'une méthode ou d'un membre de données.
Il existe quatre types de modificateurs d'accès disponibles en Java :
default – Aucun mot-clé requis, lorsqu'une classe, un constructeur, une variable, une méthode ou un membre de données est déclaré sans aucun spécificateur d'accès, il a alors une portée d'accès par défaut, c'est-à-dire accessible uniquement dans le même package.
private - lorsqu'elle est déclarée comme private , la portée d'accès est limitée à l'intérieur de la classe englobante.
protected - lorsqu'elle est déclarée comme protégée, la portée d'accès est limitée aux classes englobantes, aux sous-classes du même package ainsi qu'à d'autres packages.
public - lorsqu'il est déclaré public, accessible partout dans le programme.
... /* variables membres de données */ String firstName="Pradeep"; /* portée par défaut */ protected isValid=true; /* portée protégée */ private String otp="AB0392"; /* portée privée */ public int id = 12334; /* portée publique */
...
... /* fonctions membres de données */ String getFirstName(){ return this.firstName; } /* portée par défaut */ protected boolean getStatus(){this.isValid;} /* portée protégée */ private void generateOtp(){ /* portée privée */ this.otp = this.hashCode() << 16;
} ;
public int getId(){ return this.id ; } /* portée publique */
...
.../* classes internes */ classe A{} /* portée par défaut */ classe protégée B{} /* portée protégée */ classe privée C{} /* portée privée */ classe publique D{} /* portée publique */
...↥ retour en haut
En Java, toutes les méthodes non statiques sont des fonctions virtuelles par défaut. Seules les méthodes marquées du mot-clé final , qui ne peuvent pas être remplacés, ainsi que private methods , qui ne sont pas héritées, sont non virtuelles.
Exemple : fonction virtuelle avec interface
/** * La fonction applyBrakes() est virtuelle car * les fonctions des interfaces sont conçues pour être remplacées. **/interface Vélo { void applyBrakes();
}class ACMEBicycle implémente Bicycle { public void applyBrakes() { // Ici, nous implémentons applyBrakes() System.out.println("Freins appliqués"); // fonction
}
}↥ retour en haut
Une méthode native est une méthode Java (soit une méthode d'instance, soit une méthode de classe) dont l'implémentation est également écrite dans un autre langage de programmation tel que C/C++. De plus, une méthode marquée comme native ne peut pas avoir de corps et doit se terminer par un point-virgule :
Main.java :
classe publique Main { public native int intMethod(int i); public static void main(String[] args) { System.loadLibrary("Main"); System.out.println(new Main().intMethod(2));
}
}Principal.c :
#include <jni.h>#include "Main.h"JNIEXPORT jint JNICALL Java_Main_intMethod( JNIEnv *env, jobject obj, jint i) { return i * i;
}Compiler et exécuter :
javac Main.javajavah -jni Maingcc -shared -fpic -o libMain.so -I${JAVA_HOME}/include
-I${JAVA_HOME}/include/linux Main.cjava -Djava.library.path=. PrincipalSortir
4
↥ retour en haut
Si une méthode est déclarée comme statique, elle est membre d'une classe plutôt que d'appartenir à l'objet de la classe. Il peut être appelé sans créer d'objet de la classe. Une méthode statique a également le pouvoir d’accéder aux données statiques membres de la classe.
Il existe quelques restrictions imposées à une méthode statique
La méthode statique ne peut pas utiliser de données membres non statiques ni appeler directement une méthode non statique.
Les this et super ne peuvent pas être utilisés dans un contexte statique.
La méthode statique ne peut accéder qu'aux données de type statique (variable d'instance de type statique).
Il n'est pas nécessaire de créer un objet de la classe pour appeler la méthode statique.
Une méthode statique ne peut pas être remplacée dans une sous-classe
Exemple:
/** * Méthodes statiques */class Parent { static void display() { System.out.println("Super class");
}
}public class Exemple extends Parent { void display() // tentative de remplacer display() { System.out.println("Sub class");
}
public static void main (String[] arguments) {
Parent obj = new Exemple();
obj.display();
}
}Cela génère une erreur de compilation. Le résultat est le suivant -
Exemple.java:10 : erreur : display() dans l'exemple ne peut pas remplacer display() dans Parentvoid display() // tentative de remplacement de display()
^la méthode remplacée est une erreur static1↥ retour en haut
Quelle est la structure et les caractéristiques de l’utilisation d’une expression lambda ? Un lambda est un ensemble d'instructions qui peuvent être séparées en une variable distincte puis appelées à plusieurs reprises à différents endroits du programme.
La base de l'expression lambda est l' opérateur lambda , qui représente la flèche -> . Cet opérateur divise l'expression lambda en deux parties : le côté gauche contient une liste de paramètres d'expression et le côté droit représente en fait le corps de l'expression lambda, où toutes les actions sont effectuées.
L'expression lambda n'est pas exécutée par elle-même, mais constitue l'implémentation de la méthode définie dans l'interface fonctionnelle. Il est important que l’interface fonctionnelle ne contienne qu’une seule méthode sans implémentation.
interface Opérationnel { int calculer ( int x , int y );
}public static void main ( String [] args) { Opération opérationnelle = (x, y) -> x + y;
int résultat = opération.calculer ( 10 , 20 ); System.out.println (résultat); // 30 }En fait, les expressions lambda sont en quelque sorte une forme abrégée de classes anonymes internes qui étaient auparavant utilisées en Java.
Expressions lambda à exécution différée - elles sont définies une fois à un endroit du programme, elles sont appelées si nécessaire, n'importe quel nombre de fois et à n'importe quel endroit du programme.
Les paramètres de l'expression lambda doivent correspondre en type aux paramètres de la méthode d'interface fonctionnelle :
opération = ( int x, int y) -> x + y;// Lors de l'écriture de l'expression lambda elle-même, le type de paramètre ne peut pas être spécifié : (x, y) -> x + y;// Si la méthode n'accepte aucun paramètre, alors les parenthèses vides sont écrites, par exemple : () - > 30 + 20 ;// Si la méthode n'accepte qu'un seul paramètre, alors les parenthèses peuvent être omises : n -> n * n;
Les expressions lambda de fin ne sont pas tenues de renvoyer une valeur.
interface Imprimable { void print( String s );
}
public static void main ( String [] args) { Imprimante imprimable = s -> System.out.println(s); imprimante.print("Bonjour tout le monde");
}// _Les expressions lambda_ des blocs sont entourées d'accolades. Les expressions lambda modulaires peuvent être utilisées dans des blocs imbriqués, des boucles, `concevoir l'instruction if ` ` switch ', créer des variables, etc. d . Si vous bloquez une expression lambda doit renvoyer une valeur, elle s'applique explicitement `statement return Statement ' :Operationable operation = ( int x, int y) -> {
si (y == 0 ) { return 0 ;
} autre { return x / y ;
}
} ;Passer une expression lambda comme paramètre de méthode
Condition d'interface { boolean isAppropriate ( int n );
}somme int statique privée (nombres int [], condition de condition) { int résultat = 0 ; for ( int i : nombres) { if (condition.isAppropriate(i)) { result + = i;
}
} renvoie le résultat ;
}public static void main ( String [] args) { System.out.println(sum ( new int [] { 0 , 1 , 0 , 3 , 0 , 5 , 0 , 7 , 0 , 9 }, (n) - > n ! = 0 ));
}↥ retour en haut
L'accès aux variables de portée externe à partir d'une expression lambda est très similaire à l'accès à partir d'objets anonymes.
variables locales immuables (en fait finales - pas nécessairement marquées comme finales) ;
champs de classe
variables statiques.
Les méthodes par défaut de l'interface fonctionnelle implémentée ne sont pas accessibles dans l'expression lambda.
↥ retour en haut
Si la méthode existante dans la classe fait déjà tout ce qui est nécessaire, alors vous pouvez utiliser le mécanisme de référence de méthode (référence de méthode) pour transmettre directement cette méthode. Le résultat sera exactement le même que dans le cas de la définition d'une expression lambda qui appelle cette méthode.
Exemple:
interface privée Mesurable { public int length(String string);
}public static void main ( String [] arguments) { Mesurable a = String::length; System.out.println(a.length("abc"));
}Les références de méthodes sont potentiellement plus efficaces que l'utilisation d'expressions lambda. De plus, ils fournissent au compilateur de meilleures informations sur le type, et si vous pouvez choisir entre utiliser une référence à une méthode existante et utiliser une expression lambda, vous devez toujours utiliser une référence de méthode.
↥ retour en haut
sur la méthode statique ;
méthode par instance ;
au constructeur.
↥ retour en haut
La classe interne imbriquée peut accéder à n’importe quelle variable d’instance privée de la classe externe. Comme toute autre variable d'instance, nous pouvons avoir un modificateur d'accès privé, protégé, public et par défaut.
Exemple:
/** * Classe interne */class Outer {
classe intérieure {
public void show() {
System.out.println("Dans une méthode de classe imbriquée");
}
}
}
classe principale {
public static void main (String[] arguments) {
Outer.Inner in = new Outer().new Inner();
in.show();
}
}Une sous-classe est une classe qui hérite d’une ou plusieurs méthodes d’une superclasse.
Exemple:
/** * Sous-classe */class Car { //...}
la classe HybridCar étend la voiture { //...}↥ retour en haut
1. Chargement de classe statique :
La création d'objets et d'instances à l'aide new mot-clé est appelée chargement de classe statique. La récupération de la définition de classe et l'instanciation de l'objet se font au moment de la compilation.
Exemple:
/** * Chargement de classe statique */class TestClass { public static void main(String args[]) { TestClass tc = new TestClass();
}
}2. Chargement dynamique des classes :
Le chargement des classes utilise la méthode Class.forName() . Le chargement dynamique de la classe est effectué lorsque le nom de la classe n'est pas connu au moment de la compilation.
Exemple:
/** * Chargement dynamique de classe */Class.forName (String className);
↥ retour en haut
1. Classe d'exécution :
La classe java.lang.Runtime est une sous-classe de la classe Object, qui permet d'accéder au système d'exécution Java. Les informations d'exécution telles que la disponibilité de la mémoire, l'appel du garbage collector, etc.
Exemple:
/** * Classe d'exécution */classe publique RuntimeTest { classe statique Message extends Thread { public void run() { System.out.println(" Exit");
}
} public static void main(String[] args) { try { Runtime.getRuntime().addShutdownHook(new Message()); System.out.println("Programme démarré..."); System.out.println(" Attendez 5 secondes..."); Thread.sleep(5000); System.out.println("Programme terminé...");
} catch (Exception e) { e.printStackTrace();
}
}
}2. Classe de système :
Le but de la classe système est de fournir un accès aux ressources système. Il contient l'accessibilité aux entrées standard, à la sortie standard, aux flux de sortie d'erreur, à l'heure actuelle en millis, à la fin de l'application, etc.
↥ Retour en haut
1. En utilisant un nouveau mot-clé:
MyObject Object = new MyObject ();
2. Utilisation de class.Forname ():
MyObject Object = (myObject) class.forname ("subin.rnd.myObject"). NewInstance ();3. Utilisation de clone ():
MyObject O autre objet = new myObject (); MyObject Object = (myObject) AnotherObject.Clone ();
4. Utilisation de la désérialisation des objets:
ObjectInputStream InsideRam = new ObjectInputStream (anInputStream); MyObject Object = (MyObject) InsideRam.ReadObject ();
↥ Retour en haut
Les objets immuables sont des objets qui ne changent pas. Un objet immuable Java doit avoir tous ses champs être des champs finaux privés internes. Il ne doit pas implémenter aucun setter. Il a besoin d'un constructeur qui prend une valeur pour chaque champ.
Création d'un objet immuable:
N'ajoutez aucune méthode de set
Déclarer tous les champs finaux et privés
Si un champ est un objet mutable, en créer des copies défensives pour les méthodes Getter
Si un objet mutable transmis au constructeur doit être affecté à un champ, en créez une copie défensive
Ne permettez pas aux sous-classes de remplacer les méthodes.
/ ** * Objet immuable * / classe publique DateContainer {Date finale privée Date; public DateContainer () {this.date = new Date ();
} public Date getDate () {return new Date (date.getTime ());
}
}↥ Retour en haut
La classe immuable signifie qu'une fois un objet créé, nous ne pouvons pas modifier son contenu. En Java, toutes les classes d'emballage (comme entier, booléen, octet, courte) et string sont immuables.
Règles pour créer des classes immuables:
La classe doit être déclarée finale
Les membres de données de la classe doivent être déclarés finaux
Un constructeur paramétré
Méthode Getter pour toutes les variables
Pas de sets
/ ** * Classe immuable * / Employé de classe finale publique {Final String PancardNumber; Employé public (String PancardNumber) {this.pancardnumber = pancardnumber;
} public String getPancardNumber () {return pancardNumber;
}
}↥ Retour en haut
Bootstrap classloader est considérable pour charger des fichiers de classe JDK standard à partir de RT.Jar et il est parent de tous les chargeurs de classe en Java. Il existe trois types de chargeurs de classe intégrés en Java:
1. Chargeur de classe bootstrap: il charge les classes internes JDK, charge généralement RT.Jar et d'autres classes de base par exemple java.lang. * Classes de package
2. Extensions Class Chardeur: Il charge les classes du répertoire des extensions JDK, généralement $ java_home / lib / extréitaire ext.
3. Chargeur de classe système: il charge les classes du chemin de classe actuel qui peut être définie tout en invoquant un programme à l'aide d'options de ligne de commande -cp ou -classpath.
/ ** * classloader * / import java.util.logging.level; import java.util.logging.logger; public class classloaderTest {public static void main (string args []) {try {// imprimer classloader de ce système de classe .out.println ("classloadher:" + classloaderTest.class.getClassloader ()); // Essayant de charger explicitement cette classe à nouveau à l'aide de la classe de classe d'extension class.forname ("Charge de charge explicite", true, classloaderTest.class.getClassLoader (). getParent ());
} catch (classNotFoundException ex) {logger.getLogger (classloadETTest.class.getName ()). Log (NIVEAL.SEVERE, NULL, EX);
}
}
}↥ Retour en haut
Différentes façons de créer un objet en java
En utilisant un nouveau mot-clé:
class objectCreationExample {String propriétaire;
} public class MainClass {public static void main (String [] args) {// nous créons ici un objet de JBT en utilisant un nouveau clé de clé.
}
}En utilisant une nouvelle instance (réflexion)
class CreateObjectClass {static int j = 10; createObjectClass () {i = j ++;
} int i; @OverridePublic String toString () {return "Valeur de i:" + i;
}
} class MainClass {public static void main (string [] args) {try {class cls = class.forname ("createObjectClass"); createObjectClass obj = (createObjectClass) cls.newinstance (); createObjectClass obj1 = (createObjectClass) cls.newinstancementance) (); System.out.println (obj); System.out.println (obj1);
} catch (classNotFoundException e) {e.printStackTrace ();
} catch (InstantiationException e) {e.printStackTrace ();
} catch (illégalaccessException e) {e.printStackTrace ();
}
}
}Utilisation du clone:
classe CreateObjectWithClone implémente Clonable {@OverRideProtected Object Clone () lève ClonenotsupportException {return super.clone ();
} int i; static int j = 10; createObjectWithClone () {i = j ++;
} @OverridePublic String toString () {return "Valeur de i:" + i;
}
} classe MainClass {public static void main (string [] args) {createObjectWithClone obj1 = new CreateObjectWithClone (); System.out.println (obj1); try {createObjectWithClone obj2 = (createObjectWithClone) obj1.clone (); system.out. println (obj2);
} catch (clonenotsupportEdException e) {e.printStackTrace ();
}
}
}Utilisation de Classloader
class CreateObjectWithClassloader {static int j = 10; createObjectwithClassLoader () {i = j ++;
} int i; @OverridePublic String toString () {return "Valeur de i:" + i;
}
} public class MainClass {public static void main (string [] args) {createObjectwithClassloader obj = null; try {obj = (createObjectwithClassOader) new Mainclass (). getClass ()
.getClassLoader (). LoadClass ("CreateObjectWithClassOLODOller"). NewInstance (); // Classname entièrement qualifié doit être utilisé.
} catch (InstantiationException e) {e.printStackTrace ();
} catch (illégalaccessException e) {e.printStackTrace ();
} catch (classNotFoundException e) {e.printStackTrace ();
} System.out.println (obj);
}
}↥ Retour en haut
La classe d'objets est la classe parent de toutes les classes de Java par défaut.
| Méthode | Description |
|---|---|
| classe finale publique getClass () | Renvoie l'objet de classe de classe de cet objet. La classe de classe peut en outre être utilisée pour obtenir les métadonnées de cette classe. |
| public int hashcode () | Renvoie le numéro HashCode pour cet objet. |
| booléen public est égal (objet obj) | Compare l'objet donné à cet objet. |
| Clone d'objet protégé () lève ClonenotsupportEdException | Crée et renvoie la copie exacte (clone) de cet objet. |
| public String toString () | Renvoie la représentation de chaîne de cet objet. |
| public final void notify () | Réveille le thread unique, en attendant le moniteur de cet objet. |
| Public final void notifyall () | Réveille tous les threads, en attendant le moniteur de cet objet. |
| Public Final Void Wait (Long Timeout) Jette InterruptedException | Fait attendre le thread actuel des millisecondes spécifiées, jusqu'à ce qu'un autre thread avertit (invoke notify () ou notifyall () méthode). |
| Public final Void Wait (Long Timeout, int nanos) lève InterruptedException | Fait attendre le thread actuel pour les millisecondes et les nanosecondes spécifiées, jusqu'à ce qu'un autre thread avertit (invoke notify () ou notifyall () méthode). |
| public final void wait () lance InterruptedException | Fait attendre le thread actuel, jusqu'à ce qu'un autre thread informe (invoque notify () ou notifyall () méthode). |
| Protected void finalize () lance le jetable | est invoqué par le collecteur des ordures avant que l'objet ne soit collecté aux ordures. |
↥ Retour en haut
Une valeur facultative Optional est un conteneur pour un objet qui peut contenir ou non une valeur null . Un tel emballage est un moyen de prévention pratique
