Guide de Référence Rapide Java Dernière mise à jour : vendredi 8 février 2013

Opérateurs arithmétiques N'oubliez pas d'utiliser les méthodes Formes de l'instruction if

+ Addition equals() ou compareTo() lors de la comparaison
- Soustraction Des chaînes plutôt qu'une comparaison relationnelle Simple si Example
/ Division (int / flottant) opérateurs. si (expression) si (x < y) Le
2/3 = 0, 2,0/3,0 = 0,666667 déclaration x++; expression
String s1 = "abc", s2 = "def";
* Multiplication les parenthèses
% Modulo (reste entier) Comparaisons de chaînes : si/ sinon Exemple
pour un
Comparer pour l'égalité : si (expression) si (x < y)
Opérateurs relationnels
[Link](s2) ou déclaration; x++; instruction if
< Moins de
[Link](s2) == 0 sinon sinon
inférieur ou égal à déclaration x--; ou
> Supérieur à Remember the compareTo( ) method
>= Supérieur ou égal à retourne une des 3 valeurs : si/sinon si (si imbriqué) Exemple boucle
==Égal à neg number, pos number, 0 si (expression) si (x < y) est souvent aussi
!=Pas égal à déclaration x++;
Comparer pour l'ordre lexical : appelé un
Opérateurs Logiques [Link](s2) < 0 (s1 avant s2) sinon sinon
si (expression) si (x < z) condition
! PAS [Link](s2) > 0 (s1 après s2)
&& ET déclaration; x--;
|| OU sinon sinon
N'oubliez pas de distinguer les entiers
et des nombres réels (appelés nombres à virgule flottante dans déclaration; y++;
Opérateurs d'affectation
= affectation simple Java). Ceux-ci sont stockés différemment dans Pour exécuter conditionnellement plus d'une instruction, vous devez
+= addition/attribution mémoire et ont différentes plages de créer une déclaration composée (bloc) en englobant les déclarations
valeurs qui peuvent être stockées.
-= soustraction/assignment ( cela est vrai pour les boucles aussi ) :
= multiplication/assignment integers: 2, 3, -5, 0, 8
/= division/assignment Forme Exemple
floating-point: 2.0, 0.5, -3.,
4.653 si (expression) si (x < y)
%= modificateur/d'affectation
{ {
Incrément/Décrément (utilisé en modes préfixe et postfixe) déclaration x++;
++ Incrément préfixe - inc(déc) variable, utiliser dans une expression plus grande
déclaration [Link]( x );
-- Décrément postfix - utilisé dans une expression plus grande, variable inc(dec)
} }
Création d'objet : ( nouveau ) nouveau int[ 10 ], nouveau GradeBook("CIS 182")
Ensuite, l'opérateur new crée un objet et retourne une référence (adresse d'un objet) Entrée utilisant la classe Scanner
Types Java [valeur/référence] Scanner input = new Scanner ( [Link] ); //entrée du clavier
Un type valeur stocke une valeur d'un type primitif int x = 3; méthodes d'entrée : next(), nextLine(), nextInt(), nextDouble()
Un type de référence stocke l'adresse d'un objet Cercle c = nouveau Cercle(2);
A reference variable is created using a class name: GradeBook myGradeBook; Méthodes de sortie pour les objets [Link] ou PrintWriter
print(), println(), printf() [sortie formatée]
Types de données primitifs (types de valeur Java) Rappelez-vous : String est un type de référence
booléen flag / logical true. false [booleanliterals ] Entrée/Sortie utilisant la classe JOptionPane [ package [Link] ]
char caractère 'A', 'n', '!' [charliterals ]
byte, short,int, long intégral 2, 3, 5000, 0 [intliterals ] String numString; int num;
float,double virgule flottante 123.456, .93 [doubleliterals ] numString = [Link]("Enter a number");
Types littéraux numériques par défaut : num = [Link](numString);
intégrale int int x = 3; //3 est un littéral entier [Link](null, "Number is " + num);
floating-point: double double y = 2,5; //2.5 est un littéral double
Conversion d'une chaîne en nombre à l'aide des classes wrapper
La construction switch/case (break et default sont optionnels) double d = [Link](dString);
float f = [Link](fString);
Form: Exemple : int j = [Link](jString);
switch (expression) changer (choix)
Sortie formatée en Java [méthodes printf( ) et [Link]( )]
{ {
caseint-constant: cas 0 : 3 composants : chaîne de format et optionnellement : spécificateurs de format ( fs )
déclaration(s); [Link]( "Vous avez sélectionné 0." ); et une liste d'arguments ( al )
[ pause; ] pause; fs: " ... % [flags] [width] [precision] format-specifier ... "
al : liste d'expressions séparées par des virgules
caseint-constant: cas 1 :
déclaration(s) [Link]( "Vous avez sélectionné 1." ); Spécificateurs de format : s (chaîne), d (entier), f (à virgule flottante)
[ pause; ] pause; Exemple :[Link]("Total est %,10.2f\n", total);

[ default : default :
déclaration; ] [Link]( Conversions Numériques Java :
Vous n'avez pas sélectionné 0 ou 1. Les conversions élargissantes sont effectuées implicitement.
} } double x; int y = 100;
L'"expression" et "constante-int" sont généralement de type int ou char. Java SE 7 x = y; // la valeur de y est implicitement convertie en double.
ajoute la possibilité d'utiliser un. Narrowingconversions must be done explicitly using a cast.
Utilisez le mot-clé break pour sortir de la structure (évitez de "cascader" dans d'autres) double x = 100; int y;
cas). y = (int) x; // valeur de x explicitement convertie en int

Utilisez le mot-clé default pour fournir un cas par défaut si aucun des cas Dans les expressions mixtes, la conversion numérique se fait implicitement.
les expressions correspondent (similaire à l'« else » final dans une instruction if-else-if). le double est le type de données le plus "élevé", le byte est le plus "bas".
 Guide de Référence Rapide Java Last Update: Friday, February 8, 2013

La boucle while (boucle de pré-test) La boucle for (boucle de pré-test)

Forme : Exemple : Formulaire : Example:

pour (initialisation;test;mise à jour) pour (compteur=0;compteur<10;compteur++)
initialiser; x = 0;
tant que (test) tant que (x < 10) déclaration [Link] ( compteur );
{ { pour (init;test;mise à jour) pour (int count=1;count<=10;count++)
déclaration somme += x; { {
mise à jour x++; déclaration [Link]( Le compte est " );
} } statement; [Link]( compte );
} }
La boucle do-while (boucle de post-test)
Séquences d'échappement Priorité des opérations
Form: Exemple :
Caractères spéciaux en Java ( )
init; x = 0; ----------
\n caractère de nouvelle ligne
faire faire *, /, % [ mathématique ]
caractère de tabulation
{ { ----------
déclaration somme += x; \" double citation '\"' +, -
mise à jour x++; \' apostrophe '\'' Logical operators: !, &&, ||
} pendant (test); } pendant que (x < 10); \\ antislash '\\'
(1) mathematical (2) relational (3) logical

Utilisez la classe ArrayList pour

Structures de sélection et de boucle Tableaux Java : Créez un tableau ( 2 façons )
créer dynamiquement
Sélection : 1. <type> <nom-tableau>[ ] = new<type>[taille]; tableau redimensionnable.
Sélection unitaire ou unique 2. <type> <nom-du-tableau>[ ] = { <liste-d-initialisation> };
La classe Arrays a des méthodes statiques
Binary or dual selection
Structure du cas possible lorsque //créez un tableau de 20 éléments. méthodes qui peuvent être utilisées

ramification sur une variable

int myArray[ ] =newint[20]; avec des tableaux et des ArrayLists

Sélection simple //créer un tableau de 3 éléments définis avec les valeurs de la liste d'initialisation. chercher, trier, copier
Une condition int monTableau[] = { 1, 2, 3 }; comparer pour l'égalité, etc.
String stooges[ ] = { "Moe", "Larry", "Curly" };
Sélection de composés int num[ ];…<instructions>….
Conditions multiples jointes attribuer la valeur du premier élément de myArray à la variable entière x.
avec des opérateurs AND / OR int x = monTableau[0]; Créez un nouvel initialisé
//assign value of the last element in myArray to the integer variable y. tableau et assigner à num.
Bouclage : num = nouveau int[ ]{[Link].5};
int y = myArray[ [Link]-1 ];
JavaPréalablesBoucles
Le test précède le corps de la boucle Tous les tableaux ont un champ public nommélongueurqui contient le nombre d'éléments dans le tableau.
tandis que Étant donné cette déclaration : int x[][][];
pour
JavaPost-boucle de test [Link] est le nombre d'éléments dans le tableau dans la première dimension.
Le test suit le corps de la boucle longueur de x[m] est le nombre d'éléments pour un tableau spécifique dans la deuxième dimension.
x[m][n].longueur est le nombre d'éléments pour un tableau spécifique dans la troisième dimension.
faire-jusqu'à
Contrôle de boucle : Méthodes Java : <type> <nom-de-méthode> ( [ <type> paramètre1, [ <type> paramètre2, … ] ] )
3 types d'expressions qui Les programmes procéduraux simples en Java contiendront le mot-clé statique et peuvent également contenir le mot-clé
sont utilisés pour contrôler les boucles :
public. Les méthodes qui ne renverront pas de valeur auront le type de retour void dans l'en-tête de la méthode.
initialisation ( init )
public static void printHeadings() //aucun paramètre, le type de retour est void
test
mettre à jour { <method body> }
Boucles contrôlées par un compteur, static void printDetailLine( String name, int number, double gpa) // 3 paramètres, le type de retour est void
c'est-à-dire des boucles définies, travaillent avec { <corps de méthode> }
variable de contrôle de boucle (lcv)
intgetCount( ) //pas de paramètres, le type de retour est int
Boucles contrôlées par un sentinelle, { <method body> }
c'est-à-dire les boucles indéfinies, travaillent
avec une valeur de sentinelle publicdoublemax( doublex, doubley) //2 paramètres, le type de retour est double
{ <corps de méthode> }
Sortie précoce de boucle Java :
Lorsqu'une méthode est appelée, les données sont passées aux paramètres (s'il y en a) à l'aide des arguments.
instruction break
Remarque : l'instruction break peut //Arguments: "Jack Wilson", 100, 3.50 passed to Parameters: name, number, gpa for Method:
être utilisé avec un interrupteur imprimerLigneDétail (voir l'en-tête de méthode ci-dessus) :imprimerLigneDétail( "Jack Wilson", 100, 3.50);

déclaration ou aloopin Une méthode peut être déclarée avec un paramètre de longueur variable. Il doit s'agir du dernier paramètre.
[Link] boucles peuvent également utiliser
déclaré. La syntaxe de la déclaration est <type>...<nom-du-paramètre>.
une déclaration continue.
Exemples int...
: nombres, double... valeurs, String... noms //créationde tableau implicite