O básico da linguagem Java

Variáveis e tipos de dados
Como declarar uma variável

```java
String nome = “Guilherme”;
int idade = 28;
boolean empregado = false;
float saldoBancario = 10.0;
char letra = ‘x’; // com aspas simples
```

A partir do Java 10, o Java pode realizar a inferencia de váriável, ou seja, ele consegue saber o tipo do dado que está sendo atribuido para a variável:

```java
URL url = new URL(“https://www.example.com/")
// Pode ser reescrito da seguinte forma
var url = new URL(“https://www.example.com/)
```

Tipos de dados

Java suporta 8 tipos de dados, sendo eles:

| Tipo | Tamanho | Descrição |
| — — — — | — — — — | — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — |
| byte | 1 byte | Armazena numeros de -128 até 127 |
| bit | 1 bit | armazena true ou false, que são representados por 1 e 0 respectivamente |
| char | 2 bytes | Um caractere único ou um valor da tabela ASCII |
| short | 2 bytes | números de ``-32.768`` até ``32.767`` |
| int | 4 bytes | números de ``-2.147.583.648`` até ``2.147.583.647``. Há a versão `unsigned int` que vai de 0 até 2³² — 1, ou`4.294.967.295`. |
| float | 4 bytes | Números com 6 a 7 casas decimais. Deve terminar coma letra “f”, ``16.123f;``. Não recomendado para valores precisos, para isso você deve usar a class `java.Math.BigDecimal` |
| long | 8 bytes | números de ``-2.147.483.648L`` até ``2.147.483.647L``. O número deve terminar com a letra “L” |
| double | 8 bytes | Números com até 15 casas decimais. Deve terminar com a letra “d”. ``1.1234567890d;`` |
| boolean | 1 byte | armazena `true` ou `false` |

Convertendo um tipo de dado para outro tipo

Conversão automática, converte um tipo menor para um tipo maior:
byte -> short -> char -> int -> long -> float -> double
Por exemplo é possível fazer:

```java
int myInt = 9;
double myDouble = myInt;
```

Conversão manual, converter um tipo maior para um tipo menor:
double -> float -> long -> int -> char -> short -> byte

```java
double myDouble = 9;
int myInt = (int) myDouble;
```

Operadores aritméticos e de atribuição

Java possui os operadores aritméticos mais comuns:
- Adição: +
- Subtração: -
- Multiplicação: \*
- Divisão: /
- Modulo: %
- Incremento: ++
- Decremento: —

Os operadores de atribuição são:

Tabela: Operadroes de atribuição

Os operadores de comparação são:

Tabela: Operadores de comparação

Condicionais (if, else, else if)

Declarando um IF

if (condição){
// código
}

Declarando um IF com ELSE

if(condição){
// código
} else {
// código que será executado caso a condição dentro do IF seja avaliada como falsa
}

Declarando um ELSE IF

if(condição){
// código
} else if (condição){
// código
// se a condição do primeiro if for falsa, então a condição do else if será testada. Se ela for verdadeira, então o código será executado, caso contrário o fluxo de execução passa para a próxima verificação
} else {
// código
// será executado se as condições dos blocos anteriores forem falsas.
}

Atalho para if..else, ou operador ternário

int num = ( valor > x ) ? "Se o valor for verdadeiro isso é executado" : "Se o valor for falso, então isto é executado"

A declaração SWITCH

SWITCH pode ser uma alternativa ao IF..ELSE. Eles fazem basicamente a mesma coisa. Mas o switch exige que seja declarado um resultado que é chamado de `default` para o caso de nenhuma condição ser atendida, se ele for usado no final, então um `break` não será necessário. E também que seja declarado um `break` no final de cada `case`, caso o `break` não seja declarado, os demais casos serão testados também.

switch (condição){
 case x:
 // codigo
 break;
 case y:
 // codigo
 break;
 case z:
 // codigo
 break;
 default:
 // default codigo
 }

A partir do Java 14 é possível fazer um switch da seguinte forma:

enum Day {
DOMINGO, SEGUNDA, TERCA, QUARTA, QUINTA, SEXTA, SABADO;
}
public class Switch {
 public static void main(String[] args) {
 Day day = Day.TERCA;
 int numeroDeLetras = switch (day) {
 case DOMINGO, SEGUNDA -> {
 yield 7;
 }
 case QUARTA, QUINTA, SABADO -> {
 yield 6;
 }
 case TERCA, SEXTA -> {
 yield 5;
 }
 default -> throw new IllegalStateException("Dia inválido");
 };
 System.out.println(numeroDeLetras);
 }
}

Loops

O While loop

Uma while é declarado da seguinte forma:

int i = 0;
while(i < 10){
 // codigo
 i++;
}

- Primeiro é declarado uma variável de controle que terá seu valor alterado por alguma operação dentro ou fora do while `int i = 0;`.
- Depois uma condição é avaliada `i<10` e o while será executado sempre que ela for verdadeira.
- Dentro do while algum código será executado. Este código pode ou não interferir na nossa variavel de controle.

Get Guilherme Daniel’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Imprimindo números de forma infinita:

