Java Básico - BeatrizMaryah/Notes Wiki

Java Básico

Java é uma linguagem de programação e plataforma computacional lançada pela primeira vez pela Sun Microsystems em 1995, sendo posteriormente adquirido pela Oracle. Suas características são herdadas do C e C++ e ganhou destaque pelo seu surgimento WEB. O Java ganhou respeito a partir da versão 1.3 e 1.4 e foi adquirida pela Oracle em 2009. Pode ser utilizado para desenvolvimento de aplicações Desktop, mobile e Web. É uma linguagem fortemente tipada e case-sensitive. Possui um garbage collection e é orientada a objetos.

⚙️ Processo de Compilação

A característica que mais deixou o Java conhecido é sua “Independência de plataforma”, que possibilita escrever o código apenas uma vez e rodá-lo em diferentes dispositivos. Essa característica é possível devido ao processo de compilação do Java, que é um pouco diferente que as outras linguagens.

CompilacaoJava

A magia é feita através de um emulador conhecido como a Máquina Virtual Java ou JVM (Java Virtual Machine) que irá ler e executar os bytecodes do Java. Porém, quando criamos uma classe java, ela é salva na extensão .java que a JVM não consegue ler.

Para passar o arquivo de uma extensão .java para bytecode, ele precisa ser compilado, quem é responsável por isso é o compilador java chamado JavaC. Ele basicamente transfere a linguagem de programação salva no .java para binário. Porém o compilador java não gera um binário específico para cada plataforma, mas é gerado um binário que pode ser executado em qualquer plataforma, este binário "universal" é chamado de bytecode.

Assim, qualquer computador com uma JVM irá rodar o programa sem problemas, pois a JVM irá ler diretamente esse bytecode universal, possibilitando que o programa seja compilado apenas uma vez.

💻 Instalação e Configuração do Java

Primeiramente, devemos instalar o Java Development Kit (JDK) que provê ferramentas para o desenvolvimento de programas Java. Ele contém um compilador, um depurador e o próprio JRE (que provê os requisitos mínimos para executar um programa java, inclusive a JVM) para você executar os seus programas. Para isso clique no link aqui para ir para o site da Oracle.

Para sistemas x64 é recomendado baixar a versão 11 do Java que é uma das mais estáveis. Caso seu sistema seja x32, instale a versão 8 que irá rodar sem problemas. Para saber qual a versão do seu computador, digite "meu computador" no inicar, clique com o botão direito e vá em propriedades.

Baixe o executável (.exe) e execute, pode dar next e confirmar. Após o download estar pronto, iremos configurar as variáveis de ambiente. Primeiro você vai no explorador de arquivos na pasta do seu disco local (C:), vá para arquivos de programas, vá para a pasta do Java e clique na versão que você baixou. Depois de estar dentro da pasta, copie o caminho até ela.

No menu inicial você irá digitar Sistema, clicar em configurações Avançadas do sistema, vá em Avançado e em Variáveis do ambiente. Na primeira opção, em Variáveis de usuário, clique em Novo e escreva em Nome da variável "JAVA_HOME" e copie o caminho que você colou em Valor da variável e clique em OK.

Voltando na pasta que está a versão que instalamos, você irá clicar em Bin e copiar o caminho novamente. Ainda em Variáveis de ambiente, mas na opcão de baixo em Variáveis do sistema, você irá procurar a variável Path e clicar em editar, após isso clique em Novo, cole o caminho e de OK.

Para testar se tudo está funcionando, temos que abrir o CMD (prompt de comando) e escrever java -version ou java --version. Se aparecer a versão que você baixou, está tudo certo.

💻 Instalação do Eclipse

Para baixar o eclipse, clique no link aqui e clique em Download. Após o download ser feito, clique em Eclipse IDE for Enterprise Java and Web Developers. Após isso clique em download e está feito!

💻 Iniciando

Para começarmos a aprender os conteúdos a seguir, primeiro vamos aprender os primeiros passos de um programa. Primeiramente, no eclipse, vamos criar um novo projeto. Um projeto é onde estarão todos os seus arquivos e códigos. Para isso, vá no seguinte botão e aperte em Project.

