Java Introdução básica: sintaxe básica de Java e tipos de dados suportados por java

Um aplicativo Java pode ser definido como uma coleção de objetos que se comunicam chamando seus respectivos métodos. Vamos dar uma olhada em quais aulas, objetos, métodos e variáveis de entidade significam.

Objeto: os objetos têm estado e comportamento. Por exemplo: um cachorro tem seu estado - cor, nome, raça e também tem comportamento - abanando sua cauda, latindo e alimentando. Uma instância de uma classe de tempo de objeto.
Classe: Uma classe pode ser definida como um modelo ou plano que descreve o comportamento e o estado dos tipos suportados por um objeto.
Método: Método é um comportamento básico. Existem muitos métodos que podem ser incluídos na classe. No método, a lógica pode ser gravada, os dados podem ser manipulados e as ações podem ser executadas.
Variáveis da entidade: Cada objeto possui seu conjunto especial de variáveis de entidade, e o estado de um objeto é determinado pelos valores atribuídos por essas variáveis de entidade.
O primeiro programa Java
Vamos dar uma olhada no código a seguir que pode gerar "Hello World".

 classe pública myfirstjavaprogram { /* Este é o meu primeiro programa Java. * Isso imprimirá 'Hello World' como a saída */ public static void main (string [] args) {System.out.println ("Hello World"); // Imprime Hello World}}

Vamos ver como salvar esse arquivo, compilar e executar este programa. Siga estas etapas:

Open Notepad Adicione o código acima para salvar o arquivo com myfirstjavaprogram.java. Abra a janela Prompt de comando para ir ao local onde você salvou a classe. Suponha que seja c:/
Digite Javac myfirstjavaprogram.java na janela e pressione Enter para compilar seu código. Se o seu código não tiver erros, o prompt de comando irá para a próxima linha (assumindo: a variável do caminho será definida com sucesso).
Agora digite Java MyFirstJavaprogram para executar seu programa e você verá "Hello World" exibido na tela

 C:> javac myfirstjavaprogram.javac:> java myfirstjavaprograma

 Olá mundo

Sintaxe básica
Em relação aos programas Java, é importante lembrar alguns pontos.

Sensibilidade ao caso: o Java é uma linguagem sensível ao caso, o que significa que olá e olá representam significados diferentes em Java.
Nomeação da aula: a letra inicial de todas as classes deve ser capitalizada.
Se o nome da classe contiver várias palavras, a primeira letra de cada palavra deve ser capitalizada.
Por exemplo, classe MyFirstJavaclass
Nomeação do método: Todos os nomes de métodos devem começar com letras minúsculas.
Se o nome do método contiver várias palavras, a primeira letra de cada palavra deve ser capitalizada.
Por exemplo, public void myMethodName ()
Nome do arquivo do programa: o nome do arquivo do programa deve corresponder exatamente ao nome da classe.
Mas ao salvar o arquivo, você deve salvá -lo como o nome da classe (observe que ele é sensível ao caso) e adicione o sufixo .java após o nome do arquivo (se o nome do arquivo e o nome da classe não corresponderem, seu programa não poderá ser compilado).
Por exemplo: Supondo que o nome da classe seja myfirstjavaprograma, o nome do arquivo deve ser myfirstjavaprogram.java.
public static void Main (String args []): os programas Java começam com o método Main (), que é uma parte obrigatória do programa Java.
Identificadores Java
Todos os componentes do Java devem ter seus próprios nomes. Os nomes das classes, variáveis e métodos são chamados de identificadores.

Em Java, você precisa se lembrar dos seguintes pontos sobre identificadores. do seguinte modo:

Todos os identificadores devem começar com letras (A a Z ou A a Z), caracteres de moeda ($) ou sublinhados (_).
Qualquer combinação de letras pode ser encontrada após o primeiro identificador.
Palavras -chave não podem ser usadas como identificadores.
A maioria dos identificadores precisa ser sensível ao minúsculo.
Exemplos de identificadores legais: idade, $ salário, _value, __1_Value
Exemplo de identificador ilegal: 123ABC, -Salary
Modificadores Java
Como seu idioma, métodos, classes, etc. podem ser modificados por modificadores. Existem dois modificadores em Java:

Modificadores de acesso: padrão, público, protegido, privado
Modificadores que não são de acesso: final, abstrato, strictfp
Continuaremos a aprender sobre modificadores na próxima seção.

Palavras -chave Java
A seguir, são apresentadas as palavras -chave preservadas em Java. Essas palavras -chave não podem ser usadas como nomes para constantes, variáveis e outros identificadores.

Comentários em Java
O Java suporta comentários de linha única ou de várias linhas como C e C ++. Todas as cartas nos comentários são ignoradas pelo compilador Java.

 classe pública myfirstjavaprogram { /* Este é o meu primeiro programa Java. * Isso imprimirá 'Hello World' como a saída * Este é um exemplo de comentários de várias linhas. * / public static void main (string [] args) {// Este é um exemplo de comentário de linha única /* Este também é um exemplo de comentário de linha única. */ System.out.println ("Hello World"); }}

Use linhas vazias
Uma linha com apenas espaços pode ser um comentário. Essa linha é chamada de linha em branco, e Java o ignorará completamente.

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:

• Tipo de dados original
• 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)

Tipo de byte é um número inteiro binário de 8 bits com positivo e negativo

• O valor mínimo é -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 positivo e negativo

• O valor mínimo é -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)

Tipo inteiro é um número inteiro binário de 32 bits com positivo e negativo

• O valor mínimo é - 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 positivo e negativo

• 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)

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 um = true

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: