Guia básico sobre a linguagem de programação JAVA
- #Java
Boa noite a todos os entusiastas e amantes da tecnologia!
Hoje trago um guia básico sobre a Linguagem de programação Java espero que ajude todos dessa comunidade assim como vem me ajudando.
(obs: Se estiver difícil a visualização ou compreensão Click aqui! )
Variáveis em Java
O que são variáveis? Uma variável é um espaço na memória do computador destinado a um dado que é alterado durante a execução do algoritmo. Para funcionar corretamente, as variáveis precisam ser definidas por nomes e tipos.
Resumindo: Você criou e nomeou uma variável e/ou adicionou um valor a ela? em algum lugar da memória do seu dispositivo vai ser adicionado e reservado esses dados.
Os diferentes tipos de variáveis
byte - armazena números inteiros, sem decimais, de -128 até 127.
short - armazena números inteiros, sem decimais, de -32768 até 32767.
int - armazena números inteiros, sem decimais, de -2147483648 até 2147483647.
long - armazena números inteiros, sem decimais que possuem até 19 caracteres (é necessário adicionar 'L' no final, isso é muita coisa ).
float - armazena números de ponto flutuante, com decimais, como 999999.3 ou -999999.3. É suficiente para armazenar valores com 6 ou 7 digitos decimais (é necessário adicionar 'f' no final, é recomendado o uso invés do double se for necessário economizar memória em grandes matrizes de números de ponto flutuante).
double - armazena números de ponto flutuante, com decimais, como 999999.3223222 ou -999999.3223222. É suficiente para armazenar valores com 15 digitos decimais (é necessário adicionar 'd' no final, você precisa de uma maior precisão nas casas decimais? esse cara é o que você busca, o double ).
char - armazena caracteres únicos, como 'a', 'B' ou qualquer valor ASCII. Os valores de caractere são cercados por aspas simples.
String - armazena textos, como "H3ll0 W@rld!". Os valores de string são cercados por aspas duplas
boolean - armazena valores com dois estados: true ou false (verdadeiro ou falso).
Declarando (Criando) Variáveis
tipoVariavel nomeVariavel = valor;
Não entendeu? em "tipoVariavel" você vai colocar o tipo de dado que você quer que seja armazenado nessa variável, em "nomeVariavel" você vai informar o nome dessa variável (é recomendado usar apenas letras alfabéticas e números) e em "valor", você vai informar o valor que deseja ser armazenado nessa variável.
byte diasMes = 30;
short diasTotalVida = 30000;
int idade = 21;
long 19charsDecimalEuAguento = 1000000000000000000L;
double PI = 3.141592653589793d;
char genero = 'M';
String nomeCompleto = "Eduardo Buzzi";
boolean sempreCodando = true;
Também é possível declarar uma variável sem atribuir o valor e atribuir o valor posteriormente
String nomeCompleto;
nomeCompleto = "Eduardo Buzzi";
Se você atribuir um novo valor a uma variável existente, ele substituirá o valor anterior
int idade = 21;
idade = 22;
// O valor da variável "idade" agora é 22
Declarar múltiplas variáveis
Para declarar mais de uma variável do mesmo tipo, é possível utilizar uma lista separada por vírgulas.
int x = 57, y = 209, z = 472;
System.out.println(x + y + z);
// Será exibido o valor da soma de x + y + z que é 738
Um valor para várias variáveis
Você também pode atribuir o mesmo valor a várias variáveis em uma só linha
int x, y, z;
x = y = z = 139;
System.out.println(x + y + z);
// Será exibido o valor da soma de x + y + z que é 417
Variáveis Finais
Se você não quiser que outros (ou você mesmo) substituam os valores existentes, use a palavra final chave (isso declarará a variável como "final" ou "constante", o que significa imutável e somente leitura).
final int idade = 21;
idade = 22;Vai gerar o erro: cannot assign a value to a final variable
Exibir Variáveis
O método println() é frequentemente usado para exibir variáveis.
Para combinar texto e uma variável, use o caractere '+' sem aspas simples.
String nome = "Eduardo";
System.out.println("Olá " + nome);
// Será exibido: "Olá Eduardo"
É possível também usar o + para adicionar uma variável a outra, unindo 2 variáveis em 1 só.
String primeiroNome = "Eduardo ";
String ultimoNome = "Buzzi";
String nomeCompleto = primeiroNome + ultimoNome;
System.out.println(nomeCompleto);
// Será exibido: "Eduardo Buzzi"
Para valores numéricos, o caractere funciona como um operador + matemático (observe que é utilizado variável integer (int) no código abaixo
int x = 127;
int y = 146;
System.out.println(x + y);
// Será exibido o valor da soma de x + y que é 273
Identificadores
Todas as variáveis Java devem ser identificadas com nomes exclusivos. Os identificadores podem ser nomes curtos (como x e y) ou nomes mais descritivos (idade, somaIdade, volumeTotal). Recomenda-se usar nomes descritivos para criar um código compreensível e sustentável
int idadeMaximaVida = 104;
// Bom
int i = 104;
// É possível, mas não é fácil entender o que i quer dizer
Regras gerais para nomear variáveis
Os nomes podem conter letras, dígitos, sublinhados e cifrões.
Os nomes devem começar com uma letra minúscula e não podem conter espaços em branco.
Os nomes também podem começar com $ e _ (mas é recomendado iniciar com letras).
Os nomes de variáveis no Java são case sensitive, diferenciam maiúsculas de minúsculas ("alturaMaxima" e "alturamaxima" são variáveis diferentes).
Palavras reservadas (como palavras-chave int ou boolean) não podem ser usadas como nomes.
Tipos de dados em Java
Primitivos
Tipos de dados primitivos inclui: byte, short, int, long, float, double, boolean e char.
byte - Armazena 1 byte (8 bits) na memória.
short - Armazena 2 bytes (16 bits) na memória.
int - Armazena 4 bytes (32 bits) na memória.
long - Armazena 8 bytes (64 bits) na memória.
float - Armazena 4 bytes (32 bits) na memória.
double - Armazena 8 bytes (64 bits) na memória.
char - Armazena 2 bytes (16 bits) na memória.
boolean - Armazena 1 bit na memória.
Números Inteiros (decimais)
Os tipos inteiros armazenam números inteiros, positivos ou negativos (como 123 ou -456), sem decimais. Os tipos válidos são byte, short, int e long. O tipo que você deve usar depende do valor numérico que será armazenado.
Números Reais (flutuantes)
Os tipos de números reais float e double armazenam números fracionários. Observe que você deve terminar o valor com um "f" para floats e "d" para doubles.
Números científicos
Um número de ponto flutuante também pode ser um número científico com um "e" para indicar a potência de 10.
float varFloat = 44e2f;
double varDouble = 19E4d;
System.out.println(varFloat);
// Será exibido: 4400.0
System.out.println(varDouble);
// Será exibido: 190000.0
Booleanos
Um tipo de dado booleano é declarado com a palavra-chave boolean e só pode receber os valores true ou false.
boolean estouCodandoJava = true;
System.out.println(estouCodandoJava);
// Será exibido: true
boolean codarJavaEhFacilDemais = false;
System.out.println(codarJavaEhFacilDemais);
// Será exibido: false
int x = 171;
int y = 197;
boolean XehMaiorQueY = (x > y);
System.out.println(XehMaiorQueY);
// Será exibido: false, pois x é igual ou menor que y
Caracteres
O tipo de dado char é usado para armazenar um único caractere. O caractere deve estar entre aspas simples, como 'A' ou 'c'.
char genero = 'M';
System.out.println(genero);
// Será exibido: M
Você está familiarizado com os valores ASCII? você pode usar os números inteiros da tabela ASCII para definir o caractere que será exibido.
char charA = 65, charB = 66, charC = 67;
System.out.println(charA);
// Será exibido: A
System.out.println(charB);
// Será exibido: B
System.out.println(charC);
// Será exibido: C
Não Primitivos
Tipos não primitivos podem ser usados para chamar métodos para realizar certas operações, enquanto tipos primitivos não podem. O tamanho de um tipo primitivo depende do tipo de dados, enquanto os tipos não primitivos têm todos o mesmo tamanho. Um tipo primitivo sempre tem um valor, enquanto tipos não primitivos podem ser null.
Exemplos de tipos não primitivos são Strings, Arrays, Classes, Interface, etc. Nessa publicação será abordado os tipos Strings, Arrays e nas publicações posteriores será abrangido os outros tipos.
Strings
O tipo de dado String é usado para armazenar uma coleção de caracteres (texto). Os valores de string devem estar sempre entre aspas duplas.
String bemVindoAoJava = "Preciso de muito Café";
System.out.println(bemVindoAoJava);
// Será exibido: Preciso de muito Café
Descobrir o tamanho de uma String
Uma String em Java é na verdade um objeto, que contém métodos que podem realizar certas operações em strings. Por exemplo, o comprimento de uma string pode ser encontrado com o método length().
String texto = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
System.out.println("O tamanho da String da variável texto é: " + texto.length());
// Será exibido: O tamanho da String da variável texto é: 26
Transformar todos caracteres em Maiúsculas
O método toUpperCase() é utilizado para transformar todos caracteres alfabéticos de determinada String em letras maiúsculas.
String texto = "Gritando em caps lock!!";
System.out.println(texto.toUpperCase());
// Será exibido: GRITANDO EM CAPS LOCK!!
Transformar todos caracteres em Minúsculas
O método toLowerCase() é utilizado para transformar todos caracteres alfabéticos de determinada String em letras minúsculas.
String texto = "Eu QuErO QuE IsSo ApArEçA BoNiTo"
System.out.println(texto.toLowerCase());
// Será exibido: eu quero que isso apareça bonito
Encontrando a posição de um caractere em uma String
O método indexOf() retorna o índice (a posição) da primeira ocorrência de um texto especificado em uma string (incluindo espaços em branco).
String texto = "Encontrar a posição quando a primeira 'posição' é localizada"
System.out.println(texto.indexOf("posição"));
// Será exibido: 12
Por que o resultado não é 13? Por que em uma String você começa a contar do 0.
String nome = "Eduardo";
'E' -> Posição 0
'd' -> Posição 1
'u' -> Posição 2
'a' -> Posição 3
'r' -> Posição 4
'd' -> Posição 5
'o' -> Posição 6
Concatenação de String
O operador + pode ser usado entre as strings para combiná-las. Isso é chamado de concatenação.
String primeiroNome = "Eduardo";
String ultimoNome = "Buzzi";
System.out.println(primeiroNome + " " + ultimoNome);
// Será exibido: Eduardo Buzzi
Observe que foi adicionado um texto vazio (" ") para criar um espaço entre primeiroNome e ultimoNome na impressão.
O método concat() pode ser utilizado também para concatenar duas strings.
String primeiroNome = "Eduardo ";
String ultimoNome = "Buzzi";
System.out.println(primeiroNome.concat(ultimoNome));
// Será exibido: Eduardo Buzzi
Números e Strings
Java usa o operador + para adição e concatenação. Os números são adicionados. As strings são concatenadas.
Se você adicionar dois números, o resultado será um número.
int x = 268;
int y = 171;
int z = x + y;
// O valor de z será 439 (inteiro/numérico)
Se você adicionar duas strings, o resultado será uma concatenação de strings.
String x = "178";
String y = "161";
String z = x + y;
// O valor de z será 178161. (String)
Se você adicionar um número e uma string, o resultado será uma concatenação de strings.
String x = "259";
int y = 31;
String z = x + y;
// O valor de z será 25931. (String)
Caracteres Especiais
Como as strings devem ser escritas entre aspas, o Java interpretará mal a string abaixo e gerará um erro.
String texto = "Quem programa em "Java", é Javeiro";
//Isso vai gerar um erro
Não é possível colocar aspas duplas dentro de uma string sem usar o caractere de escape de barra invetida.
O caractere de escape de barra invertida ( \ ) transforma caracteres especiais em caracteres de string.
String texto1 = "Quem programa em \"Java\", é Javeiro";
// O valor da String texto1 será: Quem programa em "Java", é Javeiro
String texto2 = "Quem programa em \'Java\', é Javeiro";
// O valor da String texto2 será: Quem programa em 'Java', é Javeiro
String texto3 = "Ele\\Ela";
// O valor da String texto3 será: Ele\Ela
Mais caracteres especiais
\n - representa uma nova linha.
\t - representa um espaço maior (tab).
\b - representa um espaço (' ').
Arrays
Arrays são usados para armazenar vários valores em uma única variável, em vez de declarar variáveis separadas para cada valor. Para declarar um array, defina o tipo de variável com colchetes [].
String[] linguagens;
Agora declaramos uma variável que contém um array de strings. Para inserir valores nele, é possível usar um literal de array - coloque os valores em uma lista separada por vírgulas, entre chaves.
String[] linguagens = {"Java", "C++", "PHP", "Rust"};
Para criar um array de inteiros:
int[] numeros = {13, 82, 2, 93};
Acessar elementos de um array
Você acessa um elemento da matriz (array) referindo-se ao número do índice, os índices de matriz começam com 0, [0] é o primeiro elemento. [1] é o segundo elemento, etc.
String[] linguagens = {"Java", "C++", "PHP", "Rust"};
System.out.println(linguagens[0]);
// Será exibido: Java
Alterar um elemento da array
Para alterar o valor de um elemento específico, consulte o número do índice.
String[] linguagens = {"Java", "C++", "PHP", "Rust"};
linguagens[0] = "C#";
System.out.println(linguagens[0]);
// Será exibido: C# invés de Java
Tamanho de uma array
Para descobrir quantos elementos um array possui, use a propriedade length.
String[] linguagens = {"Java", "C++", "PHP", "Rust"};
System.out.println(linguagens.length);
// Será exibido: 4
Loop/percorrer uma array
Você pode percorrer os elementos da array com o loop for e usar a propriedade length para especificar quantas vezes o loop deve ser executado (que caso o índice do for seja 0, ele percorrerá todos os elementos).
String[] linguagens = {"Java", "C++", "PHP", "Rust"};
for (int idx = 0; idx < linguagens.length; idx++)
{
System.out.println(linguagens[idx]);
}
Você deseja percorrer elementos em arrays, os elementos são do mesmo tipo primitivo e não precisa da informação do índice? Utilize o For-Each que é usado exclusivamente para percorrer elementos em arrays.
String[] linguagens = {"Java", "C++", "PHP", "Rust"};
for (String linguagem : linguagens)
{
System.out.println(linguagem);
}
Em "for (String linguagem : linguagens)" será definido primeiramente o tipo da variável de cada elemento que será percorrido, o nome da variável que cada elemento receberá ao passar no loop e por último o nome da váriavel do Array.Se o array possuí elementos de tipos diferentes utilize o for normal.
Arrays multidimensionais
Um array multidimensional é um array de arrays. Para criar um array bidimensional, adicione cada array dentro de seu próprio conjunto de chaves.
String[][] stack = { {"HTML5", "CSS3", "JavaScript"}, {"Java", "C++", "PHP", "Rust"} };
stack agora é um array com dois arrays como seus elementos.
Para acessar os elementos da array stack , especifique dois índices: um para a array e outro para o elemento dentro dessa array. O exemplo abaixo acessa o terceiro elemento (2) no segundo array (1) de stack.
String[][] stack = { {"HTML5", "CSS3", "JavaScript"}, {"Java", "C++", "PHP", "Rust"} };
String backendSite = stack[1][2];
System.out.println(backendSite);
// Será exibido: PHP
Também é possível usar um loop for de outro loop for para obter os elementos de um array bidimensional.
public class Main
{
public static void main(String[] args)
{
String[][] arrayStack = { {"HTML5", "CSS3", "JavaScript"}, {"Java", "C++", "PHP", "Rust"} };
for (int stack = 0; stack < arrayStack.length; stack++)
{
for (int linguagem = 0; linguagem < arrayStack[stack].length; linguagem++)
{
System.out.println(arrayStack[stack][linguagem]);
}
}
}
}
Casting em Java
Também conhecido como conversão de tipos, ocorre quando você atribui um valor de um tipo de dados primitivo a outro tipo. Em Java, existem dois tipos de conversão: Casting Automático e Casting Manual.
Casting Automático
Converte um tipo menor em um tamanho de tipo maior automáticamente.
byteshortcharintlongfloatdouble
public class Main
{
public static void main(String[] args)
{
int notaProvaInt = 8;
double notaProvaDouble = notaProvaInt;
System.out.println(notaProvaInt);
// Será exibido: 8
System.out.println(notaProvaDouble);
// Será exibido: 8.0
}
}
Casting Manual
Converte um tipo maior para um tipo de tamanho menor manualmente.
doublefloatlongintcharshortbyte
public class Main
{
public static void main(String[] args)
{
double notaProvaDouble = 7.4d;
int notaProvaInt = (int) notaProvaDouble;
System.out.println(notaProvaDouble);
// Será exibido: 7.4
System.out.println(notaProvaInt);
// Será exibido: 7
}
}
Operadores em Java
Os operadores são usados para realizar operações em variáveis e valores. Abaixo é usado o operador + para somar dois valores.
int valorInteiro = 38 + 183;
Embora o operador + seja frequentemente usado para somar dois valores, como no exemplo acima, ele também pode ser usado para somar uma variável e um valor, ou uma variável e outra variável.
int total1 = 115 + 152; // 267 (115 + 152)
int total2 = total1 + 288; // 555 (267 + 288)
int total3 = total2 + total2; // 1110 (555 + 555)
Operadores aritméticos
Operadores aritméticos são usados para realizar operações matemáticas comuns.
Adição ( + )x + y
O operador de adição é representado pelo + (mais), ele já foi apresentado em exemplos acima, ele soma os valores que estão em sua esquerda e direita.
Subtração ( - )x - y
O operador de subtração é representado pelo - (menos), ele subtrai (diminui) o valor que está na direita pelo que está na esquerda.
Multiplicação ( * )x * y
O operador de multiplicação é representado pelo * (asterisco), ele multiplica o valor que está na direita pelo que está na esquerda.
Divisão ( / )x / y
O operador de divisão é representado pelo / (barra), ele divide o valor que está na direita pelo que está na esquerda.
Módulo ( % )x % y
O operador de módulo é representado pelo % (porcentagem), ele divide o valor que está na direita pelo que está na esquerda e armazena o resto (o que sobrou da divisão).
Incremento ( ++ )++x ou x++
O operador de incrimento é representado pelo ++ (dois mais seguidos), ele acrescenta 1 ao valor total da variável.
Decremento ( -- )--x ou x–
O operador de decremento é representado pelo -- (dois menos seguidos), ele decrementa 1 ao valor total da variável.
int numX = 246;
int numY = 238;
System.out.println(numX + numY); // Será exibido: 484
System.out.println(numX - numY); // Será exibido: 8
System.out.println(numX * numY); // Será exibido: 58548
System.out.println(numX / numY); // Será exibido: 1.0336
System.out.println(numX % numY); // Será exibido: 8
System.out.println(++numX); // Será exibido: 247
System.out.println(numX++); // Será exibido: 246, ele apenas acrescenta 1 na próxima instrução do código
System.out.println(--numX); // Será exibido: 245
System.out.println(numX--); // Será exibido: 246, ele apenas decrementa 1 na próxima instrução do código
Operadores de atribuição
Os operadores de atribuição são usados para atribuir valores a variáveis.
Atribuir valor a uma variável ( = )
Abaixo será atribuido o valor 172 para a variável chamada numX.
int numX = 172;
Atribuição de adição ( += )
Os operadores de adição são usados para adicionar valores a variáveis.
int numX = 219;
numX += 19;
// O valor de x agora será de 238
Atribuição de subtração ( -= )
Os operadores de subtração são usados para subtrair valores a variáveis.
int numX = 374;
numX -= 128;
// O valor de x agora será de 246
Atribuição de multiplicação ( *= )
Os operadores de multiplicação são usados para multiplicar valores a variáveis.
int numX = 444;
numX *= 123;
// O valor de x agora será de 54612
Atribuição de divisão ( /= )
Os operadores de divisão são usados para dividir valores a variáveis.
int numX = 102;
numX /= 135;
// O valor de x agora será de 0.7556
Atribuição de módulo ( %= )
Os operadores de módulo são usados para retornar o módulo da divisão dos valores a variáveis.
int numX = 403;
numX %= 404;
// O valor de x agora será de 403
Outros tipos de atribuição
int numX = 235;
numX &= 6; // O valor de x agora será de 2
numX |= 336; // O valor de x agora será de 507
numX ^= 183; // O valor de x agora será de 92
Operadores de comparação
Os operadores de comparação são usados para comparar dois valores.
Igual ( == )x == y
Em Java é recomendado usar as funções equals() ou equalsignorecase() para fazer comparação entre Strings.
Função equalsCompara se as duas variáveis são iguais, diferenciando letras maiúsculas de minúsculas.
Função equalsignorecaseCompara se as duas variáveis são iguais, letras maiúsculas e minúsculas indiferem.
String user1 = "maria", user2 = "maria";
System.out.println(user1.equals(user2));
// Será exibido: true
System.out.println(user1.equalsignorecase(user2));
// Será exibido: true
Diferente ( != )x != y
Maior que ( > )x > y
Menor que ( < )x < y
Maior ou igual que ( >= )x >= y
Menor ou igual que ( <= )x <= y
int numX = 5, numY = 10;
System.out.println(numX == numY);
// Será exibido: false, pois 5 é diferente de 10
System.out.println(numX == numY);
// Será exibido: false, pois 5 é diferente de 10
System.out.println(numX != numY);
// Será exibido: true, pois 5 é diferente de 10
System.out.println(numX > numY);
// Será exibido: false, pois 5 não é maior que 10
System.out.println(numX < numY);
// Será exibido: true, pois 5 é menor que 10
System.out.println(numX >= numY);
// Será exibido: false, pois 5 não é nem maior, nem igual a 10
System.out.println(numX <= numY);
// Será exibido: true, pois 5 é menor ou igual a 10
Operadores lógicos
Os operadores lógicos são usados para determinar a lógica entre variáveis ou valores.
and ( && )Retorna true se ambas declarações forem verdadeiras
or ( || )Retorna true se uma das declarações forem verdadeiras
not ( ! )Reverte o resultado, retorna false se o resultado for true
int numX = 10, numY = 1, numZ = 4;
boolean resultado;
resultado = (numX > numY && numX > numZ);
// Será exibido: true, pois 10 é maior que 1 e 10 também é maior que 4
resultado = (numX <= numY && numY >= numZ);
// Será exibido: false, pois 10 não é menor ou igual a 1 e 1 não é maior ou igual a 4
resultado = (numX == numY || numY != numZ);
// Será exibido: true, pois 1 é diferente que 4, porém 10 não é igual a 1
resultado = (numX > numZ || numY <= numX);
// Será exibido: true, pois 10 é maior que 4 e 1 é menor ou igual a 10
resultado = !(numX > numZ);
// Será exibido: false
resultado = !(numX != numY);
// Será exibido: false
Matemática
Math.max(var1, var2)
Método matemático para encontrar o maior valor entre var1 e var2.
Math.max(225, 36);
// Será exibido: 225
Math.min(var1, var2)
Método matemático para encontrar o menor valor entre var1 e var2.
Math.min(7, 127);
// Será exibido: 7
Math.sqrt(var)
Método matemático que retorna a raiz quadrada de var.
Math.sqrt(108);
// Será exibido: 10.3923
Math.abs(var)
Método matemático que retorna o valor absoluto (positivo) de var.
Math.abs(-304);
// Será exibido: 304
Math.random()
Método matemático que retorna um número aleatório entre 0.0 e 1.0.
Para obter mais controle sobre o número aleatório, por exemplo, você deseja apenas um número aleatório entre 0 e 541, você pode usar a fórmula abaixo.
int numAleatorio = (int)(Math.random() * 542);
// Será armazenado na variável numAleatorio um número entre 0 até 541
Essas funções matemáticas citadas são as principais, quer ver a lista completa? clique aqui.
Condição if
Use a instrução if para especificar um bloco de código Java a ser executado se uma condição for true.
if (condição verdadeira)
{
// Bloco de código a ser executado caso a condição == true
}
Verifique que if está em letras minúsculas. Letras maiúsculas (If ou IF) gerarão erro.
Abaixo está um exemplo com a condição if onde verifica se 66 > 46, e caso seja verdadeiro executa o código.
if (66 > 46)
{
// Código será executado, pois a condição é true
}
int x = 87
int y = 67
if (x > y)
{
System.out.println("X é maior que Y");
}
// Será exibido: X é maior que Y
Condição else if e else
Use a instrução else if para especificar uma nova condição se a primeira condição (if) for false.
Use a instrução else para fazer determinado bloco de código caso nenhuma condição for verdadeira.
if (condição verdadeira)
{
// Caso a condição for verdadeira (true), vai entrar aqui mas não vai entrar no else if e nem no else
}
else if (outra condição for verdadeira)
{
// Caso essa outra condição for verdadeira vai entrar aqui, mas não vai entrar no if e nem no else
}
else
{
// Caso nenhuma condição for verdadeira, só vai entrar aqui
}
int idade = 21;
if (idade < 18)
{
System.out.println("Sou menor de idade.");
}
else if (idade < 110)
{
System.out.println("Sou adulto, e estou vivo.");
}
else
{
System.out.println("Provavelmente estou morto, mas o conhecimento que passo nesse site é permanente.");
}
// Será exibido: Sou adulto, e estou vivo.
Operador Ternário (if/else)
Há também uma abreviação if else, que é conhecida como operador ternário porque consiste em três operandos. Ele pode ser usado para substituir várias linhas de código por uma única linha e é mais frequentemente usado para substituir instruções if else simples.
variavel = (condição) ? casoVerdade : casoFalso;
int idade = 21;
String resultado = (idade < 18) ? "Sou menor de idade." : "Sou adulto, e estou vivo (talvez).";
System.out.println(resultado);
// Será exibido: Sou adulto, e estou vivo (talvez).
switch
Use a instrução switch quando for necessário muitos blocos de código a serem executados, muitas vezes é possível utilizar no lugar de if/else if e else.
A expressão switch é avaliada uma vez. O valor da expressão é comparado com os valores de cada case. Se houver uma correspondência, o bloco de código associado será executado. As palavras-chave break e default são opcionais.
switch (expressão)
{
case x:
// Bloco de código a ser executado
break;
case y:
// Bloco de código a ser executado
break;
default:
// Bloco de código a ser executado
}
A palavra-chave break é usada para sair do bloco switch, é necessário usar ela para sair do bloco. Caso não seja adicionado o break, ele vai testar todos os casos até o final do switch e assim ocasionando um resultado diferente do esperado. O default tem a mesma função do else, caso nenhum dos casos seja verdadeiro ele vai entrar no default e executar o bloco de código e depois sair do switch.
String linguagem = "Rust";
switch (linguagem)
{
case "Java":
System.out.println("Java é a linguagem escolhida! =D");
break;
case "C++":
System.out.println("C++ é a linguagem escolhida, boa sorte com ponteiros! =P");
break;
case "Rust":
System.out.println("Rust é a linguagem escolhida, sem ponteiros mas diferente! o.O");
break;
case "PHP":
System.out.println("PHP é a linguagem escolhida, esse site foi feito com essa linguagem. \o/");
break;
case "Python":
System.out.println("easy-peasy, lemon squeezy! u.u");
break;
default:
System.out.println("A linguagem escolhida não está aqui.");
break;
}
// Será exibido: Rust é a linguagem escolhida, sem ponteiros mas diferente! o.O
while
O loop while percorre um bloco de código desde que uma condição especificada seja true. É recomendado utilizar while apenas em casos onde não se sabe quantas vezes será feito repetições ou quanto tempo vai durar. Sabe quantas repetições serão feitas? use o for que será visto mais abaixo.
while (condição)
{
// Bloco de código a ser executado
}
// EXEMPLO \\
int i = 1;
boolean vivo = true;
while (vivo)
{
if (i <= 110)
{
System.out.println("Tenho " + i + " anos, minha vida está de boas.");
i += 21;
}
else
{
System.out.println("Meu tempo acabou, mas meu conhecimento compartilhado não.");
vivo = false;
}
}
// Tenho 1 anos, minha vida está de boas.
// Tenho 22 anos, minha vida está de boas.
// Tenho 43 anos, minha vida está de boas.
// Tenho 64 anos, minha vida está de boas.
// Tenho 85 anos, minha vida está de boas.
// Tenho 106 anos, minha vida está de boas.
// Meu tempo acabou, mas meu conhecimento compartilhado não.
do while
O loop do while é uma variante do loop while. Este loop executará o bloco de código uma vez, antes de verificar se a condição é verdadeira, então repetirá o loop enquanto a condição for verdadeira.
do
{
// Bloco de código a ser executado
}
while (condição);
// EXEMPLO \\
int i = 1;
boolean vivo = true;
do
{
if (i <= 110)
{
System.out.println("Tenho " + i + " anos, minha vida está de boas.");
i += 23;
}
else
{
System.out.println("Meu tempo acabou, mas meu conhecimento compartilhado não.");
vivo = false;
}
}
while (vivo);
// Tenho 1 anos, minha vida está de boas.
// Tenho 24 anos, minha vida está de boas.
// Tenho 47 anos, minha vida está de boas.
// Tenho 70 anos, minha vida está de boas.
// Tenho 93 anos, minha vida está de boas.
// Meu tempo acabou, mas meu conhecimento compartilhado não.
for
Como foi dito anterirmente na sessão do while, quando você souber exatamente quantas vezes deseja percorrer um bloco de código, use o loop for em vez de um loop while.
for (instrução1; instrução2; instrução3)
{
// Bloco de código a ser executado
}
instrução1 é executada (apenas uma vez) antes da execução do bloco de código.
instrução2 define a condição para executar o bloco de código.
instrução3 é executada (todas as vezes) após a execução do bloco de código.
for (int i = 0; i < 9; i++)
{
System.out.println(i);
}
// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
A instrução1 define uma variável antes do início do loop (int i = 0).
A instrução2 define a condição para a execução do loop (i deve ser menor que 9). Se a condição for verdadeira, o loop começará novamente, se for falso, o loop terminará.
A instrução3 aumenta um valor (i++) cada vez que o bloco de código no loop é executado.
for (int i = 0; i < 16; i = i + 3)
{
System.out.println(i);
}
// 0
// 3
// 6
// 9
// 12
// 15
for-each
Além do for, existe o loop "for-each" que é usado exclusivamente para percorrer elementos em um array.
for (tipoPrimitivo nomeVariavel : nomeArray)
{
// Bloco de código a ser executado
}
// EXEMPLO \\
String[] linguagens = {"Java", "PHP", "C++", "Rust", "Python"};
for (String linguagem : linguagens)
{
System.out.println(linguagem);
}
// Java
// PHP
// C++
// Rust
// Python
break
Você viu o break sendo usado quando foi falado sobre o switch, além do switch o break pode ser usado para sair de um loop.
for (int i = 0; i < 13; i++)
{
if (i == 5)
{
break;
}
System.out.println(i);
}
// 0
// 1
// 2
// 3
// 4
continue
A instrução continue interrompe uma iteração (no loop), caso ocorra uma condição especificada, e continua com a próxima iteração no loop.
for (int i = 0; i < 8; i++)
{
if (i == 7)
{
continue;
}
System.out.println(i);
}
// 0
// 1
// 2
// 3
// 4
// 5
// 6
Além do loop for, é possível usar as palavras-chaves break e continue dentro de loops while também.
Se você chegou até aqui e entendeu tudo, então você sabe o básico de programação. Não entendeu? pratique muito e pense sempre fora da caixa. Isso é programação, resolver problemas e pensar muito em soluções para problemas. Você gosta de desafios? então talvez isso seja pra você.
CREDITOS : Eduardo Buzzi • Dev Full Stack
