Tipos de dados básicos Java

Variáveis ​​se aplicam à memória para armazenar valores. Em outras palavras, ao criar uma variável, você precisa solicitar espaço na memória.

O sistema de gerenciamento de memória aloca espaço de armazenamento para variáveis ​​de acordo com seu tipo, e o espaço alocado só pode ser usado para armazenar dados desse tipo.

Portanto, ao definir variáveis ​​de diferentes tipos, números inteiros, decimais ou caracteres podem ser armazenados na memória.

Os dois principais tipos de dados de Java:

• Tipos de dados integrados

• Tipo de dados de referência

Tipos de dados integrados

A linguagem Java fornece oito tipos básicos. Seis tipos numéricos (quatro inteiros, dois tipos de ponto flutuante), um tipo de caractere e um tipo booleano.

tipo de byte:

• O tipo de dados byte é um número inteiro assinado de 8 bits representado em complemento de dois;

• O valor mínimo é -128 (-2^7);

• O valor máximo é 127 (2^7-1);

• O valor padrão é 0;

• O tipo byte é utilizado para economizar espaço em arrays grandes, substituindo principalmente números inteiros, pois a variável byte ocupa apenas um quarto do espaço do tipo int;

• Exemplo: byte a = 100, byte b = -50.

tipo curto (tipo inteiro curto):

• O tipo de dados curto é um inteiro de complemento de dois com sinal de 16 bits.

• O valor mínimo é -32768 (-2^15);

• O valor máximo é 32767 (2^15 - 1);

• O tipo de dados Short também pode economizar espaço como byte. Uma variável curta é metade do espaço ocupado por uma variável do tipo int;

• O valor padrão é 0;

• Exemplo: s curto = 1000, r curto = -20000.

tipo int (tipo inteiro):

• O tipo de dados int é um inteiro assinado de 32 bits representado em complemento de dois;

• O valor mínimo é -2.147.483.648 (-2^31);

• O valor máximo é 2.147.483.647 (2^31 - 1);

• Geralmente, as variáveis ​​inteiras têm como padrão o tipo int;

• O valor padrão é 0;

• Exemplo: int a = 100000, int b = -200000.

longo (tipo inteiro longo):

• O tipo de dados longo é um número inteiro assinado de 64 bits representado em complemento de dois;

• O valor mínimo é -9.223.372.036.854.775.808 (-2^63);

• O valor máximo é 9.223.372.036.854.775.807 (2^63 -1);

• Este tipo é usado principalmente em sistemas que precisam comparar números inteiros grandes;

• O valor padrão é 0L;

• Exemplo: longo a = 100000L, longo b = -200000L.

float (tipo de ponto flutuante de precisão única):

• O tipo de dados float é um número de ponto flutuante de precisão simples de 32 bits que está em conformidade com o padrão IEEE 754;

• float pode economizar espaço de memória ao armazenar grandes matrizes de ponto flutuante;

• O valor padrão é 0,0f;

• Números de ponto flutuante não podem ser usados ​​para representar valores precisos, como moedas;

• Exemplo: float f1 = 234,5f.

double (tipo de ponto flutuante de precisão dupla):

• O tipo de dados duplo é um número de ponto flutuante de precisão dupla, 64 bits, compatível com IEEE 754;

• O tipo padrão de números de ponto flutuante é duplo;

• O tipo double também não pode representar valores precisos, como moeda;

• O valor padrão é 0,0d;

• Exemplo: duplo d1 = 123,4.

booleano:

• O tipo de dados booleano representa um bit de informação;

• Existem apenas dois valores: verdadeiro e falso;

• Este tipo é usado apenas como sinalizador para registrar situações de verdadeiro/falso;

• O valor padrão é falso;

• Exemplo: booleano um = verdadeiro.

char (tipo de caractere):

• O tipo char é um único caractere Unicode de 16 bits;

• O valor mínimo é 'u0000' (ou seja, 0);

• O valor máximo é 'uffff' (ou seja, 65.535);

• O tipo de dados char pode armazenar qualquer caractere;

• Exemplo: letra char = 'A'.

Exemplo

Para a faixa de valores dos tipos básicos de tipos numéricos, não precisamos ser forçados a lembrar, pois seus valores já foram definidos na classe de empacotamento correspondente na forma de constantes. Por favor, veja o seguinte exemplo:

 classe pública PrimitiveTypeTest {
public static void main(String[] args) {
//byte
System.out.println("Tipo básico: byte Dígitos binários: " + Byte.SIZE);
System.out.println("Classe de empacotamento: java.lang.Byte");
System.out.println("Valor mínimo: Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("Valor máximo: Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();

// curto
System.out.println("Tipo básico: dígitos binários curtos: " + Short.SIZE);
System.out.println("Classe de embalagem: java.lang.Short");
System.out.println("Valor mínimo: Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("Valor máximo: Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();

//int
System.out.println("Tipo básico: int Dígitos binários: " + Integer.SIZE);
System.out.println("Classe de pacote: java.lang.Integer");
System.out.println("Valor mínimo: Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("Valor máximo: Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();

// longo
System.out.println("Tipo básico: long Número de dígitos binários: " + Long.SIZE);
System.out.println("Classe de pacote: java.lang.Long");
System.out.println("Valor mínimo: Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println("Valor máximo: Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println();

//flutuar
System.out.println("Tipo básico: float Número de dígitos binários: " + Float.SIZE);
System.out.println("Classe de embalagem: java.lang.Float");
System.out.println("Valor mínimo: Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("Valor máximo: Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();

//dobro
System.out.println("Tipo básico: double Dígitos binários: " + Double.SIZE);
System.out.println("Classe de embalagem: java.lang.Double");
System.out.println("Valor mínimo: Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("Valor máximo: Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();

// caractere
System.out.println("Tipo básico: char Dígitos binários: " + Character.SIZE);
System.out.println("Classe de empacotamento: java.lang.Character");
// Envia Character.MIN_VALUE para o console em formato numérico em vez de formato de caractere System.out.println("Valor mínimo: Character.MIN_VALUE="
+ (int) Caractere.MIN_VALUE);
// Envia Character.MAX_VALUE para o console em formato numérico em vez de formato de caractere System.out.println("Valor máximo: Character.MAX_VALUE="
+ (int)Caracter.MAX_VALUE);
}
}

A saída da compilação do código acima é a seguinte:

 Tipo básico: byte Dígitos binários: 8
Classe de encapsulamento: java.lang.Byte
Valor mínimo: Byte.MIN_VALUE=-128
Valor máximo: Byte.MAX_VALUE=127
Tipo básico: dígitos binários curtos: 16
Classe de encapsulamento: java.lang.Short
Valor mínimo: Short.MIN_VALUE=-32768
Valor máximo: Short.MAX_VALUE=32767


Tipo básico: int Dígitos binários: 32
Classe de encapsulamento: java.lang.Integer
Valor mínimo: Inteiro.MIN_VALUE=-2147483648
Valor máximo: Inteiro.MAX_VALUE=2147483647


Tipo básico: longo Número de dígitos binários: 64
Classe de encapsulamento: java.lang.Long
Valor mínimo: Long.MIN_VALUE=-9223372036854775808
Valor máximo: Long.MAX_VALUE=9223372036854775807


Tipo básico: float Número de dígitos binários: 32
Classe de encapsulamento: java.lang.Float
Valor mínimo: Float.MIN_VALUE=1.4E-45
Valor máximo: Float.MAX_VALUE=3.4028235E38


Tipo básico: duplo Dígitos binários: 64
Classe de encapsulamento: java.lang.Double
Valor mínimo: Double.MIN_VALUE=4.9E-324
Valor máximo: Double.MAX_VALUE=1.7976931348623157E308


Tipo básico: char Dígitos binários: 16
Classe de encapsulamento: java.lang.Character
Valor mínimo: Character.MIN_VALUE=0
Valor máximo: Character.MAX_VALUE=65535

Os valores mínimo e máximo de Float e Double são exibidos na forma de notação científica. O "E+número" no final significa que o número antes de E deve ser multiplicado pela potência do "número" de 10. Por exemplo, 3,14E3 é 3,14×1000=3140 e 3,14E-3 é 3,14/1000=0,00314.

Na verdade, existe outro tipo básico void em JAVA, que também possui uma classe de empacotamento correspondente java.lang.Void, mas não podemos operar diretamente sobre eles.

tipo de referência

• Variáveis ​​de tipo de referência são criadas pelo construtor de uma classe e você pode usá-las para acessar o objeto referenciado. Essas variáveis ​​são especificadas como um tipo específico quando declaradas, como Employee, Pubby, etc. Depois que uma variável é declarada, seu tipo não pode ser alterado.

• Objetos e matrizes são tipos de dados de referência.

• O valor padrão para todos os tipos de referência é nulo.

• Uma variável de referência pode ser usada para se referir a qualquer tipo compatível.

• Exemplo: Animal animal = new Animal("girafa").

Constantes Java

Uma constante é um valor fixo. Não requerem cálculo e representam diretamente os valores correspondentes.

Uma constante refere-se a uma quantidade que não pode ser alterada. O sinalizador final é usado em Java e o método de declaração é semelhante ao das variáveis:

 IP duplo final = 3,1415927;

Embora os nomes das constantes também possam estar em letras minúsculas, para facilitar a identificação, geralmente são usadas letras maiúsculas para representar as constantes.

Literais podem ser atribuídos a variáveis ​​de qualquer tipo integrado. Por exemplo:

 byte a = 68;
caractere a = 'A'

Byte, int, long e short podem ser representados em notação decimal, hexadecimal e octal.

Ao usar constantes, o prefixo 0 indica octal e o prefixo 0x indica hexadecimal. Por exemplo:

 inteiro decimal = 100;
interno octal = 0144;
interno hexa = 0x64;

Como outras linguagens, as constantes de string do Java são sequências de caracteres colocadas entre duas aspas. A seguir está um exemplo de uma string literal:

 "Olá mundo"
"duasnlinhas"
""Isso está entre aspas""

Tanto as constantes de string quanto as constantes de caracteres podem conter qualquer caractere Unicode. Por exemplo:

 caractere a = 'u0001';
String a = "u0001";

A linguagem Java suporta algumas sequências especiais de caracteres de escape.

Esta seção explica os tipos de dados básicos de Java. A próxima seção explora os diferentes tipos de variáveis ​​e seus usos.