Ceci est un résumé de ce que j'ai appris dans le texte de référence pour l'apprentissage Java. J'ai omis l'explication détaillée et j'ai décidé de résumer les points dans un mémorandum de mon choix.
Une introduction rafraîchissante à la 2e édition de Java
Décrivez comme suit. Entrez votre nom de classe préféré dans "Nom de classe" et faites de même pour le nom de fichier. Exemple) Nom de la classe → TestJava ファイル名→TestJava.java
nom de classe de classe publique{
public static void main(String[] args) {
"Traitement du contenu"
}
}
Sortie "test" Ecrivez le contenu suivant dans un fichier, compilez-le et exécutez-le.
public class TestJava{
public static void main(String[] args){
System.out.println("test");
}
}
compiler
javac TestJava.java
Exécution (TestJava.java est créé par compilation, mais ".class" n'est pas ajouté à l'exécution)
```java testjava```
Résultat de sortie
```test```
## 3. Saut de ligne (println)
Les ruptures de contenu d'affichage de sortie standard sont commutées par la méthode. L'onglet \ <br> en html.
public class Kaigyo { public static void main(String[] args) {
System.out.print("l'impression est"); System.out.print("Ne pas casser"); System.out.println(""); System.out.println("println"); System.out.println("Briser une ligne"); } }
Résultat de sortie
l'impression ne casse pas println Briser une ligne
* A partir de là, seul le traitement de la méthode est décrit.
## 4. Évaluer de grandes valeurs (Math.max)
int a =10; int b =100; //Math.max(①,②)La plus grande valeur est adoptée int big = Math.max(a,b); System.out.println("Math.Évalué avec la méthode max." + a + "Quand" + b + "Le grand est" + big );
Résultat de sortie
#### **`Math.Évalué avec la méthode max. 10 et 100 sont les 100 plus grands`**
```Évalué avec la méthode max. 10 et 100 sont les 100 plus grands
## 5. Convertissez les chaînes en nombres (Integer.parseInt)
String age = "30"; //Convertir le type String en type int int n = Integer.parseInt(age); System.out.println("Lors de la conversion en une valeur numérique" + ( n + 1 ) + "Sera" ); System.out.println("Lorsque vous ne convertissez pas en nombre" + ( age + 1 ) + "Sera" );
Résultat de sortie
Par comparaison, on peut voir que n converti en valeur numérique est ajouté, et l'âge en tant que chaîne de caractères est combiné sans être ajouté.
Lorsqu'il est converti en valeur numérique, il devient 31. S'il n'est pas converti en nombre, ce sera 301
## 6. Aléatoire
Afficher aléatoirement les nombres supérieurs ou égaux à 0 et inférieurs à la valeur spécifiée par "nextInt". Seul "nextInt (6)" est affiché sous la forme 0-5. Si vous souhaitez afficher de 1 à 6, définissez "nextInt (6) + 1" et 1 sera ajouté au nombre aléatoire généré, de sorte que la plage de 0 à 5 sera de 1 à 6.
int r = new java.util.Random() .nextInt(6)+1; System.out.println("Lancer les dés" ); System.out.println("Le résultat des dés" + r + "est" );
Résultat de sortie
Lancer les dés Le résultat des dés est 6
## 7. Réception d'entrée (Scanner (System.in))
Vous pouvez recevoir des informations d'entrée du clavier pendant l'exécution.
System.out.println("S'il vous plaît entrez votre nom." ); //Accepte l'entrée d'une ligne de chaîne de caractères à partir du clavier. nextLine est une chaîne String gest = new java.util.Scanner(System.in).nextLine();
System.out.println("Veuillez entrer votre âge." ); //Accepte l'entrée d'un entier à partir du clavier. nextInt est un nombre int tosi = new java.util.Scanner(System.in).nextInt();
System.out.println ("Bienvenue," + tosi + "de l'âge" + gest + "M.");
Résultat d'exécution
S'il vous plaît entrez votre nom. ○○○ ← Entrée depuis le clavier Veuillez entrer votre âge. △△ ← Entrée depuis le clavier Bienvenue, M. ○○○, âgé △△
## 8. Opérateur de relation
Symbole de condition pour le branchement du processus utilisé dans l'expression conditionnelle
|opérateur|sens|
|:--:|:--|
|==|Le côté gauche et le côté droit sont égaux|
|!=|Le côté gauche et le côté droit sont différents|
|>|Le côté gauche est plus grand que le côté droit|
|<|Le côté gauche est plus petit que le côté droit|
|>=|Le côté gauche est supérieur ou égal au côté droit|
|<=|Le côté gauche est inférieur ou égal au côté droit|
* Lors de la comparaison de chaînes de caractères, utilisez "variable de type chaîne de caractères .equals (chaîne de caractères de comparaison)".
Exemple d'utilisation)
String moziretu = new String("Comparaison"); String moziretu2 = new String("Comparaison"); if(moziretu.equals(moziretu2)) { System.out.println("OK"); }else{ System.out.println("NG"); }
## 9. Formule logique
|opérateur|sens|
|:--:|:--|
|&&|~ Et|
|tuyau|~ Ou|
|!|Inversion de l'expression conditionnelle|
※tuyau=||
if((age >= 18 && grender ==1 ) || (age >= 16 && gender ==0 )) { //l'âge est de 18 ans ou plus et le sexe est de 1 ou l'âge de 16 ans ou plus et le sexe de 0
//Lorsque la condition est négative if(!( age == 10 )) { //l'âge n'est pas 10
## 10. Branche conditionnelle
* À partir de là, le résultat de l'exécution ne sera pas décrit, donc si vous ne pouvez pas imaginer le résultat du traitement, veuillez l'essayer sur votre propre terminal.
① instruction if
Il existe 3 modèles d'écriture: instruction if, instruction if-else, instruction if-else if-else
if déclaration
Si l'expression conditionnelle est vraie, exécutez le processus. Sinon, ne faites rien.
if( kakunin.equals( "OK" )) { System.out.println("Commencez à dire la bonne aventure"); }
instruction if-else
Si l'expression conditionnelle est vraie, exécutez le processus. Si ce n'est pas le cas, exécutez un autre traitement.
if( kakunin.equals( "OK" )) { System.out.println("Commencez à dire la bonne aventure"); }else{ System.out.println("Quittez l'application de bonne aventure"); }
instruction if-else if-else
Si la condition n'est pas remplie, comment évaluer sous une autre condition. Spécifiez une autre condition avec else if.
System.out.println("Voulez-vous utiliser l'application Omikuji?");
System.out.print("Y/N:");
String ck = new java.util.Scanner(System.in).nextLine();
if( ck.equals( "Y" ) || ck.equals( "y" )) { System.out.println("Votre fortune est sortie.");
int omikuji = new java.util.Random().nextInt(9);
omikuji++;
if(omikuji ==1 ) {
System.out.println("Le résultat est Daikichi");
} else if(omikuji <=3 ) {
System.out.println("Le résultat est Nakayoshi");
} else if(omikuji <=6 ) {
System.out.println("Le résultat est Kokichi");
} else if(omikuji <=9 ) {
System.out.println("Le résultat est mauvais");
//if-else if-else instruction peut ou non utiliser le dernier else
} else {
System.out.println("Le résultat est terrible");
}
} else {
System.out.println("Quittez l'application Omikuji");
}
② instruction switch
S'il existe plusieurs conditions, le processus peut être actualisé à l'aide d'une instruction switch.
[Changer la règle de l'instruction]
- ">", "<", "! =", Etc. ne sont pas utilisés dans toutes les expressions conditionnelles pour comparer si le côté gauche et le côté droit correspondent.
-Les valeurs à comparer sont des entiers, des chaînes de caractères et des correspondances de caractères, pas des fractions ou des valeurs booléennes.
・ Ce qui est écrit immédiatement après le changement n'est pas une expression conditionnelle mais un nom de variable
・ Valeur et deux-points à côté du cas
・ Déclaration de rupture à la fin du traitement du dossier
-L'étiquette par défaut peut être omise si aucun autre traitement n'est requis.
System.out.println("Souhaitez-vous réessayer l'application Omikuji?");
System.out.print("Y/N:");
String ck2 = new java.util.Scanner(System.in).nextLine();
if( ck2.equals( "Y" ) || ck2.equals( "y" )) {
System.out.println("Votre fortune est sortie.");
int omikuji2 = new java.util.Random().nextInt(4);
omikuji2++;
switch (omikuji2) {
case 1:
System.out.println("Le résultat est Daikichi");
break;
case 2:
System.out.println("Le résultat est Nakayoshi");
break;
case 3:
System.out.println("Le résultat est Kokichi");
break;
case 4:
System.out.println("Le résultat est mauvais");
break;
case 5:
System.out.println("Le résultat est terrible");
break;
}
} else {
System.out.println("Quittez l'application Omikuji");
}
À moins que le processus ne soit explicitement interrompu par une instruction break après chaque instruction case, le processus sous cette condition continuera à être exécuté. C'est parce que l'instruction switch passe simplement au processus qui remplit les conditions.
Cependant, l'exemple ci-dessous est un modèle qui utilise deux conditions sans écrire une instruction break.
System.out.println("Souhaitez-vous réessayer l'application Omikuji?");
System.out.print("Y/N:"); String ck3 = new java.util.Scanner(System.in).nextLine(); if( ck3.equals( "Y" ) || ck3.equals( "y" )) { System.out.println("Votre fortune est sortie.");
int omikuji3 = new java.util.Random().nextInt(9);
omikuji3++;
switch (omikuji3) {
case 1:
System.out.println("Le résultat est Daikichi");
break;
case 2:
case 3:
System.out.println("Le résultat est Nakayoshi");
break;
case 4:
case 5:
case 6:
System.out.println("Le résultat est Kokichi");
break;
case 7:
case 8:
case 9:
System.out.println("Le résultat est mauvais");
break;
case 10:
System.out.println("Le résultat est terrible");
break;
}
} else { System.out.println("Quittez l'application Omikuji"); }
## 11. Répéter
① instruction while
Il existe deux variantes de l'instruction while.
instruction while (jugement de préfixe)
Prenez une décision conditionnelle avant d'exécuter le bloc.
int temperature =25; //Répétez ce bloc si la condition while est remplie while (temperature >20) { temperature--; System.out.println("J'ai baissé la température d'un degré"); }
déclaration do while (jugement postfix)
Après l'exécution du bloc, la condition est évaluée.
System.out.print("Y/N:"); String ck4 = new java.util.Scanner(System.in).nextLine(); if( ck4.equals( "Y" ) || ck4.equals( "y" )) {
int temperature2 =25; do { temperature2--; System.out.println("J'ai baissé la température d'un degré"); } while(temperature2 >20); } else { System.out.println("terminer"); }
② pour phrase
[Pour la règle de la phrase]
・ Pour ((1) Traitement d'initialisation variable; (2) Condition de répétition; (3) Répéter le traitement de fin)
-Les variations déclarées ailleurs ne peuvent pas être utilisées
-Le numéro déclaré dans l'instruction for disparaît après l'exécution, il peut donc être réutilisé.
・ Comment augmenter / diminuer la valeur de l'instruction for i + = 2 | Diminuer de 1 i--
for( int i =0 ; i <10 ; i++ ) { System.out.println( "pour répéter la déclaration" + ( i + 1 ) + "La semaine"); }
Il est également possible de laisser la variable de boucle de côté et d'omettre le processus d'initialisation de for.
int i = 0 ; for(; i < 5 ; i++ ) { System.out.print( "pour répéter la déclaration" + ( i + 1 ) + "Semaine →"); }
Lorsque la boucle de l'instruction for est dupliquée.
//Quatre-vingt-dix-neuf table System.out.println("C'est le stade de quatre-vingt-dix-neuf.");
for( int x = 1; x < 10; x++) { for( int y =1; y < 10; y++) { System.out.print( x * y ); System.out.print(" "); } System.out.println(""); }
L'instruction break interrompt le processus itératif lui-même.
//Quatre-vingt-dix-neuf table //Dans l'instruction break, passez après le processus cible System.out.println("Quatre-vingt-dix-neuf étapes(déclaration break), Jusqu'à 5 étapes.");
for( int x = 1; x < 10; x++) { if( x == 6 ) { break; } for( int y =1; y < 10; y++) { System.out.print( x * y ); System.out.print(" "); } System.out.println(""); }
L'instruction continue interrompt uniquement le processus cible et passe à l'itération suivante.
//Quatre-vingt-dix-neuf table //Ignorer uniquement le processus cible avec l'instruction continue System.out.println("Quatre-vingt-dix-neuf étapes(continue déclaration), Sautez la 5ème étape.");
for( int x = 1; x < 10; x++) {
if ( x == 5 ) {
continue;
}
for( int y =1; y < 10; y++) {
System.out.print( x * y );
System.out.print(" ");
}
System.out.println("");
}
Comment créer lors de la création intentionnelle d'une boucle infinie
* Répétez pour toujours à moins d'être obligé de mettre fin
Il est généralement réalisé selon les deux méthodes suivantes.
① while (ture) {processing}
② pour (;;) {traitement}
## 12. Tableau
-Créer un tableau: "Type [] nom de la variable du tableau = nouveau type [5];"
-Vous pouvez vérifier le nombre d'éléments avec la variable de tableau name.length.
Dans l'exemple suivant, un tableau est créé, le nombre d'éléments est confirmé et la valeur mise dans le tableau (score [1]) est confirmée.
int[] score = new int[5]; int kakunin = score.length; score[1] = 30; System.out.println("Valeurs du tableau:" + kakunin); System.out.println("score[1]La valeur du:" + score[1]);
Les variables ne sont pas initialisées automatiquement, donc si vous ne définissez pas les valeurs initiales comme indiqué ci-dessous, une erreur de compilation se produira.
int x; System.out.println(x);
Les variables de tableau sont automatiquement initialisées.
int, double, etc. → 0
boolean→false
Dans les cas suivants, 0 est émis.
int[] score2 = new int[5]; System.out.println("score2[1]La valeur du:" + score2[1]);
Dans les cas suivants, false est affiché.
boolean[] score3 = new boolean[5]; System.out.println("score3[1]La valeur du:" + score3[1]);
Si la valeur initiale n'est pas définie pour le type String, elle renvoie null.
String[] score4 = new String[5]; System.out.println("score4[1]La valeur du:" + score4[1]);
Notation d'abréviation
・ Même si vous ne mettez pas de nombre entre [], vous pouvez utiliser {} pour allouer.
-Le nouveau nom de variable de tableau peut être omis.
//score5 o~Définir 4 éléments int[] score5 = new int[] { 20 ,30 ,40 ,50 ,60 }; //score6 o~Définir 4 éléments int[] score6 = { 20 ,30 ,40 ,50 ,60 };
System.out.println("score5[3]La valeur du:" + score5[3]); System.out.println("score6[4]La valeur du:" + score6[4]);
Bouclez le tableau
En définissant le nombre d'éléments dans la condition de répétition de l'instruction for, la répétition est effectuée par le nombre d'éléments dans le tableau.
for (int i = 0; i <nom de la variable de tableau.lenght; i ++);
int[] score7 = new int[] { 100 ,200 ,300 ,400 ,500 }; for( int i = 0 ; i < score7.length ; i++ ) { System.out.println(score7[i]); }
Essayez de calculer les totaux et les moyennes à l'aide d'un tableau
//Stocker des points dans un tableau int[] score8 = { 80 , 85 , 70 , 70 , 80 }; int sum = 0 ; //Traitement itératif pour le nombre de séquences for( int i = 0 ; i < score8.length ; i++ ) { //Ajouter la valeur du tableau à la variable somme sum = sum + score8[i]; } System.out.println("sum:" + sum); //Divisez le nombre d'éléments de la somme pour calculer la moyenne int ave = sum / score8.length; System.out.println("ave:" + ave);
Étendu pour déclaration
-Pour (nom de variable arbitraire de type d'élément: nom de variable de tableau)
-Pour instruction utilisée pour écrire facilement une boucle qui récupère les éléments du tableau un par un
En regardant l'exemple ci-dessous, vous pouvez voir que c'est assez simple.
pour la phrase: for (int i = 0; i <score8.length; i ++) {
Étendu pour instruction: for (int value: score9) {
int[] score9 = { 100 , 90 , 100 , 100 , 90 }; int sum2 = 0 ; for( int value : score9 ) { sum2 = sum2 + value; } System.out.println("sum2:" + sum2); int ave2 = sum / score9.length; System.out.println("ave2:" + ave2);
Longueur du tableau et longueur de la chaîne ()
-Pour les tableaux, comptez le nombre d'éléments avec "nom de variable de tableau.longueur"
-Pour les chaînes de caractères, comptez le nombre de caractères avec "chaîne de caractères variable name.length ()"
String s ="Développé avec JAVA"; System.out.println( s + "Est" + s.length() + "C'est un personnage." );
Un tableau bidimensionnel
-Déclaration-> Type d'élément [] Nom de la variable de tableau = nouveau Type d'élément [Nombre de lignes] [Nombre de colonnes]
-Nom de la variable de tableau [indice de ligne] [indice de colonne]
Dans l'exemple suivant, le nombre d'éléments du tableau parent et du tableau enfant est affiché.
int[][] score10 = { { 10 , 20 ,30 } , { 40 , 50 , 60 } }; System.out.println("Afficher le nombre de lignes" + score10.length ); //Tableau parent(Nombre de lignes)Spectacle System.out.println("Afficher le nombre de colonnes" + score10[0].length ); //Tableau enfant(Nombre de colonnes de l'élément 0)Spectacle
## 13. Collecte des ordures
Un mécanisme pour supprimer automatiquement la mémoire inutilisée qui n'est pas référencée pour éviter la pression de la mémoire
Si vous mettez null dans la variable de type référence, la référence est coupée (si elle n'est référencée de nulle part, elle sera soumise au garbage collection)
L'exemple suivant n'est intentionnellement pas référencé.
int[] a = { 1 , 2 , 3}; a = null; a[0] = 10; System.out.println(a[0]); Dans le cas ci-dessus, la référence est coupée, donc "NullPointerException" est affiché.
## 14. Méthode
Définition de la méthode
public static return value Nom de la méthode (liste d'arguments){ Que se passe-t-il lorsqu'une méthode est appelée }
Exemple de création
public static void hello(String name){ System.out.println( name + "Salut,"); }
Utilisation de la valeur de retour
Mettez une formule de calcul en ans et utilisez le contenu à renvoyer en mettant une valeur dans la méthode rouge
public static int ret(int a, int b){ int ans = a + b; return ans; }
Comment appeler une méthode
Méthode (liste d'arguments) * Spécifiez les variables que vous voulez passer au moment de l'appel dans la liste d'arguments séparés par des virgules.
public static void main(String[] args){ hello("Taro"); hello("Jiro");
int ans = ret(100,50);
System.out.println("La valeur de retour est:" + ans);
System.out.println(ret(ret(10,20) , ret(30,40)));
ret(10,5);
}
## 15. Surcharge
-Normalement, la même méthode ne peut pas être utilisée, mais elle peut être utilisée si le type est différent. La définition du même nom s'appelle surcharge
-La surcharge est possible si les informations après le type de retour (signature de méthode: nom de méthode, type d'argument / numéro / ordre) sont différentes.
Exemple d'utilisation
//type int public static int ret(int a, int b){ return a + b; }
//type double public static double ret(double a, double b){ return a + b; }
//Type de chaîne public static String ret(String a, String b){ return a + b; }
//La surcharge est possible même si le nombre d'arguments est différent public static int ret2(int a, int b){ return a + b; }
public static int ret2(int a, int b, int c){
return a + b + c;
}
## 16. Utilisez un tableau pour les arguments de méthode et les valeurs de retour
Puisque le tableau est passé pour chaque adresse, pas le contenu de la variable, la modification de l'appelé aura un effet tel quel.
//Mettez un tableau dans l'argument(Utiliser une instruction étendue) public static void ckArray(int[] array){ for(int x : array){ System.out.println(x); } }
//Passer le tableau dans un appel de méthode public static void methArray(int[] array){ for(int i =0; i < array.length; i++){ array[i]++; } }
//Passer un tableau comme valeur de retour(Utiliser une instruction étendue) public static int[] retArray(int size){ int[] newArray = new int[size]; for(int i = 0; i < newArray.length; i++ ){ newArray[i] = i; } return newArray; }
## 17. Arguments de ligne de commande
Vous pouvez recevoir un tableau de chaînes en exécutant le tableau de types de chaînes de la méthode main avec un argument à l'exécution.
public class CmdLine { public static void main(String[] args){ //Nom comme premier argument System.out.println("Bonjour," + args[0] +"M."); //L'occupation dans le deuxième argument System.out.println("Occupation" + args[1] +"n'est-ce pas"); } }
Créez un fichier avec le contenu ci-dessus, compilez-le et exécutez-le comme suit.
```ingénieur Taro java cmdline```
Résultat d'exécution
Salut, Taro L'occupation est un ingénieur
C'est tout pour ce résumé.
De plus, je publierai lorsque le contenu d'apprentissage sera accumulé.