Análise abrangente de tipos de dados suportados por Java e constantes Java e tipos variáveis

Tipos de dados básicos
Variáveis são locais de memória reservados para armazenar valores. Isso significa que, quando você cria uma variável, ele ocupa uma certa quantidade de espaço na memória.

Com base no tipo de variável de dados, o sistema operacional fabrica alocação de memória e decide o que será armazenado na memória reservada. Portanto, atribuindo diferentes tipos de dados a variáveis, você pode armazenar números inteiros, decimais ou letras nessas variáveis.

Existem dois tipos de dados eficientes em Java:

1. Tipo de dados original
2. Tipo de dados de referência

Tipo de dados original

O Java suporta 8 tipos de dados primitivos. O tipo de dados original é predefinido pelo idioma e nomeado com palavras -chave. Vamos aprender mais sobre esses 8 tipos de dados abaixo.

Tipo de byte (byte)

O tipo de byte é um número inteiro binário de 8 bits com valor mínimo positivo e negativo é -128 (-2^7)
O valor máximo é 127 (2^7-1)
O valor padrão é 0
Os tipos de dados do tipo byte são usados principalmente para economizar espaço em grandes matrizes e são usados principalmente para substituir os números inteiros. Porque o tipo de byte é 4 vezes menor que os números inteiros.
Por exemplo:

 byte a = 100, byte b = -50

Inteiro curto (curto)

O número inteiro curto é um número inteiro binário de 16 bits com valor mínimo positivo e negativo é -32768 (-2^15)
O valor máximo é 32767 (2^15-1)
Os dados do tipo inteiro curto também podem ser usados para economizar espaço como tipos de bytes. Inteiros curtos são duas vezes menores que os números inteiros. O valor padrão é 0.
Por exemplo:

 curto s = 10000, curto r = -20000

Int tipo (int)

O tipo inteiro é um número inteiro binário de 32 bits com valor mínimo positivo e negativo é-2.147.483.648 (-2^31)
O valor máximo é de 2.147.483.647 (2^31 -1)
Os tipos de número inteiro geralmente são aplicados aos valores inteiros por padrão, a menos que você esteja preocupado com a memória insuficiente.
O valor padrão é 0
Por exemplo:

 int a = 100000, int b = -200000

Tipo longo (longo)

O número inteiro longo é um número inteiro binário de 64 bits com valor mínimo positivo e negativo é -9.223.372.036.854.775.808 (-2^63)
O valor máximo é 9.223.372.036.854.775.807 (2^63 -1)
Esse tipo de dados é geralmente aplicado quando é necessário um intervalo maior que um tipo inteiro.
O valor padrão é 0L
Por exemplo:

 longo a = 100000l, int b = -200000l

Flutuador

Os dados de ponto flutuante são um IEEE 754 de precisão única de 32 bits 754 dados de ponto flutuante padrão.
Os dados de ponto flutuante são usados principalmente para salvar a memória em grandes matrizes digitais de ponto flutuante.
O valor padrão é 0,0F.
Os dados de ponto flutuante não podem ser usados para dados precisos, como moeda.
Por exemplo:

 Float F1 = 234,5f

Tipo de precisão dupla (duplo)

Os dados de precisão dupla é uma precisão dupla de 64 bits IEEE 754 Dados de ponto flutuante padrão.
Esse tipo de dados é usado principalmente por padrão para representar o valor do decimal e geralmente é a opção padrão.
Os dados de precisão dupla não podem ser usados para dados precisos, como moeda.
O valor padrão é 0,0D
Por exemplo:

 duplo d1 = 123,4

Booleano

Os dados booleanos representam um bit de informação.
Tem apenas dois valores possíveis: verdadeiro (verdadeiro) e falso (falso)
Esse tipo de dados é usado para tags simples em condições reais ou falsas.
O valor padrão é falso (falso)
Por exemplo:

 Booleano One = Verdadeiro

Tipo de personagem (char)

Os dados do caractere são caracteres padrão simples de unicode de 16 bits.
O valor mínimo é: '/u0000' (ou 0).
O valor máximo é: '/uffffff' (ou 65.535).
Os dados do caractere podem ser usados para armazenar qualquer carta.
Por exemplo: Char letra A (carta de caractere A) = 'A'
Tipo de dados de referência
O tipo de dados de referência é definido pelo editor da classe. Eles são usados para acessar objetos. Essas variáveis são definidas como tipos específicos que não são alteráveis. Por exemplo: funcionário, filhote, etc.
Objetos de classe e variáveis de matriz são esse tipo de tipo de dados de referência.
O valor padrão para qualquer tipo de dados referenciado está vazio.
Um tipo de dados de referência pode ser usado para qualquer objeto que declara e tipos compatíveis.
Por exemplo:

 Animal animal = novo animal ("girafa");

Constantes Java
As constantes são o código -fonte representando valores fixos. Eles são representados diretamente no formulário de código sem nenhuma estimativa.
As constantes podem ser atribuídas a qualquer tipo de variável original. Por exemplo:

 byte a = 68; char a = 'a'

Byte, inteiro, longo e curto também podem ser representados por sistemas de contagem decimal, hexadecimal e octal.

Quando esses sistemas técnicos representam quantidades diretas, o prefixo 0 é indicar octal, e o prefixo 0x é indicar hexadecimal. Por exemplo:

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

As disposições das constantes de cordas em Java, como a maioria dos outros idiomas, também devem ser escritas no meio das citações duplas. Exemplos de quantidade direta do tipo string são os seguintes:

 "Hello World" "Two/nlines" "/" Isto está em citações/""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

Constantes de caracteres e string podem conter qualquer letras unicode. Por exemplo:

 char a = '/u0001'; string a = "/u0001";

A linguagem Java também suporta sequências especiais de fuga de caracteres e cordas diretamente. Eles são:

Escapar de personagens	significado
/n	Quebra de linha (0x0a)
/r	Digite (0x0d)
/f	Alteração da página (0x0c)
/b	Backspace (0x08)
/s	Espaço (0x20)
/t	guia
/"	Citações duplas
/'	Citações únicas
/	Barragem
/ddd	Personagens octais (DDD)
/uxxxxx	Caracteres hexadecimal unicode (xxxx)

Tipo variável
As variáveis podem nos fornecer armazenamento nomeado que nosso programa pode manipular. Cada variável em Java possui um tipo específico, que determina o tamanho da variável e seu design de espaço de memória Occupy; Os valores dessas colunas podem ser armazenados nesse espaço de memória; as operações que variáveis podem aplicar.

Antes de usá -lo, agora você deve declarar a variável que deseja usar. O formato básico de declarar variáveis é o seguinte:

Tipo de dados variável [= valor] [, variável [= value] ...];
O tipo de dados aqui é um tipo de dados em Java e a variável é o nome de uma variável. Para declarar mais de um tipo de variável específico, você pode usar vírgulas para separá -lo.

A seguir, são apresentados exemplos de declarações e tarefas variáveis válidas em Java:

 int a, b, c; // declara três ints, a, b e c.int a = 10, b = 10; // Exemplo de InitializationByte B = 22; // inicializa uma variável de tipo de byte b.double pi = 3.14159; // declara e atribui um valor de pi.char a = 'a'; // a variável char a IIS é inicializada com o valor 'a'

Existem três variáveis em Java:

1. Variáveis locais
2. Variáveis de instância
3. Classe, variáveis estáticas

Variáveis locais

• Variáveis locais são declaradas em um método, construtor ou bloco
• Variáveis locais são criadas quando um método, construtor ou bloco entra e, assim que saem, serão destruídos
• Descritores acessíveis não podem ser usados para variáveis locais
• Variáveis locais são visíveis apenas em métodos, construtores ou blocos declarados
• As variáveis locais são implementadas dentro da profundidade da pilha
• As variáveis locais não têm valores padrão, portanto as variáveis locais devem ser declaradas e atribuídas valores antes de usar primeiro

exemplo

Aqui, a idade (idade) é uma variável local. Isso é definido no método pupage () e seu escopo é limitado a esse método.

 public class Test {public void pupage () {int Age = 0; idade = idade + 7; System.out.println ("A idade do filhote é:" + idade); } public static void main (string args []) {test test = new test (); test.pupage (); }}

O código acima produzirá os seguintes resultados:

 A idade do filhote é: 7

Exemplo O exemplo a seguir usa a idade da variável local, mas não é inicializada, portanto, um erro será exibido ao editar.

 public class Test {public void pupage () {int Age; idade = idade + 7; System.out.println ("A idade do filhote é:" + idade); } public static void main (string args []) {test test = new test (); test.pupage (); }}