int i = 0;
while(i < 10){
 System.out.println(i);
}

ou

int i = 0;
while (true){
 x++;
 System.out.println(i);
}

Normalmente um loop infinito não é uma situação desejada, mas isso depende do caso. Por exemplo, quando uma aplicação desktop é executado há um loop infinito que é executado avaliando os botões do teclado e do mouse que foram pressionados para poder executar alguma ação com base nisso e também para manter a janela aberta.

O `do While`.

Similar ao `while`, mas o `do while()` primeiro executa algo e depois avalia um condição:

int i = 0;
do {
System.out.println(i);
i++;
} while(i < 10);

O loop `FOR`

Declaramos um loop `FOR` assim:

for(variavel de controle; condição; incremento){
// código
}

for(int i = 0; i < 10; i++){
 System.out.println(i);
}

O código acima irá imprimir os valores de 0 até 9.

É possível declarar a variável de controle fora do loop:

int i = 0;
for (; i < 5; i++) {
 System.out.println("i = " + i);
}

É possível declarar a variável de incremento dentro do loop:

for (int i = 0; i < 5;) {
 System.out.println("i = " + i);
 i++; // Incremento dentro do corpo do loop
}

Um loop infinito com for:

for (int i = 0;; i++) {
 System.out.println("i = " + i);
 //if (i == 10) {
 // break; // Sai do loop quando i for igual a 10
 //}
}

Um `FOR` dedcrementando:

for (int i = 5; i > 0; i - ) {
 System.out.println("i = " + i);
}

Um `FOR` que percorre coleções:

int[] numeros = {1, 2, 3, 4, 5};
for (int numero : numeros) {
 System.out.println("Número: " + numero);
}

É possível colocar um `FOR` dentro de outro `FOR`:

for(int i = 0; i < 3; i++){
 for(int j = 0; j < 3; j++){
 System.out.println("i = " + i + " j = " + j);
 }
}

A saída do código acima será:

i = 0 j = 0
i = 0 j = 1
i = 0 j = 2
i = 1 j = 0
i = 1 j = 1
i = 1 j = 2
i = 2 j = 0
i = 2 j = 1
i = 2 j = 2

É possível parar um loop com o `break` ou pular uma verificação com o `continue`:

for(int i = 0; i < 10; i++){
 for(int j = 0; j < 10; j++){
 if(i % 2 == 0){
 // Isso irá pular a execução sempre o valor de i for par.
 continue;
 }
 if(i == 7){
 // Isso irá parar a execução do for quando o valor de i for 7.
 break;
 }
 System.out.println("i = " + i + " j = " + j);
 }
}

Arrays

Array é um objeto que pode conter um conjunto de valores de um único tipo. O tamanho do array é fixo e deve ser informado na criação do array:

int[] numeros = new int[10]; // Isso cria um array de inteiros com 10 posições

Todo array inicia na posição 0 e vai até o tamanho definido menos 1. No caso de um array de 10 posições, o primeiro elemento está na posição 0 e o último elemento na posição 9.
Para inserir um elemento em uma posição do array façamos o seguinte:

numeros[0] = 100; // Isso irá adicionar o número 100 no inicio do array.
//…
numeros[9] = 1000; // // Isso irá adicionar o número 1000 na última posição do array.

Se tentarmos adicionar um valor em uma posição além daquelas que foram definidas na inicialização do array, receberemos o seguinte erro: `java.lang.ArrayIndexOutOfBoundsException`.
Para acessar um elemento de dentro de um array façamos da seguinte forma:

System.out.println(numeros[1]); // Isso irá imprimir no console o elemento da posição 1 do array, ou seja, nosso segundo elemento.

É possível criamos um array dentro de outro array, chamamos isso de array multidimensional:

String[][] nomes = {
{"ana", "maria", "julia"},
{"pedro", "paulo", "joão"}
};

Para acessarmos estes elementos, nós fazemos de modo similar a quando acessamos ao array simples, mas adicionamos mais um `[]`, assim:

nomes[0][0]; // O primeiro 0 indica o primeiro elemento do array externo, que é o array de nomes femininos, e o segundo 0 indica a possição dentro do array, que é o nome "ana".

Podemos também copiar os valores de um array para o outro utilizando o método `arraycopy` da classe `System`:

class ArrayCopyDemo {
 public static void main(String[] args) {
 String[] copyFrom = {
 "Affogato", "Americano", "Cappuccino", "Corretto", "Cortado", 
 "Doppio", "Espresso", "Frappucino", "Freddo", "Lungo", "Macchiato", 
 "Marocchino", "Ristretto" };
 
 String[] copyTo = new String[7];
 System.arraycopy(copyFrom, 2, copyTo, 0, 7);
 for (String coffee : copyTo) {
 System.out.print(coffee + " "); 
 }
 }
}

Java oferece a classe `java.util.Arrays` que contém um serie de métodos para trabalharmos com arrays, como por exemplo: buscar, comparar, preencher, ordenar, converter um array para uma string e muito mais, que podemos entrar mais afundo em um outro momento.