J'avais besoin d'utiliser Java au travail et j'ai décidé de prendre Java Silver pour un apprentissage systématique, je vais donc résumer brièvement ce que j'ai appris là-bas par mot-clé.
Les déclarations de classe se composent de champs et de méthodes. Le constructeur fait partie de la méthode
Les classes appartenant à un package ne sont accessibles que par les classes du même package. Les classes appartenant à un package anonyme ne sont accessibles que par les classes appartenant au même package anonyme
À l'origine, les champs et méthodes statiques doivent être spécifiés au format nom de classe.nom de champ (nom de méthode). Importation statique pour les rendre abrégés uniquement par leur nom
importer le nom du package statique.nom de la classe.Nom du champ (nom de la méthode)
N'ajoutez pas de parenthèses ou d'arguments aux noms de méthode dans les déclarations d'importation statique de méthode
Vous pouvez définir plusieurs méthodes dans une classe, mais les méthodes pour démarrer le traitement, les descriptions des points d'entrée et les règles sont les suivantes.
public static void main(String[] args) {
}
La commande java est une commande de démarrage d'une machine virtuelle Java. La syntaxe est la suivante
nom de classe complet java[Argument Argument ...]
Les types de données Java incluent les types primitifs (entier, nombre à virgule flottante, valeur booléenne, caractère) et le type de référence (type d'objet, type d'énumération, type de tableau). Les types de données des types primitifs sont les suivants Il n'y a pas de type booléen
| Type de données | valeur |
|---|---|
| boolean | true,false |
| char | Caractère Unicode 16 bits |
| short | Entier 16 bits |
| int | Entier 32 bits |
| long | Entier 64 bits |
| float | Nombre à virgule flottante simple précision 32 bits |
| double | Nombre à virgule flottante simple précision 64 bits |
Un littéral est une valeur décrite dans le code source. En Java, les valeurs entières sont gérées en tant que type int, type double pour les valeurs décimales flottantes, type booléen pour les valeurs booléennes et type char pour les caractères. Sera
En ajoutant un suffixe ou un préfixe, il est possible de spécifier le type de données et la notation autres que les nombres décimaux.
・ Exemple de suffixe type long ・ ・ ・ L, type flotteur ・ ・ ・ f
・ Exemple de préfixe 0 ・ ・ ・ octadécimal 0x ・ ・ ・ hexadécimal 0b ・ ・ ・ nombre binaire
La notation numérique utilisant le trait de soulignement est utilisée dans le but d'améliorer la visibilité des littéraux numériques avec de nombreux chiffres, et a les règles suivantes
char est un type de données qui représente un caractère Les éléments suivants peuvent être attribués au type de chara
Les caractères littéraux doivent être placés entre guillemets simples Mettre les chaînes littérales entre guillemets
Un identifiant est le nom d'une variable, d'une méthode, d'une classe, etc. Les bases peuvent être décidées librement, mais il existe les règles suivantes
null null est un littéral pour représenter qu'une variable de type référence ne contient pas de référence. Différent des caractères vides ("")
La méthode est appelée comme suit
Une signature est un ensemble de noms de méthodes et une liste d'arguments. Java a un mécanisme appelé surcharge, et il peut y avoir plusieurs méthodes avec le même nom, alors utilisez des signatures pour identifier les méthodes.
En langage C etc., il est nécessaire d'écrire le code pour allouer ou libérer la mémoire dans le programme, mais Java a une fonction de gestion automatique de la mémoire. Le garbage collector trouve les instances inutiles et les détruit, ce qui est appelé garbage collection. La cible du garbage collection est une instance qui n'est plus référencée de n'importe où, et comme un timing typique, lorsque null est assigné à une variable.
Les types et les significations des opérateurs d'affectation sont les suivants
| opérateur | Exemple d'utilisation | sens |
|---|---|---|
| = | a = 10; | Remplacez 10 par un |
| += | a += 10 | a à a+Suppléant 10 |
| -= | a -= 10 | a à a-Suppléant 10 |
| *= | a *= 10 | a à a*Suppléant 10 |
| /= | a /= 10 | a à a/Suppléant 10 |
Il existe deux types d'opérateurs moins (-): la soustraction et l'inversion positive / négative.
Un cast explicite est requis lors de l'attribution d'une large plage de valeurs à une petite variable
int a = 15;
short b = (short) a;
Les littéraux entiers numériques sont essentiellement de type int, et dans le cas de virgule flottante, de type double, donc si vous mettez cette valeur dans une petite variable, vous devez la convertir explicitement en principe. Dans le cas d'un littéral de variable affecté à un type d'octet ou à une variable de type court, si la valeur se trouve dans la plage, aucune erreur de compilation ne se produira.
・ Type d'octet et plage de type courte
| Nom du modèle | intervalle |
|---|---|
| byte | -128~127 |
| short | -32768~32767 |
Increment (++) et Decrement (-) sont des opérateurs pour ajouter ou soustraire 1 à la valeur d'une variable. Lorsqu'il est combiné avec d'autres opérateurs, lorsqu'il est préfacé, il est incrémenté (décrémenté) puis attribué, et lorsqu'il est postfixé, il est attribué puis incrémenté (décrémenté).
int a = 10
int b = 10
int c = ++a //Incrémenter a puis attribuer à c a=11,c=11
int d = b++ //Remplacez b puis incrémentez d=10,b=11
L'opérateur relationnel est l'opérateur qui compare les valeurs gauche et droite et renvoie la valeur booléenne.
| opérateur | Exemple | sens |
|---|---|---|
| == | a == b | vrai si a et b sont égaux |
| != | a != b | vrai si a et b ne sont pas égaux |
| > | a > b | vrai si a est supérieur à b |
| >= | a >= b | vrai si a est supérieur ou égal à b |
| instanceof | a instanceof b | true si a est une instance de la même classe que b ou une sous-classe de b |
,> = Ne peut comparer que des nombres grands et petits
Les opérateurs logiques sont utilisés pour combiner plusieurs opérateurs relationnels et spécifier des conditions complexes.
| opérateur | Exemple | sens |
|---|---|---|
| & | a>10 & b>10 | Vrai si les expressions des deux côtés sont vraies |
| && | a>10 && b>10 | Vrai si les expressions des deux côtés sont vraies |
| ｜ | a>10 ｜ b>10 | Vrai si l'une des expressions de chaque côté est vraie |
| ｜｜ | a>10 ｜｜ b>10 | Vrai si l'une des expressions de chaque côté est vraie |
| ! | !a>0 | False si l'expression est vraie,vrai si faux |
&&、||Est appelé un opérateur de raccourci, et si l'expression sur le côté gauche est false, false est fixé dans son ensemble, donc l'expression sur le côté droit n'est pas évaluée. Si l'expression sur le côté droit contient un traitement qui modifie la valeur, comme l'incrémentation&Ou|Le résultat est différent de.
Les opérateurs ont des priorités, et s'ils ont la même priorité, les éléments avec des priorités différentes sont calculés par ordre décroissant de priorité à partir de la gauche.
| Priorité | opérateur |
|---|---|
| 1 | [Tableau] . (argument) a++ a-- |
| 2 | ++a --a +a ~ ! |
| 3 | new (Moule) |
| 4 | * / % |
| 5 | + - |
| 6 | << >> >>> |
| 7 | < > <= >= instanceof |
| 8 | == != |
| 9 | & |
| 10 | ^ |
| 11 | ｜ |
| 12 | && |
| 13 | ?: |
| 14 | = += *= /= %= &= ^= != <<= >>= >>>= |
La même instance est appelée la même valeur et la même valeur est appelée la même valeur. L'identité est jugée par l'opérateur ==
Object a = new Object;
Object b = a; //Remplacer une copie de la référence de la variable a par b
System.out.println(a == b); //Sera vrai
L'équivalence est la propriété de différentes instances mais ayant la même valeur. Utilisez la méthode égale pour voir si elles sont égales. La méthode eauals de la classe Object prend le type Object comme argument et renvoie la valeur de retour du type booléen. Il est courant de faire du bar.
//Méthode Equals de la classe Object
Public boolean equals(Object obj){
return(this == obj);
}
La méthode equals est décrite dans la documentation de l'API. Pour les valeurs de référence x non nulles, x.equals (null) renvoie false. Document de la classe Object
Une instance de String décrit uniquement une chaîne et lors de la comparaison de différentes références avec ==, true est renvoyé si le même littéral de caractère est utilisé. Il s'agit d'un mécanisme appelé pool constant pour réduire la charge de traitement.
String a = "test";
String b = "test";
System.out.print(a == b); //La référence est différente, mais elle est affichée comme vraie
Le pool de constantes n'est valide que lors de l'utilisation de chaînes littérales, et chaque fois qu'une nouvelle instance est créée à l'aide de l'opérateur new, une instance est créée et a une référence différente. Dans le cas de la méthode equals, seule la chaîne de caractères est la même, mais elle est confirmée.
String a = new String("test");
String b = "text";
System.out.print(a == b); //faux
Syttem.out.println(a.equals(b)); //Sera vrai
La syntaxe de l'instruction if est la suivante.
if (Expression conditionnelle) {
//Écrivez le processus lorsque les conditions sont remplies
}
Si le {} de l'instruction if est omis, seule la première phrase est traitée par la syntaxe if. Lorsque j'exécute le code ci-dessous, seul b s'affiche.
public class Main{
public static void main(String[] args){
int a = 1;
int b = 2;
if (a = b)
System.out.println("a")
System.out.println("b")
}
}
La syntaxe de l'instruction if-else est la suivante.
if (Expression conditionnelle) {
//Traitement lorsque les conditions sont remplies
} else {
//Traitement lorsque les conditions ne sont pas remplies
}
la syntaxe de l'instruction if-else if-else est la suivante: En guise de mise en garde, si vous coupez une ligne entre else et if, la syntaxe sera que l'instruction if est incluse dans l'instruction else.
if (Expression conditionnelle A) {
//Traitement lorsque l'expression conditionnelle A est satisfaite
} else if (Expression conditionnelle B){
//Traitement lorsque l'expression conditionnelle B correspond
} else if (Expression conditionnelle C) {
//Traitement lorsque l'expression conditionnelle C correspond
} else {
//Traitement lorsque toutes les conditions ne sont pas remplies
}
La syntaxe de l'instruction switch est la suivante
switch (Expression conditionnelle){
valeur de cas:En traitement
break;
valeur de cas:En traitement
break;
default :En traitement
break;
}
Il existe des restrictions sur les types de valeurs qui peuvent être renvoyées par des expressions conditionnelles, et les types qui peuvent être renvoyés sont limités aux types entiers et aux classes wrapper de type int et inférieur, aux caractères et chaînes de caractères et aux types d'énumération. Double, float, boolean, etc. ne peuvent pas être retournés.
Les valeurs qui peuvent être utilisées pour la valeur de cas sont également limitées, comme suit
Après le processus qui correspond à la valeur de cas, écrivez une pause et quittez le processus, mais s'il n'y a pas de pause, tous les processus sont exécutés jusqu'à ce que la prochaine interruption apparaisse. Dans le processus suivant, a, b, c, d sont affichés
int num = 1;
switch (num) {
case(1): System.out.println("a")
case(2): System.out.println("b")
case(3): System.out.println("c")
default: System.out.println("d")
}
L'opérateur ternaire est un opérateur qui change la valeur à renvoyer selon que la condition est remplie et la syntaxe est la suivante.
Expression booléenne? Expression pour vrai: expression pour faux
L'opérateur ternaire est difficile à voir lorsqu'il est imbriqué, mais difficile à voir lorsqu'il est écrit sur une seule ligne. Quant à la syntaxe ,? Et: apparaît en alternance, et si elle se termine par: à la fin, la syntaxe correcte
variable=Équation A?Expression lorsque l'expression A est vraie
:Équation B?Expression lorsque l'expression B est vraie
:Équation C?Expression lorsque l'expression C est vraie
:Traitement quand tout est faux
variable=Équation A?Expression lorsque l'expression A est vraie:Équation B?Expression lorsque l'expression B est vraie:Équation C?Expression lorsque l'expression C est vraie:Traitement quand tout est faux
Pour utiliser un tableau, vous devez déclarer une instance du tableau à l'aide du mot clé new. La séquence a les caractéristiques suivantes.
int[] array = new int[4]
La méthode println est une méthode qui imprime la valeur transmise à l'argument sur la console. Si vous passez une référence d'objet à cette méthode, elle appellera la méthode toString de l'instance référencée et affichera le résultat. La transmission d'une référence de tableau à cette méthode appelle la méthode toString de l'instance de tableau et retourne une combinaison du nom de la classe et du code de hachage qui identifie de manière unique l'instance.
Les variables de type tableau sont déclarées en utilisant []. [] Peut être écrit non seulement après le type de données mais aussi après le nom de la variable.
int[] array;
int array2[];
Le tableau peut gérer des tableaux multidimensionnels tels que des tableaux à 2 dimensions et des tableaux à 3 dimensions, et les positions de [] n'ont pas besoin d'être décrites ensemble à la fois.
int[][] array2; //Tableau bidimensionnel
int[] array22[]; //Un tableau bidimensionnel
int array3[][][]; //Matrice 3D
int[][] array33[]; //Matrice 3D
Pour un tableau, si le nombre d'éléments est défini lors de la création de l'instance et le nombre d'éléments est spécifié lorsque les variables du tableau sont déclarées, une erreur de compilation se produira.
int[2] array; //Erreur de compilation
Lors de la création d'une instance de tableau, les règles suivantes s'appliquent.
Exemple d'erreur de compilation
int[] array = new int[]; //Aucun nombre d'éléments spécifié
int[] array = new int[1.5]; //C'est en virgule flottante
int[][] array = new int[][3]; //Le nombre d'éléments dans la première dimension n'est pas spécifié
OK exemple
int[][] array = new int[3][];
array[0] = new int[2];
array[1] = new int[2];
array[2] = new int[2];
//Déclarez le nombre d'éléments dans la deuxième dimension séparément
Après avoir créé une instance de tableau, vous devez attribuer une valeur à l'élément.
int[] array = new int[3]
array[0] = 10;
array[1] = 15;
array[2] = 20;
Les valeurs par défaut des éléments du tableau sont déterminées comme suit
| Moule | Valeur par défaut |
|---|---|
| Type entier | 0 |
| Type à virgule flottante | 0.0 |
| Type d'authenticité | false |
| Type de caractère | ¥u0000 |
| Type d'objet | null |
Vous pouvez également utiliser l'opérateur d'initialisation pour initialiser les éléments d'un tableau.
int[] array = {10,20,30};
Le nombre d'éléments est spécifié lorsqu'une instance de tableau est créée, et l'instance de tableau contient des variables pour le nombre d'éléments spécifié à l'intérieur. Chaque variable est accessible à l'aide d'un indice. Si vous affectez null à un élément, cet élément ne sera référencé nulle part.
public class Main {
public static void main(String[] args) throws Exception {
// Your code here!
String[] array = {"A","B","C"};
array[0] = null;
for(String str : array){
System.out.print(str); //Affiché comme nullBC
}
}
}
Il est courant d'utiliser l'opérateur d'initialisation pour créer et initialiser une instance de tableau, déclarer une variable de type tableau et affecter une référence.
int[] array = {1,2};
//Le code ci-dessous a la même signification
int[] array = new int[]{1,2};
Normalement, lors de la création d'une instance de tableau à l'aide de new, spécifiez le nombre d'éléments dans [], mais lors de l'utilisation de l'opérateur d'initialisation, ne spécifiez pas le nombre d'éléments dans []. ..
Créer une instance de tableau avec zéro élément n'a pas de sens, mais ce n'est pas grammaticalement faux.
int[] array = {};
int[] array = new int[0];
Pour les tableaux multidimensionnels, décrivez l'opérateur d'initialisation à l'intérieur de l'opérateur d'initialisation, séparé par des virgules.
int[][] array = { {1,2,},{3,4} };
Si le nombre de dimensions de la variable et le nombre de dimensions de la destination de référence ne correspondent pas, une erreur de compilation se produira.
int[][] array = new int[]{}; //Erreur de compilation
int[][] array = new int[][]{}; //Pas d'erreur
De plus, si vous n'écrivez que l'opérateur d'initialisation sans utiliser new, aucune erreur de compilation ne se produira. Cela est dû au fait que l'opérateur d'initialisation calcule automatiquement le nombre requis de dimensions et effectue l'initialisation requise.
int[][] array = {}; //Aucune erreur de compilation
La fonction de l'opérateur d'initialisation qui calcule automatiquement le nombre requis de dimensions ne peut être utilisée qu'en même temps que la déclaration de variable. Lorsque la déclaration de variable et l'instanciation du tableau sont décrites séparément sur deux lignes, l'opérateur d'initialisation ne peut pas être utilisé, et lors de son utilisation, le nombre de dimensions doit être explicitement décrit.
int[][] array;
array = new int[][]{}; //Aucune erreur de compilation
int[] array2;
array2 = {1,2}; //Erreur de compilation
Dans un tableau multidimensionnel, il n'est pas nécessaire d'égaliser le nombre d'éléments dans le deuxième tableau et les suivants. Les arrangements avec différents nombres d'éléments après la deuxième dimension sont appelés tableaux multidimensionnels asymétriques. Le code ci-dessous a un nombre différent d'éléments dans la deuxième dimension, mais n'entraîne pas d'erreur de compilation. Cependant, au moment où le nombre d'éléments est compté dans tmp.length, le nombre d'éléments nuls qui n'ont pas de référence ne peut pas être compté, donc une exception est levée lors de l'exécution (erreur d'exécution).
public class Main{
public static void main(String[] args){
string[][] array = { {"Ah", "je"}, null, {"U","e","Oh"} };
int total = 0;
for (String[] tmp : array) {
total += tmp.length;
}
System.out.println(total);
}
}
Lorsqu'une classe a une relation d'héritage, une variable de type tableau de type superclasse peut gérer un ensemble d'instances de sous-classes. Une variable de type tableau qui gère uniquement le type Object et une instance de tableau qui ne gère que String ont des types différents, mais comme la classe String hérite de la classe Object, le code suivant peut être compilé et exécuté sans aucun problème.
Object[] obj = {"A", "B", "C"};
Ces relations peuvent également être appliquées entre les interfaces et les classes de réalisation, les classes abstraites et leurs classes concrètes héritées. Si vous avez une interface appelée A et une classe appelée B qui l'implémente, vous pouvez attribuer une référence à une instance de tableau qui ne gère que B à une variable de type tableau qui ne gère que A.
public interface A {}
public class B implements A {}
A[] array = new B[]{ new B(), new B() };
Vous pouvez utiliser la méthode clone pour générer une copie du tableau. C'est juste un processus pour générer une copie, et la destination de référence est différente.
int[] arrayA = {1,2,3,4};
int[] arrayB = arrayA.clone();
System.out.println(arrayA == arrayB); //La destination de référence étant différente, elle s'affiche sous la forme false
Lors du clonage d'un tableau multidimensionnel, la première instance de dimension est différente, mais la seconde instance de dimension et les suivantes sont partagées.
Pour découper et copier uniquement une partie du tableau, utilisez la méthode arraycopy de la classe System. La méthode arraycopy prend 5 arguments
| argument | La description |
|---|---|
| Premier argument | Tableau à partir duquel copier |
| Deuxième argument | À partir de quelle position dans la source de la copie commencer la copie(0 début) |
| Troisième argument | Copier la matrice de destination |
| Quatrième argument | À partir de quelle position dans la destination de la copie commencer la copie(0 début) |
| Cinquième argument | Combien d'éléments à copier à partir de la position du deuxième argument |
char[] arrayA = {'a','b','c','d','e'};
char[] arrayB = {'f','g','h','i','j'};
System.arraycopy(arrayA,1,arrayB,1,3);
System.out.println(arrayB); //fbcdj s'affiche
java a les quatre syntaxes itératives suivantes.
L'instruction while est une syntaxe permettant de répéter le traitement tandis que l'expression conditionnelle renvoie true. L'expression conditionnelle doit toujours renvoyer une valeur booléenne. Une seule expression peut être décrite comme une condition pour répéter l'instruction while. Si vous écrivez literal: true dans l'expression conditionnelle, ce sera une boucle infinie, et si vous écrivez literal: false, elle ne sera jamais exécutée.
while (Expression conditionnelle) {
//Traitement itératif
}
L'instruction do-while exécute le processus itératif, puis détermine la condition. Par conséquent, il est exécuté au moins une fois quelles que soient les conditions. A; est requis après l'expression conditionnelle do-while. Il n'y a pas () après faire
do {
//Traitement itératif
}while (expression conditionnelle);
Recommended Posts