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
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 une valeur minimale positive et négative 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)
L'entier court est un entier binaire 16 bits avec une valeur minimale positive et négative 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 une valeur minimale positive et négative 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 une valeur minimale positive et négative 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:
| Personnages d'échappement | signification |
|---|---|
| / n | Break de ligne (0x0a) |
| / r | Entrée (0x0d) |
| / f | Changement de page (0x0c) |
| / b | Backspace (0x08) |
| / | Espace (0x20) |
| / T | languette |
| / " | Citations doubles |
| / ' | Citations uniques |
| / / | Barre de barre |
| / ddd | Caractères octaux (DDD) |
| / uxxxxx | Caractères Unicode hexadécimaux (xxxx) |
Avant de l'utiliser, vous devez maintenant déclarer la variable que vous souhaitez utiliser. Le format de base de la déclaration des variables est le suivant:
Variable de type de données [= valeur] [, variable [= valeur] ...];
Le type de données ici est un type de données en Java et la variable est le nom d'une variable. Pour déclarer plus d'un type de variable spécifique, vous pouvez utiliser des virgules pour la séparer.
Voici des exemples de déclarations de variables valides et d'affectations en Java:
int a, b, c; // déclare trois INTS, A, B et C.INT A = 10, B = 10; // Exemple de l'initialisation par B = 22; // initialise une variable de type d'octet B.Double pi = 3,14159; // déclare et attribue une valeur de pi.char a = 'a'; // La variable char a IIS initialisée avec la valeur «a»
Il y a trois variables en Java:
Variables locales
exemple
Ici, l'âge (âge) est une variable locale. Ceci est défini sous la méthode Pupage (), et sa portée est limitée à cette méthode.
Test de classe publique {public void pupage () {int age = 0; âge = âge + 7; System.out.println ("L'âge du chiot est:" + âge); } public static void main (String args []) {test test = new test (); test.pupage (); }}Le code ci-dessus sortira les résultats suivants:
L'âge du chiot est: 7
Exemple L'exemple suivant utilise l'âge variable local mais n'est pas initialisé, donc une erreur sera affichée lors de l'édition.
Test de classe publique {public void pupage () {int Age; âge = âge + 7; System.out.println ("L'âge du chiot est:" + âge); } public static void main (String args []) {test test = new test (); test.pupage (); }}L'erreur suivante sera générée lors de l'édition:
Test.java:4: le nombre variable n'a peut-être pas été initialisé = âge + 7; ^ 1 erreur
Variables d'instance
exemple
Importer java.io. *; Employé de classe publique {// Cette variable d'instance est visible pour toute classe d'enfants. nom de chaîne publique; // La variable salariale est visible uniquement dans la classe des employés. Salaire double privé; // La variable de nom est attribuée dans le constructeur. Employé public (String EmpName) {name = empname; } // La variable salariale se voit attribuer une valeur. public void setsalary (double empsal) {salaire = empsal; } // Cette méthode imprime les détails de l'employé. public void printEmp () {System.out.println ("name:" + name); System.out.println ("salaire:" + salaire); } public static void main (String args []) {Employee Empone = New Employee ("Ransika"); Empone.SetSalary (1000); Empone.printemp (); }}Le code ci-dessus sortira les résultats suivants:
Nom: Ransikasalary: 1000.0
Classe, variables statiques
exemple
Importer java.io. *; Employé de classe publique {// La variable salariale est une variable statique privée double salaire statique privé; // Département est un département de chaîne finale statique statique constante = "développement"; public static void main (String args []) {salaire = 1000; System.out.println (département + "salaire moyen:" + salaire); }}Le code ci-dessus sortira les résultats suivants:
Salaire moyen de développement: 1000
Remarque: Si une variable est accessible depuis l'extérieur de la classe, la constante doit être accessible en tant que employee.Département.