Cet article partage les phrases anglaises que les programmeurs Java doivent maîtriser pour votre référence. Le contenu spécifique est le suivant
Classe de résumé: la classe abstraite ne peut pas créer d'objets et est principalement utilisé pour créer des sous-classes. Les classes abstraites de Java sont définies à l'aide de modificateurs abstraits.
Type de données abstrait ADT: le type de données abstrait indique les types et opérations possibles autorisés, mais aucune implémentation n'est fournie.
Identifiant d'accès: utilisé pour la méthode ou les définitions de variables, qui définit les classes qui peuvent accéder à la méthode ou à la variable. Les identifiants d'accès à Java sont publics, protégés et privés. La visibilité par défaut de la variable sans accéder à la modification de l'identifiant est "package".
Enregistrement d'activité: l'enregistrement d'activité contient toutes les informations nécessaires pour implémenter les appels de sous-programme, y compris les valeurs de paramètres, les variables locales dans le sous-programme et l'adresse de retour de l'ordinateur lorsque les appels de sous-programme se terminent. Les enregistrements d'activité sont stockés dans la pile, ce qui permet à plusieurs appels de sous-programme d'être actifs simultanément. Ceci est très important pour la récursivité, où plusieurs appels vers le même sous-programme doivent être activés simultanément.
Paramètre réel: les paramètres d'un sous-programme sont appelés déclarations. Lorsque l'appel est exécuté, la valeur est transmise à l'auto-fonctionment par déclaration. Les paramètres réels sont également appelés "paramètres".
Adresse: Chaque emplacement dans la mémoire de l'ordinateur a une adresse, indiquant le nombre de cet emplacement. Les emplacements de mémoire sont disposés par numéro de séquence. Dans les ordinateurs modernes, chaque octet en mémoire a sa propre adresse. Utilisez l'adresse lors du stockage ou de la lecture d'informations mémoire.
Algorithme: un processus étape par étape requis pour effectuer une tâche. Le processus lui-même n'est pas une ambiguïté et peut garantir que la tâche est terminée dans un nombre limité d'étapes.
Composant de couleur alpha: La composition des couleurs est utilisée pour décrire la transparence ou l'opacité de la couleur. Plus la composition alpha est élevée, plus la couleur est opaque.
API: interface de programmation d'application. Instructions d'interface pour les packages ou les "boîtes à outils". L'API contient toutes les classes ou sous-programmes de la boîte à outils et leurs instructions à utiliser.
Applet: Contrairement aux applications qui peuvent être exécutées séparément, Applet est un programme Java qui s'exécute sur des pages Web dans un navigateur Web.
Animation: un ensemble d'images statiques affiche rapidement des effets dynamiques. Chaque image statique est appelée cadre. En Java, les animations sont généralement motivées par des objets temporaires. Chaque fois que la minuterie se déclenche, le cadre suivant de l'animation s'affiche.
Antialiasing: Lorsque les graphiques et le texte sont affichés en pixels, l'effet "déchiqueté" peut être atténué en ajustant la couleur des pixels. Lors du dessin de l'anti-aliasing, les graphiques ne couvrent qu'une partie du pixel et la couleur des graphiques est mélangée avec la couleur précédente du pixel. Le degré de mélange est déterminé par la quantité de pixels couverts.
Array: une liste d'éléments disposés dans l'ordre. Dans la liste, chaque élément peut être identifié par son propre index, c'est-à-dire le numéro de séquence. En Java, tous les éléments d'un tableau doivent avoir le même type, et ce type est également appelé type de base du tableau. Un tableau est une structure de données accessible au hasard, ce qui signifie que vous pouvez accéder directement à n'importe quel élément du tableau à tout moment.
Type de tableau: la valeur de ce type de données est un tableau. Par exemple, si le nom du type est type, le type [] est le type de tableau et que le type de base est type.
Instruction d'attribution: une instruction dans un programme informatique qui peut lire ou calculer les valeurs numériques et les stocker en variables. L'instruction d'affectation en java est: name variable = expression.
Événement asynchrone: un événement asynchrone fait référence à un événement avec une période inattendue que le programme informatique ne peut pas contrôler. Les événements d'entrée de l'utilisateur comme cliquer sur la souris et appuyer sur la touche sont asynchrones.
Code ASCII: Code standard d'échange d'informations américaines. Ce codage utilise 7 bits pour coder les caractères. Le code ASCII ne prend en charge que 128 caractères et ne prend pas en charge les caractères accentués, les caractères non anglais, les symboles spéciaux ou les idéogrammes dans des langues non caractérisées, comme le chinois. Java utilise un codage Unicode plus grand et plus complet pour traiter les caractères.
Cas de base: Dans l'algorithme récursif, les conditions de référence peuvent être directement traitées sans poursuivre la récursivité.
Numéro binaire: la valeur est codée en un ensemble de séquences 0 et 1. Généralement, les nombres sont basés sur "10" et les nombres binaires leur sont similaires, sauf qu'ils sont basés sur "2".
Arbre binaire: un arbre binaire est une structure de données de chaîne. Il peut s'agir d'un arbre vide, ou se compose de deux petits arbres binaires (peut-être un arbre vide) avec le nœud racine. Le nœud racine contient un pointeur vers deux sous-arbres. Ces deux petits arbres binaires sont appelés le sous-arbre gauche et le sous-arbre droit.
Bit: un numéro binaire, qui peut être 0 ou 1.
Boîte noire: fait référence au système ou au composant qui n'a pas besoin de se soucier de la structure interne lorsqu'elle est utilisée. La boîte noire comprend des interfaces et des implémentations. Dans le système, la boîte noire utilisée comme composant est appelée module.
BLOCK: Dans la programmation Java, un ensemble d'instructions entourés de bretelles bouclées ({}) est appelée blocs. Le bloc (code) est utilisé pour combiner un groupe d'instructions dans une instruction. Un bloc peut être vide, indiquant qu'il ne contient aucune instruction, c'est-à-dire une paire d'accès bouclés vides.
Opération de blocage: une opération est appelée opération "Blocking" si elle doit attendre que certains événements se produisent, tels que la lecture des données à partir d'une connexion réseau. Le fil qui effectue l'opération de blocage restera dans un état de "blocage" jusqu'à ce que l'événement se produise. En cas de blocage, le thread ne peut exécuter aucune instruction. Les autres threads du programme peuvent continuer à s'exécuter.
Blocking Fitre: Lorsque la file d'attente de blocage est vide, l'opération de désagréation provoquera un blocage jusqu'à ce qu'un nouveau membre de la file d'attente rejoigne. S'il y a une limite de taille pour la file d'attente de blocage, l'opération d'agitation entraînera également un blocage lorsque la file d'attente est pleine.
Conception ascendante: la conception ascendante est une méthode de conception logicielle. Commencez à concevoir à partir des composants de base du système, puis les combiner en composants plus complexes, etc.
Classe BufferedImage: La classe BufferedImage affiche "toile hors écran", c'est-à-dire que l'image est stockée dans la mémoire de l'ordinateur et peut être dessinée hors écran.
Branche: Une branche est une structure de contrôle dans laquelle un ordinateur sélectionne deux ou plusieurs chemins d'exécution différents à travers les branches. Java a deux instructions de branche: IF Instruction et Switch Instruction.
Byte: l'octet est une unité de mémoire composée de 8 bits. Un octet peut contenir des numéros binaires 8 bits.
ByteCode: "Java Bytecode" est un nom commun pour le langage de la machine virtuelle Java. Les programmes Java sont compilés dans Java Bytecode, qui est exécuté par le JVM.
Charset: un jeu de caractères est une forme de codage spécifique qui code pour les données de caractères en binaire. Par exemple, UTF-8 et ISO-8859-1.
Exception vérifiée: l'exception vérifiée doit être traitée en Java. Il peut être capturé par l'instruction TRY CATCH ou lancer l'exception en utilisant l'instruction Throw sur la méthode. Si l'exception détectée n'est pas gérée dans les deux sens, une erreur de syntaxe sera signalée.
Classe: La classe est l'unité de programmation de base de Java. Une classe est une collection de méthodes statiques, de méthodes non statiques et de variables. Les membres statiques font partie de la classe elle-même, et les membres non statiques ou "d'instance" sont le plan pour créer des objets, et les objets créés à partir d'eux "appartiennent" à "à cette classe.
Variables de classe et méthodes de classe: alias pour "variables statiques" et "méthodes statiques". Ils font partie d'une classe et n'ont rien à voir avec l'objet.
Client / serveur: un mode de communication réseau. Parmi eux, le "serveur" attend une adresse connue sur le réseau et attend le "client" pour y initier une demande de connexion. Il s'agit du modèle de communication de base du protocole TCP / IP.
Interface de ligne de commande: une méthode d'interaction informatique. L'utilisateur entre les commandes sur l'ordinateur et l'ordinateur répond à chaque commande.
Commentaire: Dans un programme informatique, les commentaires sont du texte qui est ignoré par l'ordinateur. Le but des commentaires est de faciliter les gens à lire et à aider à comprendre le programme.
Compiler: Un compilateur est un programme informatique qui traduit des programmes écrits dans un certain langage informatique (généralement un langage de haut niveau) en programmes de langue machine.
Composant: le composant est un terme général pour les éléments visuels de GUI, y compris les fenêtres, les boutons ou les menus. Dans Java, les composants apparaissent sous forme d'objets créés par la sous-classe Java.awt.component.
Constructeur: un sous-programme spécial d'une classe, principalement utilisé pour créer des objets de classe. Les constructeurs sont généralement appelés à l'aide du nouvel opérateur et ne sont généralement pas considérés comme une «méthode».
Conteneur: des composants comme JPanel, les conteneurs peuvent contenir d'autres composants GUI. L'appel de la méthode ADD () du conteneur peut y ajouter des composants.
Contrat d'une méthode: la composante sémantique d'une interface de méthode. Il spécifie la méthode et les responsabilités de son appelant, comment appeler la méthode et les tâches qui seront exécutées lorsque la méthode est appelée correctement. Le contrat de méthode doit être entièrement décrit dans les commentaires Javadoc de la méthode.
Structure de contrôle: une structure de programme similaire aux instructions IF et bien que les boucles peuvent affecter le flux de contrôle du programme (c'est-à-dire l'ordre d'exécution des instructions dans le programme).
CPU: Processeur central. Le CPU est la partie de l'ordinateur qui exécute réellement des calculs et exécute des programmes.
Structure de données: une collecte de données organisée. Il est traité comme une unité du programme.
Dedlock: une situation où plusieurs threads attendent l'infini. Les raisons des impasses sont, telles que chaque thread attend des ressources verrouillées par d'autres threads.
Méthode par défaut: une méthode dans l'interface Java 8, qui fournit sa propre implémentation. Toutes les interfaces qui implémentent les méthodes par défaut peuvent utiliser des implémentations par défaut, mais ne peuvent pas remplacer les méthodes par défaut. Gardez la méthode par défaut par défaut. Java 7 ne prend pas en charge la méthode par défaut.
Package par défaut: le package par défaut n'a aucun nom de package. Les classes qui ne sont pas déclarées dans des packages avec des noms appartiennent au package par défaut.
Affectation définie: Dans un programme, les variables doivent être assurées d'être attribuées avant utilisation. Les variables locales ne peuvent être utilisées légalement qu'après l'attribution. Pour atteindre cette exigence, le compilateur doit effectuer des vérifications d'attribution sur chaque chemin du début de la déclaration à l'utilisation de la variable.
Débroupillé: signifie qu'il a été abandonné, mais il est toujours conservé pour la compatibilité. Les classes ou méthodes Java obsolètes font toujours partie de la langue Java, mais ne sont pas recommandées pour une utilisation dans le nouveau code. Dans les futures versions Java, le contenu obsolète sera supprimé.
Boîte de dialogue: Une boîte de dialogue est un nouveau formulaire créé en s'appuyant sur d'autres formulaires. Une boîte de dialogue contextuelle est généralement utilisée pour obtenir des informations utilisateur ou afficher des messages. Dans l'API Swing, la boîte de dialogue est représentée comme un objet créé par JDialog.
Informatique distribuée: un traitement parallèle effectué dans plusieurs ordinateurs connectés par un réseau.
Paramètre factice: l'identifiant utilisé pour remplacer les paramètres réels passés lors de l'appel d'un sous-programme. Les paramètres virtuels sont également appelés "paramètres formels" (parfois "l'argument variable" est utilisé pour représenter des paramètres réels, et à ce moment, les paramètres virtuels sont également appelés "paramètres").
Enum: Type d'énumération. La définition de type d'énumération répertorie toutes les valeurs possibles du type. Dans Java, un type d'énumération est une classe et toutes les valeurs possibles sont des objets.
Événement: Dans la programmation GUI, les événements se réfèrent aux opérations qui se produisent en dehors du contrôle du programme, comme cliquer sur la souris. Le programme doit répondre aux événements qui se produisent.
Exception: une erreur d'erreur ou d'exception en dehors du processus de contrôle du programme. En Java, les exceptions sont représentées comme des objets jetables et peuvent être capturés et traités par des instructions Try..catch.
Cycle de récupération et d'exécution: également connu sous le nom de cycle d'instructions. Fait référence au processus par lequel le CPU exécute un programme de langage de machine. Le CPU va récupérer (c'est-à-dire lire) les instructions de la mémoire, exécuter (exécuter) les instructions, puis répéter le processus.
Drapeau: une valeur booléenne. Situé sur Vrai signifie que quelque chose est rencontré ou que quelque chose s'est produit. Un peu dans un numéro binaire peut être utilisé comme drapeau.
Paramètre formel: un autre terme pour "Paramètre virtuel".
Cadre: une certaine image qui forme une animation, qui est une autre façon de dire des enregistrements d'activité.
Fonction: un sous-programme avec une valeur de retour.
Collection des ordures: le processus de collecte automatique de la mémoire. La mémoire recyclée est occupée par l'objet mais ne lui est plus accessible.
Programmation générique: le code écrit n'est pas limité à un seul type de données, mais peut être adapté à plusieurs types de données. Le cadre de collection Java et d'autres classes qui utilisent des technologies similaires sont des exemples de programmation générique.
Méthode Getter: une méthode d'instance dans la classe, utilisée pour lire une valeur de propriété d'une classe. En règle générale, les attributs représentent les valeurs de certaines variables d'instance. Par convention, la méthode Getter est nommée getxyz (), où xyz est le nom de la propriété.
Variable globale: un alias pour les variables membres. Soulignez que les variables des membres dans une classe peuvent exister en dehors d'une méthode de classe.
Contexte graphique: les données et les méthodes nécessaires pour dessiner certains emplacements spécifiques. Le contexte graphique de Java est un objet appartenant à la classe graphique.
GUI: L'interface utilisateur graphique est un moyen moderne d'interagir avec les ordinateurs. L'ordinateur affiche des composants d'interface comme les boutons et les menus sur l'écran via une interface graphique, et les utilisateurs peuvent interagir avec lui via un clic de souris.
Tableau de hachage: une structure de données optimisée qui peut rechercher, insérer et supprimer efficacement les objets. Le tableau de hachage contient un tableau d'adresses des objets. L'adresse du stockage d'objets est déterminée par son propre "code de hachage". La valeur entière d'adresse peut être calculée efficacement via le contenu de l'objet.
Tas: la zone dans la mémoire de l'ordinateur où les objets sont stockés.
Langue de haut niveau: un langage informatique similaire à Java est pratique pour les gens à lire, mais il doit être traduit en langage de la machine avant l'exécution.
HSB: un système couleur. Lorsque la couleur est représentée par 3 valeurs numériques (en Java, les valeurs numériques réelles sont comprises entre 0,0 et 1,0). Représente respectivement la teinte, la saturation et la luminosité.
IDE: Environnement de développement intégré. Un environnement de programmation avec interface utilisateur graphique qui intègre divers outils pour créer, modifier et exécuter des programmes.
Identifiant: un ensemble d'identifiants qui peuvent être utilisés comme noms dans un programme. Les identifiants peuvent être utilisés comme noms de variables, noms de méthode et noms de classe.
Numéro d'index: le numéro de position de l'élément dans le tableau.
Implémentation: l'implémentation interne de la boîte noire, telle que le code d'implémentation du sous-programme.
Objet immuable: l' objet immuable ne peut pas être modifié une fois la construction de l'objet immuable terminé, car toutes les variables de l'instance sont marquées finales.
Boucle infinie: la boucle ne se termine jamais parce que sa condition de boucle est toujours jugée vraie.
Héritage: une classe peut hériter d'une autre classe. Les héritiers héritent des données et du comportement de la classe parent.
Instance d'une classe: fait référence à un objet qui appartient à une classe (ou à une sous-classe du type). Lorsqu'une classe est utilisée comme modèle d'objet, l'objet créé par le constructeur de la classe appartient à cette classe.
Méthode d'instance: une méthode non statique dans une classe, toutes les instances de la classe ont cette méthode.
Variable d'instance: une variable non statique dans une classe, et toutes les instances de la classe contiennent cette variable.
Interface: un dicton commun sur la façon d'utiliser des boîtes noires comme les sous-programmes. L'interface ne fournit aucune information sur ce qui se passe à l'intérieur. "Interface" est également un mot réservé en Java. En ce sens, une interface est un type qui définit une ou plusieurs méthodes abstraites. L'objet implémentant l'interface doit fournir une définition de ces méthodes.
Interprète: un programme informatique qui exécute un programme et le programme exécuté est écrit par un certain langage de programmation. En lisant les instructions une par une du programme, puis en les exécutant une par une (traduire les instructions en langage de machine équivalent).
E / S: entrée / sortie. Les méthodes de communication des programmes informatiques avec d'autres pièces, telles que l'affichage des données aux utilisateurs, l'obtention d'informations des utilisateurs, la lecture et l'écriture de fichiers, l'envoi et l'obtention de données sur le réseau.
Iterator: un objet associé à une collection telle que la liste ou le jeu. Peut être utilisé pour traverser la collection. L'itérateur se retire à tour de rôle dans chaque élément de la collection.
Java Collection Framework JCF: un ensemble de classes standard qui implémentent les structures de données génériques. Y compris ArrayList, Treeset, etc.
Javafx: nouvel ensemble d'outils GUI pour l'application. Recommandé dans Java 8. Javafx n'est pas dans le cadre de ce livre.
JDK: ensemble d'outils de développement Java. Logiciel de base qui prend en charge la compilation et l'exécution de programmes Java. JDK inclut l'environnement de programmation de ligne de commande et JRE. Pour compiler le code source Java ou exécuter des programmes précompilés, vous devez utiliser JDK.
JRE (Java Runtime Environment): Java Runtime Environment. Prend en charge l'exécution de programmes Java standard compilés. JRE comprend une machine virtuelle Java et toutes les classes Java standard.
Compilateur juste à temps: une combinaison d'interprète et de compilateur qui peut être compilée lors de l'interprétation d'une partie d'un programme. L'étape suivante consiste à exécuter cette partie du programme plus rapidement que la première exécution. Cela peut améliorer considérablement la vitesse d'exécution. Les JVM modernes utilisent des compilateurs instantanés.
JVM: machine virtuelle Java. Un ordinateur virtuel qui exécute Java Bytecode comme un langage de machine. Également utilisé pour faire référence à des programmes informatiques qui analysent les programmes Bytecode. Pour exécuter des programmes Java sur votre ordinateur, vous devez utiliser un JVM.
Gestionnaire de mise en page: l'objet responsable de la disposition des composants dans le conteneur. Certaines opérations effectuées incluent la taille et la position du réglage. Différents types de gestionnaires de disposition mettent en œuvre différentes stratégies de mise en page.
Structure de données liée: un ensemble de données d'objet liées les unes aux autres par des pointeurs. Ces pointeurs sont stockés dans la variable d'instance de l'objet. Une structure de données enchaînées comprend une liste liée et un arbre binaire.
Liste liée: une structure de données enchaînées, où les pointeurs sont connectés pour former une liste liée linéaire.
Écouteur: Dans la programmation GUI, les notifications de déclenchement pour des événements spécifiques peuvent être enregistrées auprès d'objets. Par conséquent, on peut dire que l'objet "écoute" ces événements.
Littéral: un ensemble de caractères a été tapé dans le programme pour représenter des valeurs constantes. Par exemple, lorsque A apparaît dans un programme Java, «A» est un caractère constant.
(Mémoire) Emplacement (emplacement en mémoire): La mémoire de l'ordinateur se compose d'une série d'emplacements. Ces emplacements sont numérotés en séquence et le nombre identifiant un emplacement particulier est appelé l'adresse de cet emplacement.
Variable locale: une variable déclarée à l'intérieur d'une méthode ne peut être utilisée que dans la méthode. La validité des variables déclarées dans un bloc de code commence à la déclaration et se termine à la fin du bloc de code.
Loop: une structure de contrôle qui exécute à plusieurs reprises un ensemble d'instructions. Java fournit 3 types de boucles: pour la boucle, lors de la boucle et de la boucle.
Variable de contrôle de boucle: une variable dans une boucle. La valeur de la variable de boucle sera modifiée chaque fois que la boucle pour la boucle est exécutée. En vérifiant la variable, s'il faut mettre fin à la boucle.
Langage de la machine: un langage de programmation composé d'instructions que l'ordinateur peut exécuter directement. Les instructions dans le langage de la machine sont codées en numéros binaires. Chaque type d'ordinateur a son propre langage de machine. Les programmes écrits dans d'autres langues doivent être traduits dans le langage de la machine du calcul avant de pouvoir être exécutés dessus.
Mémoire principale: les programmes et les données peuvent être stockés dans la mémoire principale de l'ordinateur, et la mémoire principale peut être directement accessible par le CPU. D'autres formes de mémoire, telles que des lecteurs de disque, peuvent également stocker des informations, mais seule la mémoire principale peut être directement accessible par le CPU. Les programmes et les données dans les partitions de disque ne peuvent être accessibles que par le CPU s'ils sont copiés en mémoire.
Carte: un tableau de carte. Cette structure de données associe un objet dans une collection avec tous les objets d'un ensemble. En Java, la carte est représentée par la carte générique de l'interface <t, s>.
Variable membre: une variable définie dans une classe, mais n'appartient à aucune méthode. Les variables des membres sont différentes des variables locales, qui sont définies dans une méthode.
Mémoire: La mémoire de l'ordinateur est utilisée pour stocker des programmes et des données.
Méthode: Un autre nom pour les sous-programmes, utilisé dans la programmation orientée objet. Une méthode fait référence à un sous-programme contenu dans une classe ou un objet.
Module: composants dans les grands systèmes qui interagissent avec d'autres parties du système de manière simple, claire et directe.
Multitâche: exécutez plusieurs tâches de programmation à la fois. Basculez rapidement entre plusieurs tâches ou effectuez plusieurs tâches une par une en même temps.
Multiprocessement: le multiprocessement utilise plusieurs processeurs lors de l'exécution de multitâche. De cette façon, plusieurs tâches peuvent être exécutées une par une en même temps.
Exclusion mutuelle: empêche deux threads d'accéder à la même ressource en même temps. Dans Java, cette méthode est appliquée à plusieurs threads accédant simultanément sur des ressources dans des méthodes de synchronisation ou des instructions de synchronisation. L'exclusion mutuelle peut empêcher les conditions de course, mais peut déclencher des impasses.
Modèle MVC: mode modèle-visual-contrôleur. Une stratégie de division des responsabilités dans les composantes de l'interface graphique. Le modèle représente les données du composant, la vue fait référence à l'affichage du modèle à l'écran et le contrôleur est responsable de la réponse aux événements de changement de modèle. En mode MVC, ces responsabilités sont gérées par différents objets.
Valeur non numérique (NAN): pas une valeur numérique. Double.nan représente une double valeur spéciale, indiquant une valeur non définie ou illégale.
Node: un nom commun pour un objet dans une structure de données de chaîne.
NULL: une valeur de pointeur spéciale qui signifie "pas de pointage vers quoi que ce soit".
Analyse numérique: utilisez des méthodes d'approximation pour étudier les champs des algorithmes, tels que les nombres réels et les erreurs obtenus à partir des calculs d'approximation.
Erreur hors un: une erreur courante, qui réduit ou ajoute un élément de plus lors du traitement. Habituellement, il est causé par des erreurs ou des cycles techniques en raison de l'arrêt prématuré ou de l'exécution excessive.
Objet: Une entité dans un programme informatique avec des données (variables) et des comportements (méthodes). Les objets de Java doivent utiliser une certaine classe comme modèle à créer. La classe à laquelle appartient l'objet détermine les classes et méthodes que l'objet contient.
Type d'objet: La valeur de ce type est un objet plutôt qu'un type de base. Les classes et les interfaces sont des types d'objets.
POO (programmation orientée objet): programmation orientée objet. Une méthode de programmation et d'implémentation informatique. OOP utilise des classes et des objets pour créer et représenter des entités et des interactions entre entités.
Système d'exploitation: logiciel de base qui fonctionne sur l'ordinateur. Les ordinateurs sans système d'exploitation ne fonctionneront pas. Le système d'exploitation est en Linux, Mac OS et Windows Vista.
Opérateur: les opérateurs comme "+", "<=" ou "++", peuvent calculer une ou plusieurs valeurs dans une expression.
(Opérateur) Surcharge (surcharge d'opérateurs): Le même opérateur peut être utilisé sur différents types de données. Par exemple, l'opération "+" peut être appliquée aux types numériques et de caractères en même temps.
(Nom de la méthode) Surcharge (surcharge des noms de méthode): Plusieurs méthodes avec le même nom sont définies dans la même classe, la différence est que les signatures de chaque méthode sont différentes.
Remplacement: redéfinir dans une sous-classe. Dans une sous-classe, la méthode héritée de la classe parent est redéfinie et la méthode nouvellement définie consiste à réécrire la méthode d'origine.
Package: Dans Java, une célèbre collection de cours et de sous-packages connexes s'appelle des packages, tels que java.awt et javax.swing.
Traitement parallèle: exécuter plusieurs tâches en même temps, soit plusieurs processeurs, soit un processeur peut réexécuter entre plusieurs tâches.
Paramètre: Lors de l'appel d'un sous-programme, les paramètres sont utilisés pour fournir des informations au sous-programme. Avant d'exécuter le code de sous-programme, les "arguments réels" dans l'instruction d'appel de sous-programme seront attribués aux "paramètres virtuels" définis par le sous-programme.
Type paramétré: similaire à ArrayList <string>, un type contenant un ou plusieurs types de paramètres (le type de paramètre ici est une chaîne).
Analyse: le processus de détermination de la structure de syntaxe des chaînes dans la répétition. La chaîne d'analyse est utilisée pour déterminer si la chaîne suit la syntaxe de la langue; Si c'est le cas, il détermine comment la chaîne est créée en fonction de la syntaxe.
Array partiellement complet: les tableaux sont utilisés pour stocker des éléments de différents nombres. Les tableaux partiellement complets sont représentés comme un tableau normal avec un compteur pour les éléments de traçage.
Pixel: fait référence à "l'élément d'image" dans l'écran ou l'image. Une image se compose de lignes et de colonnes de pixels. Les couleurs de chaque pixel peuvent être réglées séparément.
Polymorphisme: le polymorphisme fait référence à la signification d'appeler une méthode d'instance dépend du type réel de l'objet lors de l'appel de la méthode. Autrement dit, si le type de la variable est VAR, l'instruction qui appelle la méthode, telle que var.Action (), dépend du type d'objet que Var pointe au temps d'exécution, plutôt que du type de la variable VAR.
Pointer: la valeur d'une certaine adresse dans la mémoire de l'ordinateur, il peut donc être considéré comme "pointant" vers l'emplacement avec cette adresse. En Java, les variables n'ont pas d'objets; Les variables pointent simplement vers l'emplacement où l'objet est stocké. Les pointeurs sont également appelés "références".
Pragmatique: règles de base pour décrire comment rédiger un bon programme. Par exemple, les règles de style et les guides d'organisation de programme font tous partie de la programmation de la pragmatique.
Précédence: La priorité d'un opérateur fait référence à l'ordre dans lequel plusieurs opérateurs agissent dans l'expression sans supports.
Précondition: Pendant l'exécution du programme, pour que le programme s'exécute correctement, la condition préalable doit être déterminée comme vraie. La condition préalable à un sous-programme fait référence à la condition préalable qui doit être remplie pour que le sous-programme fonctionne correctement. La condition préalable à un sous-programme est généralement une restriction sur les valeurs réelles des paramètres du sous-programme entrant.
File d'attente de priorité: une structure de données qui représente la combinaison d'éléments, où chaque élément a sa propre "priorité". La file d'attente prioritaire a des opérations ajoutées et supprimées. Des éléments peuvent être ajoutés dans n'importe quel ordre, mais les éléments avec la priorité la plus basse sont toujours supprimés en premier lors de la suppression. (Certaines versions de la file d'attente prioritaire supprimeront d'abord l'élément de priorité le plus élevé)
Postcondition: sur un nœud où le programme est exécuté, le résultat de calcul de cette condition est vrai. La condition post-condition du sous-programme doit être vraie après l'exécution du sous-programme. La limite de post-condition d'une fonction est généralement exprimée comme la valeur de retour de la fonction.
Type primitif: les 8 types de données de base intégrés en Java incluent Double, Float, Long, Int, Short, Byte, Boolean et Char. La variable de type primitif stocke la valeur réelle, pas un pointeur vers la valeur numérique.
Priorité du thread (priorité d'un thread): une valeur entière associée à un thread, qui peut affecter l'ordre d'exécution des threads. Les fils avec une priorité élevée s'exécutent à l'avance que les threads avec une faible priorité.
Producteur / consommateur: un modèle classique en programmation parallèle dans lequel les produits produits par un ou plusieurs producteurs sont utilisés par un ou plusieurs consommateurs. Les producteurs et les consommateurs sont conçus pour être exécutés en parallèle. La difficulté ici réside dans la façon de savoir en toute sécurité et efficacement des producteurs aux consommateurs sans les produits correspondants. En Java, le modèle producteur / consommateur est mis en œuvre en bloquant les files d'attente.
Programme: un ensemble d'instructions rédigées dans un langage de programmation approprié, exécuté par un ordinateur. Lorsqu'il est utilisé comme verbe, il indique l'action pour créer l'instruction.
Langage de programmation: un langage utilisé pour programmer des ordinateurs. La complexité des langages de programmation s'étend beaucoup du langage de la machine aux langages de haut niveau comme Java.
Protocole: un ensemble de spécifications qui constituent une communication légale dans un contexte spécifié. L'accord stipule les messages juridiques, le temps de transmission, le type de récupération attendu, etc.
Pseudocode: spécification d'algorithme informelle. Par rapport aux langages de programmation réels, le pseudocode est plus proche de l'anglais. Et, il n'est souvent pas nécessaire d'écrire explicitement chaque détail du processus.
File: une structure de données composée d'un ensemble d'éléments. Vous ne pouvez ajouter des données qu'à une extrémité de la liste et supprimer les données à l'autre extrémité de la liste.
Condition de course: source possible d'erreurs dans la programmation parallèle. Une erreur est augmentée car un thread modifie l'état du programme (tel que la valeur variable) dont dépend le deuxième programme.
RAM (mémoire d'accès aléatoire): mémoire d'accès aléatoire. Synonymes pour la mémoire principale de l'ordinateur. Cependant, d'un point de vue technique, RAM signifie que les adresses de mémoire sont accessibles à tout moment. La RAM signifie également que les données peuvent être lues et écrites simultanément.
Récursion: définissez-vous sous votre propre forme. En particulier, un sous-programme récursif peut indirectement s'appeler directement ou à travers une série d'autres sous-programmes. La façon dont les algorithmes récursifs fonctionnent en divisant un problème complexe en sous-problèmes plus petits. Le sous-problème peut être résolu directement, soit le même algorithme peut être utilisé "récursivement".
RVB: un système couleur. La couleur est définie par 3 valeurs numériques (en Java, la plage de valeurs varie de 0 à 255). Il représente la composition du rouge, du vert et du bleu dans la couleur respectivement.
Référence: un autre terme pour "pointeur".
Retour Type d'une fonction: Le type de fonction renvoie la valeur.
Mot réservé: un ensemble de séquences de chaînes qui ressemblent très similaires aux identifiants. Cependant, il ne peut pas être utilisé comme identifiant car il a une signification particulière dans les langages de programmation. Par exemple, la classe et le public sont des mots réservés en Java.
Ressource: les images, les sons, les textes ou les fichiers de données dans les programmes sont des ressources. Les fichiers de ressources Java sont stockés dans le même chemin que les fichiers de classe compilés.
Programme robuste: les programmes robustes sont non seulement corrects, mais peuvent également gérer les erreurs, tels que les fichiers n'existent pas ou que la connexion réseau ne peut pas être établie.
Ensemble: un ensemble d'objets sans doublons. En Java, les collections sont représentées par l'ensemble d'interface générique <T>.
Portée: représente la portée valide de l'identifiant déclaré dans le programme.
Sémantique: La sémantique fait référence aux règles sémantiques d'une langue qui déterminent la signification des symboles de chaîne (tels que des phrases ou des déclarations) dans la langue.
Valeur sentinelle: une marque spéciale qui indique la fin de la séquence de données, indiquant que les données sont terminées.
Méthode de setter : une méthode d'instance dans la classe, utilisée pour définir certaines valeurs d'attribut dans la classe. Habituellement, ces propriétés ne sont que des valeurs variables d'instance. Par convention, la méthode du secteur est nommée setxyz (), où xyz est le nom de la propriété.
方法签名（signature of a method）：方法名、方法定义中形参的个数以及每个形参的类型。编译器通过方法签名来识别指定子程序调用语句究竟调用了哪个方法。
套接字（socket）：网络上两个计算机之间的连接，对其中一端的抽象表示。套接字表示计算机程序间的一个逻辑连接，而非计算机间的物理连接。
栈（stack）：一组元素组成的列表数据结构，只能在列表的尾部，也称作“栈顶”。向栈中添加元素叫“入栈push”，移除元素称作“出栈pop”。栈也指用来实现子程序调用的活动记录。
标准输入（standard input）：程序读取输入数据的标准源，由System.in 对象表示。通常，标准输入来自用户键入的文本，但是标准输出也可以重定向到其它源，比如文件。
标准输出（standard output）：程序将输出文本写入的标准目标，由System.out 对象表示。通常，标准输出会向用户展示，但是也可以“重定向”到其它目标，比如文件。此外，System.err 对象用来输出错误信息。
状态机（state machine）：一种计算机模型。抽象的“机器”可处于有限状态集中的任何一种状态。机器会根据自身的状态决定行为，根据输入或事件进行状态切换。GUI程序的基本逻辑可表现为状态机。
逐步精化法（step-wise refinement）：一种算法开发技术。开始列出算法步骤大纲，通常用伪代码表示，然后逐步填充细节。
流（stream）：输入数据源或输出数据目标的抽象表示。Java为字符和二进制数据输入、输出流提供了4个基础类。这些类组成了Java I/O API的基础。
源代码（source code）：用高级编程语言编写的文本。在计算机执行前，必须翻译成机器语言，比如Java字节码。
子类（subclass）：一个类，直接或间接继承了其它类，从而继承了它的数据和行为。前一个类就叫做第二类的子类。
子程序（subroutine）：一系列程序指令。通过子程序名可以“调用”该子程序。在面向对象编程中，子程序也称作方法。
子程序调用语句（subroutine call statement）：程序中调用子程序的语句。当执行子程序调用语句时，计算机会执行子程序内部的代码。
super：一个特殊变量，在实例方法中自动定义。super指包含该方法的对象，归属于方法所在类的父类。super可以访问父类中被隐藏的成员变量，这些变量与子类中的成员变量同名。
语法（syntax）：定义了该语言中哪些字符串符号符合该语言的语法规则。
TCP/IP：Internet上用来网络通讯的协议。
this：一个特殊变量，在实例方法中自动定义，归属于方法所在的类。
线程（thread）：对一系列逐条执行语句的抽象表示。计算机可以并行执行多个线程。
线程池（thread pool）：执行任务时可以使用的一组“工作线程”。当任务就绪时，可分配给池中的线程。线程池通常使用阻塞式队列存储任务。
自顶向下设计（top-down design）：一种软件设计方法。开始把问题作为一个整体，然后拆分成更小的问题，再逐步细化，直到子问题可以直接解决。
类型（type）：数值的特定类型。例如，int类型规定了整形值可以表示为32比特二进制数。在Java中，类型可以是基本类型、类名或接口名。类型名可用来定义变量的类型，子程序中的虚拟参数和子程序的返回类型。
类型转换（type cast）：把一种类型的值强制转换为另一种类型。例如，在(int)(6*Math.random()) 中，(int) 是一个类型转换操作，将(6*Math.random()) 的浮点值转换为了整形，丢弃了实数中的小数部分。
Unicode：将字符编码成二进制数的一种方式。Unicode字符集包含了许多语言的字符，不仅限于英语。Java内部使用的就是Unicode字符集。
URL：全球资源定位器。Internet上资源的地址，比如网页。
变量（variable）：一个带名字的内存位置（或一系列位置），用来存储数据。在程序中创建变量，通过变量声明语句将名字赋予该变量。根据使用情况，这个名字在程序中可以代指该内存位置，或者向内存地址中存储数据。在Java中，变量具有类型，可以表示变量持有数据的种类。
包装类（wrapper class）：类似Double、Integer这样的类，将一个基本类型的值“包装”在对象中，该对象归属于包装类。这样，在需要使用对象的地方也可以使用基本类型值，比如Java集合框架。
XML（eXtensible Markup Language）：可扩展标记语言。一种非常常见且语法标准、支持良好的语言。用来创建基于文本的数据表示。
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.