Syntaxe Java : une très brève introduction au langage de programmation

Qu'est-ce que la syntaxe Java ?

La syntaxe Java est une base du langage, toutes les principales règles, commandes, constructions pour écrire des programmes que le compilateur et l'ordinateur "comprennent". Chaque langage de programmation a sa syntaxe ainsi que son langage humain. Cet article se concentre sur la syntaxe de base du langage de programmation Java et s'adresse aux développeurs novices ou à ceux qui connaissent un autre langage de programmation. Certains aspects peuvent ne pas être clairs pour les débutants. Si c'est le cas, il est préférable de les ignorer et de se concentrer sur des exemples. Comme dans tout le reste, il est préférable d'apprendre un langage de programmation de manière cyclique, en venant progressivement à une compréhension plus approfondie de certains concepts. Chaque programme Java est un ensemble d'objets qui s'incorporent les uns aux autres avec des données (variables) et un comportement (fonctions ou méthodes). Aussi le programme Java est une classe ou quelques classes. Un objet est une instance d'une classe. Vous pouvez comprendre la classe comme un modèle, par exemple, les emporte-pièces et les objets comme les cookies. Ou classez comme un "programmeur Java" abstrait et un objet comme "Java Programmer John" ou "Java Programmer Ivy".

Objet en Java

Les objets en Java ont des états et des comportements. Exemple : Un chat a des états : son nom est Furr, sa couleur est rouge, son propriétaire est John ; le chat a aussi un comportement. Maintenant, Furr dort. Il pouvait aussi ronronner, marcher, etc. Un objet est une instance d'une classe.

Classe en Java

La classe est un modèle ou un modèle ou un plan de l'objet. Il décrit le comportement et indique que l'objet de son type prend en charge. Par exemple, la classe Cat a son nom, sa couleur, son propriétaire ; chat a aussi des comportements tels que manger, ronronner, marcher, dormir.

Méthodes en Java

Les méthodes servent à décrire les logiques, à manipuler les données et à exécuter toutes les actions. Chaque méthode définit le comportement. Une classe peut contenir plusieurs méthodes. Par exemple, nous pouvons écrire une méthode sleep() pour la classe Cat (pour dormir) ou purr() pour ronronner.

Variables d'instance en Java

Chaque objet a un ensemble unique de variables d'instance. L'état de l'objet est généralement généré par les valeurs affectées à ces variables d'instance. Par exemple, le nom ou l'âge du chat peut être une variable. Nous allons commencer par le programme Java le plus simple. À l'aide de cet exemple, nous allons comprendre les concepts de base de la syntaxe Java, puis les examiner de plus près.

Programme Java simple : Bonjour, Java !

Voici un programme Java simple :

class HelloJava {
   public static void main(String[] args) {
       System.out.println("Hello, Java!");
   }
}

Ce programme imprime une chaîne "Hello, Java!" consoler. Je vous recommande d'installer JDK et IntelliJ IDEA et d'essayer d'écrire le code que vous voyez ci-dessus. Ou pour la première fois, trouvez un IDE en ligne pour faire de même. Prenons maintenant ce programme ligne par ligne, mais omettons certains détails qui ne sont pas nécessaires pour un débutant.

class HelloJava 

Chaque programme en Java est une classe ou plus souvent plusieurs classes. La classe de ligne HelloJava signifie qu'ici nous créons une nouvelle classe et son nom est HelloJava. Comme nous l'avons défini ci-dessus, la classe est une sorte de modèle ou de plan directeur, elle décrit le comportement et les états des objets de la classe. Cela pourrait être difficile pour les programmeurs novices, vous apprendrez ce concept un peu plus tard. Pour l'instant, la classe HelloJava n'est que le début de votre programme. Vous avez peut-être remarqué l'accolade { sur la même ligne et dans tout le texte. Une paire d'accolades {} désigne un bloc, un groupe d'instructions de programmation qui est traité comme une seule unité. Où { signifie le début de l'unité et }sa fin. Les blocs peuvent être imbriqués les uns dans les autres ou ils peuvent être séquentiels. Il y a deux blocs imbriqués dans le programme ci-dessus. L'externe contient le corps de la classe Hello . Le bloc interne contient le corps de la méthode main() .