Depois disso, clique em Java Project e em Next. Após isso, informe o nome que você quer dar para o seu projeto em Project Name e clique em Finish. Clique em Don't Create na janela que irá aparecer e com isso, nosso projeto está criado.

Depois disso, você irá clicar no seu projeto para abri-lo. Irá aparecer duas coisas, uma pasta src onde estará todo o nosso código e uma pasta JRE System Library, onde estarão todos os elementos necessários para o java funcionar, como o compilador. Clicando com o botão direito na pasta src, e indo em new, podemos criar novos elementos. Nesse momento, iremos criar um pacote, que é uma forma de deixar o projeto organizado, como pastas com arquivos.

Após isso, de o nome ao seu pacote e clique em Finish. Depois de criar um pacote, iremos criar uma classe no mesmo caminho, porém clicando no Class. Uma classe é o arquivo que guardará o código em si, ou seja, sempre que quisermos fazer um código, teremos que criar uma classe.

Iremos abordar mais assuntos da classe após a programação orientada a objetos, por enquanto, iremos colocar todo o código no método main da nossa classe. O método main é o ponto de partida do seu programa, ou seja, se você tiver mais classes, quem irá ser responsável por iniciar e gerenciar o programa é o main. O main é composto pelos seguintes elementos:

public static void main(String[] args) {
	System.out.print("Exemplo de código") //Irá imprimir na tela: Exemplo de código	
}

Para rodar nosso programa, iremos clicar no botão .

É importante saber, que no java, temos algumas convenções em relação a nomeação dos elementos. Em geral, não usamos acentos, cedilha (Ç), e símbolos em si nos nomes quando estamos programando, apenas quando mostramos algo na tela. Nossos pacotes serão todos com letras minúsculas e a separação de níveis será feita com um ponto (.). Nossas classes sempre terão a primeira letra maiúscula.

🗃️ Variáveis

Uma variável é um recurso das linguagens de programação utilizado para armazenar valores em memória. Assim, sempre que precisarmos desse valor, basta referenciarmos essa variável. Nossas variáveis são como caixas, onde nomeamos que tipo de coisa ela irá guardar e depois podemos facilmente pegar o que está guardado para utilizar.

O Java é uma linguagem fortemente tipada, ou seja, seus tipos precisam ser bem definidos e precisam ser informados no momento de sua criação. Além disso, podemos declarar variáveis, variáveis finais e constantes. As variáveis podem ter seu valor modificado a qualquer momento, enquanto as variáveis finais e constantes recebem um valor e não podem ser alteradas.

Tipos Primitivos

Além dos tipos primitivos, existem os tipos por referência, que são classes que especificam os tipos de objeto Strings, Arrays Primitivos e Objetos. String armazena um texto, pode-se dizer que ele é uma "lista" de chars. Os demais veremos depois.

Para declararmos uma variável em java, precisamos informar o tipo de dados que ela poderá receber e seu nome. Por exemplo:

int numero;
String nome = "Maria";
float numeroReal = 9.2;
boolean isValid = true;

Neste código informamos que a variável numero é do tipo inteiro e, por isso, só poderá receber valores desse tipo. No caso da variável nome, já iniciamos ela atribuindo um valor "Maria" com o sinal de =. Quando lidamos com valores com vírgula no Java, utilizamos o . no lugar dela.

Em relação a nomeação das variáveis: elas podem conter letras, números e o caractere sublinhado (_), mas não pode começar com um número. Devem ser declaradas em minúsculo, caso sejam nomes compostos, a primeira letra de todas as palavras, menos da primeira, deve ser maiúscula. É importante destacar que Java é uma linguagem case sensitive, ou seja, o nome numeroUm é diferente de numeroum. Além disso, os nomes tem que fazer sentido para que o seu programa seja mais legível. Por exemplo, não faz sentido que uma variável que vá guardar um nome tenha o nome de abacaxi, pois esse "abacaxi" não indica nada para o programador.

Como dito anteriormente, as variáveis finais são declaradas quando precisamos lidar com dados que não devem ser alterados durante a execução do programa. No Java declaramos uma variável final utilizando a palavra-chave final antes do tipo da variável. No caso das constantes, seu conceito é melhor entendido após o POO. Para declarar uma constante uitilizamos as palavras-chave static final antes do tipo da variável. Quando nomeamos uma constante, utilizamos apenas letras maíusculas e um caractere sublinhado (_) para os espaços.

💻 Scanner

No Java, não existe uma função padrão para ler uma entrada de dados diretamente pelo teclado. A partir do Java 1.5, foi disponibilizada a classe Scanner que tem exatamente esse papel. É importante destacar que a saída de dados do Scanner é totalmente em console, em linhas de texto. Para utilizarmos a classe Scanner, precisamos primeiramente importá-la com o seguinte comando:

import java.util.Scanner;

É importante destacar que esse import ficará acima da declaração da classe que você está fazendo! Após isso, precisamos criar e instânciar nosso Scanner para ser utilizado, como uma variável.

Scanner leitor = new Scanner (System.in);

Nesse caso, o nome que dei ao Scanner é leitor e é o que utilizarei nos exemplos seguintes. Porém, você pode chamar como preferir, seja ler, scr, read, etc. Também é comum instânciar o Scanner logo abaixo do método main.

Usamos o scanner para chamar um método para ler o teclado e atribuir esse valor a uma variável. Normamente utilizamos o scanner abaixo de um System.out.print() que pede ao usuario alguma informação, por exemplo um "Informe seu Nome:" ou "Qual é seu nome?".

System.out.print("Qual é o seu nome?");
String nome = sc.nextLine();

No exemplo acima, o programa perguntará qual o nome da pessoa, a pessoa irá digitar no teclado e dar enter. Esse valor digitado irá ser atribuido na variável nome.

Métodos

Os métodos do Scanner variam de acordo com o tipo de dado que eu quero ler e atribuir a uma variável.

float numFloat = sc.nextFloat();
int numInt = sc.nextInt();
byte numByte = sc.nextByte();
long numLong = sc.nextLong();
boolean isValid = sc.nextBoolean();
double numDouble = sc.nextDouble();
String texto = sc.nextLine();

O Scanner também tem outros métodos importantes, como o método close() que fecha o escaneamento de leitura, como se ele apagasse o Scanner quando ele não é mais necessário.

💻 JOptionPane

O JOptionPane é uma classe do pacote visual Swing e é a forma mais simples de ter uma programação mais visual no Java. Ele nos proporciona uma série de métodos estáticos que ao serem invocados criam caixas de diálogos simples e objetivas. Para usá-lo, devemos primeiramente importar o seu pacote com o seguinte comando:

import javax.swing.JOptionPane;

Existem alguns comandos que invocam caixinhas específicas, agora vamos falar um pouco sobre cada uma delas.

Caixa de Diálogo Input

Essa caixinha serve para fazer uma requisição de algum dado ao usuário de forma bem simples e direta. O que é digitado é retornado em formato de String. Além disso, a caixa conta com opções de OK, CANCEL e o X que faz o mesmo que cancelar.

caixaInput

Para chamar essa caixinha, chamamos o comando e a mensagem que queremos que aparece colocamos entre os parênteses. Essa mensagem podemos passar como uma String direto ou como uma variável String. Além disso, como no Scanner, podemos usar essa caixinha para atribuir um valor a uma variável.

String nome = JOptionPane.showInputDialog("Qual o seu nome?");
Caixa de Diálogo Confirm

Essa é uma caixa de confirmação com as opções, que consiste de uma caixa contendo uma mensagem, um ícone e três botões: sim, não e cancelar. Essa caixa pode ser facilmente configurada.

image

Esse método sempre retorna uma constante referente a opção que o usuário clicou. Caso ele clique em YES, retornará 0, caso ele clique em NO retornará 1 e caso ele clique em CANCEL retornará 2. Também é possível armazenar esse valor retornado em uma variável para poder alterar o fluxo do programa dependendo da opção que o usuário escreveu, seja com ifs ou o próprio switch case.

int opcao = JOptionPane.showConfirmDialog(null, "O seu nome é Fulano?");

Quando chamamos o método padrão, usamos dois argumentos. O primeiro sinaliza de qual janela esta confirmação está sendo gerada e por enquanto sempre usaremos null nesse argumento. O segundo argumento é a mensagem que desejamos mostrar ao usuário.

Caixa de Diálogo de Mensagem

A caixa de diálogo de mensagem é uma caixa que serve apenas para emitir uma mensagem. Esta caixa também é muito configurável e versátil, pois serve para muitas situações distintas como uma mensagem de erro, um alerta, ou simplesmente uma informação. Essa caixa apenas contém uma mensagem e um botão de OK.

image

Como a caixa de Confirm, essa caixa padrão também tem os dois argumentos, sendo o que iremos usar o null e a mensagem em si. Esse método não usamos para atribuir valores, ele é mais como um System.out.print().

JOptionPane.showMessageDialog(null, "Seu nome é Fulano");

Aqui está um pequeno exemplo da utilização de todos as caixas comentadas acima:

  String nome = null;
  int resposta;
  nome = JOptionPane.showInputDialog("Qual é o seu nome?"); //Pergunta o nome
  resposta = JOptionPane.showConfirmDialog(null, "O seu nome é " + nome + "?"); //Pede para confirmar o nome
  
   if (resposta == JOptionPane.YES_OPTION) { // verifica se o usuário clicou no botão YES
       JOptionPane.showMessageDialog(null, "Seu nome é " + nome); //Clicou no yes
   } else {
        JOptionPane.showMessageDialog(null, "Seu nome não é " + nome); //Não clicou no yes
   }
Caixa de Diálogo com opções

Também é possível fazer uma caixa de diálogo com opções personalizadas, onde você precisará criar um vetor de String com as opções e usá-las no comando:

String[] opcoes = { "Opção 1", "Opção 2", "Opção 3" };
		int opcao = JOptionPane.showOptionDialog(null, "Mensagem Central", "Sub",
				JOptionPane.DEFAULT_OPTION, JOptionPane.INFORMATION_MESSAGE, null, opcoes, opcoes[0]);

Essa caixa é totalmente customizável e retorna constantes igual a caixa de confirmação. O número que retornará será referente a qual posição o elemento está no vetor. Nesse caso, a Opção 1 retornará 0, a Opção 2 retornará 1 e assim por diante. A caixa terá essa aparência:

image

Customizações

Além disso, como dito anteriormente, algumas caixas são customizáveis. Nós podemos mudar o que vem escrito em cima dela e até mudar o ícone para um ícone de erro entre outros. Para customizar uma caixinha, vamos adicionar mais alguns argumentos aos métodos. Vou usar de exemplo uma caixa de mensagem.

JOptionPane.showMessageDialog(null, "Mensagem central", "Sub Mensagem", JOptionPane.[tipo do ícone])

A mensagem central será a mensagem que irá aparecer como as anteriores. A sub-mensagem irá aparecer em cima da caixinha. O tipo do ícone será referente a qual ícone aparecera na mensagem. No tipo de ícone temos: o INFORMATION_MESSAGE para informações, que terá um ícone de i, o WARNING_MESSAGE para avisos, que terá um ! e o ERROR_MESSAGE para erros, que terá um x.

💻 Operadores Aritméticos e de Igualdade

Para comparar se um valor é igual ao outro, utilizamos o operador de igual ==. Agora quando queremos comparar se um valor é diferente de outro, utilizamos o operador diferente !=. Para realizarmos contas no Java, usamos alguns operadores aritméticos que funcionam como na vida real.

operadoresAritmeticos

Os primeiros operadores a serem executados sempre serão os de multiplicação, divisão e resto de divisão. Depois disso são executados os de soma e subtração e só ai o de atribuição(=). Para definir uma ordem de precedência(execução), usamos os parênteses().

Operadores Relacionais

São utilizados para formar condições, que iremos usar nos métodos if depois. Essas condições expressam valores booleanos, ou seja, que podem ser verdadeiras o falsas.

operadoresRelacionais

Por exemplo, se eu formo a condição 14 > 20 retornará falso, pois 14 não é maior que 20.

Operadores Lógicos

São usados com os operadores relacionais para comparar mais de uma condição. Também retornam valores booleanos.

💻 Estruturas de Controle

Estruturas de Controle de decisão são instruções em linguagem Java que permitem que blocos específicos de código sejam escolhidos para serem executados, redirecionando determinadas partes do fluxo do programa. Essa é a primeira estrutura que irá mudar o fluxo do código, não lendo o código por inteiro que nem antes.

Declaração If

A declaração if específica que uma instrução ou bloco de instruções seja executado e se, somente se, uma expressão lógica for verdadeira.

if(condição)
  instrução

Ou

If(condição){
  bloco de instruções;
  ...
}

Também temos o chamado IF ternário. Onde caso ela seja verdadeira, o código 1, declarado após o ponto de interrogação ? será executado; do contrário, o programa irá executar o código 2, declarado após os dois pontos :.

(expressão booleana) ? código 1 : código 2;
If-Else

A declaração Else vem acompanhada da declaração If. Este cascateamento de estruturas permite ter decisões lógicas muito mais complexas. Pode ter várias estruturas else-if depois de uma declaração if. A estrutura else é opcional e pode ser omitida Essa declaração possui a seguinte forma:

if(condição){
  intrução 1;
} else {
  intrução 2;
}

Nesse exemplo, se a condição for verdadeira, ele entra no if executa a instrução 1. Se não for verdadeira, o programa executa a instrução 2.

ifElse

Switch-Case

O Switch Case é uma estrutura de controle apenas para comparar se uma variável é igual a determinados valores. Ele serve para que não precisemos fazer uma cadeia gigante de ifs para determinar o que executar dependendo do valor da variável. Ele é muito mais legível e permite que uma variável tenha múltiplas possibilidades de execução.

switch(variavel){
  case valor1:
     intrucao1;
     ...
     break;
  case valor2:
     instrução2;
     ...
     break;
  default: 
     instrução3;
     ...
     break;
}

Nesse exemplo, ele verifica qual o valor da variável. Se for o valor1, executa a primeira instrução, se for o valor 2, executa a segunda instrução. Se não for nenhum dos valores anteriores, ele cai no default (padrão) e executa o código lá. O comando break é utilizado para sair de uma estrutura, ele pode ser usado em estruturas de repetição também.

switchCase

💻 Estruturas de Repetição

Estruturas de repetição permitem executar mais de uma vez um mesmo trecho de código. Trata-se de uma forma de executar blocos de comandos somente sob determinadas condições, mas com a opção de repetir o mesmo bloco quantas vezes for necessário. As estruturas de repetição são úteis, por exemplo, para repetir uma série de operações semelhantes que são executadas para todos os elementos de uma lista ou de uma tabela de dados, ou simplesmente para repetir um mesmo processamento até que uma certa condição seja satisfeita.

While

O while é a estrutura de repetição mais simples. Ele repete a execução de um bloco desentenças enquanto uma condição permanecer verdadeira. Na primeira vez que a condição se tornar falsa, o while não repetirá a execução do bloco.

while(expressao){
  instrução;
  ...
}

Normalmente usamos o while quando não sabemos quantas vezes o bloco de código terá que ser executado.

Do While

É semelhante ao while, porém a condição é verificada após executar o bloco de instruções correspondente. Isso faz com que o bloco de código seja executado no mínimo uma vez.

do {
  instrução;
  ...
} while(expressao);

A diferenças entre a estrutura while e do while é sutil e depende do programador qual ele irá usar

while

For

O for é uma estrutura de repetição contadora. Utilizamos ele quando sabemos previamente quantas vezes o bloco de código terá que ser executado. A contagem do for é feita através de uma variável própria que comumente chamamos de i.

for ([expressão 1]; [condição]; [expressão 2]){
   instrução
}

Primeiro temos que definir um valor pra essa variável, este é o papel da expressão 1. Depois, iremos definir uma condição que irá dizer até onde esse for irá contar. Então, temos que sinalizar como sera a incrementação, ou seja, se ele irá contar de um em um ou se irá contar em ordem regressiva por exemplo. Esse é o papel da expressão 2. Exemplo:

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

Nesse exemplo, o for irá executar 5 vezes. Isso acontece pois definimos o valor da nossa variável como 0 e que ela terá que ser menor que 5, ou seja, irá até 4. Depois disso, sinalizamos que ela irá incrementar um por um com o comando i++. Executando esse código, irá imprimir na tela os números 0, 1, 2, 3 e 4.

💻 Vetores

Vetores são estruturas de dados que armazenam uma quantidade fixa de dados de um certo tipo. Internamente, um vetor armazena diversos valores, cada um associado a um número que se refere à posição de armazenamento, e é conhecido como índice.

O número de posições de um vetor corresponde ao tamanho que ele tem, ou seja, um vetor de tamanho 10 pode armazenar 10 elementos. No Java o vetor é zero-based, isto é, as posições do vetor iniciam a numeração a partir do valor 0. Portanto, um vetor de tamanho 10 teria índices iniciados em 0 prosseguindo até o 9.

int vetor[] = new int[tamanho];

Para declararmos um vetor, é semelhante a uma variável normal, com seu tipo e seu nome, porém com um []. Porém, apenas declarando um vetor ele não está pronto para ser usado. Utilizando o new int[10] criamos uma instância desse vetor na memória e assim podemos guardar os elementos. Utilizasse o new pois no Java, um vetor é uma classe. O tamanho do vetor será conhecido através do campo length, normalmente usados nas condições do for.

Para atribuirmos valores aos vetores após serem instânciados, utilizamos o [] com o índice do espaço que queremos guardar e o = com um valor.

vetor[3] = 10;

No exemplo, um vetor na posição 3, irá guardar o valor 10.

String nome[] = {"Maria", "José", "Ronaldo"};

Podemos ter vetores de vários tipos, e também podemos inicializar o vetor e atribuir valores a eles ao mesmo tempo com as chaves {}. No exemplo acima, temos um vetor de String que guardam os valores Maria, José e Ronaldo. Dessa forma não é necessário indicar o tamanho do vetor e também fazer a alocação de espaço através do operador new.

Existem alguns métodos na classe Math do java que podem ser utilizados com os vetores. Por exemplo o random() que retorna um valor aleatório dos valores que estão no vetor.

For each

O For Each é um for criado para percorrer os elementos de um vetor sem utilizar um contador estruturado. Ele é mais legível e simples de entender. Ele aloca um membro do vetor no parâmetro por vez e executa a instrução, até o último elemento.

for (parâmetro: nomeDoVetor) {
   instrução;
}

💻 Matrizes

No java, temos como criar um vetor de vetores. Chamamos isso de vetores multidimensionais ou matrizes. Segue a mesma linha de raciocínio que as matrizes na matemática, onde temos linhas e colunas. Levam a mesma regra dos vetores de começar em 0 e sua diferença é o uso de dois [][].

int matriz[][] = new int[2][4];

No exemplo acima, criamos um vetor com 2 linhas e 4 colunas. Sendo assim, sabe-se que o primeiro colchete representa o número de linhas e o segundo representa o número de colunas.

Matriz

Podemos ver como funcionam as posições na matriz. Por exemplo, na posição m[0][2] temos um elemento na primeira linha e na terceira coluna. Além disso, também podemos inicializar e atribuir valores ao mesmo tempo, como nos vetores.

int matriz[][] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

Nessa sintaxe, as {} separam as linhas, ou seja, com três {} teremos três linhas. Os valores separados pela , são os valores que estarão alocados nessa linha e na coluna que ele está na ordem. Sendo assim nossa matriz ficará mais ou menos assim:

Martiz01

Trazendo isso para as nossas posições nos [], temos esse cenário:

// 1ª linha:
 m[0][0] = 1;
 m[0][1] = 2;
 m[0][2] = 3;
 // 2ª linha:
 m[1][0] = 4;
 m[1][1] = 5;
 m[1][2] = 6;
 // 3ª linha:
 m[2][0] = 7;
 m[2][1] = 8;
 m[2][2] = 9;

Quando trabalhamos com matrizes, precisamos utilizar dois for. Isso acontece pois precisamos percorrer pelas linhas e pelas colunas, usando respectivamente o i e o j. Além disso, as condições do for ficam um pouco diferentes. O primeiro for usa apenas o m.lenght, que irá retornar o número de linhas da matriz. O segundo for usaremos o m[i].lenght que irá retornar o número de colunas da i-ésima linha. Por exemplo:

 for (i=0; i<m.length; i++) {
    System.out.printf("linha: ", (i+1)); //Mostra em que linha está
    for (j=0; j<m[i].length; j++) {
       System.out.printf("valor", m[i][j]); //Imprime o valor alocado na linha i + coluna j.
    }
    System.out.printf("\n"); //Pula a linha
 }

💻 Sub-rotinas

Sub-rotinas são trechos de códigos que podem ser reutilizados. Elas são muito úteis quando um trecho de código, exatamente igual, se repete diversas vezes ao longo do programa. Ela é isolada do código principal e é chamada por um comando específico para ser usada novamente. Dessa forma, você só escreve o trecho que se repete uma vez, e quando precisar dele, é só chamá-lo.

Essas sub-rotinas ficam separadas do método main e são divididas em dois tipos: Funções e Procedimentos.

Para declarar uma rotina, você precisa obrigatoriamente colocar a palavra resevada static, informar o tipo de retorno (no caso dos procedimentos será void), o nome da sub-rotina e por fim, seus parâmetros entre parenteses se necessários.

public static [tipo de retorno] [nome da subrotina]([parâmetros]){
    instrução;
    ...
}

Os parâmetros de uma sub-rotina são variáveis com informações que ela precisa pra funcionar. Eles nem sempre são necessários e devem ser informados entre os () com seu tipo e nome. Esses parâmetros basicamente indicam que quando essa sub-rotina for chamada, teremos que passar alguma informação para ele e os parâmetros que irão guardar essas informações. Por exemplo:

public static int somaDoisNumeros(int numero1, int numero2) {
    int soma = numero1 + numero2;
    return soma;
}

Nesse exemplo, temos uma função que irá receber dois números, somá-los e retornar esse resultado. Para chamar essa sub-rotina, usamos o nome dela e informamos os valores que irão ir para os parâmetros. Como o exemplo acima é uma função que retornará um valor, podemos usar essa sub-rotina como atribuição de valor de outra variável, como no exemplo a seguir:

int resultado = somaDoisNumeros(3, 4);

Nesse caso, eu passei o número 3 e o número 4 para serem somados. Considerando isso, o valor retornado será 7 e consequentemente, a variável resultado irá guardar esse valor retornado. É importante destacar que, quando eu estou chamando a sub-rotina, os valores que eu estou passando para os parâmetros são chamados de argumentos. Os argumentos e os parâmetros devem ser do mesmo tipo para funcionar.

🐛 Debugar

Também chamado de debugging ou, em português, depuração, é o nome dado ao processo de encontrar e remover os erros. O termo faz parte do processo de desenvolvimento e com ele, é possível determinar o que está ocorrendo dentro do código-fonte e obter sugestões de ações de melhorias. Com ele é possível controlar as variáveis, o que elas estão guardando e passar pelo programa de linha de código por linha de código. Por enquanto veremos apenas o básico da funcionalidade do debug.

Para debugar no java, primeiro você deverá dar dois cliques na lateral esquerda do seu código, ao lado do número das linhas. Se você fizer isso, aparecerá a seguinte bolinha:

Essa bolinha se chama breakpoint, ele representa em qual ponto gostaríamos que a aplicação fosse pausada. Também podemos criar um breakpoint com o atalho Ctrl + Shift + B. Essa pausa que o breakpoint da no programa, será o nosso ponto de partida do debug.

Para rodarmos o programa em modo de depuração, podemos clicar no botão ou clicar em nossa classe, ir em Debug As e clicar em Java Application. Após começarmos a rodar o programa, ele irá pedir para trocar para o modo de Debug. Clique em Switch na janela que irá aparecer e o programa iniciará.

Percebe-se que a linha que selecionamos ficou verde. Esse destaque verde sinaliza qual a linha que o programa irá executar no próximo passo. A partir dai, podemos rodar nosso programa passo a passo para verificar os valores desejados. Para seguir para o próximo, clique no botão a seguir ou clique em F6.

Com isso, podemos passar por todo o nosso programa visualizando o que está acontecendo em cada passo. No lado direito estão localizadas as variáveis, onde podemos verificar seus valores. Além das variáveis, temos os nossos breakpoints e onde estão colocados e as expressões, que veremos mais tarde no java avançado.

No exemplo acima por exemplo, temos um i que guarda um valor 0.

Para sair do modo debug, você pode rodar o programa normalmente e clicar no botão no canto diagonal direito para mudar para o modo Java novamente.