Quels sont les types primitifs de Java?
Quels sont les types primitifs en Java?
Quelle est la différence entre un type primitif et un type de référence?
Combien de types primitifs Java a-t-il et quels sont-ils?
En Java, chaque variable a un type déclaré dans le code source. Il existe deux types de types: types de référence et types primitifs. Les types de référence sont des références à des objets. Les types primitifs contiennent directement des valeurs. Il y a 8 types primitifs:
- octet
- court
- int
- longue
- carboniser
- float
- double
- booléen
A partir de Spécification de langage Java , Chapitre 4. Types, valeurs et variables :
Le langage de programmation Java est un langage à typage statique, ce qui signifie que chaque variable et chaque expression a un type connu au moment de la compilation.
Le langage de programmation Java est également un langage fortement typé, car les types limitent les valeurs qu'une variable peut contenir [...] ou qu'une expression peut produire, limitent les opérations prises en charge sur ces valeurs et déterminent la signification des opérations. Le typage statique fort permet de détecter les erreurs au moment de la compilation.
Les types de langage de programmation Java sont divisés en deux catégories: les types primitifs et les types de référence. Les types primitifs sont le type booléen et les types numériques. Les types numériques sont les types intégraux octet, court, int, long et char, et les types à virgule flottante float et double. Les types de référence sont [...] des types de classe, des types d'interface et des types de tableaux. Il existe également un type null spécial. Un objet est une [...] instance créée dynamiquement d'un type de classe ou un tableau créé dynamiquement. Les valeurs d'un type de référence sont des références à des objets. Tous les objets, y compris les tableaux, supportent les méthodes de la classe Object [...].
Qu'est-ce que les gens entendent par "Types"?
Dans le monde réel, vous avez différents types de véhicules, par exemple. Chacun sert un but distinct. Vous avez des voitures de sport pour conduire vite, des outils pour transporter des outils, des camions pour transporter beaucoup de marchandises et des limousines pour voyager dans le luxe. De la même manière, en Java, vous pouvez avoir différents types de données ayant différentes finalités, par ex. vous avez des nombres (qui sont utilisés pour ajouter/soustraire, etc.), vous pouvez avoir des "chaînes" qui permettent de communiquer des mots et des lettres. Vous ne pouvez pas utiliser de lettres pour ajouter - cela n’a aucun sens, vous ne pouvez pas non plus utiliser de chiffres pour écrire une phrase. Vous devez utiliser le bon type de données pour faire ce que vous voulez faire.
Primtives vs types de référence - qu'est-ce que cela signifie? Quelle est la différence?
Il existe maintenant quelques "types" de données qui sont basiques. Celles-ci sont déjà créées par les bureaux de Redmond/Sun. Ils sont appelés types Java "primitifs" et stockent les valeurs entre eux. Qu'est-ce que ça veut dire? C'est mieux expliqué par exemple:
Exemple de type primitif
Si je vous ai donné un billet de 50 dollars, le billet en lui-même vaut 50 dollars. La valeur est stockée dans la note elle-même.
Primitives juxtaposées à des types de référence
Maintenant, imaginez qu'au lieu de vous donner 50 dollars, je vous remets un morceau de papier sur lequel figure l'adresse d'un coffre-fort dans ma banque en Suisse. Le morceau de papier que je vous ai donné ne vaut pas 50 dollars en lui-même, mais il indique une adresse où vous pouvez obtenir vos 50 dollars. Ce morceau de papier est fondamentalement un type "de référence", car il ne stocke aucune valeur en lui-même, il pointe simplement vers certaines adresses. Mais je peux vous donner une adresse pour n'importe quoi: avions, châteaux, forêts tropicales: n'importe quoi!
Résumé
Vous ne pouvez pas simplement donner à quelqu'un un avion ou un train Shinkansen de votre poche arrière: vous lui donnez simplement une adresse. Mais si vous avez 50 dollars, ou n'importe quel type de devise: la substance est dans votre poche. Vous n'allez pas leur donner une carte au trésor sur votre billet de 50 $.
En bref, c’est la différence entre les types primitif et référence.
J'espère que ça aide.
Les types primitifs en Java sont des types sans classe. Ils ne stockent que des valeurs.
double d = 3.0;
d.intValue(); //compiler error!
Double d2 = new Double(3.0);
d2.intValue(); //works!
Il existe des types de référence, des types de primitifs et void
Pour chaque type primitif (et void), il existe un type wrapper qui définit une constante appelée TYPE qui a la classe du type primitif.
Pour compiler une classe pour un type primitif, le compilateur utilise la notation .class. par exemple.
Class<Integer> intClass = int.class; // == Integer.TYPE
Class<Void> voidClass = void.class; // == VOID.TYPE
Java prend en charge le type de données de base int, double, float, etc. total huit . Ce sont les données de type primitif ou le type de base de vos données.
booléen, omble, octet, court, int, long, double, float
Les types primitifs ne sont pas des classes, mais peuvent être utilisés pour stocker des valeurs telles que des nombres et des caractères.
- octet
- court
- int
- longue
- carboniser
- float
- double
- booléen
Il existe deux types de types de données, Primitive et Référence d'objet . Les types de données primitifs ne sont pas des objets, ils ne font que stocker les valeurs réelles, alors que les variables de référence d'objet stockent l'adresse de l'objet auquel ils font référence.
Tout type de données intégré à un langage de programmation est appelé type de données primitif . Les mots primitifs ou les types de données intégrés ou de base sont utilisés de manière interchangeable par les auteurs. Les types de données primitifs en Java sont fournis par le langage de programmation Java en tant que bloc de construction de base et sont appelés pour cela des types primitifs en Java. Java permet également aux programmeurs de définir leurs propres types (types définis par l'utilisateur). Pour les types primitifs, Java dispose d’un support intégré. Les types primitifs sont prédéfinis par le langage Java et sont nommés par un mot clé réservé. Java prend en charge 8 types de données intégrés et leur comportement de base. Les opérations prises en charge ne peuvent pas être modifiées par les programmeurs.
Ce sont des types non-classes qui ne contiennent qu'une valeur. Lors du passage d'une variable primitive, vous transmettez la valeur elle-même au lieu de la référence de la valeur.
La signification réelle de primitive est de savoir si les types de données sont des classes ou non. Java n'est pas un langage purement orienté objet car, en Java, les types de données ne sont pas des primitives, ce qui signifie que les types de données ne sont pas des classes.
Eg:- int a; a=10;
/*Integer a=new Integer();
a=10;
*/not possible
tandis que dans c # les types de données sont des classes et c’est pourquoi il s’agit d’un langage orienté objet pur
En Java a deux types de type,
- Types primitifs
- Types de référence
Types primitifs
Les types primitifs contiennent directement des valeurs.
int i = 24;
Il y a 8 types primitifs,
- octet
- court
- int
- longue
- carboniser
- flotte
- double
- booléen
Types de référence
Les types de référence sont des références à des objets. Lorsque vous créez un nouvel objet Test dans la classe Test.Java, il existe un type de référence.
Test t = new Test();
Spécialement, String est un type de référence . Ce n'est pas un type primitif. Il existe deux manières de créer un objet String.
String s = "abc";
String y = new String("abc");
Il existe deux divisions dans les types de données qui sont primitives et reference ..____. Les primitives représenteront ce qui suit:
- Nombres
- Booléen
- Float
- Double
- Carboniser
Sous les chiffres que nous avons
- Octet: -128 à 127
- Courte: -32 768 à 32 767
- Int: -2 ^ 31 à 2 ^ 31
- Long: -2 ^ 63 à 2 ^ 63 - 1
Ceux-ci représenteront des nombres et auront différentes allocations de mémoire pour économiser de la mémoire. Nous pouvons l'utiliser efficacement. Entre int et long nous avons signé et non signé. Unsigned commence avec min = 0.
Les huit types de données primitifs pris en charge par Java Programming Language:
octet - Il s'agit d'un entier complémentaire du complément à deux signé de 8 bits. Il a une valeur minimale de -128 et une valeur maximale de 127.
short - Il s'agit d'un entier complémentaire du complément à deux signé de 16 bits. Il a une valeur minimale de -32 768 et une valeur maximale de 32 767.
Pour une explication détaillée Cliquez ici