Observe que como os arrays começam com indice igual a **0 (zero)**, iniciamos a nossa variável **`x`** também com valor zero e validamos a quantidade de repetições a partir da quantidade de elementos do array.
93 |
94 | {% hint style="info" %}
95 | Fala a verdade: Depois desta explicação deu até sono em? 😴😴
96 | {% endhint %}
97 |
98 | ### For Each
99 |
100 | O uso do **`for / each`** está fortemente relacionado com um cenário onde contenha um array ou coleção, e assim, a interação é baseada aos elementos da coleção.
101 |
102 | ```java
103 | // ExemploFor.java
104 | public class ExemploFor {
105 | public static void main(String[] args) {
106 | String alunos [] = {"FELIPE","JONAS","JULIA","MARCOS"};
107 |
108 | //Forma abreviada
109 | for(String aluno : alunos) {
110 | System.out.println(alunos);
111 | }
112 |
113 | }
114 | }
115 | ```
116 |
117 |
118 |
119 | 1. `String aluno : alunos` -> De forma abreviada é criada uma variável `nome` obtendo um elemento do vetor a cada ocorrência.
120 | 2. A impressão de cada aluno é realizada.
121 |
122 | ### break e continue
123 |
124 | **Break** significa quebrar, parar, frear, interromper. E é isso que se faz quando o Java encontra esse comando pela frente. **Continue**, como o nome diz, ele 'continua' o laço. O comando **`break`** interrompe o laço, já o **`continue`** interrompe somente a iteração atual.
125 |
126 | ```java
127 | // class ExemploBreakContinue.java
128 | public class ExemploBreakContinue {
129 | public static void main(String[] args) {
130 |
131 | for(int numero = 1; numero <=5; numero ++){
132 | if(numero==3)
133 | break;
134 |
135 | System.out.println(numero);
136 |
137 | }
138 | //Qual a saída no console ?
139 |
140 | }
141 | }
142 | ```
143 |
144 | ```java
145 | // class ExemploBreakContinue.java
146 | public class ExemploBreakContinue {
147 | public static void main(String[] args) {
148 |
149 | for(int numero = 1; numero <=5; numero ++){
150 | if(numero==3)
151 | continue;
152 |
153 | System.out.println(numero);
154 |
155 | }
156 | //Qual a saída no console ?
157 |
158 | }
159 | }
160 | ```
161 |
162 | {% hint style="success" %}
163 | Observem que sempre o **`break`** e **`continue`** está condicinado a um critério de negócio.
164 | {% endhint %}
165 |
166 | ## While
167 |
168 | O laço **`while`** (na tradução literal para a língua portuguesa “enquanto”) determina que enquanto uma condição for válida, o bloco de código será executado. O laço **`while`** testa a condição antes de executar o código, logo, caso a condição seja inválida no primeiro teste o bloco nem será executado.
169 |
170 | A estrutura de sintaxe do controle de repetição **`while`** é exibida abaixo:
171 |
172 | ```
173 | //estrutura do controle de fluxo while
174 |
175 | while (expressão booleana de validação)
176 | {
177 | // comando que será executado até que a
178 | // expressão de validação torne-se falsa
179 | }
180 | ```
181 |
182 |  (1).png>)
183 |
184 | Joãozinho recebeu R$ 50,00 de mesada e foi em uma loja de doces gastar todo o seu dinheiro, logo, enquanto o valor dos doces não igualar a R$ 50,00 ele foi adicionando itens no carrinho.
185 |
186 | ```java
187 | // ExemploWhile.java
188 | import java.util.concurrent.ThreadLocalRandom;
189 | public class ExemploWhile {
190 | public static void main(String[] args) {
191 | double mesada = 50.0;
192 | while(mesada>0) {
193 | Double valorDoce = valorAleatorio();
194 | if(valorDoce > mesada)
195 | valorDoce = mesada;
196 |
197 | System.out.println("Doce do valor: " + valorDoce + " Adicionado no carrinho");
198 | mesada = mesada - valorDoce;
199 | }
200 | System.out.println("Mesada:" + mesada);
201 | System.out.println("Joãozinho gastou toda a sua mesada em doces");
202 |
203 | /*
204 | * Não se preocupe quanto a formatação de valores
205 | * Iremos explorar os recursos de formatação em breve !!
206 | */
207 | }
208 | private static double valorAleatorio() {
209 | return ThreadLocalRandom.current().nextDouble(2, 8);
210 | }
211 | }
212 | ```
213 |
214 |
215 |
216 | ## Do While
217 |
218 | O laço **`do / while`** (na tradução literal para a língua portuguesa “faça…enquanto”), assim como o laço while, considera que enquanto uma determinada condição for válida o bloco de código será executado. Entretanto, **`do / while`** testa a condição após executar o código,sendo assim, mesmo que a condição seja considerada inválida no primeiro teste o bloco será executado pelo menos uma vez.
219 |
220 | A estrutura de sintaxe do controle de repetição **`do / while`** é exibida abaixo:
221 |
222 | ```
223 | //estrutura do controle de fluxo do while
224 |
225 | do
226 | {
227 | // comando que será executado até que a
228 | // expressão de validação torne-se falsa
229 | }
230 | while (expressão booleana de validação);
231 | ```
232 |
233 | .png>)
234 |
235 | Joãozinho resolveu ligar para o seu amigo dizendo que hoje se entupiu de comer docinhos:
236 |
237 | ```java
238 | // ExemploDoWhile.java
239 |
240 | import java.util.Random;
241 | public class ExemploDovWhile {
242 | public static void main(String[] args) {
243 | public static void main(String[] args) {
244 | System.out.println("Discando...");
245 |
246 | do {
247 | //excutando repetidas vezes até alguém atender
248 | System.out.println("Telefone tocando");
249 |
250 | }while(tocando());
251 |
252 | System.out.println("Alô !!!");
253 | }
254 | private static boolean tocando() {
255 | boolean atendeu = new Random().nextInt(3)==1;
256 | System.out.println("Atendeu? " + atendeu);
257 | //negando o ato de continuar tocando
258 | return ! atendeu;
259 | }
260 | }
261 | ```
262 |
--------------------------------------------------------------------------------
/gitbook/controle-de-fluxo/estruturas-excepcionais.md:
--------------------------------------------------------------------------------
1 | # Estruturas excepcionais
2 |
3 | ## Exceções
4 |
5 | Ao executar o código Java, diferentes erros podem acontecer: erros de codificação feitos pelo programador, erros devido a entrada errada ou outros imprevistos.
6 |
7 | Quando ocorre um erro, o Java normalmente para e gera uma mensagem de erro. O termo técnico para isso é: Java lançará uma **exceção** (jogará um erro).
8 |
9 | De forma interpretativa em Java, um erro é algo irreparável, a aplicação trava ou é encerrada drasticamente. Já exceções é um fluxo inesperado da nossa aplicação, exemplo: Querer dividir um valor por zero, querer abrir um arquivo que não existe, abrir uma conexão de banco com usuário ou senha inválida. Todos estes cenários e os demais não são erros mas sim fluxos não previstos pela aplicação.
10 |
11 | É ai que entra mais uma responsabilidade do desenvolvedor, prever situações iguais a estas e realizar o que denominamos de _**Tratamento de Exceções**_.
12 |
13 | ### Mão na massa
14 |
15 | Vamos trazer o cenário que estudamos na aula sobre [Terminal e Argumentos](../sintaxe/terminal-e-argumentos.md) onde via terminal informamos alguns dados pessoais.
16 |
17 | ```java
18 | import java.util.Locale;
19 | import java.util.Scanner;
20 |
21 | public class AboutMe {
22 | public static void main(String[] args) {
23 | //criando o objeto scanner
24 | Scanner scanner = new Scanner(System.in).useLocale(Locale.US);
25 |
26 | System.out.println("Digite seu nome");
27 | String nome = scanner.next();
28 |
29 | System.out.println("Digite seu sobrenome");
30 | String sobrenome = scanner.next();
31 |
32 | System.out.println("Digite sua idade");
33 | int idade = scanner.nextInt();
34 |
35 | System.out.println("Digite sua altura");
36 | double altura = scanner.nextDouble();
37 |
38 |
39 | //imprimindo os dados obtidos pelo usuario
40 | System.out.println("Ola, me chamo " + nome.toUpperCase() + " " + sobrenome.toUpperCase());
41 | System.out.println("Tenho " + idade + " anos ");
42 | System.out.println("Minha altura é " + altura + "cm ");
43 | scanner.close();
44 | }
45 | ```
46 |
47 | Aparentemente é um programa simples, mas vamos listar algumas possíveis exceções que podem acontencer.
48 |
49 | * Não informar o nome e sobrenome
50 | * O valor da idade ter um caractere NÃO numérico
51 | * O valor da altura ter uma vírgula ao invês de ser um ponto _**(conforme padrão americano)**_
52 |
53 | Executando o nosso programa com os valores abaixo, vamos entender qual exceção acontecerá:
54 |
55 | | Entrada | Valor | Exceção | Causa |
56 | | --------------------- | --------------- | -------------------------------- | -------------------------------------------------------------------------------------------- |
57 | | Digite seu nome: | **Marcelo** | | |
58 | | Digite seu sobrenome: | **Azevedo** | | |
59 | | Digite sua idade: | **quinze (15)** | java.util.InputMismatchException | O programa esperava o valor do tipo numérico inteiro. |
60 | | Digite sua altura: | **1,65** | java.util.InputMismatchException | O programa esperava o valor do tipo numérico decimal no formata americano, exemplo: **1.65** |
61 |
62 | {% hint style="info" %}
63 | A melhor forma de prever que pode ocorrer uma exceção, é pensar que ela pode ocorrer.\
64 | _**Lei de Murphy**_
65 | {% endhint %}
66 |
67 | ### Conhecendo algumas exceções já mapeadas
68 |
69 | A linguagem Java dispõe de uma vasta lista de classes que representam exceções, abaixo iremos apresentar as mais comuns:
70 |
71 | | Nome | Causa |
72 | | ------------------------------ | -------------------------------------------------------------------- |
73 | | java.lang.NullPointerException | Quando tentamos obter alguma informação de uma variável nula. |
74 | | java.lang.ArithmeticException | Quando tentamos dividir um valor por zero. |
75 | | java.sql.SQLException | Quando existe algum erro relacionado a interação com banco de dados. |
76 | | java.io.FileNotFoundException | Quando tentamos ler ou escrever em um arquivo que não existe. |
77 |
78 | ### Tratamento de exceções
79 |
80 | E quando inevitavelmente ocorrer uma exceção? Como nós desenvolvedores podemos ajustar o nosso algoritmo para amenizar o ocorrido?
81 |
82 | A instrução **`try`** permite que você defina um bloco de código para ser testado quanto a erros enquanto está sendo executado.
83 |
84 | A instrução **`catch`** permite definir um bloco de código a ser executado, caso ocorra um erro no bloco try.
85 |
86 | A instrução **`finally`** permite definir um bloco de código a ser executado independente de ocorrer um erro ou não. As palavras-chave `try` e `catch` vêm em pares:
87 |
88 | Estrutura de um bloco com try e catch
89 |
90 | ```java
91 | try {
92 | // bloco de código conforme esperado
93 | }
94 | catch(Exception e) {// precisamos saber qual exceção
95 | // bloco de código que captura as exceções que podem acontecer
96 | // em caso de um fluxo não previsto
97 | }
98 | ```
99 |
100 | {% hint style="warning" %}
101 | O bloco **`try`** / **`catch`** pode conter um conjunto de **catchs** correspondentes a cada exceção que **prevista** em uma funcionalidade do programa.
102 | {% endhint %}
103 |
104 | ### Hierarquia das exceções
105 |
106 | A linguagem Java dispõe de uma variedade de classes que representam exceções, e estas classes são organizadas em uma hierarquia denominadas **Checked and Unchecked Exceptions** ou _Exceções Checadas e Não Checadas_.
107 |
108 | .png>)
109 |
110 | {% hint style="info" %}
111 | O que determina uma exceção ser classificado como **checada** ou **não checada** ?\
112 | É o risco dela ser disparada logo você precisa tratá-la, exemplo:
113 | {% endhint %}
114 |
115 | Vamos imaginar que precisamos realizar de duas maneiras a conversão de uma String para um número, porém o texto contém Alfanuméricos.
116 |
117 | ```java
118 | public class ExemploExcecao {
119 | public static void main(String[] args) {
120 | Number valor = Double.valueOf("a1.75");
121 |
122 | valor = NumberFormat.getInstance().parse("a1.75");
123 |
124 | System.out.println(valor);
125 |
126 | }
127 | }
128 | ```
129 |
130 | {% hint style="info" %}
131 | As linhas 3 e 5 apresentarão uma exceção ao serem executadas, e a linha 5 contém um método que pode disparar uma exceção checada, logo nós programadores que iremos usar este método teremos que tratá-la explicitamente com **`try \ catch`**.
132 | {% endhint %}
133 |
134 | ### Exceções customizadas
135 |
136 | Nós podemos criar nossas próprias exceções baseadas em regras de negócio e assim melhor direcionar quem for utilizar os recursos desenvolvidos no projeto, exemplo:
137 |
138 | * Imagina que como regra de negócio, para formatar um cep necessita sempre de ter 8 dígitos, caso contrário lançará uma exceção que denominamos de **CepInvalidoException**.
139 | * Primeiro criamos nossa exceção:
140 |
141 | ```java
142 | public class CepInvalidoException extends Exception {}
143 | ```
144 |
145 | * Em seguida criamos nosso método de formatação de cep.
146 |
147 | ```java
148 | static String formatarCep(String cep) throws CepInvalidoException{
149 | if(cep.length() != 8)
150 | throw new CepInvalidoException();
151 |
152 | //simulando um cep formatado
153 | return "23.765-064";
154 | }
155 | ```
156 |
157 | #### Referências
158 |
159 | {% embed url="https://www.w3schools.com/java/java_try_catch.asp" %}
160 |
161 | {% embed url="https://www.oracle.com/br/technical-resources/article/java/erros-java-exceptions.html" %}
162 |
--------------------------------------------------------------------------------
/gitbook/fundamentos/configurando-o-ambiente-de-desenvolvimento.md:
--------------------------------------------------------------------------------
1 | # Configurando o ambiente
2 |
3 | Para começar a desenvolver em Java é necessário que tenhamos o JDK instalado.
4 |
5 | {% hint style="warning" %}
6 | É extremamente relevante determinar a versão do Java que precisa utilizar diante de alguns requisitos do projeto.
7 | {% endhint %}
8 |
9 | ### Instalando o JDK no Windows
10 |
11 | {% hint style="info" %}
12 | Algumas IDEs como o [VSCode](https://code.visualstudio.com/docs/java/java-tutorial) já consegue baixar e instalar o JDK e realizar a configuração de forma fácil.
13 | {% endhint %}
14 |
15 | * Busque no Google por Java [JDK xxx](https://www.oracle.com/br/java/technologies/javase/javase8-archive-downloads.html) (versão desejada)
16 | * Selecione a opção **.exe** de acordo com o seu sistema operacional. No meu exemplo eu baixei a versão: [jdk-8u202-windows-x64.exe](https://www.oracle.com/br/java/technologies/javase/javase8-archive-downloads.html#license-lightbox)
17 |
18 |  (1).png>)
19 |
20 | * Depois você precisará realizar um login no site da [Oracle](https://login.oracle.com/mysso/signon.jsp).
21 |
22 |  (1) (1).png>)
23 |
24 | * Após realizar o download, executar o instalador para instalar o Java no Windows. Este processo instalará tanto o **JDK** quanto a **JRE**.
25 |
26 |  (1) (1).png>)
27 |
28 | {% hint style="warning" %}
29 | Evite mudar o diretório de instalação
30 | {% endhint %}
31 |
32 | * Em seu explorer deve ter algo mais ou menos assim:
33 |
34 | .png>)
35 |
36 | * Precisamos agora validar se a instalação também já configurou nossa variável de ambiente para poder executar o Java pelo Prompt de comando ou PowerShell do Windows.
37 | * Abre o Prompt de comando e execute o comando `java -version`.
38 |
39 | 
40 |
41 | {% hint style="info" %}
42 | Não iremos configurar as variáveis de ambiente pois não é um pré-requisito para desenvolver em Java considerando que iremos usufruir das mais poderosas IDEs para aumentar nossa produtividade em codificar na linguagem.
43 | {% endhint %}
44 |
45 | {% content-ref url="escolha-sua-ide.md" %}
46 | [escolha-sua-ide.md](escolha-sua-ide.md)
47 | {% endcontent-ref %}
48 |
--------------------------------------------------------------------------------
/gitbook/fundamentos/escolha-sua-ide.md:
--------------------------------------------------------------------------------
1 | # Escolha sua IDE
2 |
3 | Para aumentar nossa produtividade, nós podemos escolher algumas ferramentas denominadas de IDE - Integrated Development Environment ou Ambiente de Desenvolvimento Integrado. É um software que dispõe de recursos que auxiliar muito nosso desenvolvimento como:
4 |
5 | * Aceleração de nossa escrita com **Auto-complete** ou **IntelliSense**
6 | * Formatação de palavras e blocos de códigos
7 | * Análise de erro de sintaxe
8 | * Compilação de programa
9 | * Depuração (acompanhamento) de execução do programa.
10 |
11 | Cada IDE dispõe de recursos comuns ou plugins específicos para te auxiliar na agilidade de desenvolvimento.
12 |
13 |  (1).png>)
14 |
15 | {% hint style="success" %}
16 | Antes de escolhar sua IDE super recomendamos realizar uma pesquisa e ter uma experiência em cada uma delas.
17 | {% endhint %}
18 |
19 | ## Eclipse
20 |
21 | O [Eclipse IDE](https://www.eclipse.org/downloads/) é uma alternativa muita comum de encontrar ambientes de desenvolvimento, principalmente pelo aspecto de uma interface simples, plugins para recursos adicionais, atalhos para operações de menu e de escrita e para quem trabalhar com Java Swing você pode adicionar o plugin [WindowBuilder](https://www.eclipse.org/windowbuilder/download.php) que de dispõe de uma interface gráfica para criar as telas gerando o código de layout para o desenvolvedor.
22 |
23 | {% hint style="warning" %}
24 | Se houver algum erro quanto a versão do Java no Eclipse, [veja o vídeo pelo link](https://www.youtube.com/watch?v=CgwpdheXvls)
25 | {% endhint %}
26 |
27 | ## IntelliJ
28 |
29 | O [IntelliJ](https://www.jetbrains.com/pt-br/idea/) é uma plataforma de código aberto para criação de IDEs e ferramentas para desenvolvedores, mas nem todos os recursos estão disponíveis de forma gratuita.
30 |
31 | Mesmo com a proposta de ser inteligente, talvez em um primeiro contato, é difícil já desfrutar de todos os recursos, fazendo com você opte por mudar ou voltar para uma IDE como o Eclipse. Claro que não podemos deixar de destacar que muitas coisas a gente não precisa se como: Salvar aquivo, encode padrão UTF-8 e sugestões que vão surgindo ao longo da nossa interação com a ferramenta.
32 |
33 | ## Visual Studio Code
34 |
35 | Desenvolvido pela Microsoft, é uma editor de texto muito simples e interativo que conta com inúmeras extensões, temas variados e integração com tecnologias como NodeJS e Java.
36 |
37 | Comparando-se em performance, o [VS Code](https://code.visualstudio.com/docs/languages/java) demonstra um grande desempenho de inicialização, codificação e execução dos programas desenvolvidos.
38 |
39 | #### Resumindo:
40 |
41 | * Eclipse: Mais utilizada no ambiente corporativo com interface bem interativa.
42 | * NetBeans: Utilizada mais em ambiente acadêmico e com versão de menu e assistentes em português.
43 | * IntelliJ: Ofereça muitos recursos de inteligência para agilidade de nosso desenvolvimento com sugestões de ações bem assertivas.
44 | * VS Code: Hoje muito utilizada por desenvolvedores que já atuam com NodeJs ou plataformas de front-end.
45 |
46 | ## Mão na massa
47 |
48 | Vamos explorar alguns principais recursos utilizando as IDEs, Eclipse, IntelliJ e VSCode.
49 |
50 | 
51 |
52 | * O que são workspaces ?
53 | * Definir a JDK na IDE
54 | * Criar \ abrir um projeto Java
55 | * Criar \ importar um projeto Maven
56 | * Conhecer os principais atalhos
57 | * Code Snippet
58 | * Executar \ Depurar nosso programa
59 | * Conhecer alguns atalhos
60 |
61 | {% hint style="info" %}
62 | **Maven**, é uma ferramenta de automação de compilação utilizada primariamente em projetos Java, mas hoje ambém é utilizada para construir e gerenciar projetos escritos em C#, Ruby, Scala e outras linguagens
63 | {% endhint %}
64 |
65 | ## Atalhos
66 |
67 | Todas as IDEs possuem combinações de comandos que são facilitadores para criação de arquivo, digitação de códigos, localização e execução das classes em nosso programa, além de comandos já pré-definidos de linhas de código (code snippet).
68 |
69 | > _**Code Snippets**_, que numa tradução livre seria algo como “retalhos de código”, são pedaços de código pré-fabricados e parametrizáveis que podemos inserir em nossa aplicação\
70 | > \
71 | > [Linha do código](http://www.linhadecodigo.com.br/artigo/2274/code-snippets.aspx#ixzz7KEQ3PlmT)
72 |
73 | #### Comparação de alguns atalhos
74 |
75 | | Comando | Eclipse | IntelliJ |
76 | | ----------------------------------- | --------------------------- | -------------- |
77 | | Cria o método principal main | main, ctrl + espaço, enter | psvm |
78 | | Localiza recurso \ arquivo | ctrl + shit + R | ctrl+shift + N |
79 | | Método de impressão no Console | sysout, ctrl + espaço | sout |
80 | | Renomeando variável ou método | alt+shift+R | shift + F6 |
81 | | Localizar a utilização de um método | ctrl+shift+G | alt + F7 |
82 | | Entrar na implementação do método | ctrl+click | ctrl+click |
83 |
84 | #### Referências
85 |
86 | {% embed url="https://www.youtube.com/watch?v=vim1bTa-Bkc" %}
87 |
88 | {% embed url="https://blog.algaworks.com/atalhos-e-configuracoes-para-ganhar-produtividade-com-eclipse" %}
89 |
90 | {% embed url="http://www.w3big.com/pt/eclipse/eclipse-shortcuts.html" %}
91 |
92 | {% embed url="https://medium.com/@francisco.kindermann/alguns-atalhos-do-eclipse-65ad47eec6ae" %}
93 |
94 | {% embed url="http://www.basef.com.br/index.php/Atalhos_do_IntelliJ_Idea" %}
95 |
--------------------------------------------------------------------------------
/gitbook/fundamentos/java-e-sua-historia.md:
--------------------------------------------------------------------------------
1 | # Java e sua história
2 |
3 | Interessada em dispositivos eletrônicos inteligentes, a Sun Microsystems financiou uma pesquisa interna com o codinome Green em 1991. O projeto resultou no desenvolvimento de uma linguagem baseada em C e C++ que seu criador, James Gosling, chamou de Oak (carvalho) em homenagem a uma árvore que dava para a janela do seu escritório na Sun.
4 |
5 |  (1) (1) (1).png>)
6 |
7 | Descobriu-se mais tarde que já havia uma linguagem de computador chamada Oak. Quando uma equipe da Sun visitou uma cafeteria local, o nome Java (cidade de origem de um tipo de café importado) foi sugerido e pegou.
8 |
9 | Mas o projeto Green atravessava algumas dificuldades. O mercado para dispositivos eletrônicos inteligentes destinados ao consumidor final não estava se desenvolvendo tão rapidamente como a Sun tinha previsto. Pior ainda, um contrato importante pelo qual a Sun competia fora concedido a outra empresa. Então, o projeto estava em risco de cancelamento. Por pura sorte, a World Wide Web explodiu em popularidade em 1993 e as pessoas da Sun viram o imediato potencial de utilizar Java para criar páginas da Web com o chamado conteúdo dinâmico. Isso deu nova vida ao projeto.
10 |
11 | Em maio de 1995, a Sun anunciou Java formalmente em uma conferência importante. Normalmente, um evento como esse não teria gerado muita atenção. Entretanto, Java gerou interesse imediato na comunidade comercial por causa do fenomenal interesse pela World Wide Web.
12 |
13 | {% hint style="info" %}
14 | Um pouco mais da história sobre Java no canal do [Guanabara Curso em Vídeo](https://www.youtube.com/watch?v=sTX0UEplF54\&list=PLHz\_AreHm4dkI2ZdjTwZA4mPMxWTfNSpR)
15 | {% endhint %}
16 |
17 | ### Java é agora utilizada praticamente em todo lugar:
18 |
19 | * Páginas da Web com conteúdo interativo e dinâmico;
20 | * Aplicações corporativas de grande porte;
21 | * Softwares destinados ao consumidor final.
22 | * Aplicativos para Smartphones.
23 |
24 | .png>)
25 |
26 | Características de cada versão
27 |
28 | | Versão | Data | Recurso |
29 | | -------------- | -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
30 | | JDK 1.0 | 23 de janeiro de 1996 | É a 1ª versão sendo hoje usada para compatibilidade de browsers mais antigos. |
31 | | JDK 1.1 | 19 de fevereiro de 1997 | Muitas bibliotecas adicionadas, das quais se destacaram o Java RMI, JavaBeans, novo modelo de eventos e JDBC driver para conexão com banco de dados. |
32 | | J2SE 1.2 | 8 de dezembro de 1998 | Obteve um grande aumento das classes na biblioteca Java (API) |
33 | | J2SE 1.3 | 8 de maio de 2000 | Foram incluidas as bibliotecas JNDI, JavaSound, entre outros. |
34 | | J2SE 1.4 | 6 de fevereiro de 2002 | Foi criada a palavra reservada “assert”, biblioteca NIO, entre outros. |
35 | | **J2SE 5.0** | **30 de setembro de 2004** | **Introdução dos Generics, Enumeração, Auto-boxing, for-each entre outros.** |
36 | | JAVA SE 6 | 11 de dezembro de 2006 | Obteve uma melhora significativa na performance e na estabilidade, tendo o surgimento do JIT. |
37 | | JAVA SE 7 | 28 de julho de 2011 | Suporte ao uso de strings em condições do switch, inferência na criação de objetos com tipos genéricos, simplificação na invocação de métodos com parâmetros VarArgs e tipos genéricos, entre outros. |
38 | | **JAVA SE 8** | **18 de março de 2014** | **Expressões Lambdas, forEach, Consumer e interfaces no java.util.functions, Default methods, Method references e etc.** |
39 | | JAVA SE 9 | 21 de setembro de 2017 | Uma das novidades dessa versão são os factory methods para coleções. |
40 | | JAVA SE 10 | 20 de março de 2018 | Dentre as novidades do java 10 podemos apontar a nova API para criação de coleções imutáveis e a nova forma de se declarar variáveis locais. |
41 | | **JAVA SE 11** | **25 de setembro de 2018** | **Métodos readString() writeString(). Alguns métodos foram adicionados no tocante a manipulação de cordas como o repeat, strip, stripLeading, stripTrailing, lines e isBlank. Também vale ressaltar a utilização de variáveis por inferência.** |
42 | | JAVA SE 12 | 19 de março de 2019 | Expressão Switch melhorada e métodos String indent e transform. |
43 | | JAVA SE 13 | 17 de setembro de 2019 | O Java 13 trouxe dois novos recursos de linguagem, embora no modo de visualização. Usando yield, agora podemos efetivamente retornar valores de uma expressão switch. O segundo recurso de visualização são blocos de texto para Strings de várias linhas, como JSON, XML, HTML, etc. |
44 | | JAVA SE 14 | 17 de março de 2020 | Helpful NullPointerExceptions nos permite saber quem causou e a consequência, Records (Preview) criado pela oracle para reduzir a verbosidade, Switch Expressions tornando a sintaxe do switch mais fácil e simples, deixando o código mais limpo e agradável. |
45 | | JAVA SE 15 | Setembro de 2020 | O Java 15 oferece aos desenvolvedor 14 aprimoramentos/alterações, incluindo um módulo de incubadora, três recursos de visualização, dois recursos obsoletos e duas remoções. Algumas mudanças servem para reduzir o tamanho e o escopo do JDK através da Depreciação, que é uma técnica para transmitir informações sobre o ciclo de vida de uma API. |
46 | | JAVA SE 16 | Março de 2021 | Foram acrescentados muitos recursos para melhorar a perfomance, consumo de memória e uso da linguagem. Alguns dos novos recursos incluem mudanças no ZGC, suporte à versão 14 do C++ para evolução da JDK e JVM, capacidade elástica do metaspace, novas APIs e ferramentas. |
47 | | JAVA SE 17 LTS | Setembro de 2021 | Entre os novos recursos da nova versão do Java padrão estão o suporte a filtros de desserialização específicos do contexto, que é um aprimoramento de segurança e uma visualização de correspondência de padrões para instruções switch. |
48 |
--------------------------------------------------------------------------------
/gitbook/fundamentos/plataformas.md:
--------------------------------------------------------------------------------
1 | # Plataformas
2 |
3 | Com a linguagem Java conseguimos desenvolver softwares para várias finalidades de negócio. Seja uma aplicação desktop, uma distribuição web, eletrônicos e dispositivos móveis.
4 |
5 | Isso graças a distribuição dos recursos da linguagem através de plataformas bem estruturadas.
6 |
7 | ### Plataformas da linguagem Java
8 |
9 | A linguagem Java conta com quatro ambientes de desenvolvimento.
10 |
11 |  (1) (1).png>)
12 |
13 | * **JSE (Java Standard Edition):** É a base da plataforma. Inclui o ambiente de execução e as bibliotecas comuns, sendo direcionado a aplicações para PCs e servidores. O toolkit Swing, por exemplo, é usado para desenvolver softwares com interface gráfica para desktop.
14 | * **JEE (Java Enterprise Edition):** A edição voltada para o desenvolvimento de aplicações corporativas e para a Web. Possui diversos frameworks, como JPA (Java Persistence API), JSP (Java Server Pages), etc.
15 | * **JME (Java Micro Edition):** É a edição para o desenvolvimento de aplicações para dispositivos móveis e embarcados.
16 | * **JFX (Java FX):** JavaFX é uma tecnologia de software que, ao ser combinada com Java, permite a criação e implantação de aplicações de aparência moderna e conteúdo rico de áudio e vídeo.
17 |
18 | ### Componentes da plataforma
19 |
20 | Agora que já sabemos que podemos desenvolver para vários cenários de negócio, é hora de conhecer as ferramentas de desenvolvimento da linguagem:
21 |
22 | O Java se subdivide em componentes de desenvolvimento (JDK) e de execução (JRE). Isso significa que, para desenvolver aplicações, é necessário ter instalado o JDK. Mas para apenas iniciar o executável (.jar) simplesmente a instalação da JRE será o suficiente.
23 |
24 | **JDK (Java Development Kit) - Kit de Desenvolvimento Java**
25 |
26 | * Composto pelo Compilador (javac + JVM)
27 | * Visualizador de applets, bibliotecas de desenvolvimento
28 | * Programa para composição de documentação (javadoc)
29 | * Depurador básico de programas e versão da JRE.
30 |
31 | **JRE (Java Runtime Environment) - Ambiente de Execução Java**
32 |
33 | * É composta de uma JVM e por um conjunto de bibliotecas que permite a execução de softwares em Java.
34 | * Apenas permite a execução de programas, ou seja é necessário o programa Java compilado pela JDK gerando os arquivos **.class**.
35 |
36 | ### Processo de desenvolvimento
37 |
38 | * Todo código-fonte escrito em arquivo texto possui extensão .java
39 | * Este arquivo é compilado com o javac gerando o arquivo .class.
40 | * O arquivo .class não contém código de máquina nativo, e sim o `bytecodes`.
41 |
42 | .png>)
43 |
44 | ### JVM - Java Virtual Machine
45 |
46 | **Máquina virtual Java** (em [inglês](https://pt.wikipedia.org/wiki/L%C3%ADngua\_inglesa): _Java Virtual Machine_, **JVM**) é um programa que carrega e executa os aplicativos [Java](https://pt.wikipedia.org/wiki/Linguagem\_de\_programa%C3%A7%C3%A3o\_Java), convertendo os [bytecodes](https://pt.wikipedia.org/wiki/Bytecode\_Java) em código executável de máquina. A JVM é responsável pelo gerenciamento dos aplicativos, à medida que são executados.
47 |
48 | Graças à máquina virtual Java, os programas escritos em Java podem funcionar em qualquer plataforma de hardware e software que possua uma versão da JVM, tornando assim essas aplicações independentes da plataforma onde funcionam.
49 |
50 |  (1) (1).png>)
51 |
52 | #### Referências
53 |
54 | {% embed url="https://www.devmedia.com.br/introducao-as-plataformas-java/29544" %}
55 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/classes.md:
--------------------------------------------------------------------------------
1 | # Classes
2 |
3 | Toda a estrutura de código na linguagem Java é distribuído em arquivos com extensão **.java** denominados de **classe**.
4 |
5 | As classes existentes em nosso projeto serão composta por:
6 |
7 | **Identificador**, **Características** e **Comportamentos**.
8 |
9 | * **Classe** _(class)_: A estrutura e ou representação que direciona a criação dos objetos de mesmo tipo.
10 | * **Identificador** (identity): Propósito existencial aos objetos que serão criados.
11 | * **Características** _(states)_**:** Também conhecido como **atributos** ou **propriedades**, é toda informação que representa o estado do objeto.
12 | * **Comportamentos** _(behavior)_**:** Também conhecido como **ações** ou **métodos**, é toda parte comportamental que um objeto dispõe.
13 | * **Instanciar** _(new)_**:** É o ato de criar um objeto a partir de estrutura definida em uma classe.
14 |
15 | .png>)
16 |
17 | Para ilustrar as etapas de desenvolvimento orientada a objetos em Java, iremos reproduzir a imagem acima em forma de código para explicar que primeiro criamos a estrutura correspondente para assim podermos cria-los com as características e possibilidade de realização de ações (comportamentos) como se fosse no "mundo real".
18 |
19 | ```java
20 | // Criando a classe Student
21 | // Com todas as características e compartamentos aplicados
22 |
23 | public class Student {
24 | String name;
25 | int age;
26 | Color color;
27 | Sex sex;
28 |
29 | void eating(Food food){
30 | //NOSSO CÓDIGO AQUI
31 | }
32 | void drinking(Eat eat){
33 | //NOSSO CÓDIGO AQUI
34 | }
35 | void running(){
36 | //NOSSO CÓDIGO AQUI
37 | }
38 | }
39 |
40 | ```
41 |
42 | ```java
43 | // Criando objetos a partir da classe Student
44 |
45 | public class School {
46 | public static void main(String[] args) throws Exception {
47 | Student student1 = new Student();
48 | student1.name= "John";
49 | student1.age= 12;
50 | student1.color= Color.FAIR;
51 | student1.sex= Sex.MALE;
52 |
53 | Student student2 = new Student();
54 | student2.name= "Sophia";
55 | student2.age= 10;
56 | student2.color= Color.FAIR;
57 | student2.sex= Sex.FEMALE;
58 |
59 | Student student3 = new Student();
60 | student3.name= "Lily";
61 | student3.age= 11;
62 | student3.color= Color.DARK;
63 | student3.sex= Sex.FEMALE;
64 | }
65 | }
66 | j
67 | ```
68 |
69 | {% hint style="warning" %}
70 | No exemplo acima, **NÃO** estruturamos a classe `Student` com o padrão Java Beans **getters** e **setters**.
71 | {% endhint %}
72 |
73 | Seguindo algumas convenções, as nossas classes são classificadas como:
74 |
75 | * **Classe de modelo (model)**: classes que representem estrutura de domínio da aplicação, exemplo: Cliente, Pedido, Nota Fiscal e etc.
76 | * **Classe de serviço (service)**: classes que contém regras de negócio e validação de nosso sistema.
77 | * **Classe de repositório (repository)**: classes que contém uma integração com banco de dados.
78 | * **Classe de controle (controller)**: classes que possuem a finalidade de disponibilizar alguma comunicação externa à nossa aplicação, tipo http web ou webservices.
79 | * **Classe utilitária (util)**: classe que contém recursos comuns à toda nossa aplicação.
80 |
81 | .png>)
82 |
83 | {% hint style="success" %}
84 | Exercite a distribuição de classes por papéis dentro da sua aplicação para que se possa determinar a estrutura mais conveniente em cada arquivo do seu projeto.
85 | {% endhint %}
86 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/conceito-de-poo.md:
--------------------------------------------------------------------------------
1 | # Conceito de POO
2 |
3 | **Programação orientada a objetos** (**POO**, ou **OOP** segundo as suas siglas em inglês) é um [paradigma de programação](https://pt.wikipedia.org/wiki/Paradigma\_de\_programa%C3%A7%C3%A3o) baseado no conceito de "[objetos](https://pt.wikipedia.org/wiki/Objeto\_\(ci%C3%AAncia\_da\_computa%C3%A7%C3%A3o\))", que podem conter [dados](https://pt.wikipedia.org/wiki/Dados) na forma de [campos](https://pt.wikipedia.org/wiki/Campo\_\(ci%C3%AAncia\_da\_computa%C3%A7%C3%A3o\)), também conhecidos como _atributos_, e códigos, na forma de [procedimentos](https://pt.wikipedia.org/wiki/Procedimento), também conhecidos como [métodos](https://pt.wikipedia.org/wiki/M%C3%A9todo\_\(programa%C3%A7%C3%A3o\)).
4 |
5 | Como se trata de um contexto análogo ao mundo real, tudo no qual nos referimos são objetos, exemplo: Conta bancária, Aluno, Veículo, Transferência etc.
6 |
7 | A programação orientada a objetos é bem requisitada no contexto das aplicações mais atuais no mercado devido a possibilidade de reutilização de código e a capacidade de representação do sistema ser muito mais próximo do mundo real.
8 |
9 | Para uma linguagem ser considerada orientada a objetos, esta deve seguir o que denominamos como _**Os quatro pilares da orientação a objetos**_:
10 |
11 | * **Encapsulamento:** Nem tudo precisa estar visível, grande parte do nosso algoritmo pode ser distribuído em métodos com finalidades específicas que complementa uma ação em nossa aplicação.
12 |
13 | Exemplo: Ligar um veículo exige muitas etapas para a engenharia, mas o condutor só visualiza a ignição, dar a partida e a _“magia”_ acontece.
14 | * **Herança:** Características e comportamentos comuns podem ser elevados e compartilhados através de uma hierarquia de objetos.
15 |
16 | Exemplo: Um Carro e uma Motocicleta possuem propriedades como placa, chassi, ano de fabricação e métodos como acelerar, frear. Logo para não ser um processo de codificação redundante, podemos desfrutar da herança criando uma classe **Veiculo** para que seja herdada por Carro e Motocicleta.
17 | * **Abstração:** É a indisponibilidade para determinar a lógica de um ou vários comportamentos em um objeto.
18 |
19 | Exemplo: **Veículo** determina duas ações como acelerar e frear, logo estes comportamentos deverão ser _abstratos_ pois existem mais de uma maneira de se realizar a mesma operação. ver _Polimorfismo_.
20 | * **Polimorfismo:** São as inúmeras maneiras de se realizar uma mesma ação.
21 |
22 | Exemplo: Veículo determina duas ações como acelerar e frear, primeiramente precisamos identificar se estaremos nos referindo a **Carro** ou **Motocicleta** para determinar a lógica de aceleração e frenagem dos respectivos veículos.
23 |
24 |
25 |
26 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/construtores.md:
--------------------------------------------------------------------------------
1 | # Construtores
2 |
3 | Sabemos que para criar um objeto na linguagem Java utilizamos a seguinte estrutura de código:
4 |
5 | ```java
6 | Classe novoObjeto = new Classe();
7 | ```
8 |
9 | Desta forma será criado um novo objeto na memória, este recurso também é conhecido como instanciar um novo objeto.
10 |
11 | Muitas das vezes já queremos que na criação (instanciação) de um objeto, a linguagem já solicite para quem for criar este novo objeto defina algumas propriedades essenciais. Abaixo iremos ilustrar uma classe Pessoa onde a mesma terá os atributos: Nome, CPF, Endereço.
12 |
13 | ```java
14 | public class Pessoa {
15 | private String nome;
16 | private String cpf;
17 | private String endereco;
18 |
19 | public String getNome() {
20 | return nome;
21 | }
22 | public String getCpf() {
23 | return cpf;
24 | }
25 | public String getEndereco() {
26 | return endereco;
27 | }
28 | public void setEndereco(String endereco) {
29 | this.endereco = endereco;
30 | }
31 | //...
32 | //setters de nome e cpf ?
33 | }
34 |
35 | ```
36 |
37 | Criaremos uma Pessoa mas como não temos o setter para nome e cpf, este objeto não tem como receber estes valores.
38 |
39 | ```java
40 | public class SistemaCadastro {
41 | public static void main(String[] args) {
42 | //criamos uma pessoa no sistema
43 | Pessoa marcos = new Pessoa();
44 |
45 | //definimos o endereço de marcos
46 | marcos.setEndereco("RUA DAS MARIAS");
47 |
48 | //e como definir o nome e cpf do marcos ?
49 |
50 | //imprimindo o marcos sem o nome e cpf
51 |
52 | System.out.println(marcos.getNome() + "-" + marcos.getCpf());
53 | }
54 | }
55 |
56 | ```
57 |
58 | Entrando em cena o construtor para criar nossos objetos já com valores requeridos na momento da criação\instanciação (`new`).
59 |
60 | ```java
61 | public class Pessoa {
62 | private String nome;
63 | private String cpf;
64 | private String endereco;
65 |
66 | // método construtor
67 | // o nome deverá ser igual ao nome da classe
68 | public Pessoa (String cpf, String nome) {
69 | this.cpf = cpf;
70 | this.nome = nome;
71 | }
72 |
73 | //...
74 | //getters
75 | //setters
76 | }
77 | ```
78 |
79 | Alterando o nosso sistema para agora criar o objeto com informações já requeridas conforme definição da ordem dos parâmetros do construtor.
80 |
81 | ```java
82 | public class SistemaCadastro {
83 | public static void main(String[] args) {
84 | //criamos uma pessoa no sistema
85 | Pessoa marcos = new Pessoa("06724506716","MARCOS SILVA");
86 |
87 | //continua ...
88 |
89 | }
90 | }
91 | ```
92 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/enums.md:
--------------------------------------------------------------------------------
1 | # Enums
2 |
3 | Enum é um tipo especial de classe onde os objetos são previamente criados, imutáveis e disponíveis por toda aplicação.
4 |
5 | Usamos Enum quando o nosso modelo de negócio contém objetos de mesmo contexto que já existem de pré-estabelecida com a certeza de não haver tanta alteração de valores.
6 |
7 | #### **Exemplos:**
8 |
9 | **Grau de Escolaridade**: Analfabeto, Fundamental, Médio, Superior
10 |
11 | **Estado Civil**: Solteiro, Casado, Divorciado, Viúvo
12 |
13 | **Estados Brasileiros**: São Paulo, Rio de Janeiro, Piauí, Maranhão.
14 |
15 | {% hint style="warning" %}
16 | Não confunda uma lista de constantes com enum.
17 | {% endhint %}
18 |
19 | Enquanto que uma constante é uma variável de tipo com valor imutável, um enum é um conjunto de objetos já pre-definidos na aplicação.
20 |
21 | Como um enum é um conjunto de objetos, logo, estes objetos podem conter atributos e métodos. Veja o exemplo de um enum para disponibilizar os quatro estados brasileiros citados acima, contendo informações de: Nome, Sigla e um método que pega o nome do de cada estado e já retorna para tudo maiúsculo.
22 |
23 | ```java
24 | // Criando o enum EstadoBrasileiro para ser usado em toda a aplicação.
25 | public enum EstadoBrasileiro {
26 | SAO_PAULO ("SP","São Paulo"),
27 | RIO_JANEIRO ("RJ", "Rio de Janeiro"),
28 | PIAUI ("PI", "Piauí"),
29 | MARANHAO ("MA","Maranhão") ;
30 |
31 | private String nome;
32 | private String sigla;
33 |
34 | private EstadoBrasileiro(String sigla, String nome) {
35 | this.sigla = sigla;
36 | this.nome = nome;
37 | }
38 | public String getSigla() {
39 | return sigla;
40 | }
41 | public String getNome() {
42 | return nome;
43 | }
44 | public String getNomeMaiusculo() {
45 | return nome.toUpperCase();
46 | }
47 |
48 | }
49 |
50 | ```
51 |
52 | #### Boas práticas para criar objetos Enum
53 |
54 | * As opções (objetos) devem ser descritos em caixa alta separados por underline (**\_**_),_ ex.: OPCAO\_UM, OPCAO\_DOIS
55 | * Após as opções deve-se encerrar com ponto e vírgula (**;**)
56 | * Um enum é como uma classe, logo poderá ter atributos e métodos tranquilamente
57 | * Os valores dos atributos devem já ser definidos após cada opção dentro de parênteses como se fosse um `new`
58 | * O construtor deve ser privado
59 | * Não é comum um enum possuir o recurso `setter` (alteração de propriedade), somente os métodos `getters` correspondentes.
60 |
61 | Agora **NÃO** precisaremos criar objetos que representam cada estado toda vez que precisarmos destas informações, basta usar o **enum** acima e escolher a opção (objeto) já pré-definido em qualquer parte do nosso sistema.
62 |
63 | ```java
64 | // qualquer classe do sistema poderá obter os objetos de EstadoBrasileiro
65 | public class SistemaIbge {
66 | public static void main(String[] args) {
67 | //imprimindo os estados existentes no enum
68 | for(EstadoBrasileiro uf: EstadoBrasileiro.values() ) {
69 | System.out.println(uf.getSigla() + "-" + uf.getNomeMaiusculo());
70 | }
71 |
72 | //selecionando um estado a partir das opções disponíveis
73 | EstadoBrasileiro ufSelecionado = EstadoBrasileiro.PIAUI;
74 |
75 | System.out.println("O estado selecionado foi: " + ufSelecionado.getNome());
76 | }
77 | }
78 |
79 | ```
80 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/getters-e-setters.md:
--------------------------------------------------------------------------------
1 | # Getters e Setters
2 |
3 | Seguindo a convensão Java Beans
4 |
5 | Os métodos "Getters" e "Setters" são utilizados para buscar valores de atributos ou definir novos valores de atributos de instâncias de classes.
6 |
7 | O método **Getter** retorna o valor do atributo especificado.
8 |
9 | O método **Setter** define outro novo valor para o atributo especificado.
10 |
11 | Vemos o código abaixo da criação de um objeto Aluno com nome e idade:
12 |
13 | ```java
14 | /arquivo Aluno.java
15 | public class Aluno {
16 | String nome;
17 | int idade;
18 | }
19 |
20 | //arquivo Escola.java
21 | public class Escola {
22 | public static void main(String[] args) {
23 | Aluno felipe = new Aluno();
24 | felipe.nome="Felipe";
25 | felipe.idade = 8;
26 |
27 | System.out.println("O aluno " + felipe.nome + " tem " + felipe.idade + " anos ");
28 | //RESULTADO NO CONSOLE
29 | //O aluno Felipe tem 8 anos
30 | }
31 | }
32 | ```
33 |
34 | Seguindo a convenção Java Beans, uma classe que contém esta estrutura de estados deverá seguir as regras abaixo:
35 |
36 | * Os atributos precisam ter o modificador de acesso `private`. Ex.: private String nome;
37 | * Como agora os atributos estarão somente a nível de classe, precisaremos dos métodos **get**X e **set**X, Ex.: getNome() e setNome(String novoNome);
38 | * O método **get** é responsável por obter o valor atual do atributo, logo ele precisa ser `public` retornar um tipo correspondente ao valor, Ex.: `public String getNome() {}`;
39 | * O método **set** é responsável por definir ou modificador o valor de um atributo em um objeto, logo ele também precisa ser `public`, receber um parâmetro do mesmo tipo da variável mas não retorna nenhum valor void. Ex.: `public void setNome(String newNome)`;
40 |
41 | ```java
42 | //arquivo Aluno.java
43 | public class Aluno {
44 | private String nome;
45 | private int idade;
46 |
47 | public String getNome() {
48 | return nome;
49 | }
50 | public void setNome(String newNome) {
51 | nome = newNome;
52 | }
53 | public int getIdade() {
54 | return idade;
55 | }
56 | public void setIdade(int newIdade) {
57 | this.idade = newIdade;
58 | }
59 | }
60 | //arquivo Escola.java
61 | public class Escola {
62 | public static void main(String[] args) {
63 | Aluno felipe = new Aluno();
64 | felipe.setNome("Felipe");
65 | felipe.setIdade(8);
66 |
67 | System.out.println("O aluno " + felipe.getNome() + " tem " + felipe.getIdade() + " anos ");
68 | }
69 | }
70 | ```
71 |
72 | {% hint style="info" %}
73 | A proposta do código acima é a mesma que o código anterior, a diferença é que adotamos a convenção Java Beans para definir e obter as características dos nossos objetos.
74 | {% endhint %}
75 |
76 | Uso do `this` no método `set`. É muito comum vermos nossos métodos de definição ter a seguinte sintaxe:
77 |
78 | ```java
79 | //arquivo Aluno.java
80 | private String nome;
81 |
82 | public void setNome(String nome) {
83 | this.nome = nome;
84 | }
85 | ```
86 |
87 | {% hint style="warning" %}
88 | Observe que a descrição do nosso atributo `nome` é igual a descrição do parâmetro, logo utilizamos mais uma palavra reservada `this` para distinguir um do outro. Para mais detalhes veja [Palavras Reservadas](broken-reference).
89 | {% endhint %}
90 |
91 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/instanciacao.md:
--------------------------------------------------------------------------------
1 | # Instânciação
2 |
3 | Instância de objetos e enums
4 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/pilares-do-poo/README.md:
--------------------------------------------------------------------------------
1 | # Pilares do POO
2 |
3 | Apresentar os 4 pilares
4 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/pilares-do-poo/abstracao.md:
--------------------------------------------------------------------------------
1 | # Abstração
2 |
3 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/pilares-do-poo/encapsulamento.md:
--------------------------------------------------------------------------------
1 | # Encapsulamento
2 |
3 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/pilares-do-poo/heranca.md:
--------------------------------------------------------------------------------
1 | # Herança
2 |
3 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/pilares-do-poo/polimorfimo.md:
--------------------------------------------------------------------------------
1 | # Page 1
2 |
3 |
--------------------------------------------------------------------------------
/gitbook/programacao-orientada-a-objetos/uml.md:
--------------------------------------------------------------------------------
1 | # UML
2 |
3 |
--------------------------------------------------------------------------------
/gitbook/sintaxe/anatomia-das-classes.md:
--------------------------------------------------------------------------------
1 | ---
2 | description: Uma classe bem estruturada não quer guerra com ninguém
3 | ---
4 |
5 | # Anatomia das classes
6 |
7 | A escrita de códigos de um programa é feito através da composição de palavras pré-definidas pela linguagem com as expressões que utilizamos para determinar o nome do nossos arquivos, classes, atributos e métodos.
8 |
9 | É muito comum mesclarmos expressões no idioma americano com o nosso vocabulário. Existem projetos que recomendam que toda a implementação do seu programa seja escrita na língua inglesa.
10 |
11 | **Sintaxe de declaração de uma nova classe:**
12 |
13 |  (1) (1).png>)
14 |
15 | * 99,9% das nossas classes iniciarão com `public class;`
16 | * Toda classe precisa de nome, exemplo `MinhaClasse;`
17 | * O nome do arquivo deve ser idêntico ao nome da classe pública;
18 | * Após o nome, definir o corpo `{ }` , onde iremos compor nossas classes com atributos e métodos.
19 |
20 |  (1) (1) (1) (1).png>)
21 |
22 | * É de suma importância que agora você consiga se localizar dentro do conjunto de chaves `{ }` existentes em sua classe.
23 | * Dentro de uma aplicação, **recomenda-se que somente uma classe possua o método** `main`, responsável por iniciar todo o nosso programa.
24 | * O método main recebe seu nome `main`, sempre terá a visibilidade `public`, será difinido como `static`, não retornará nenhum valor com `void` e receberá um parâmetro do tipo array de caracteres `String[]`.
25 |
26 | ## Padrão de nomenclatura
27 |
28 | Quando se trata de escrever códigos na linguagem Java, é recomendado seguir algumas convenções de escrita. Esses padrões estão expressos nos itens abaixo:
29 |
30 | * **Arquivo .java**: Todo arquivo .java deve começar com letra MAIÚSCULA. Se a palavra for composta, a segunda palavra deve também ser maiúscula, exemplo:
31 |
32 | `Calculadora.java`, `CalculadoraCientifica.java`
33 | * **Nome da classe no arquivo**: A classe deve possuir o mesmo nome do arquivo.java, exemplo:
34 |
35 | ```java
36 | // arquivo CalculadoraCientifica.java
37 |
38 | public class CalculadoraCientifica {
39 |
40 | }
41 | ```
42 |
43 | * **Nome de variável**: toda variável deve ser escrita com letra minúscula, porém se a palavra for composta, a primeira letra da segunda palavra deverá ser MAIÚSCULA, exemplo: `ano` e `anoFabricacao`. O nome dessa prática para nomear variáveis dessa forma se chama "camelCase".
44 |
45 | {% hint style="info" %}
46 | Existe uma regra adicional para variáveis quando na mesma queremos identificar que ela não sofrerá alteração de valor, exemplo: queremos determinar que uma variável de nome **br** sempre representará **"Brasil"** e nunca mudará seu valor, logo, determinamos como escrita o código abaixo:
47 | {% endhint %}
48 |
49 | ```java
50 | String BR = "Brasil"
51 | double PI = 3.14
52 | int ESTADOS_BRASILEIRO = 27
53 | int ANO_2000 = 2000
54 | ```
55 |
56 | {% hint style="danger" %}
57 | Recomendações: Para declarar uma variável nós podemos utilizar caracteres, números e símbolos, porém devemos seguir algumas regras da linguagem.
58 | {% endhint %}
59 |
60 | * Deve conter apenas letras, \_ (underline), $ ou os números de 0 a 9
61 | * Deve obrigatoriamente se iniciar por uma letra (preferencialmente), \_ ou $, jamais com número
62 | * Deve iniciar com uma letra minúscula (boa prática – ver abaixo)
63 | * Não pode conter espaços
64 | * Não podemos usar palavras-chave da linguagem
65 | * O nome deve ser único dentro de um escopo
66 |
67 | ```java
68 | // Declação inválida de variáveis
69 |
70 | int numero&um = 1; //Os únicos símbolos permitidos são _ e $
71 | int 1numero = 1; //Uma variável não pode começar com númerico
72 | int numero um = 1; //Não pode ter espaço no nome da variável
73 | int long = 1; //long faz parte das palavras reservadas da linguagem
74 |
75 | // Declaração válida de veriáveis
76 | int numero$um = 1;
77 | int numero1 = 1;
78 | int numeroum = 1;
79 | int longo = 1;
80 |
81 | ```
82 |
83 | ## Declarando variáveis e métodos
84 |
85 | Como identificar entre declaração de variáveis e métodos em nossa programa? Existe uma estrutura comum para ambas as finalidades, exemplo:
86 |
87 | * Declarar uma variável em Java segue sempre a seguinte estrutura:
88 |
89 | ```java
90 | // Estrutura
91 |
92 | Tipo NomeBemDefinido = Atribuição (opcional em alguns casos)
93 |
94 | // Exemplo
95 |
96 | int idade = 23;
97 | double altura = 1.62;
98 | Dog spike; //observe que aqui a variável spike não tem valor, é normal
99 | ```
100 |
101 | * Declarando métodos em Java segue uma estrutura bem simples:
102 |
103 | ```java
104 | // Estrutura
105 |
106 | TipoRetorno NomeObjetivoNoInfinitivo Parametro(s)
107 |
108 | //Exemplo
109 |
110 | int somar (int numeroUm, int numero2)
111 |
112 | String formatarCep (long cep)
113 | ```
114 |
115 | {% hint style="warning" %}
116 | Como parte da estrutura de declaração de variáveis e métodos também temos o aspecto da **visibilidade**, mas ainda não é necessário nesta etapa de estudos.
117 | {% endhint %}
118 |
119 | ## Identação
120 |
121 | Basicamente **indentar** é um termo utilizado para escrever o código do programa de forma hierárquica, facilitando assim a visualização e o entendimento do programa.
122 |
123 |  (1) (1) (1).png>)
124 |
125 | Abaixo, veja um exemplo de um algoritmo de validação de aprovação de estudante. Em uma aba, temos um código sem identação nenhuma, e na outra aba, temos o mesmo código seguindo um padrão de identação. Observe como é muito mais fácil entender a hierarquia do código na segunda aba.
126 |
127 | {% tabs %}
128 | {% tab title="Sem Identação" %}
129 | ```java
130 | // arquivo BoletimEstudantil.java
131 |
132 | public class BoletimEstudantil {
133 | public static void main(String[] args) {
134 | int mediaFinal = 6;
135 | if(mediaFinal<6)
136 | System.out.println("REPROVADO");
137 | else if(mediaFinal==6)
138 | System.out.println("PROVA MINERVA");
139 | else
140 | System.out.println("APROVADO");
141 | }
142 | }
143 | ```
144 | {% endtab %}
145 |
146 | {% tab title="Com Identação" %}
147 | ```java
148 | public class BoletimEstudantil {
149 | public static void main(String[] args) {
150 | int mediaFinal = 6;
151 | if (mediaFinal < 6)
152 | System.out.println("REPROVADO");
153 | else if (mediaFinal == 6)
154 | System.out.println("PROVA MINERVA");
155 | else
156 | System.out.println("APROVADO");
157 | }
158 | }
159 | ```
160 | {% endtab %}
161 | {% endtabs %}
162 |
163 | ## Organizando arquivos
164 |
165 | À medida que nosso sistema vai evoluindo, surgem novos arquivos (código fonte) em nossa estrutura de arquivos do projeto. Isso exige que seja realizado uma organização destes arquivos através de pacotes (packages).
166 |
167 | .png>)
168 |
169 | Com o uso de pacotes as nossas classes (.java) passam a possuir duas identificações, o nome simples e nome qualificado:
170 |
171 | * **Nome Simples**: Nome do arquivo, exemplo `ContaBanco`.
172 | * **Nome Qualificado**: Nome do pacote + nome do arquivo, exemplo: `com.suaempresa.ContaBanco`.
173 |
174 | ## Java Beans
175 |
176 | Umas das maiores dificuldades na programação é escrever algoritmos legíveis a níveis que sejam compreendidos por todo seu time ou por você mesmo no futuro. Para isso a linguagem Java sugere, através de convenções, formas de escrita universal para nossas classes, atributos, métodos e pacotes.
177 |
178 | #### Variáveis
179 |
180 | Mais cedo já aprendemos algumas regras de declaração de variáveis, mas agora iremos conhecer algumas sugestões de de nomenclatura:
181 |
182 | * Uma variável deve ser clara, sem abreviações ou definição sem sentido;
183 | * Uma variável é sempre no singular, **exceto quando se referir a um array ou coleção**.
184 | * Defina um idioma único para suas variáveis. Se você for declarar variáveis em inglês, defina todas em inglês.
185 |
186 | #### Não recomendado
187 |
188 | ```java
189 | double salMedio = 1500.23 //variável abreviada, o que dificulta a compreensão
190 | String emails = "aluno@escola.com" //confuso se a variável seria um array ou único e-mail
191 | String myName = "JOSEPH" //se idioma pt-BR, o valor poder ser de outro idioma mas o nome da variável não
192 | ```
193 |
194 | #### Recomendado
195 |
196 | ```java
197 | double salarioMedio=1500.23;
198 | String email ="aluno@escola.com";
199 | String [] emails = {"aluno@escola.com","professor@escola.com"}
200 | String meuNome = "JOSEPH"
201 | ```
202 |
203 | #### Métodos
204 |
205 | Os métodos deverão ser nomeados como verbos, através de uma mistura de letras minúsculas e maiúsculas. Em princípio todas as letras que compõem o nome devem ser mantidas em minúsculo, com exceção da primeira letra de cada palavra composta a partir da segunda palavra.
206 |
207 | Exemplos sugeridos para nomenclatura de métodos:
208 |
209 | ```java
210 | somar(int n1, int n2){}
211 |
212 | abrirConexao(){}
213 |
214 | concluirProcessamento() {}
215 |
216 | findById(int id){} // não se assuste, você verá muito método em inglês em sua jornada
217 |
218 | calcularImprimir(){} // há algo de errado neste método, ele deveria ter uma única finalidade
219 | ```
220 |
221 | ##
222 |
--------------------------------------------------------------------------------
/gitbook/sintaxe/documentacao.md:
--------------------------------------------------------------------------------
1 | # Documentação
2 |
3 | Uma das maiores características da linguagem Java é que desde suas primeiras versões tínhamos em nossas mãos uma documentação rica e detalhada dos recursos da linguagem.
4 |
5 | Conforme site oficial, podemos compreender e explorar todos os recursos organizados por pacotes e classes bem específicas sem nem mesmo escrever uma linha de código.
6 |
7 | Hoje costuma-se afirmar que para se tornar um desenvolvedor nível avançado, é um requisito imprescindível adquirir a habilidade de compreender a documentação oficial da linguagem e dos frameworks que são incorporados nos projetos atuais.
8 |
9 | Aqui temos o link da documentação de uma das principais classes da linguagem Java.
10 |
11 | {% embed url="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html" %}
12 | Documentação da classe String na versão 7 da linguagem
13 | {% endembed %}
14 |
15 | ## Tags
16 |
17 | Mas e quais as informações que obtemos através de classes documentadas na linguagem ? Java Documentation é composto por tags que representam dados relevantes para a compreensão da proposta de uma classe e os conjunto de seus métodos e atributos conforme tabela abaixo:
18 |
19 | | Tag | Descrição |
20 | | -------- | ------------------------------------------------------ |
21 | | @autor | Autor / Criador |
22 | | @version | Versão do recurso disponibilizado |
23 | | @since | Versão / Data de início da disponibilização do recurso |
24 | | @param | Descrição dos parâmetros dos métodos criados |
25 | | @return | Definição do tipo de retorno de um método |
26 | | @throws | Se o método lança alguma exceção |
27 |
28 | Abaixo iremos ilustrar a classe Calculadora com um exemplo de documentação destacando as **tags** mais utilizadas.
29 |
30 | {% tabs %}
31 | {% tab title="Código" %}
32 | ```java
33 | /**
34 | * Calculadora
35 | * A Calculadora realiza operações matemáticas entre números inteiros
36 | *
37 | * Note: Leia atentamente a documentação desta classes
38 | * para desfrutar dos recursos oferecidos pelo autor
39 | *
40 | * @author Gleyson Sampaio
41 | * @version 1.0
42 | * @since 01/01/2022
43 | */
44 | public class Calculadora {
45 | /**
46 | * Este método é utilizado para somar dois números inteiros
47 | * @param numeroUm este é o primeiro parâmetro do método
48 | * @param numeroDois este é o segundo parâmetro do método
49 | * @return int o resultado deste método é a soma dos dois números.
50 | */
51 | public int somar(int numeroUm, int numeroDois) {
52 | return numeroUm + numeroDois;
53 | }
54 | }
55 |
56 | ```
57 | {% endtab %}
58 |
59 | {% tab title="Guia" %}
60 |  (1).png>)
61 | {% endtab %}
62 | {% endtabs %}
63 |
64 | ### Tipos de comentários
65 |
66 | {% tabs %}
67 | {% tab title="One Line" %}
68 | ```
69 | // Olá, eu sou um comentário em uma única linha
70 | ```
71 | {% endtab %}
72 |
73 | {% tab title="Mult Line" %}
74 | ```
75 | /* Olá,
76 | * Eu sou um comentario
77 | * que posso ser mais detalhadod
78 | * quando necessário
79 | */
80 | ```
81 | {% endtab %}
82 |
83 | {% tab title="Documentation" %}
84 | ```
85 | /**
86 | * Estas duas estrelinhas acima
87 | * é para identificar que você
88 | * pretende elaborar um comentário
89 | * a nível de documentação.
90 | * Que incrível !!!
91 | */
92 | ```
93 | {% endtab %}
94 | {% endtabs %}
95 |
96 | {% hint style="danger" %}
97 | Um comentário não possui a finalidade de **amenizar** um algoritmo não estruturado conforme as convenções da linguagem.
98 | {% endhint %}
99 |
100 | ```java
101 | /*
102 | * Este método foi elaborado as pressas
103 | * por isso eu abrevei o nome das variáveis
104 | * mas olha, ele tem a finalidade somar ou multiplicar
105 | * dois números
106 | * /
107 | public int somaMultiplica (int n, int x, String m){
108 | int r = 0; // r é igual ao resultado
109 | if (m == "M"){ // M= multiplicação
110 | r= n * x;
111 | }else{
112 | // se não soma mesmo
113 | r = n + x
114 | }
115 | return r;
116 | }
117 | ```
118 |
119 | ## Javadoc
120 |
121 | **Javadoc** é um gerador de documentação criado pela [Sun Microsystems](https://pt.wikipedia.org/wiki/Sun\_Microsystems) para documentar a [API](https://pt.wikipedia.org/wiki/API) dos programas em [Java](https://pt.wikipedia.org/wiki/Linguagem\_de\_programa%C3%A7%C3%A3o\_Java), a partir do [código-fonte](https://pt.wikipedia.org/wiki/C%C3%B3digo-fonte). O resultado é expresso em [HTML](https://pt.wikipedia.org/wiki/HTML). É constituído, basicamente, por algumas marcações muitos simples inseridas nos comentários do programa.
122 |
123 | Este sistema é o padrão de documentação de classes em Java, e muitas dos [IDEs](https://pt.wikipedia.org/wiki/Ambiente\_de\_desenvolvimento\_integrado) desta linguagem irão automaticamente gerar um Javadoc em [HTML](https://pt.wikipedia.org/wiki/HTML).
124 |
125 | {% embed url="https://pt.wikipedia.org/wiki/Javadoc" %}
126 |
127 | Criando nossa documentação no formato html para disponibilizar via web.
128 |
129 | ```
130 | // No terminal execute o comando abaixo
131 |
132 | javadoc -encoding UTF-8 -docencoding ISO-8859-1 -d ../docs src/*.java
133 | ```
134 |
135 |
136 |
137 | ##
138 |
--------------------------------------------------------------------------------
/gitbook/sintaxe/escopo.md:
--------------------------------------------------------------------------------
1 | # Escopo
2 |
3 | O escopo pode ser entendido como o ambiente onde uma variável pode ser acessada. Em Java, o escopo de variáveis **vai de acordo com o bloco onde ela foi declarada**.
4 |
5 | A variável é criada no primeiro acesso à ela, se tornando inacessível após o interpretador sair do bloco de execução ao qual ela pertence. Portanto, esta variável não pode ser lida ou manipulada por rotinas e códigos que estão fora do seu bloco de declaração, ou seja, fora do escopo da variável.
6 |
7 | Em uma Classe, podemos visualizar a diferença de escopos. Os atributos (variáveis) são declarados no corpo principal da Classe, sendo portanto acessíveis por todos os métodos.
8 |
9 | Caso você declare uma variável DENTRO DE UM MÉTODO, o escopo dessa variável está limitado apenas ao corpo desse método, ou seja, dentro das chaves que limitam o método.
10 |
11 | Uma parte fundamental na elaboração de algoritmos simples ou complexos é determinar a localização do código em questão. Sem um domínio sobre escopo de códigos seu projeto tende a conter falhas estruturais e comprometer a proposta principal da aplicação.
12 |
13 | ```java
14 | public class Conta {
15 | //variavel da classe conta
16 | double saldo=10.0;
17 |
18 | public void sacar(Double valor) {
19 | //variavel local de método
20 | double novoSaldo = saldo - valor;
21 | }
22 | public void imprimirSaldo(){
23 | //disponível em toda classe
24 | System.out.println(saldo);
25 | //somente o método sacar conhece esta variavel
26 | System.out.println(novoSaldo);
27 |
28 | }
29 | public double calcularDividaExponencial(){
30 | //variável local de método
31 | double valorParcela = 50.0;
32 | double valorMontante = 0.0; // começando a variável com valor zero
33 | for(int x=1; x<=5; x++) {//x variável de escopo de fluxo
34 | //esta variável será reiniciada a cada execução for
35 | double valorCalculado = valorParcela * x;
36 | valorMontante = valorMontante + valorCalculado;
37 | }
38 | //escopo de fluxo
39 | //x e valorCalculado nunca estarão disponíveis fora do for
40 |
41 | return valorMontante;
42 | }
43 | }
44 | ```
45 |
--------------------------------------------------------------------------------
/gitbook/sintaxe/metodos.md:
--------------------------------------------------------------------------------
1 | ---
2 | description: Todas as ações das aplicações são consideradas métodos.
3 | ---
4 |
5 | # Métodos
6 |
7 | Uma classe é definida por atributos e métodos. Já vimos que atributos são, em sua grande maioria, variáveis de diferentes tipos e valores. Os métodos, por sua vez, correspondem a **funções** ou **sub-rotinas** disponíveis dentro de nossas classes.
8 |
9 | ### Critério de nomeação de Métodos
10 |
11 | Esses critérios não são obrigatórios, mas é recomendável que sejam seguidos, pois essas convenções facilitam a vida dos programadores ao trabalharem em códigos de forma colaborativa. Ao seguir estas convenções, tornamos o código mais legível para nós e também para outras pessoas. Para métodos, os critérios são:
12 |
13 | * Deve ser nomeado como verbo
14 | * Seguir o padrão camelCase (Todas as letras minúsculas com a exceção da primeira letra da segunda palavra).
15 |
16 | Exemplos sugeridos para nomenclatura de métodos:
17 |
18 | ```java
19 | somar(int n1, int n2){}
20 |
21 | abrirConexao(){}
22 |
23 | concluirProcessamento() {}
24 |
25 | findById(int id){} // não se assuste, você verá muito método em inglês em sua jornada
26 |
27 | calcularImprimir(){} // há algo de errado neste método, ele deveria ter uma única finalidade
28 |
29 | ```
30 |
31 | {% hint style="info" %}
32 | ATENÇÃO! Não existe em **Java** o conceito de **métodos** globais. Todos os **métodos** devem SEMPRE ser definidos dentro de uma classe.
33 | {% endhint %}
34 |
35 | ### Critério de definição de métodos
36 |
37 | Mas, como sabemos a melhor forma de definir os métodos das nossas classes? Para chegar à essa conclusão, somos auxiliados por uma convenção estrutural para todos os métodos. Essa convenção é determinada pelos aspectos abaixo:
38 |
39 | 1. **Qual a proposta principal do método?** Você deve se perguntar constantemente até compreender a real finalidade do mesmo.
40 | 2. **Qual o tipo de retorno esperado após executar o método?** Você deve analisar se o método será responsável por retornar algum valor ou não.
41 |
42 | {% hint style="info" %}
43 | Caso o método não retorne nenhum valor, ele será representado pela palavra-chave `void`.
44 | {% endhint %}
45 |
46 | 1. **Quais os parâmetros serão necessários para execução do método?** Os métodos as vezes precisam de argumentos como critérios para a execução.
47 | 2. **O método possui o risco de apresentar alguma exceção?** Exceções são comuns na execução de métodos, as vezes é necessário prever e tratar a possível existência de uma exceção.
48 | 3. **Qual a visibilidade do método?** Será necessário que o método seja visível a toda aplicação, somente em mesmo pacotes, através de herança ou somente a nível a própria classe.
49 |
50 | Abaixo temos um exemplo de uma classe com dois métodos e suas respectivas considerações:
51 |
52 | ```java
53 | public class MyClass {
54 |
55 | public double somar(int num1, int num2){
56 | //LOGICA - FINALIDADE DO MÉTODO
57 | return ... ;
58 | }
59 |
60 | public void imprimir(String texto){
61 | //LOGICA - FINALIDADE DO MÉTODO
62 | //AQUI NÃO PRECISA DO RETURN
63 | //POIS NÃO SERÁ RETORNADO NENHUM RESULTADO
64 | }
65 | // throws Exception : indica que o método ao ser utilizado
66 | // poderá gerar uma exceção
67 | public double dividir(int dividendo, int divisor) throws Exception{}
68 |
69 | // este método não pode ser visto por outras classes no projeto
70 | private void metodoPrivado(){}
71 |
72 | //alguns equívocos estruturais
73 | public void validar(){
74 | //este método deveria retornar algum valor
75 | //no caso boolean (true ou false)
76 | }
77 | public void calcularEnviar(){
78 | //um método deve representar uma única responsabilidade
79 | }
80 | public void gravarCliente(String nome, String cpf, Integer telefone, ....){
81 | //este método tem a finalidade de gravar
82 | //informações de um cliente, por que não criar
83 | //um objeto cliente e passar como parâmetro ?
84 | //veja abaixo
85 | }
86 | public void gravarCliente(Cliente cliente){}
87 | //ou
88 | public void gravar(Cliente cliente){}
89 | }
90 | ```
91 |
92 | ## Exercitando
93 |
94 | Vamos criar um exemplo de uma classe para representar uma SmartTV onde:
95 |
96 | 1. Ela tenha as características: ligada (boolean), canal (int) e volume (int)
97 | 2. Nossa TV poderá ligar e desligar e assim mudar o estado ligada
98 | 3. Nossa TV aumentará e diminuirá o volume sempre em +1 ou -1
99 | 4. Nossa TV poderá mudar de canal de 1 em 1 ou definindo o número correspondente
100 |
--------------------------------------------------------------------------------
/gitbook/sintaxe/operadores.md:
--------------------------------------------------------------------------------
1 | ---
2 | description: >-
3 | Símbolos especiais que tem um significado próprio para a linguagem e estão
4 | associados a determinadas operações.
5 | ---
6 |
7 | # Operadores
8 |
9 | Geralmente as primeiras palavras que ouvimos em um curso de programação são: um programa é um conjunto de instruções lógicas que, quando executadas, produzem algum resultado. Com isso em mente, ao começar a criar as primeiras linhas de código, logo você notará que é comum receber dados do usuário, prover alguma lógica para processá-los e então apresentar o resultado desse processamento.
10 |
11 |  (1) (1) (1).png>)
12 |
13 | ## Classificação do operadores
14 |
15 | ### Atribuição
16 |
17 | Representado pelo símbolo de igualdade `=`.
18 |
19 | O operador de atribuição é utilizado para definir o valor inicial ou sobrescrever o valor de uma variável. em Java definimos um tipo, nome e opcionalmente atribuímos um valor à variável através do operador de atribuição. Exemplos abaixo:
20 |
21 | ```java
22 | //classe Operadores.java
23 | String nome = "GLEYSON";
24 | int idade = 22;
25 | double peso = 68.5;
26 | char sexo = 'M';
27 | boolean doadorOrgao = false;
28 | Date dataNascimento = new Date();
29 | ```
30 |
31 | ### Aritméticos
32 |
33 | O operador aritmético é utilizado para realizar operações matemáticas entre valores numéricos, podendo se tornar ou não uma expressão mais complexa.
34 |
35 | Os operadores aritméticos são: `+` (adição), `-` (subtração), `*` (multiplicação) e `/` (divisão).
36 |
37 | ```java
38 | //classe Operadores.java
39 | double soma = 10.5 + 15.7;
40 | int subtração = 113 - 25;
41 | int multiplicacao = 20 * 7;
42 | int divisao = 15 / 3;
43 | int modulo = 18 % 3;
44 | double resultado = (10 * 7) + (20/4);
45 | ```
46 |
47 | {% hint style="warning" %}
48 | ATENÇÃO! O operador de adição (+), quando utilizado em variáveis do tipo texto, realizará a “concatenação de textos”.
49 | {% endhint %}
50 |
51 | ```java
52 | //classe Operadores.java
53 | String nomeCompleto = "LINGUAGEM" + "JAVA";
54 |
55 | //qual o resultado das expressoes abaixo?
56 | String concatenacao ="?";
57 |
58 | concatenacao = 1+1+1+"1";
59 |
60 | concatenacao = 1+"1"+1+1;
61 |
62 | concatenacao = 1+"1"+1+"1";
63 |
64 | concatenacao = "1"+1+1+1;
65 |
66 | concatenacao = "1"+(1+1+1);
67 | ```
68 |
69 | ### Unários
70 |
71 | Esses operadores são aplicados juntamente com um outro operador aritmético. Eles realizam alguns trabalhos básicos como incrementar, decrementar, inverter valores numéricos e booleanos.
72 |
73 | * (+) **Operador unário de valor positivo** – números são positivos sem esse operador explicitamente;
74 | * (-) **Operador unário de valor negativo** – nega um número ou expressão aritmética;
75 | * (++) **Operador unário de incremento de valor** – incrementa o valor em 1 unidade;
76 | * (--) **Operador unário de decremento de valor** – decrementa o valor em 1 unidade;
77 | * (!) **Operador unário lógico de negação** – nega o valor de uma expressão booleana;
78 |
79 | Exemplos abaixo:
80 |
81 | ```java
82 | //classe Operadores.java
83 | int numero = 5;
84 |
85 | //Imprimindo o numero negativo
86 | System.out.println(- numero);
87 |
88 | //incrementando numero em mais 1 numero, imprime 6
89 | numero ++;
90 | System.out.println(numero);
91 |
92 | //incrementando numero em mais 1 numero, imprime 7
93 | System.out.println(numero ++);// ops algo de errado não está certo
94 |
95 | System.out.println(numero);// agora sim, numero virou 7
96 |
97 | //ordem de precedencia conta aqui
98 | System.out.println(++ numero);
99 |
100 | boolean verdadeiro = true;
101 |
102 | System.out.println("Inverteu " + !verdadeiro);
103 | ```
104 |
105 | {% hint style="danger" %}
106 | Muito cuidado com ordem de precedência dos operadores unários!
107 | {% endhint %}
108 |
109 | ### Ternário
110 |
111 | O Operador de Condição Ternária é uma forma resumida para definir uma condição e escolher por um dentre dois valores. Você deve pensar numa condição ternária como se fosse uma condição IF normal, porém, de uma forma em que toda a sua estrutura estará escrita numa única linha.
112 |
113 | O operador ternário é representado pelos símbolos `?:` utilizados na seguinte estrutura de sintaxe:
114 |
115 | ``` `**`?`**` ```` `**`:`**` ```
116 |
117 | Exemplos abaixo:
118 |
119 | ```java
120 | // classe Operadores.java
121 | int a, b;
122 |
123 | a = 5;
124 | b = 6;
125 |
126 | /* EXEMPLO DE CONDICIONAL UTILIZANDO UMA ESTRUTURA IF/ELSE
127 | if(a==b)
128 | resultado = "verdadeiro";
129 | else
130 | resultado = "falso";
131 | */
132 |
133 | //MESMA CONDICIONAL, MAS DESSA VEZ, UTILIZANDO O OPERADOR CONDICIONAL TERNÁRIO
134 | String resultado = (a==b) ? "verdadeiro" : "false";
135 |
136 | System.out.println(valor);
137 | ```
138 |
139 | {% hint style="info" %}
140 | O operador ternário é aplicado para qualquer tipo de valor.
141 | {% endhint %}
142 |
143 | ### Relacionais
144 |
145 | Os operadores relacionais avaliam a relação entre duas variáveis ou expressões. Neste caso, mais precisamente, definem se o operando à esquerda é igual, diferente, menor, menor ou igual, maior ou maior ou igual ao da direita, retornando um valor booleano como resultado.
146 |
147 | * `==` Quando desejamos verificar se uma variável é IGUAL A outra.
148 | * `!=` Quando desejamos verificar se uma variável é DIFERENTE da outra.
149 | * `>` Quando desejamos verificar se uma variável é MAIOR QUE a outra.
150 | * `>=` Quando desejamos verificar se uma variável é MAIOR OU IGUAL a outra.
151 | * `<` Quando desejamos verificar se uma variável é MENOR QUE outra.
152 | * `<=` Quando desejamos verificar se uma variável é MENOR OU IGUAL a outra.
153 |
154 | ```java
155 | //classe Operadores.java
156 | int numero1 = 1;
157 | int numero2 = 2;
158 |
159 | if(numero1 > numero2)
160 | System.out.print("Numero 1 maior que numero 2");
161 |
162 | if(numero1 < numero2)
163 | System.out.print("Numero 1 menor que numero 2");
164 |
165 | if(numero1 >= numero2)
166 | System.out.print("Numero 1 maior ou igual que numero 2");
167 |
168 | if(numero1 <= numero2)
169 | System.out.print("Numero 1 menor ou igual que numero 2");
170 |
171 | if(numero1 != numero2)
172 | System.out.print("Numero 1 é diferente de numero 2");jav
173 | ```
174 |
175 | #### Comparações avançadas
176 |
177 | Quando se refere a comparação de conteúdos na linguagem, devemos ter um certo domínio de como o Java trata o armazenamento deste valores na memória.
178 |
179 | {% hint style="success" %}
180 | Quando estiver mais familiarizado com linguagem, recomendamos se aprofundar no conceito de espaço em memória **Stack** versus **Heap**.
181 | {% endhint %}
182 |
183 | Vamos a alguns exemplos para ilustrar:
184 |
185 | **Valor e referência**: Precisamos entender que em Java tudo é objeto, logo objetos diferentes podem ter as mesmas características, mas lembrando, _**são objetos diferentes**_.
186 |
187 | ```java
188 | // ComparacaoAvancada.java
189 | public static void main(String[] args) {
190 |
191 | String nome1 = "JAVA";
192 | String nome2 = "JAVA";
193 |
194 | System.out.println(nome1 == nome2); //true
195 |
196 | String nome3 = new String("JAVA");
197 |
198 | System.out.println(nome1 == nome3); //false
199 |
200 | String nome4 = nome3;
201 |
202 | System.out.println(nome3 == nome4); //true
203 |
204 | //equals na parada
205 | System.out.println(nome1.equals(nome2)); //??
206 | System.out.println(nome2.equals(nome3)); //??
207 | System.out.println(nome3.equals(nome4)); //??
208 |
209 | }
210 | ```
211 |
212 | **== versus equals:** Existe uma relevância forte em realizar comparações com **==** e **equals** na qual precisamos ter uma compreensão de quais as regras seguidas pela linguagem **** , exemplo:
213 |
214 | ```java
215 | // ComparacaoAvancada.java
216 | public static void main(String[] args) {
217 |
218 | int numero1 = 130;
219 | int numero2 = 130;
220 | System.out.println(numero1 == numero2); //true
221 |
222 | Integer numero1 = 130;
223 | Integer numero2 = 130;
224 |
225 | System.out.println(numero1 == numero2); //false
226 |
227 | // A razão pela qual o resultado é false, é devido o Java tratar os valores
228 | // Como objetos a partir de agora.
229 | // Qual a solução ?
230 | // Quando queremos comparar objetos, usamos o método equals
231 |
232 | System.out.println(numero1.equals(numero2));
233 | }
234 | ```
235 |
236 | ### Lógicos
237 |
238 | Os operadores lógicos representam o recurso que nos permite criar expressões lógicas maiores a partir da junção de duas ou mais expressões.
239 |
240 | * `&&` Operador Lógico "E"
241 | * `||` Operador Lógico "OU"
242 |
243 | ```java
244 | // Operadores.java
245 | boolean condicao1=true;
246 |
247 | boolean condicao2=false;
248 |
249 | /* Aqui estamos utilizando o operador lógico E para fazer a união de duas
250 | expressões.
251 | É como se estivesse escrito:
252 | "Se Condicao1 e Condicao2 forem verdadeiras, executar código"
253 | */
254 |
255 | if(condicao1 && condicao2)
256 | System.out.print("Os dois valores precisam ser verdadeiros");;
257 |
258 | //Se condicao1 OU condicao2 for verdadeira, executar código.
259 | if(condicao1 || condicao2)
260 | System.out.print("Um dos valores precisa ser verdadeiro");
261 | ```
262 |
263 | #### Expressões lógicas avançadas
264 |
265 | Nós acabamos de aprender que existem os operadores lógicos **`&`** (E) e `||` (OU), mas por quê no exemplo acima, foram ilustradas as condições:
266 |
267 | if (condicao1 **&&** condicao2) e if(condicao1 **||** condicao2) ?
268 |
269 | {% hint style="success" %}
270 | A duplicidade nos operadores lógicos é um recurso conhecido como _**Operador Abreviado**_, isso quer que se a condição1 atender aos critérios não será necessário validar a condição2.
271 | {% endhint %}
272 |
273 | ```java
274 | // ComparacaoAvancada.java
275 | int numero1 = 1;
276 | int numero2 = 1;
277 |
278 | if(numero1== 2 & numero2 ++ == 2 )
279 | System.out.println("As 2 condições são verdadeiras");
280 |
281 | System.out.println("O numero 1 agora é " + numero1);
282 | System.out.println("O numero 2 agora é " + numero2);
283 |
284 | // Vamos mudar a linha 5 do código acima para: if(numero1== 2 && numero2 ++ == 2 )
285 |
286 | ```
287 |
288 | {% hint style="success" %}
289 | O mesmo acontece com o operador | e || considerando que operador agora representa que, se uma das alternativas for verdadeira, a outra nem precisa ser avaliada.
290 | {% endhint %}
291 |
292 |
293 |
294 |
--------------------------------------------------------------------------------
/gitbook/sintaxe/palavras-reservadas.md:
--------------------------------------------------------------------------------
1 | # Palavras reservadas
2 |
3 | Palavras reservadas são identificadores de uma linguagem que já possuem uma finalidade específica, portanto não podem ser utilizados para nomear variáveis, classes, métodos ou atributos.
4 |
5 | A linguagem Java possui 52 palavras reservadas. Todas essas palavras são classificadas em grupos e escritas com letra minúscula, sendo identificadas com uma cor especial pela maioria das IDE's. Abaixo temos a lista de palavras agrupadas por sua finalidades.
6 |
7 |  (1) (1) (1).png>)
8 |
9 | | Controle de pacotes |
10 | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
11 | | import: importa pacotes ou classes para dentro do código
package: especifica a que pacote todas as classes de um arquivo pertencem
|
12 |
13 | | Modificadores de acesso |
14 | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
15 | | public: acesso de qualquer classe
private: acesso apenas dentro da classe
protected: acesso por classes no mesmo pacote e subclasses
|
16 |
17 | | Primitivos |
18 | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
19 | | boolean: um valor indicando verdadeiro ou falso
byte: um inteiro de 8 bits (signed)
char: um character unicode (16-bit unsigned)
double: um número de ponto flutuante de 64 bits (signed)
float: um número de ponto flutuante de 32 bits (signed)
int: um inteiro de 32 bits (signed)
long: um inteiro de 64 bits (signed)
short: um inteiro de 32 bits (signed)
void: indica que o método não tem retorno de valor
|
20 |
21 | | Modificadores de classes, variáveis ou métodos |
22 | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
23 | | abstract: classe que não pode ser instanciada ou método que precisa ser implementado por uma subclasse não abstrata
class: especifica uma classe
extends: indica a superclasse que a subclasse está estendendo
final: impossibilita que uma classe seja estendida, que um método seja sobrescrito ou que uma variável seja reinicializada
implements: indica as interfaces que uma classe irá implementar
interface: especifica uma interface
native: indica que um método está escrito em uma linguagem dependente de plataforma, como o C
new: instancia um novo objeto, chamando seu construtor
static: faz um método ou variável pertencer à classe ao invés de às instâncias
strictfp: usado em frente a um método ou classe para indicar que os números de ponto flutuante seguirão as regras de ponto flutuante em todas as expressões
synchronized: indica que um método só pode ser acessado por uma thread de cada vez
transient: impede a serialização de campos
volatile: indica que uma variável pode ser alterada durante o uso de threads
|
24 |
25 | | Controle de fluxo dentro de um bloco de código |
26 | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
27 | | break: sai do bloco de codigo em que ele está
case: executa um bloco de código dependendo do teste do switch
continue: pula a execução do código que viria após essa linha e vai para a próxima passagem do loop
default: executa esse bloco de codigo caso nenhum dos teste de switch-case seja verdadeiro
do: executa um bloco de código uma vez, e então realiza um teste em conjunto com o while para determinar se o bloco deverá ser executado novamente
else: executa um bloco de código alternativo caso o teste if seja falso
for: usado para realizar um loop condicional de um bloco de código
if: usado para realizar um teste lógico de verdadeiro o falso
instanceof: determina se um objeto é uma instância de determinada classe, superclasse ou interface
return: retorna de um método sem executar qualquer código que venha depois desta linha (também pode retornar uma variável)
switch: indica a variável a ser comparada nas expressões case
while: executa um bloco de código repetidamente enquanto a condição for verdadeira
|
28 |
29 | | Tratamento de erros |
30 | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
31 | | assert: testa uma expressão condicional para verificar uma suposição do programador
catch: declara o bloco de código usado para tratar uma exceção
finally: bloco de código, após um try-catch, que é executado independentemente do fluxo de programa seguido ao lidar com uma exceção
throw:usado para passar uma exceção para o método que o chamou
throws: indica que um método pode passar uma exceção para o método que o chamou
try: bloco de código que tentará ser executado, mas que pode causar uma exceção
|
32 |
33 | | Variáveis de referência |
34 | | ----------------------------------------------------------------------------------------------------------------------------------------- |
35 | | super: refere-se a superclasse imediata
this: refere-se a instância atual do objeto
|
36 |
37 |
38 |
39 | | Palavras reservadas não utilizadas |
40 | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
41 | | const: Não utilize para declarar constantes; use public static final
goto: não implementada na linguagem Java por ser considerada prejudicial
|
42 |
43 | | Literais reservados |
44 | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
45 | | De acordo com a Java Language Specification, **null**, **true** e **false** são tecnicamente chamados de valores literais, e não keywords. Se você tentar criar algum identificador com estes valores, você também terá um erro de compilação. |
46 |
47 | #### Escopo de uso
48 |
49 | | Uso | Palavras | Observação |
50 | | -------- | ---------------------------------------------------------------------------- | -------------------------------------------------------------------- |
51 | | Arquivo | package, import, static | |
52 | | Classe | public ou protected ou private + final ou abstract + extends ou implements | **private** (em caso de classe interna), **final** ou **abstract** ? |
53 | | Método | public ou protected ou private + static ou final ou abstract + void e return | **void** em caso de não ter retorno ou **return** se houver |
54 | | Atributo | public ou protected ou private + static ou final + tipo primitivo | **** |
55 |
56 | #### Palavras "opostas"
57 |
58 | Assim como nas classificações gramaticais da língua portuguesa, existem algumas palavras que são completamente opostas (antônimas) na linguagem Java conforme tabela abaixo:
59 |
60 | | Palavra | Palavra | Explicação |
61 | | ------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
62 | | package | import | Enquanto **package** determina o diretório real da classe, o **import** informe de onde será imprtada a classe. Isso porque podemos ter classes de mesmo nome. |
63 | | extends | implements | enquanto **extends** determinas que uma classe estende outra classe, **implements** determina que uma classe implementa uma interface, porém nunca o contrário |
64 | | final | abstract | enquanto **final** determina fim de alteração de valor ou lógica comportamental, **abstract** em métodos exige que sub-classes precisarão definir comportamento é um método abstrato. NOTA: Se uma classe contém um único método abstrato, toda classe precisa ser. |
65 | | throws | throw | Esta é uma das situações mais complicadas de compreensão destas duas palavras. Enquanto a **throws** determina que um método pode lançar uma exceção, **throw** é a implementação que dispara a exceção**. Vamos conhecer mais sobre este conceito no assunto Exceções.** |
66 |
67 | #### Referência
68 |
69 | {% embed url="http://www.linhadecodigo.com.br/artigo/83/as-52-palavras-reservadas-do-java.aspx" %}
70 |
71 |
--------------------------------------------------------------------------------
/gitbook/sintaxe/terminal-e-argumentos.md:
--------------------------------------------------------------------------------
1 | # Terminal e Argumentos
2 |
3 | Nem sempre executamos nosso programa Java pela IDE, já pensou nossos clientes tendo que instalar o Eclipse ou VsCode para rodar o sistema em sua empresa ?
4 |
5 | Com a JVM devidamente configurada, nós podemos criar um executável do nosso programa e disponibilizar o instalador para qualquer sistema operacional.
6 |
7 | No nosso caso iremos aprender como executar um programa Java via terminal como MS - DOS ou terminal do VsCode.
8 |
9 | Vamos criar uma classe chamada `MinhaClasse.java` com o código abaixo:
10 |
11 | ```java
12 | public class MinhaClasse {
13 | public static void main(String[] args) {
14 | System.out.println("Oi, fui executado pelo Terminal");
15 | }
16 | }
17 | ```
18 |
19 | {% hint style="info" %}
20 | Observe que nosso projeto Java criado por um IDE, ele terá uma pasta chamada **bin**. É nesta pasta que ficarão os arquivos **.class**, o nosso `bytecode`.
21 | {% endhint %}
22 |
23 | .png>)
24 |
25 | Mesmo usando uma IDE, nós sempre precisaremos identificar aonde se encontram as classes do nosso projeto, no meu caso está em: **C:\estudos\dio-trilha-java-basico\java-terminal.**
26 |
27 |  (1).png>)
28 |
29 | ## Terminal
30 |
31 | Vamos ilustrar como executar uma classe, depois de compilada, sem precisar usar a IDE.
32 |
33 | 1. Abra o MS-DOS ou Power Shell
34 | 2. Localize o diretório do seu projeto: **`cd C:\estudos\dio-trilha-java-basico\java-terminal`**
35 | 3. Acesse a pasta **** _bin_: ** `cd bin`**
36 | 4. Agora digite o comando:**`java MinhaClasse` ** _(nome da sua classe sem a extensão .**class**)_
37 |
38 | .png>)
39 |
40 | ## Argumentos
41 |
42 | Quando executamos uma classe que contenha o método main, o mesmo permite que passemos um array `[]` de argumentos do tipo String. Logo podemos após a definição da classe a ser executada informar estes parâmetros, exemplo:
43 |
44 | ```
45 | java MinhaClasse agumentoUm argumentoDois
46 | ```
47 |
48 | Exemplo
49 |
50 | ```java
51 | public class AboutMe {
52 | public static void main(String[] args) {
53 | //os argumentos começam com indice 0
54 | String nome = args [0];
55 | String sobrenome = args [1];
56 | int idade = Integer.valueOf(args[2]); //vamos falar sobre Wrappers
57 | double altura = Double.valueOf(args[3]);
58 |
59 | System.out.println("Ola, me chamo " + nome + " " + sobrenome);
60 | System.out.println("Tenho " + idade + " anos ");
61 | System.out.println("Minha altura é " + altura + "cm ");
62 | }
63 | }
64 |
65 | ```
66 |
67 | **Passando valores aos argumentos pelo VsCode.**
68 |
69 | .png>)
70 |
71 | .png>)
72 |
73 | ```json
74 | {
75 | "version": "0.2.0",
76 | "configurations": [
77 | {
78 | "type": "java",
79 | "request": "launch",
80 | "mainClass": "AboutMe",
81 | "args": ["GLEYSON", "SAMPAIO", "28", "1.58"]
82 | }
83 | ]
84 | }
85 | ```
86 |
87 | Executando o programa agora no terminal
88 |
89 | ```
90 | cd C:\estudos\dio-trilha-java-basico\java-terminal
91 | cd bin
92 |
93 | java AboutMe GLEYSON SAMPAIO 28 1.58
94 |
95 | ```
96 |
97 | ## Scanner
98 |
99 | Nos exemplos anteriores percebemos que podemos receber dados digitados pelo usuário do nosso sistema, porém tudo precisa estar em uma linha e também é necessário informar os valores nas posições correspondentes. Esta abordagem pode deixar margens de execução com erro do nosso programa. Para isso, com a finalidade de deixar as nossas entradas de dados mais seguras agora vamos receber estes dados via **Scanner**.
100 |
101 | A classe **Scanner** permite que o usuário tenha uma interação mais assertiva com o nosso programa, veja como vamos mudar o nosso programa **`AboutMe`** para deixar mais intuitivo aos usuários.
102 |
103 | ```java
104 | import java.util.Locale;
105 | import java.util.Scanner;
106 |
107 | public class AboutMe {
108 | public static void main(String[] args) {
109 | //criando o objeto scanner
110 | Scanner scanner = new Scanner(System.in).useLocale(Locale.US);
111 |
112 | System.out.println("Digite seu nome");
113 | String nome = scanner.next();
114 |
115 | System.out.println("Digite seu sobrenome");
116 | String sobrenome = scanner.next();
117 |
118 | System.out.println("Digite sua idade");
119 | int idade = scanner.nextInt();
120 |
121 | System.out.println("Digite sua altura");
122 | double altura = scanner.nextDouble();
123 |
124 |
125 | //imprimindo os dados obtidos pelo usuario
126 | System.out.println("Ola, me chamo " + nome + " " + sobrenome);
127 | System.out.println("Tenho " + idade + " anos ");
128 | System.out.println("Minha altura é " + altura + "cm ");
129 |
130 |
131 | }
132 | }
133 |
134 | ```
135 |
136 |
137 |
138 |
139 |
140 |
141 |
142 |
143 |
144 | {% embed url="https://code.visualstudio.com/docs/java/java-debugging" %}
145 |
146 | {% embed url="https://linuxtut.com/pass-parameters-when-debugging-vscode-java.-note-462e0" %}
147 |
--------------------------------------------------------------------------------
/gitbook/sintaxe/variaveis.md:
--------------------------------------------------------------------------------
1 | # Tipos e Variáveis
2 |
3 | ## Tipos de dados
4 |
5 | No Java, existem algumas palavras reservadas para a representação dos tipos de dados básicos que precisam ser manipulados para a construção de programas. Estes tipos de dados são conhecidos como tipos primitivos (Primitive Types).
6 |
7 | {% hint style="info" %}
8 | Os oito tipos primitivos em Java são:
9 |
10 | int, byte, short, long, float, double, boolean e char – esses tipos não são considerados objetos, e portanto representam valores brutos. Eles são armazenados diretamente na pilha de memória. (Memory stack)
11 | {% endhint %}
12 |
13 | Tabela de Tipos Primitivos e seus valores:
14 |
15 | | Tipo | Memória | Valor Mínimo | Valor Máximo |
16 | | ----- | ------- | -------------------------- | ------------------------- |
17 | | byte | 1 byte | -128 | 127 |
18 | | short | 2 byte | -32.768 | 32.767 |
19 | | int | 4 bytes | -2.147.483.648 | 2.147.483.647 |
20 | | long | 8 bytes | -9.223.372.036.854.775.808 | 9.223.372.036.854.775.807 |
21 |
22 |
23 |
24 | Os tipos primitivos que podem conter partes fracionárias podem ser representados por dois tipos:
25 |
26 | | Tipo | Memória | Mínimo | Máximo | Precisão |
27 | | ------ | ------- | -------------- | ------------- | ------------- |
28 | | float | 4 bytes | -3,4028E + 38 | 3,4028E + 38 | 6 – 7 dígitos |
29 | | double | 8 bytes | -1,7976E + 308 | 1,7976E + 308 | 15 dígitos |
30 |
31 | Apesar de o tipo **float** ocupar metade da memória consumida do que um tipo double, ele é menos utilizado. Ele sofre de uma limitação que compromete seu uso em determinadas situações: somente mantém uma precisão decimal entre 6 e 7 dígitos.
32 |
33 | Atualmente, com os computadores modernos, se tornou desnecessário utilizar os tipos `short` e `byte`, pois não precisamos nos preocupar tanto assim com o espaço de memória reduzido.
34 |
35 | Da mesma forma, dificilmente utilizaremos o tipo `long`, pois não é tão comum trabalharmos com valores tão grandes.
36 |
37 | Portanto, para representar números, na grande maioria das vezes utilizaremos o tipo `int` para representar números inteiros ou `double` para representar números fracionados.
38 |
39 | {% hint style="info" %}
40 | _O ponto mais relevante em compreender a definição dos tipos de dados é o momento da definição do tipo para uma variável. **Qual tipo de dados eu utilizaria para determinar a idade de uma pessoa ou o salário de um funcionário?**_
41 |
42 |
43 | {% endhint %}
44 |
45 | .png>)
46 |
47 | ## Declaração de Variáveis
48 |
49 | Variável é uma identificação de um espaço em memória utilizado pelo nosso programa. Seguindo as convenções em linguagem de programação, toda variável é composta por: tipo de dados + identificação + valor atribuído.
50 |
51 | A estrutura padrão para se declarar uma variável sempre é:
52 |
53 | ` `
54 |
55 | Exemplos abaixo:
56 |
57 | ```java
58 | int idade; //Tipo "int", nome "idade", com nenhum valor atribuído.
59 | int anoFabricacao = 2021; //tipo "int", nome "anoFabricacao", com valor 2021.
60 | double salarioMinimo = 2.500; //tipo "double", nome "salarioMinimo", valor 2.500.
61 | ```
62 |
63 | Atenção: existe algumas peculiaridades a trabalhar com alguns tipos específicos. Observe no exemplo abaixo:
64 |
65 | ```java
66 | public class TipoDados {
67 | public static void main(String[] args) {
68 | byte idade = 123;
69 | short ano = 2021;
70 | int cep = 21070333; // se começar com zero, talvez tenha que ser outro tipo
71 | long cpf = 98765432109L; // se começar com zero, talvez tenha que ser outro tipo
72 | float pi = 3.14F;
73 | double salario = 1275.33;
74 | }
75 | }
76 | ```
77 |
78 | {% hint style="warning" %}
79 | Observe que o tipo long precisa terminar com L, o tipo float precisa terminar com F e alguns cenários do dia-a-dia podem estimular uma alteração de tipos de dados convencional.
80 | {% endhint %}
81 |
82 | Muitas das vezes criamos uma variável, definimos um valor correspondente, manipulamos esta variável e temos consciência de seu valor na aplicação. Mas cuidado !!
83 |
84 | {% hint style="warning" %}
85 | Java é fortemente "tipado"
86 | {% endhint %}
87 |
88 | Veja o cenário abaixo:
89 |
90 | ```java
91 | // TiposEVariaveis.java
92 |
93 | short numeroCurto = 1;
94 | int numeroNormal = numeroCurto;
95 | short numeroCurto2 = numeroNormal;
96 | ```
97 |
98 | {% hint style="info" %}
99 | Por mais que temos ciência que valor de `numeroNormal` cabe é um short, o **Java** não permite correr o risco.
100 | {% endhint %}
101 |
102 | ## Variáveis e Constantes
103 |
104 | Uma **variável** é uma área de memória, associada a um nome, que pode armazenar valores de um determinado tipo. Um tipo de dado define um conjunto de valores e um conjunto de operações. **Java** é uma linguagem com rigidez de tipos, diferente de linguagens como JavaScript, onde declarar o tipo da variável não é obrigatório.
105 |
106 | No Java utilizamos identificadores que representam uma referência (ponteiro) a um valor em memória, e esta referência pode ser redirecionada a outro valor, sendo portanto esta a causa do nome "variável", pois o valor pode variar.
107 |
108 | Já as **Constantes** são valores armazenados em memória que não podem ser modificados depois de declarados. Em Java, esses valores são representados pela palavra reservada `final`, seguida do tipo.
109 |
110 | Por convenção, **Constantes** são sempre escritas em CAIXA ALTA.
111 |
112 | Abaixo temos um exemplo explicativo sobre uso de variáveis e constantes:
113 |
114 | ```java
115 | public class ExemploVariavel {
116 | public static void main(String[] args) {
117 | /*
118 | * esta linha é considerada como declaração de variável iniciamos a existência
119 | * variavel numero com valor 5 regra: tipo + nome + valor
120 | */
121 | int numero = 5;
122 |
123 | /*
124 | * na linha abaixo iremos alterar o valor do varíavel para 10 observe que o tipo
125 | * não é mais necessário, pois a variável já foi declarada anteriormente
126 | */
127 | numero = 10;
128 |
129 | System.out.print(numero);
130 |
131 | /*
132 | * ao usar a palavra reservada final, você determina que jamais
133 | * esta variavel poderá obter outro valor;
134 | * logo a linha 25 vai apresentar um erro de compilação
135 | * isso é considerado uma CONSTANTE na linguagem Java
136 | */
137 | final double VALOR_DE_PI = 3.14;
138 |
139 | VALOR_DE_PI=3.15; //Esta linha vai apresentar erro de compilação!
140 | }
141 | }
142 | ```
143 |
144 | {% hint style="warning" %}
145 | Compreendemos que para declarar uma variável como uma constante, utilizamos a palavra `final`, mas por convenção, esta variável deverá ser escrita toda em caixa alta.
146 | {% endhint %}
147 |
148 |
--------------------------------------------------------------------------------