O seguinte erro será gerado durante a edição:

 Test.java:4: Número de variável pode não ter sido inicializado = idade + 7;^1 erro

Variáveis de instância

• Uma variável de instância é declarada na classe, mas está fora de um método, construtor ou bloco.
• Quando um objeto na pilha é alocado um espaço, a localização de cada variável de instância é criada.
• A variável de instância é criada quando o objeto é criado com a palavra -chave "nova" e, quando o objeto é destruído, ele também é destruído.
• O valor de uma variável de instância deve ser referenciado por mais de um método, construtor ou bloqueio ou partes importantes do estado do objeto que devem aparecer na classe.
• As variáveis de instância podem ser declaradas no nível da aula antes ou após o uso.
• As variáveis de instância podem ser acessadas com um descritor acessível.
• Uma variável de instância é visível para todos os métodos, construtores ou blocos da classe. De um modo geral, é recomendado a essas variáveis privadas (nível de acesso). No entanto, a visibilidade da subclasse pode ser dada a essas variáveis com descritores de acessibilidade.
• As variáveis de instância têm valores padrão. O valor padrão de um número é zero, o valor padrão de um tipo booleano é falso e o valor padrão de uma referência de objeto está vazio. As atribuições podem ser executadas em uma declaração ou construtor.
• As variáveis de instância podem ser acessadas diretamente na classe. No entanto, nomes totalmente qualificados devem ser usados em métodos estáticos e diferentes classes (variáveis de instância podem ser acessadas). Objectreference.VariAblename

exemplo

 importar java.io. Nome de String Public; // A variável salarial é visível apenas na aula de funcionários. Salário duplo privado; // A variável de nome é atribuída no construtor. funcionário público (string empname) {name = empname; } // A variável salarial recebe um valor. public void Setsalary (duplo Empsal) {Salário = Empsal; } // Este método imprime os detalhes do funcionário. public void printemp () {System.out.println ("nome:" + nome); System.out.println ("Salário:" + Salário); } public static void main (string args []) {funcionário empone = new funcionário ("ransika"); Empone.SetSalary (1000); empone.printeMp (); }}

O código acima produzirá os seguintes resultados:

 Nome: Ransikasalary: 1000.0

Classe, variáveis estáticas

• As variáveis de classe também são chamadas de variáveis estáticas. Eles são declarados na classe com a palavra -chave estática, mas são métodos, construtores ou blocos externos.
• Existe apenas uma variável de classe em cada classe, não importa quantos objetos essa classe tenha.
• Além de serem declarados como constantes, as variáveis de classe raramente são usadas. As constantes são variáveis declaradas como públicas, privadas, finais e estáticas. O valor inicial da variável de instância não será alterado.
• As variáveis estáticas são armazenadas na memória estática e as variáveis estáticas raramente são usadas em vez de declarar um fim ou usar um público ou privado constante.
• As variáveis estáticas começam e terminam com o início e o fim do programa.
• A visibilidade é semelhante às variáveis de instância. No entanto, a maioria das variáveis estáticas é declarada como pública porque deve ser usada pelo consumidor da classe.
• O valor padrão é semelhante à variável de instância. O valor padrão dos números é zero, o valor padrão do booleano é falso e o valor padrão da referência do objeto está vazio. As atribuições podem ser executadas em uma declaração ou construtor. Além disso, os valores podem ser atribuídos em uma área de inicialização estática especial.
• Variáveis estáticas podem ser acessadas com o nome da classe. ClassName.VariableName
• Quando uma variável estática é declarada como uma final estática pública, os nomes das variáveis (constantes) devem estar em letras maiúsculas. Se a variável estática não for pública e final, seu método de nomeação é o mesmo que a variável de instância e a variável local.

exemplo

 importar java.io.*; funcionário da classe pública {// variável salarial é uma variável estática privada private // Departamento é um constante departamento de string final público estático = "Desenvolvimento"; public static void main (string args []) {salário = 1000; System.out.println (Departamento+"Salário Médio:"+Salário); }}

O código acima produzirá os seguintes resultados:

 Salário médio de desenvolvimento: 1000

Nota: Se uma variável for acessada de fora da classe, a constante deverá ser acessada como funcionário.