Java Introduction Basics: Java's Basic Syntax and Data Types pris en charge par Java

Une application Java peut être définie comme une collection d'objets qui communiquent en appelant leurs méthodes respectives. Jetons un coup d'œil à ce que signifient les classes, objets, méthodes et variables d'entités.

Objet: les objets ont un état et un comportement. Par exemple: un chien a son état - couleur, nom, race et a également un comportement - remuer sa queue, aboyer et manger. Une instance d'une classe d'objet.
Classe: Une classe peut être définie comme un modèle ou un plan qui décrit le comportement et l'état des types pris en charge par un objet.
Méthode: la méthode est un comportement de base. Il existe de nombreuses méthodes qui peuvent être incluses dans la classe. Dans la méthode, la logique peut être écrite, les données peuvent être manipulées et les actions peuvent être effectuées.
Variables d'entité: chaque objet a son ensemble spécial de variables d'entité, et l'état d'un objet est déterminé par les valeurs attribuées par ces variables d'entité.
Le premier programme Java
Jetons un coup d'œil au code suivant qui peut produire "Hello World".

 classe publique MyFirstJavapRogram {/ * Ceci est mon premier programme Java. * Cela imprimera 'Hello World' en tant que sortie * / public static void main (String [] args) {System.out.println ("Hello World"); // imprime Hello World}}

Voyons comment enregistrer ce fichier et compiler et exécuter ce programme. Veuillez suivre ces étapes:

Ouvrez le bloc-notes Ajoutez le code ci-dessus pour enregistrer le fichier avec myfirstjavaprogram.java. Ouvrez la fenêtre de l'invite de commande pour aller à l'emplacement où vous avez enregistré la classe. Supposons que c'est c: /
Entrez Javac MyFirstjavaprogram.java dans la fenêtre et appuyez sur Entrée pour compiler votre code. Si votre code n'a pas d'erreurs, l'invite de commande passera à la ligne suivante (en supposant: la variable de chemin est définie avec succès).
Entrez maintenant Java MyFirstJavaprogram pour exécuter votre programme et vous verrez "Hello World" affiché à l'écran

 C:> javac myfirstjavaprogram.javac:> java myfirstjavaprogram

 Bonjour le monde

Syntaxe de base
En ce qui concerne les programmes Java, il est important de se souvenir de quelques points.

Sensibilité à la caisse: Java est un langage sensible au cas, ce qui signifie que Hello et Hello représentent différentes significations en Java.
NAMING DE CLASSE: La lettre initiale de toutes les classes doit être capitalisée.
Si le nom de classe contient plusieurs mots, la première lettre de chaque mot doit être capitalisée.
Par exemple, classe MyFirstjavaclass
Nommer la méthode: tous les noms de méthode doivent commencer par des lettres minuscules.
Si le nom de la méthode contient plusieurs mots, la première lettre de chaque mot doit être capitalisée.
Par exemple public void myMethodName ()
Nom du fichier du programme: le nom de fichier du programme doit correspondre exactement au nom de classe.
Mais lors de l'enregistrement du fichier, vous devez l'enregistrer sous forme de nom de classe (notez qu'il est sensible à la casse) et ajouter le suffixe .java après le nom du fichier (si le nom du fichier et le nom de classe ne correspondent pas, votre programme ne pourra pas être compilé).
Par exemple: en supposant que le nom de classe est myfirstjavaprogram, le nom du fichier doit être myfirstjavaprogram.java.
Public Static Void Main (String Args []): les programmes Java commencent par la méthode principale (), qui est une partie obligatoire du programme Java.
Identificateurs Java
Toutes les composantes de Java doivent avoir leurs propres noms. Les noms des classes, variables et méthodes sont appelés identificateurs.

En Java, vous devez vous souvenir des points suivants sur les identifiants. comme suit:

Tous les identifiants doivent commencer par des lettres (A à Z ou A à Z), des caractères de change ($) ou des soulignements (_).
Toute combinaison de lettres peut être trouvée après le premier identifiant.
Les mots clés ne peuvent pas être utilisés comme identifiants.
La plupart des identifiants doivent être sensibles à la casse.
Exemples d'identifiants juridiques: âge, $ salaire, _value, __1_value
Exemple d'identifiant illégal: 123ABC, -Salary
Modificateurs Java
Comme sa langue, ses méthodes, ses classes, etc. peuvent être modifiées par les modificateurs. Il y a deux modificateurs en Java:

Modificateurs d'accès: par défaut, public, protégé, privé
Modificateurs non-access: final, abstrait, strictfp
Nous continuerons à en savoir plus sur les modificateurs dans la section suivante.

Mots-clés Java
Voici les mots clés conservés en Java. Ces mots clés ne peuvent pas être utilisés comme noms pour les constantes, les variables et autres identifiants.

Commentaires dans Java
Java prend en charge des commentaires en ligne ou multi-lignes comme C et C ++. Toutes les lettres dans les commentaires sont ignorées par le compilateur Java.

 classe publique MyFirstJavapRogram {/ * Ceci est mon premier programme Java. * Cela imprimera «Hello World» en tant que sortie * Ceci est un exemple de commentaires multi-lignes. * / public static void main (String [] args) {// Ceci est un exemple de commentaire de ligne unique / * Ceci est également un exemple de commentaire à ligne unique. * / System.out.println ("Hello World"); }}

Utiliser les lignes vides
Une ligne avec seulement des espaces peut être un commentaire. Une telle ligne est appelée une ligne vierge, et Java l'ignorera complètement.

Types de données de base
Les variables sont des emplacements de mémoire réservés au stockage des valeurs. Cela signifie que lorsque vous créez une variable, elle occupera une certaine espace en mémoire.

Sur la base du type de données des variables, le système d'exploitation fait une allocation de mémoire et décide de ce qui sera stocké dans la mémoire réservée. Par conséquent, en attribuant différents types de données aux variables, vous pouvez stocker des entiers, des décimales ou des lettres de ces variables.

Il existe deux types de données efficaces en Java:

• Type de données d'origine
• Type de données de référence
• Type de données d'origine

Java prend en charge 8 types de données primitives. Le type de données d'origine est prédéfini par la langue et nommé avec des mots clés. Apprenez-en plus sur ces 8 types de données ci-dessous.

Type d'octet (octet)

Le type d'octet est un entier binaire 8 bits avec positif et négatif

• La valeur minimale est de -128 (-2 ^ 7)
• La valeur maximale est de 127 (2 ^ 7-1)
• La valeur par défaut est 0

Les types de données de type d'octets sont principalement utilisés pour économiser de l'espace dans de grands tableaux et sont principalement utilisés pour remplacer les entiers. Parce que le type d'octet est 4 fois plus petit que les entiers.

Par exemple: octet A = 100, octet b = -50
Entier court (court)

Entier court est un entier binaire 16 bits avec positif et négatif

• La valeur minimale est de -32768 (-2 ^ 15)
• La valeur maximale est de 32767 (2 ^ 15-1)

Les données de type entier court peuvent également être utilisées pour économiser de l'espace comme les types d'octets. Les entiers courts sont deux fois plus petits que les entiers

• La valeur par défaut est 0

Par exemple: court S = 10000, court r = -20000

Int type (int)

Le type entier est un entier binaire 32 bits avec positif et négatif

• La valeur minimale est - 2 147 483 648 (-2 ^ 31)
• La valeur maximale est de 2 147 483 647 (2 ^ 31 -1)

Les types entiers sont généralement appliqués aux valeurs entières par défaut, sauf si vous êtes inquiet de la mémoire insuffisante.

• La valeur par défaut est 0

Par exemple: int a = 100000, int b = -200000

Type long (long)

Le long entier est un entier binaire 64 bits avec positif et négatif

• La valeur minimale est de -9 223,372,036 854 775 808 (-2 ^ 63)
• La valeur maximale est de 9 223 372 036 854 775 807 (2 ^ 63 -1)

Ce type de données est généralement appliqué lorsqu'une gamme plus grande qu'un type entier est requise.

• La valeur par défaut est 0L

Par exemple: long a = 100000L, int b = -200000l

Flotter

Les données de points flottants sont une seule précision 32 bits IEEE 754 Données de points flottants standard.
Les données de point flottantes sont principalement utilisées pour enregistrer la mémoire dans de grands tableaux numériques à virgule flottante.

• La valeur par défaut est de 0,0f.

Les données à point flottantes ne peuvent pas être utilisées pour des données précises telles que la monnaie.

Par exemple: float f1 = 234,5f
Type de double précision (double)

Les données à double précision sont une double précision de données standard IEEE 754 IEEE 754.
Ce type de données est principalement utilisé par défaut pour représenter la valeur de la décimale et est généralement le choix par défaut.
Les données à double précision ne peuvent pas être utilisées pour des données précises telles que la devise.

• La valeur par défaut est 0,0d

Par exemple: double d1 = 123.4

Booléen

Les données booléennes représentent un bit d'information.
Il n'a que deux valeurs possibles: vrai (vrai) et false (false)
Ce type de données est utilisé pour des balises simples dans des conditions réelles ou fausses.

• La valeur par défaut est fausse (false)

Par exemple: Boolean One = True

Type de caractère (char)

Les données des caractères sont simples des caractères standard UNICODE 16 bits.

• La valeur minimale est: «/ u0000» (ou 0).
• La valeur maximale est: «/ uffffff» (ou 65 535).

Les données des caractères peuvent être utilisées pour stocker n'importe quelle lettre.

Par exemple: la lettre de charbon A (Lettre de caractère A) = 'A'
Type de données de référence
Le type de données de référence est défini par l'éditeur de la classe. Ils sont utilisés pour accéder aux objets. Ces variables sont définies comme des types spécifiques qui ne sont pas modifiables. Par exemple: employé, chiot, etc.

• Les objets de classe et les variables de tableau sont ce type de type de données de référence.
• La valeur par défaut pour tout type de données référencé est vide.
• Un type de données de référence peut être utilisé pour tout objet qui déclare et les types compatibles.

Par exemple: animal animal = nouvel animal ("girafe");

Constantes Java
Les constantes sont le code source représentant des valeurs fixes. Ils sont représentés directement sous forme de code sans aucune estimation.
Les constantes peuvent être affectées à n'importe quel type de variable d'origine. Par exemple:

 octet a = 68; char a = 'a'

Des octets, des entiers, longs et courts peuvent également être représentés par des systèmes décimaux, hexadécimaux et octaux.

Lorsque ces systèmes techniques représentent des quantités directes, le préfixe 0 est d'indiquer octal et le préfixe 0x est d'indiquer hexadécimal. Par exemple:

 int encimal = 100; int octal = 0144; int hexa = 0x64;

Les dispositions des constantes de cordes en Java, comme la plupart des autres langues, devraient également être écrites au milieu de Double Quotes. Des exemples de quantité directe de type chaîne sont les suivants:

 "Hello World" "Two / nlines" "/" Ceci est dans citations/""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

Les constantes de caractère et de chaîne peuvent contenir des lettres Unicode. Par exemple:

 char a = '/ u0001'; chaîne a = "/ u0001";

La langue Java prend également en charge directement des séquences d'échappement spéciales de personnages et de chaînes. Ils sont: