 Exemple d’écriture d’une variable 

: cookiesSansSucres (L'une des conventions

d'appellation les plus populaires est le Camel Case)
 En Java, les variables qui contiennent des nombres sont déclarées en
utilisant un mot clé tel que  int  suivi du nom d'une variable et de sa valeur
initiale. Par exemple :
 int ongoingAllowance = 500;
 int savings = 1000;
 Vous pouvez utiliser le type  double, qui stocke les nombres décimaux (ou
« flottants »).

 Types de variables :
o String = texte
o int = nombre entier
o double = nombre en virgule flottante
 Pour déclarer une constante en Java, vous devez utiliser le mot clé final :
 final int numberOfWeekdays = 7;
 final String myFavouriteFood = "Icecream";
 Les décimales :
o Si vous avez besoin de stocker quelque chose de grand, comme un numéro à
12 chiffres  1876.79797657, vous devrez utiliser  double. En effet,
float  ne pourra stocker que la moitié de ce chiffre... 
 Mais que se passe-t-il si je fournis des valeurs supérieures ?
Par exemple :

double a = 1876.79797657765609870978709780987;

float b = 1876.79797657765609870978709780987;
Eh bien, elles vont perdre toutes les deux un peu de précision, mais pas au même
degré :

// a -> 1876.797976

// b -> 1876.79

Mélangez des types numériques

 Afin d’éviter une division entière(Faire une division en virgule flottante):

int a = 10;

int b = 4;

double c = a/(double) b; //-> c contient 2.5, car la valeur de b est transformée en double

Les chaînes de caractères (strings)

Vous pouvez fusionner une ou plusieurs d'entre elles. Rassemblons quelques
strings  :

String firstFavoriteCity = "New York";

String secondFavoriteCity = "Buenos Aires";

String favorites = firstFavoriteCity + secondFavoriteCity; // -> "New YorkBuenos Aires"

 Mais, il n'y a pas d'espace entre les deux. C'est bizarre, non ?
Rendons ce code plus lisible en concaténant, c'est-à-dire en mettant bout à bout des
chaînes de caractères et des variables :

String firstFavoriteCity = "New York"

String secondFavoriteCity = "Buenos Aires"

String favorites = "My favorite cities are " +firstFavoriteCity+ " and
"+secondFavoriteCity; // -> "My favorite cities are New York and Buenos Aires"

Une classe est un ensemble de variables, nommées attributs, et de comportements,

nommés méthodes.

 Programme qui écrit Hello World :

package hello;

/** Ceci est une implémentation du message traditionnel "Hello world!"

* @author L'équipe Education d'OpenClassrooms

*/

public class HelloWorld {

/** Le programme commence ici */

public static void main(String[] args) {

System.out.println("Hello World!");
 }

Le compilateur intervient en amont pour interpréter le code et le transformer en byteCode

(ou code binaire). Puis l'interpréteur traduit le byteCode en instructions pour exécuter le
programme.

 En Java, il y a une correspondance directe entre :

 les packages et les dossiers ;

 les classes et les fichiers.

 Vous pouvez définir des types complexes qui regroupent différents attributs
représentant un concept nommé. Ce sont des classes de modèles.Le
deuxième type de classes: les classes utilitaires.

 Utilisation de quelques méthodes de la classe String :

package stringDemo;

public class StringDemo {

public static void main(String[] args) {

// Déclarez et créez une chaîne de caractères

String shockingSentence="The Java String type actually is a class, not a simple

type!";

// Faites-le savoir

System.out.println(shockingSentence.toUpperCase());

// Inversez-le

System.out.println(shockingSentence.replace("simple","primitive"));

}
}
 Page java doc :
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/
lang/String.html

Penchons-nous maintenant sur votre fonction main  et prenons-en le contrôle. Nous

allons la rendre aussi propre et nette que possible. Voici une implémentation
« propre et nette » de notre programme HelloWorld :

package cleanHello;

/** Ceci est une implémentation du message traditionnel "Hello world!"

* @author L'équipe Education d'OpenClassrooms

*/

public class CleanWorld {

/** Le programme commence ici */

public static void main(String[] args) {

sayHelloTo("world");

/** affiche le message "hello" au destinataire fourni

* @param recipient

*/

private static void sayHelloTo(String recipient) {

System.out.println("Hello " + recipient);

 }

La portée (scope) de cette variable est tout ce qui se trouve entre ces deux accolades.
La portée d'une variable peut être locale ou globale, en fonction de l'endroit où la variable est
déclarée. Une variable globale peut être disponible pour toutes les classes et méthodes d'un
programme, alors qu'une variable locale ne peut être disponible que dans la méthode dans
laquelle elle est déclarée :
Portée variable dans les classes

La portée d'une variable limite (par définition) son accessibilité. Cependant,

les champs (attributs) de classe sont accessibles en dehors de la classe et
peuvent être utilisés par tout autre bloc de code.

Dans notre exemple, ce sont les champs  height  et  power. Si nous déclarons une
variable Unicorn (licorne), nous pouvons lire ou modifier ces valeurs :

Unicorn unicorn = new Unicorn();

System.out.println("I know it's height: "+(unicorn.height);

// et peut changer son pouvoir !

unicorn.power = 0; // pas drôle!

Niveaux de contrôle

En Java, vous devez utiliser un des mots clés pour désigner un niveau de contrôle :

 public : visible pour tous et par conséquent le moins restrictif ;

 protected (protégé) : visible pour le package et l'ensemble de ses sous-
classes ;
  package-protected (protégé par paquet) : généralement visible uniquement
par le package dans lequel il se trouve (paramètres par défaut) ;
 private (privé) : accessible uniquement dans le contexte dans lequel les
variables sont définies (à l'intérieur de la classe dans laquelle il est situé).

Un package regroupe des classes liées entre elles. C'est un peu comme un vrai paquet
rempli de petites choses, sauf que ces choses sont des classes ! Vous pouvez ainsi
rechercher le nom d'un package et trouver tout un tas de classes dont vous avez besoin en
un seul endroit. 

Rappelez-vous que le paramètre "par défaut" est plus restrictif que "public" ou "protégé".

Placez un mot clé approprié devant la déclaration correspondante :

class Unicorn {

// propriétés

private int height = 170;

public String power = "Double.infinity";

// méthodes

private static void sleep() {

public static void run() {

}
Ensuite, si vous essayez d'accéder à des membres privés de l'extérieur de la classe,
vous obtenez des erreurs :

Unicorn unicorn = new Unicorn();

System.out.println(unicorn.power); // Ok

unicorn.height = 180; // Erreur

unicorn.sleep(); // Erreur

unicorn.run(); // Ok

Les niveaux de contrôle peuvent être affectés aux éléments de classe ainsi qu'aux
classes :

public class PublicClass {

private class PrivateClass {

}
Tous les éléments de code (variables, classes et membres de classe) ont des niveaux de
contrôle qui sont affectés explicitement ou par défaut.
En plus de la sécurité, la spécification de niveaux de contrôle pour les membres du
groupe permet une meilleure lisibilité. Si un développeur prépare un fichier source,
les éléments pouvant être utilisés en externe seront ainsi toujours visibles.

Hiérarchie de contrôle
Un élément peut avoir le même niveau de contrôle ou un niveau de contrôle plus restrictif
que son élément contenant :

public class PublicClass {

public boolean publicProperty = true;

int internalProperty = 0; //par défaut pour package-private

private String fileprivateProperty = "Hello!"

private static void privateMethod() {

Si vous déclarez une classe comme  private, ses éléments ne peuvent être que
package-private  ou  private  :
class PrivateClass {

int internalProperty = 0; // assigne automatiquement package-private par défaut

protected defaultProperty = true; // assigne automatiquement package-private

public boolean publicProperty = true; // convertit automatiquement en package-private

private String fileprivateProperty = "Hello!"; //disponible seulement pour la classe

private static void privateMethod() {

Une classe de premier niveau ne peut pas être marquée comme private, mais la définir
comme « par défaut » la placera dans le niveau package-protected.

Déclarons une variable PrivateClass :

PrivateClass a = new PrivateClass(); // Erreur

private PrivateClass b = new PrivateClass(); // Ok

private PrivateClass c = new PrivateClass(); // Ok

Comme vous pouvez le voir, si le niveau d'accès par défaut du contexte d'une
variable est supérieur à une classe que vous lui affectez, vous devez explicitement
spécifier le niveau de la variable comme étant le même ou inférieur à celui de la
classe.

 Les boucles "for" avec une valeur entière :

for (int i=0; i<5;i++) {

System.out.println("Clap your hands!");

 Découvrez les boucles "for" avec les collections

int[] myArray = new int[]{7,2,4};

for (int i=0; i<myArray.length; i++) {

 System.out.println(myArray[i]);

Parfois, vous ne vous souciez pas de l'index et voulez simplement afficher la valeur
contenue dans le tableau ou la collection. Dans ce cas, Java fournit
une construction améliorée qui a la syntaxe générale suivante :

for (int number: myArray){

System.out.println(number);

}
Avec le "for" amélioré, il vous suffit de définir une variable du type du tableau ou de
la collection que vous souhaitez mettre en boucle. Cette variable se verra attribuer la
valeur de chaque élément du tableau ou de la collection, jusqu'à ce que vous ayez
atteint la fin.

 Les boucles while :

int numberOfTrees = 0;

while (numberOfTrees < 10) {

numberOfTrees += 1;

System.out.println("I planted " + numberOfTrees + " trees");

System.out.println("I have a forest!");

Découvrez la boucle "do... while" :

int pushUpGoal = 10;

do{

print ("Push up!");

pushUpGoal -= 1;
} while(pushUpGoal > 0);

Ignorez quelques instructions à l'intérieur d'une boucle :

En Java, pour ignorer une itération dans la boucle, utilisez une instruction  continue 
:

for ( int i=0; i <10; i++) {

// déclarations exécutées à chaque itération

if(i == 2 ||i == 5) {

continue;

// déclarations non-exécutées quand i == 2 or 5

 En Java, pour interrompre une séquence d'exécution, utilisez une

instruction break

 Comment définir des noms de classe ?

Comme pour les variables de nommage, les noms de classes doivent être
descriptifs. La principale différence, c'est qu'au lieu d'utiliser un camelCase standard,
la première lettre devrait également être en majuscule ; par exemple,
CréationMerveilleuse et non créationMerveilleuse.

Concevez des classes

class Book {

String title;

String author;

int numberOfPages;
String publisher="OC";

 Avez-vous remarqué que les trois premiers n'ont pas de valeurs, mais que le dernier
en a une ?

Psk publisher aura une valeur fixe.

Avec cela, vous avez créé une instance de la classe Book ! 📔

  Vous avez votre objet "livre", mais imaginons que vous changiez d'avis sur la valeur
de vos variables. Comment accéder aux champs associés à votre nouvel objet
flambant neuf ?
instanceVariableName.attributeName

myBook.title = "Coding is Art"

myBook.author = "Becky James";

myBook.numberOfPages = myBook.numberOfPages + 10;

Vous pouvez maintenant modifier la valeur des champs à l'intérieur de votre objet !
Imaginez que vous vouliez ajouter dix pages parce que vous avez oublié de prendre
en compte l'index du livre. Vous pouvez soit taper le nouveau numéro directement,
soit ajouter dix pages à la valeur existante comme dans la troisième ligne. C'est très
pratique pour faire de petits changements. 🙂

Spécialisez une classe grâce à l’héritage

Commençons par définir la classe mère FigureGeo :

public class FigureGeo {

private int x;

private int y;

public void moveTo(int newX, int newY) {

this.x = newX;

this.y = newY;

}
Ensuite, nous créons une classe fille Carre :

public class Carre extends FigureGeo {

private long cote;

public long getCote() {

return cote;
 }

public long getPerimetre(){

return 4*cote;

Redéfinissez une méthode de classe grâce au polymorphisme

Considérons le code ci-dessous, considérons la méthode  déplacer()  dans la
classe mère  Animal :

class Animal {

void deplacer() {

System.out.println("Je me déplace");

}
Appliquons le principe de polymorphisme pour cette méthode dans les différentes
classes filles  Chien,  Oiseau  et  Pigeon  :

class Chien extends Animal {

void deplacer() {

System.out.println("Je marche");

class Oiseau extends Animal {

void deplacer(){

System.out.println("Je vole");
 }

class Pigeon extends Oiseau {

void deplacer() {

System.out.println("Je vole surtout en ville");

}
Sur toutes ces classes, vous pouvez donc appeler  deplacer(). Le polymorphisme
permet alors d'appeler la méthode adéquate selon le type d'objet :

public class Test {

public static void main(String[] args) {

Animal a1 = new Animal();

Animal a2 = new Chien();

Animal a3 = new Pigeon();

a1.deplacer();

a2.deplacer();

a3.deplacer();
 }

}
Et à l'exécution, ça donne :
Je me déplace
Je marche
Je vole surtout en ville

 If/else :

1. Vérifier si le tableau  args  contient une valeur (la propriété  length  fournie
par les tableaux peut nous aider ici).
2. Si c'est le cas, appeler la méthode  sayhelloTo  avec la valeur qu'elle contient.
3. Sinon, continuer à appeler la méthode avec la chaîne  world.
Voilà ce que ça donne :

package conditions;

/**Ce programme affiche

* - un message Hello personnalisé si un argument a été envoyé lors de l'exécution du

programme

* - le message traditionnel "Hello World!" si ce n'est pas le cas

* @author L'équipe éducation d'OpenClassrooms

*/

public class ConditionalHello {

/** Le programme commence ici

* @param args arguments envoyé avec la ligne de commande

*/
 public static void main(String[] args) {

if (args.length==1) {

sayHelloTo(args[0]);

else {

sayHelloTo("world");

/** affiche le message hello au destinataire fourni

* @param recipient

*/

private static void sayHelloTo(String recipient) {

System.out.println("Hello " + recipient + "!");

}
Maintenant :

1. Compilez le programme avec la commande javac.

$ javac conditions/ConditionalHello.java
2. Exécutez le programme sans argument.
$ java conditions/ConditionalHello
Hello world!
$
3. Exécutez le programme en ajoutant "Esther" après le nom de la classe.
$java conditions/ConditionalHello Esther
Hello Esther!
$

Testez vos conditions avec des booléens

Par exemple :

String weather="The weather is good";

weather.startsWith("The weather"); // -> true

startsWith 
est une méthode de la classe  String  qui retourne  true  si cette chaîne
commence par le préfixe spécifié. Elle peut donc être utilisée comme une condition.

Gérez une chaîne de conditions

if(condition1) {

// instructions

else if(condition2) {

// instructions

else {

// instructions

L'instruction Switch

public static void main(String[] args) {

switch(args.length) {

case 0: // aucun argument n'a été envoyé

sayHelloTo("world");

break;

case 1: // l'utilisateur a fourni un argument dans le terminal

 sayHelloTo(args[0]);

break;

case 2: // l'utilisateur a fourni 2 arguments

sayHelloTo(args[0] + "-" + args[1]);

break;

default: // l'utilisateur a fourni plus d'arguments qu'on peut en gérer !

System.out.println("Sorry, I don't know how to manage more than 2 names!");

Avec l'instruction switch :

 l'expression conditionnelle  args.length  n'est évaluée qu'une seule fois ;

 chaque cas compare le résultat de l'expression à une valeur spécifique ;
 par défaut, une fois qu'un cas est évalué true, tous les cas ci-dessous sont
également évalués en cascade. Pour éviter cela, terminez chaque cas par
une instruction  break; ;
 la clause Default à la fin traite de tous les cas où le résultat de l'expression ne
correspond à aucun cas.

Utilisez le type d'énumération

Comme le switch doit couvrir tous les cas possibles, nous pouvons utiliser deux approches.
La première est de lister tous les cas d'énumération en switch, afin que nous n'ayons
pas à utiliser l'instruction  default ;

public class myDirection {

/** listez toutes les directions possibles */

enum Direction {

north, east, south, west;

/** trouvez le nord */

 public static void main(String[] args) {

Direction direction = Direction.north;

switch (direction) {

case north:

System.out.println("You are heading north");

break;

case east:

System.out.println("You are heading east");

break;

case south:

System.out.println("You are heading south");

break;

case west:

System.out.println("You are heading west");

break;

Dans ce cas, nous couvrons toutes les directions, nous n'avons donc pas besoin de
la clause  default.
Nous pouvons également définir un cas d'utilisation où nous ne devrions nous diriger
que vers le nord :

public static void main(String[] args) {

Direction direction = Direction.north;

switch (direction) {

case north:
 System.out.println("You are heading north");

break;

default:

System.out.println("You are lost!");