public static void main (String args []) {

Voici le début de la méthode principale. Une méthode est un comportement, ou la séquence de commandes qui vous permet d'effectuer une opération dans un programme. Par exemple, multipliez 2 nombres ou imprimez une chaîne. Autrement dit, une méthode est une fonction. Dans certains autres langages de programmation, les méthodes sont souvent appelées "fonctions". Les méthodes, comme tous les éléments d'un programme Java, sont situées dans une classe. Chaque classe peut avoir une, plusieurs ou aucune méthode. public est un modificateur d'accès. Une variable, une méthode ou une classe marquée avec le modificateur public est accessible de n'importe où dans le programme. Il y en a quatre en Java : public, private, protected et default (vide). Nous en parlons un peu plus tard. Pour la première étape, il est préférable de rendre toutes vos méthodes publiques. annulerest le type de retour de la méthode. Void signifie qu'il ne renvoie aucune valeur. main représente le point de départ du programme. C'est le nom de la méthode. String[] args est un argument de méthode principal . Pour l'instant, il suffit de savoir que presque tous les programmes Java ont la méthode principale , ils démarrent le programme et déclarent tels que public static void main(String[] args) Les méthodes statiques sont celles qui fonctionnent avec la classe. Les méthodes qui utilisent le mot-clé static dans leur déclaration ne peuvent fonctionner directement qu'avec des variables locales et statiques.

 System.out.println("Hello, Java!"); 

Formellement, cette ligne exécute la méthode println de l'objet out. L'objet out est déclaré dans la classe OutputStream et initialisé statiquement dans la classe System . Cependant, c'est un peu compliqué pour un débutant total. Il suffit qu'un débutant sache que cette ligne imprime les mots "Hello, Java!" à la console. Donc, si vous exécutez le programme dans votre IDE, vous obtiendrez la sortie dans la console :

Règles de syntaxe de base Java

Il existe quelques règles de syntaxe principales à suivre lors de la programmation en Java :

• le nom du fichier doit être identique au nom de la classe ;
• le plus souvent, chaque classe se trouve dans un fichier séparé avec une extension .java. Les fichiers de classe sont généralement regroupés dans des dossiers. Ces dossiers sont appelés packages ;
• les caractères sont sensibles à la casse. String n'est pas égal à string ;
• Le début du traitement du programme Java commence toujours dans la méthode main : public static void main (String [] args) . La méthode main() est une partie obligatoire de tout programme Java ;
• La méthode (procédure, fonction) est une séquence de commandes. Les méthodes définissent le comportement d'un objet ;
• L'ordre des méthodes dans le fichier programme n'a pas d'importance ;
• Gardez à l'esprit que la première lettre d'un nom de classe est en majuscule. Si vous utilisez plusieurs mots, utilisez des majuscules pour la première lettre de chaque mot ("MyFirstJavaClass");
• les noms de toutes les méthodes de la syntaxe Java commencent par une lettre minuscule. Lors de l'utilisation de plusieurs mots, les lettres suivantes sont en majuscules ("public void myFirstMethodName ()");
• les fichiers sont enregistrés avec le nom de classe et l'extension .java ("MyFirstJavaClass.java");
• Dans la syntaxe Java, il existe des délimiteurs "{...}" qui désignent un bloc de code et une nouvelle zone de code ;
• Chaque instruction de code doit se terminer par un point-virgule.

Variables Java et types de donnéesLes variables sont des entités spéciales utilisées pour stocker des données. Toutes les données. En Java, toutes les données sont stockées dans des variables. Vous pouvez dire qu'une variable est un emplacement réservé ou une boîte dans laquelle placer une variable. Chaque variable a son type de données, son nom (identifiant) et sa valeur. Les types de données peuvent être primitifs et non primitifs ou de référence. Les types de données primitifs peuvent être :

• Nombres entiers : byte, short, int, long
• Fractionnaires : flotter et doubler
• Valeurs logiques : booléen
• Valeurs symboliques (pour représenter les lettres et les chiffres) : char

Exemple de variables Java :

int s;
s = 5;  
char myChar = ‘a’; 

Dans ce code, nous avons créé une variable entière s (un conteneur vide) puis y avons mis une valeur 5. La même histoire avec une variable nommée myChar . Nous l'avons créé avec un type de données char et l'avons défini comme une lettre a . Dans ce cas, nous avons créé une variable et lui avons simultanément attribué une valeur. La syntaxe Java vous permet de le faire de cette façon. Les types de référence sont des objets qui conservent des références à des valeurs ou à d'autres objets. Ils peuvent également contenir une référence au null. Null est une valeur spéciale pour indiquer l'absence de valeur. Parmi les types de référence figurent String, Arrays et toutes les classes que vous souhaitez. Si vous avez une classe Violon, vous pouvez créer une variable de cette classe. Exemple de variables de type référence Java :

String s = “my words”; 
Violin myViolin; 

Vous en apprendrez plus à leur sujet plus tard. Rappelez-vous que les types de variables non primitifs commencent par des lettres majuscules tandis que primitifs - par des lettres minuscules. Exemple:

int i = 25;
String s = “Hello, Java!”; 

Tableaux Java

Les tableaux sont des objets qui stockent plusieurs variables du même type. Cependant, un tableau lui-même est un objet sur le tas. Nous verrons comment déclarer, construire et initialiser dans les prochains chapitres. Exemple de tableau :

int[] myArray = {1,7,5};

Ici, nous avons un tableau qui contient des trois entiers (1,7 et 5)

Énumérations Java

En plus des types de données primitifs, Java possède un type tel que enum ou enumeration. Les énumérations représentent une collection de constantes logiquement liées. Une énumération est déclarée à l'aide de l'opérateur enum, suivi du nom de l'énumération. Vient ensuite une liste d'éléments d'énumération séparés par des virgules :

enum DayOfWeek {
     MONDAY,
     TUESDAY,
     WEDNESDAY,
     THURSDAY,
     FRIDAY,
     SATURDAY,
     SUNDAY
}

Une énumération représente en fait un nouveau type, nous pouvons donc définir une variable de ce type et l'utiliser. Voici un exemple d'utilisation de l'énumération.

Exemple d'énumération Java

public class MyNum{      
    public static void main(String[] args) {
          
        Day myDay = DayOfWeek.FRIDAY;
        System.out.println(myDay);	//print a day from the enum     
}
}
enum DayOfWeek{
  
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

Si vous exécutez le programme, VENDREDI est imprimé dans la console. Vous pouvez mettre votre code de classe Enum et MyNum dans un seul fichier, mais il est préférable de créer deux fichiers distincts : un pour la classe MyNum et un pour Day enum. IntelliJ IDEA vous permet de choisir enum lors de la création.

Déclarer des variables en Java

En fait, nous avons déclaré certaines variables ci-dessus et même les avons identifiées. La déclaration est un processus d'allocation de mémoire pour une variable d'un certain type et de la nommer. Quelque chose comme ca:

int i; 
boolean boo; 

Nous pouvons également déclarer initialiser une variable en utilisant l'opérateur d'affectation (=). Cela signifie que nous mettons une valeur particulière dans la mémoire que nous avons allouée. Nous pouvons le faire correctement dans un moment de déclaration ou plus tard.

déclaration d'une variable exemple

String str; 
int i = 5; 
Str = “here is my string”; 

Si vous déclarez une variable sans initialisation, elle obtient quand même une valeur par défaut. Pour int, cette valeur est 0, pour String ou tout autre type de référence, il s'agit d'un identifiant null spécial .

Identifiants Java

Les identificateurs ne sont que des noms de composants Java - classes, variables et méthodes. Tous les composants Java doivent avoir des noms.

Class Violin {
int age; 
String masterName;  
}

Violin est l'identificateur de classe. age et masterName sont des identifiants de variables. Voici quelques règles d'identifiants Java :

• Tous les identifiants commencent par une lettre latine (A à Z ou a à z), un caractère monétaire ($) ou un trait de soulignement (_).
• Après le premier caractère, les identificateurs peuvent avoir n'importe quelle combinaison de caractères.
• Un mot-clé Java ne peut pas être un identifiant (vous découvrirez des mots-clés un peu plus tard).
• Les identifiants sont sensibles à la casse.

Exemple d'identifiants

Identifiants légaux : java, $mySalary, _something Identifiants illégaux : 1stPart, -one

Modificateurs Java

Les modificateurs sont des mots spéciaux du langage Java que vous pouvez utiliser pour modifier des éléments (classes, méthodes, variables). Java a deux catégories de modificateurs : les modificateurs d'accès et de non-accès.

Exemple de modificateurs d'accès

Il existe 4 modificateurs d'accès en Java :

• publique . Un élément public Il est accessible depuis la classe, en dehors de la classe, à l'intérieur et à l'extérieur du package
• L'élément avec le modificateur par défaut (vide) est accessible uniquement dans le package
• Le modificateur protégé est accessible à l'intérieur et à l'extérieur du package via la classe enfant
• élément privé disponible uniquement dans la classe qu'il a déclarée.

Exemple de modificateurs autres que d'accès

Il y en a 7

• statique
• final
• abstrait
• synchronisé
• transitoire
• volatil
• indigène

Mots clés Java

Les mots-clés Java sont les mots spéciaux à utiliser en Java qui agissent comme une clé pour un code. Ils sont également bien connus sous le nom de mots réservés : vous ne pouvez pas les utiliser pour identifier des variables, des méthodes, des classes, etc. Les voici :

• abstract : mot-clé pour déclarer une classe abstraite.
• boolean : mot-clé booléen Java pour déclarer une variable de type booléen. Ces variables ne peuvent être que vraies et fausses.
• break : utilisez le mot-clé Java break pour casser la boucle ou l'instruction switch.
• byte : mot-clé Java byte pour la déclaration d'une variable entière d'un octet.
• case : est utilisé avec les instructions switch pour marquer des blocs de texte.
• catch : est utilisé pour intercepter les exceptions après le bloc try .
• char : mot clé Java char pour une variable de type caractère. Il peut contenir des caractères Unicode 16 bits non signés.
• class : mot-clé de classe Java pour déclarer une classe.
• continue : mot-clé Java pour continuer la boucle.
• default : mot-clé Java par défaut pour spécifier le bloc de code par défaut dans une instruction switch.
• do : est utilisé dans la construction de boucles do-while.
• double : le mot clé Java double est utilisé pour déclarer une variable numérique. Il peut contenir des nombres à virgule flottante de 8 octets.
• else : vous pouvez l'utiliser dans des instructions conditionnelles else-if.
• enum : est utilisé pour définir un ensemble fixe de constantes.
• extend : Mot-clé Java extend pour indiquer qu'une classe étend une autre classe (est une classe enfant de l'autre classe).
• final : mot clé pour indiquer qu'une variable est une constante.
• finally : marque un bloc de code qui sera exécuté qu'une exception soit gérée ou non.
• float : une variable qui contient un nombre à virgule flottante de 4 octets.
• for : un mot-clé pour démarrer une boucle for. Il est utilisé pour exécuter un ensemble d'instructions de manière répétée alors que certaines conditions sont vraies.
• if : mot clé pour vérifier la condition. Il exécute le bloc si la condition est vraie.
• implements : le mot clé pour implémenter une interface.
• import : mot-clé d'importation Java pour importer un package, une classe ou une interface.
• instanceof : vérifie si l'objet est une instance d'une classe ou d'une interface particulière.
• int : une variable pouvant contenir un nombre entier signé de 4 octets.
• interface : le mot-clé d'interface Java est utilisé pour déclarer une interface.
• long : une variable pouvant contenir un nombre entier signé de 8 octets.
• native : spécifie qu'une méthode est implémentée en code natif à l'aide de JNI (Java Native Interface).
• new : mot-clé Java new pour créer de nouveaux objets.
• package : déclare un package Java (dossier) pour les fichiers des classes Java.
• private : un modificateur d'accès indique qu'une méthode ou une variable peut n'être visible que dans la classe où elle est déclarée.
• protected : un modificateur d'accès indique qu'une méthode ou une variable est accessible à l'intérieur et à l'extérieur du package via une classe enfant.
• public : un modificateur d'accès indique qu'un élément est accessible n'importe où.
• return : retourne un résultat de l'exécution d'une méthode.
• short : une variable pouvant contenir un nombre entier signé de 2 octets.
• statique : indique qu'une variable ou une méthode est une classe, pas un objet, une méthode.
• strictfp : restreint les calculs en virgule flottante.
• super : fait référence à l'objet de classe parent.
• switch : sélectionne un bloc de code (ou plusieurs d'entre eux) à exécuter.
• synchronized : un modificateur de non-accès. Il spécifie que la méthode n'est accessible que par un thread à la fois.
• this : fait référence à l'objet courant dans une méthode ou un constructeur.
• throw : est utilisé pour lever explicitement une exception.
• throws : Le déclare une exception.
• transitoire : une donnée transitoire ne peut pas être sérialisée.
• try : démarre un bloc de code qui sera vérifié pour les exceptions.
• void : spécifie qu'une méthode ne renvoie pas de valeur.
• volatile : indique qu'une variable peut changer de façon asynchrone.
• while : démarre une boucle while. itère une partie du programme plusieurs fois tant que la condition est vraie.

Commentaires en Java

Java prend en charge les commentaires sur une seule ligne et sur plusieurs lignes. Tous les caractères disponibles dans n'importe quel commentaire et ils sont ignorés par le compilateur Java. Les développeurs les utilisent pour expliquer le code ou pour rappeler quelque chose. Exemples de commentaires :

//single-line comment 
/*here we have a multi-line comment. As you can see it uses slash and asterisks from both sides of it.*/   

public class HelloJava {
   /* this program was created to demonstrate comments in Java. This one is a multi-line comment.
   You can use such comments anywhere in your programs*/
   public static void main(String[] args) {
       //here is a single-line comment
       String j = "Java"; //This is my string
       int a = 15; //here I have an integer
       System.out.println("Hello, " + j + " " + a + "!");
       int[] myArray = {1,2,5};
       System.out.println(myArray.length);
   }
}

Littéraux en Java

Les littéraux en Java sont des valeurs constantes affectées à la variable. Il peut s'agir de chiffres, de textes ou de quelque chose d'autre pour représenter une valeur.

• Littéraux intégraux
• Littéraux à virgule flottante
• Char littéraux
• Littéraux de chaîne
• Littéraux booléens

Exemples de littéraux Java

 int i = 100; //100 is an integral  literal 
double d = 10.2;//10.2 is a floating point literal 
char c = ‘b’; //b is a char literal 
String myString = “Hello!”; 
boolean bool = true; 

Remarque : null est également littéral.

Opérateurs de base en Java

Il existe différents types d'opérateurs : Arithmétique

• + (addition de nombres et concaténation de chaînes)
• – (moins ou soustraction)
• * (multiplication)
• / (division)
• % (module ou reste)

Comparaison

• < (Inférieur à)
• <= (inférieur ou égal à)
• > (supérieur à)
• >= (supérieur ou égal à)
• == (égal à)
• != (NON égal à)

Logique

• && (ET)
• || (OU)
• ! (PAS)
• ^ (XOR)

Nous avons déjà appris les types de données, les variables, les méthodes et les opérateurs. Prenons un exemple simple du code mais un peu plus compliqué que le tout premier programme Java. Créons une classe appelée NumberOperations

public class NumbersOperations {
   int a;
   int b;
   public static int add(int a,int b){
       return a+b;
   }
   public static int sub (int a, int b){
       return a-b;
   }
   public static double div (double a, int b){
       return a/b;
   }
}

Ici nous avons une classe avec des méthodes arborescentes à manipuler avec 2 nombres. Vous pouvez essayer d'écrire la 4ème méthode int mul (int a, int b) pour multiplier 2 nombres dans ce programme. Créons également une classe pour démontrer le travail de NumberOprations :

public class NumberOperationsDemo {
   public static void main(String[] args) {
       int c = NumbersOperations.add(4,5);
       System.out.println(c);
       double d = NumbersOperations.div(1,2);
       System.out.println(d);
   }
}

Si vous exécutez NumberOperationsDemo , vous obtiendrez la sortie suivante :

conclusion

Ce ne sont que les bases du langage Java, et beaucoup de choses peuvent prêter à confusion. Il faut beaucoup de programmation pour comprendre ce qui est quoi. C'est la seule façon d'apprendre cette langue - par la pratique. Commencez à coder dès maintenant, essayez de terminer la première quête du cours CodeGym Practical Java . Bonne chance dans votre apprentissage de Java !