# CORE JAVA TUTORIAL: ## Download e Instalação Java é um dos línguagens de programação mais populares do mundo, com mais de 3 milhões de dispositivos executando Java em todo o mundo. Ele foi desenvolvido por James Gosling e o grupo de engenheiros da Sun Microsystems na década de 90 e renomeado para Java em 1994. O primeiro lançamento público foi Java 1. 0 em 1995 e já há várias versões do Java atualizadas e diferentes desde então. Por este motivo, vamos aprender como instalar o Java na nossa máquina, utilizando como exemplo o Windows 10. ### Download do Java Development Kit (JDK) 1. Abrir um navegador web de preferência e digite `jdk java download` na barra de pesquisa. 2. Procure o link oficial [Java SE Downloads](https://www.oracle.com/java/technologies/javase-downloads.html) e clique nele. 3. Nesta página, você encontra várias versões do Java, o que permite escolher a versão desejada. Você pode escolher entre a Long Term Support (LTS), ou seja, versões apoiadas a longo prazo, ou as de edição padrão. ### Instalação do JDK no Windows 10 1. Clique no botão "Download" adjacente a versão desejada. 2. Isto levará à página de download do JDK, clique em "Accept License Agreement" e depois em "Download" novamente. 3. Após a finalização do download, abra o programa de instalação para iniciar a configuração. 4. Ao completar a instalação, vá para "Configuração do Java" na janela de configuração do Windows. 5. Clique em "Vá para a configuração avançada do sistema". 6. Clique em "Variáveis de ambiente" para abrir a tela de variáveis do sistema. 7. Clique em "Nova" e EM "Variável do sistema". 8. Preencha os campos: `JAVA_HOME` no nome e `Caminho do JDK` no valor, onde o caminho do JDK poderá ser encontrado no sistema de arquivos. 9. Clique em "OK" e em "OK" novamente para fechar as janelas. 10. Clique em "Path" para abrir a tela de variáveis de PATH. 11. Clique em "Nova" e EM "Variável de sistema". 12. Preencha o campo "Nome" com: `%JAVA_HOME%\bin` 13. Clique em "OK" e em "OK" novamente para fechar as janelas. 14. Sacar uma nova janela de comando e escreva o comando: ``` java -version ``` A saída da execução do comando deverá mostrar uma versão válida do Java instalado corretamente. ## Instalação do JDK no Ubuntu Embora Java seja principalmente apoiado às plataformas Windows e Linux, vamos abordar como instalar o JDK no Ubuntu aqui também. ### Download do JDK 1. Abrir um terminal e digite: ```bash sudo apt-get update ``` 2. Em seguida, escreva: ```bash sudo apt-get install openjdk-8-jdk ``` Ao completar, Java já estará instalado no sistema. ## Instalação do Eclipse IDE Ao tocar Java no nosso projeto, vamos usar o Eclipse IDE como ambiente de desenvolvimento. ### Download do Eclipse 1. Acessar o link [Eclipse Downloads](https://www.eclipse.org/downloads/) e clicar em "Download Latest Release". 2. Baixar o arquivo da versão 4. 16 ou posterior. 3. Extrair o arquivo do seampack em uma pasta de trabalho. ### Instalação do Eclipse no Windows 10 1. Abra o arquivo binário extraído. 2. Aceitar a licença. 3. Clique em "Browse. . . " e navegar para a pasta onde deseja salvar o Eclipse no computador. 4. Definir o perfil de música do Eclipse para "Eclipse Java EE" ou "Eclipse Java". 5. Clique em "Finalizar" oinstall. ### Instalação do Eclipse no Ubuntu 1. Abrir um terminal e digite: ```bash sudo apt-get update ``` 2. Em seguida, escrever: ```bash sudo apt-get install eclipse ``` 3. Ao completar, abra o programa Eclipse. Nos próximos tópicos, aprenderemos os princípios fundamentais de Java como datatypes, suas operações e outras sobre os --- ### Introdução a Java URL: https://www.youtube.com/watch?v=mAtkPQO1FcA Transcrição não disponível ### História do Java URL: https://www.youtube.com/watch?v=i6AZdFxTK9I idioma: en Hey guys welcome to the second episode of flashback friday today i will be taking you through one of the most popular and powerful programming languages of all time java with over 3 billion devices running java it has helped shape the world as we know it today so without further ado let's jump in and learn some interesting facts about the history of java james gosling and colleagues at sun microsystems developed java in the early 1990s this team of engineers called themselves the green team and initiated the project for interactive television a typical example of interactive television would be the real time voting on the screen in which the user can control the show however this technology was too advanced for the industry and was better suited for the world wide web java was initially named the green talk and then as oak in 1994 it was officially renamed to java the first public implementation was java 1. 0 in 1995. in 2006 sun released java virtual machine as a free and open source software in the same year j2sc was renamed as java standard edition or se major releases involved java se6 in march 2006 and java se8 in 2014. as of today java 8 and java 11 are identified as long term support versions popular java based products like junit eclipse hadoop and android revolutionized the iit industry the biggest internet company google has a huge percentage of its development in java accenture is using java for most of its clients hardware companies like intel symantec philips thompson are all java users java is also considered the official language for android game development pubg the latest youth obsession is a cross-platform game that uses java as a sourcing language since 2007 java has remained a de facto standard and is controlled through the java community process java has evolved to become the most popularly used language and continues to make remarkable contribution into the field of technology so that is all for today's episode of flashback friday this is your host shinmei signing off we will be back with another technology in the next episode until then keep learning and stay tuned to simply learn [Music] --- Esta transcrição foi realizada com a ajuda de uma ferramenta de realização de transcrições automáticas baseado em linguagem natural e pode conter várias falhas e imprecisões. # Instalando Java Development Kit (JDK) 15 em uma máquina de Windows Hoje, vamos aprender como instalar o JDK 15 em uma máquina de Windows. Se estiver a trabalhar em uma máquina Linux ou macOS, baixe os respectivos instaladores. ! [Instalador X64 de Windows](https://example.com/windows_x64_installer.png) 1. Baixe o instalador x64 do Windows. 2. Quando baixado, clique duas vezes no instalador para abrir. Haverá uma caixa de diálogo solicitando a aceitação do acordo de licença da Oracle Technology Network. Ative a caixa de verificação para aceitar e clique em `Baixar JDK 15`. > Observação: Como já mencionado, o Java SE Development Kit (JDK) está sendo baixado. Recorda-se que, quando instalar Java, estás a instalar de facto o JDK, que é uma coleção de ferramentas, bibliotecas e APIs utilizadas para o desenvolvimento e a execução de programas Java. No momento em que aceitas o acordo, iniciará-se a descarga e vais ver algumas ficheiros sendo baixados no seu caixa de transferências. 3. Devido à descarga demorar algum tempo, já tivemos baixado o JDK 15 para este demonstrativo. O JDK baixado encontra-se no nossa mesa de trabalho. Iremos executar neste EXE particular para continuar o processo. Clique duas vezes no EXE e irá aparecer uma caixa de diálogo a pedir se confia nestem executável. Clique em `Sim` pois estejamos a descarregar do website oficial da Oracle. 4. O instalador começará a desempacotar e, se tiver instalado Java, irá mostrar-lhe um ecrã resumo da instalação do Java SE Development Kit 15. 5. Antes de prosseguir, descrimos um ponto importante. Observaste que JDK é o mesmo termo que mencionamos no último ensaio ao discutirmos instalação de Java. Quando instalar Java, estás a instalar de facto o JDK (Java Development Kit). 6. Agora, vamos verificar se Java foi instalado corretamente. Abre um comando prompt e digita `java -version`. Se vêres uma mensagem exibindo a versão de Java, significa que foi instalado corretamente. Se Java não é reconhecido como comando, siga os passos para reinstallar Java para depurar. ## Instalar o Eclipse em uma máquina de Windows Para começar a utilizar Java para escrever e executar programas, vamos ter de instalar o Eclipse. 1. Abra o navegador da Web e lotre `eclipse download` na barra de pesquisa. Aperte Enter. 2. Clique no primeiro link, `eclipse. org downloads`, pertencente à Eclipse Foundation – a organização que mantém os instaladores do Eclipse. 3. Na página de downloads do Eclipse, selecione o instalador do Eclipse Configurador para Linux, macOS e Windows. 4. O Eclipse identificará automaticamente se precisa de um instalador 64-bit ou 32-bit para o sistema e fornecer-lhe um link de descarga correspondingly. Por exemplo, este link baixa o instalador X64. Clique duas vezes na descarga e o instalador começará a descansar e a criar os ficheiros de instalação. Quando esteja pronto, verá a janela do instalador Eclipse. 5. Escolha o Eclipse IDE para desenvolvedores de Java. Enquanto é fornecido múltiplas IDEs para diferentes comunidades de desenvolvedores, este é o que utilizaremos para propósitos deste ensino. Pode escolher outras IDEs baseado no seu idioma preferido. 6. As localizações virtual e de instalação serão definidas automaticamente. Se tiver várias instalações do JDK e quiser alterar a localização virtual e de instalação, podes fazer isso utilizando as opções apropriadas. 7. Clique no `Instalar` para iniciar o processo de instalação. Aceita o acordo de utilização quando solicitado. A instalação prossegue e, quando estiver a terminado, execute o Eclipse IDE para começar a escrever e executar programas Java. A próxima lição, vamos aprender a configurar o Eclipse para o desenvolvimento de Java. # Introdução ao Eclipse e tipos primitivos de dados Java O Eclipse é um ambiente de desenvolvimento integrado (IDE) popularmente utilizado para a criação de aplicações Java. Este guia vai te guiar através do processo de iniciar o Eclipse e criar um projeto Java, além de uma introdução aos tipos primitivos de dados Java. ## Iniciando o Eclipse 1. **Escolha o Workspace: ** O Eclipse usará um workspace como diretório base para todos os seus projetos. Por padrão, está definido como `workspace- incorp`. No entanto, você pode alterá-lo clicando no botão **"Navegar"** e selecionando a localização desejada. ! [Escolha o Workspace](https://www.tutorialspoint.com/eclipse/images/eclipse_workspace_config.jpg) 2. **Check ou desmarque "Use this as the default and do not ask me again. ": ** Se você não quer que o Eclipse pergunte a cada vez que for iniciado sobre a seleção do workspace, marque a caixa de seleção ao lado de "Use this as the default and do not ask me again. " 3. **Inicie o Eclipse: ** Após ter definido o workspace, clique em **"Iniciar"** para iniciar o Eclipse. Você será apresentado com uma tela de boas-vindas mostrando as opções disponíveis. ! [Tela de Boas-vindas do Eclipse](https://www.eclipse.org/images/m/articles/2009/04/22/eclipse_welcome.png) ## Explorando a Interface do Eclipse O Eclipse tem uma interface bem organizada, que inclui: - **Explorador de Projetos: ** Lista todos os projetos do seu workspace. - **Loja de Extensões: ** Para encontrar e instalar extensões e plugins. - **Opções: ** Para personalizar as configurações do Eclipse. - **Visualizações: ** Diferentes janelas para tarefas específicas. ## Criando um Projeto Java no Eclipse 1. **Crie um novo projeto: ** Acesse `Arquivo > Novo > Projeto. . . `. 2. **Escolha `Java > Projeto Java`**. 3. **Digite um `Nome do Projeto`** (por exemplo, `test-demo`) e clique em `Próximo`. Usaremos o valor padrão para JRE e não precisaremos definir uma JRE específica do projeto, portanto deixe-a assim. 4. **Escolha a configuração desejada** (por exemplo, pastas separadas para fontes e classes) e clique em `Próximo`. Vamos manter a opção padrão. 5. **Revise as configurações do projeto** e clique em `Finalizar` uma vez que estejam satisfeitas. 6. **Não crie um módulo: ** Se você não quer criar um módulo, desmarque a caixa de seleção ao lado de **"Criar arquivo module-info. java"**. 7. **Abrir a Perspectiva Java: ** Acesse `Janela > Abrir Perspectiva > Java`. Um novo projeto Java aparecerá, onde você pode criar arquivos Java. ## Tipos Primitivos de Dados Java No Java, os tipos primitivos de dados representam valores básicos de dados como números, valores booleanos e caracteres. Vamos discutir cada tipo primitivo de dados e suas características. 1. **Byte (`byte`): ** É o tipo de dados mais pequeno em Java, utilizado para armazenar inteiros dentro do intervalo de -128 a 127. Ele requer menos memória do que outros tipos de dados inteiros. 2. **Short (`short`): ** Utilizado para armazenar inteiros # String: Um Tipo de Dados Non-Primitivo em Java (Português Europeu) Nesta lição, discutiremos o tipo de dados `String` em Java, que é um tipo de dados não primitivo, apesar de ter uma classificação discutível na comunidade Java. Do ponto de vista técnico, a String é um tipo de dado especial que nem inteiramente pertence à categoria primitiva nem à categoria não primitiva; no entanto, iremos cobrir a String como um tipo de dados não primitivo porque está inclinada para a categoria não primitiva devido ao suporte nativo de Java para manipulação de strings na JDK. ## Definição de String No aula anterior, abordamos o tipo de dados `Char`, que é utilizado para armazenar um único caractere. No entanto, se desejou armazenar um nome completo ou qualquer outra sequência contínua de caracteres, será necessário um tipo de dado para esse propósito. Exatamente por que aString vem em mm. Em essência, uma String pode armazenar uma sequência contínua de caracteres. Técnicamente, uma String é um array de caracteres, e para sua conveniência, podemos chamá-la de array de caracteres. Não se preocupe se não estiver familiarizado com a palavra array; explicaremos isso na mesma aula. Para criar uma String em Java, necessita utilizar o tipo de dados `String`, seguido de um nome de variável. Pode dar qualquer nome e depois provê o valor que a String armazenará. A seguir, hes um exemplo: ```java String teste = "teste"; ``` Neste caso, a String `teste` armazena a sequência contínua de caracteres "teste". ## Criação de Strings em Java As Strings podem ser criadas de duas maneiras em Java: 1. Utilizando atribuição direta, como mostrado no exemplo anterior. 2. Utilizando o `new` palavra-chave, seguida pelo tipo de dados `String`, um nome de variável e o valor a ser armazenado: ```java String str1 = new String("teste"); ``` Neste caso, tanto `teste` e `str1` possuem o mesmo valor, mas há diferenças subtis entre eles. Na abordagem de atribuição direta, o mesmo objeto de string será reutilizado várias vezes; no entanto, com o uso da palavra-chave novo, uma nova instância será criada a cada vez que referenciada. ## Arrays Em Java, o array é uma estrutura de dados não primitiva utilizada para armazenar uma sequência contínua de valores de mesmo tipo. Arrays podem armazenar números inteiros, caracteres ou até mesmo números ao longo. Para criar um array em Java, usa-se a seguinte sintaxe: ```java int arr[] = new int[2]; ``` Neste caso, `arr` é um array de inteiros capaz de armazenar dois valores, conforme especificado por `new int[2]`. arrays começam na posição zero, então pode acessar elementos utilizando seus números de índice. # Criando uma classe Java no Eclipse Este guia irá você conduzir à criação de uma classe Java usando o Eclipse. ## Criando uma nova classe 1. Clique no pacote onde você deseja criar sua nova classe. 2. Selecione `Arquivo > Novo > Classe`. 3. Na janela `Novo Java Classe`, entre com o nome para sua classe (por exemplo, `TestamentoMundo`). 4. Selecione um superclasse (neste caso, `Object` é suficiente). 5. Marque a caixa de verificação para `public static void main(String[] args)` se você deseja que a sua classe tenha um ponto de entrada. 6. Clique `Concluir`. ## Estrutura da classe Quando você cria uma nova classe, o Eclipse adiciona a estrutura básica para uma classe Java. Aqui está o que você pode esperar ver: ``` package <seu_pacote_ nome>; public class TestamentoMundo { public static void main(String[] args) { System. out. println("Olá, Mundo! "); } } ``` ## Convenções de nomenclatura Quando você estiver dando nome à sua classe, é uma boa prática seguir as convenções de nomenclatura para Java: - Comece o nome da classe com uma letra maiúscula. - Use camelCase para novas palavras no nome da classe. Na nossa exemplo, `TestamentoMundo` segue esta convenção de nomenclatura. ## Declaração do pacote A declaração do pacote é obrigatória no começo de seu arquivo de classe Java. Ela deve especificar o nome do pacote para sua classe. Certifique-se de incluir a palavra-chave `package` seguida do nome do seu pacote e terminar a declaração com um ponto-e-vírgula. ## Modificadores de acesso As classes Java podem ter os seguintes modificadores de acesso: - `público`: Faz a classe acessível de outras classes Java no seu projeto. - `padrão` (sem modificador de acesso): Faz a classe acessível apenas dentro do seu pacote. - `privado`: Faz a classe acessível apenas dentro da mesma classe. - `protegido`: Faz a classe e seus membros acessíveis dentro do seu pacote e sub classes em outros pacotes. Na nossa exemplo, a classe `TestamentoMundo` é pública desde que ela tem o modificador de acesso `público`. ##Executando a classe Para executar sua classe Java, você pode fazer o seguinte: 1. Clique com o botão direito do mouse no nome da classe no Explorador de Pacotes. 2. Selecione `Executar Como > Java Aplicação`. Seu classe deverá agora compilar e executar, imprimindo "Olá, Mundo! " na janela de saída. ## Mais recursos Para obter informações mais detalhadas sobre classes Java, modificadores de acesso e a declaração de `package`, veja as [Oficiais Tutoriais Java](https://docs.oracle.com/javase/tutorial/java/javaOO/index.html). # Arrays em Java Um *array* pode conter até 10 elementos, mas o índice começa em 0 e termina na posição de comprimento menos 1, que neste caso seria 9. É importante lembrar que o índice sempre começa em 0 e vai até o comprimento menos um. O comprimento pode ser qualquer coisa, neste caso ele é 10. Se o comprimento fosse 20, a última posição seria 19. No entanto, um *array* ocupa 10 locações de memória contíguas. Nós chamamos nossas locações de memória contíguas de *locações de memória* contínuas porque são organizadas de forma contígua na memória. O *array* basicamente reserva um contêiner para 10 locações de memória e bloqueia essas locações para que você possa armazenar seus dados. Quando você quer acessar os elementos do *array*, você especifique o seu índice. Por exemplo, se você quiser acessar o elemento que está no índice 8, você precisará especificar o índice do array de 8. Conheça este exemplo! ```java public class ArrayExample { public static void main(String[] args) { int[] array = new int[10]; // Zerando todos os elementos do array com 0 for (int i = 0; i < array. length; i++) { array[i] = 0; } // Acessando e atualizando um elemento do array array[8] = 100; // Imprimindo todos os elementos do array for (int i = 0; i < array. length; i++) { System. out. println("Elemento no índice '" + i + "': " + array[i]); } } } ``` Neste exemplo, usamos um *array* de inteiros com um comprimento de 10. Usamos um *loops* `for` para zerar todos os elementos do *array* e acessar o elemento no índice 8 para armazenar um valor. Finalmente, usamos um outro loop `for` para imprimir todos os elementos do array. ## Operadores em Java No Java, existem vários tipos de operadores, que se dividem em: - Operadores de atribuição; - Operadores aritméticos; - Operadores unários; - Operadores condicionais e lógicos; - Operadores bitwise; Este tópico vai dar uma visão geral de cada um destes tipos de operadores. ### Operadores de atribuição Quando você atribui um valor a uma variável, você usa o operador de atribuição, que é a barra equal (=). Sabe-lo já? Eu já discutei isso em vários exemplos anteriores, então neste tópico, vou discutir em detalhes operadores aritméticos. #### Operadores aritméticos Operadores aritméticos são usados para executar operações aritméticas em um java program. Estes operadores são: - Adição: + - Subtração: - - Multiplicação: \* - Divisão: / - Módulo (remainder de uma divisão): % O símbolo para cada operador é, de fato, o esperado em matemática! ```java public class ArithmeticDemo { public static void main(String[] args) { int result = 1 + 2; // Adição int result = 1 - 2; // Subtração int result = 1 * 2; // Multiplicação float result = 1 / 2; // Divisão int result = 1 % 2; // Módulo System. out. println("Resultado da adição: " + result); System. out. println("Resultado da subtração: " + result); System. out. println("Resultado da multiplicação: " + result); System. out. println("Resultado da divisão: " + result); System. out. println("Resultado do módulo: " + result); } } ``` No exemplo acima, usei o operador de atribuição para colocar o valor resultado de cada operação aritmética em uma variável chamada `result`. A partir desta variável, eu chamo o método `println` para imprimir o valor resultante. Mantenha a memória de que você pode acessar uma determinada posição de um *array* usando o símbolo de colchetes ([]) seguido do índice da posição e, após isso, acessar o elemento que está armazenado naquela posição. ```java // Acessando um elemento do array no índice 0, que é a primeira posição array[0]; ``` # Demonstração de Operadores Aritméticos e Relacionais Esta demonstração mostrará como usar os operadores de adição, multiplicação, subtração, divisão e módulo em Java. Depois disso, discutiremos operadores de igualdade e relacionais (também conhecidos como operadores de comparação). ## Operadores Aritméticos Os operadores aritméticos executam operações matemáticas como adição, subtração, multiplicação, divisão e módulo. ``` 1. Adição: + 2. Subtração: - 3. Multiplicação: * 4. Divisão: / 5. Módulo: % ``` Aqui está um programa de exemplo que demonstra a utilização de operadores aritméticos: ```java public class OperadoresAritmeticos { public static void main(String[] args) { int resultado = 3; // Valor inicial do resultado // Adição resultado += 1; System. out. println("1 + 2 valoriza o resultado: " + resultado); // Imprime: 4 // Subtração resultado -= 1; System. out. println("Valor atual: " + resultado + ". Valor inicial do resultado menos 1 é: " + (resultado - 1)); // Imprime: Valor atual: 3. Valor inicial do resultado menos 1 é: 2 // Multiplicação resultado *= 2; System. out. println("Valor inicial do resultado: " + 2 + ". Valor atual: " + resultado); // Imprime: Valor inicial do resultado: 2. Valor atual: 4 // Divisão resultado /= 2; System. out. println("2 dividido por 4 é: " + (2 / 4)); // Imprime: 0. 5 System. out. println("Valor inicial do resultado: " + 2 + ". Valor atual: " + resultado); // Imprime: Valor inicial do resultado: 2. Valor atual: 1 // Módulo resultado = 10 % 7; System. out. println("10 módulo 7 é: " + resultado); // Imprime: 3 } } ``` ## Operadores de Igualdade e Relacionais Quando se fala sobre operadores relacionais (também conhecidos como operadores de comparação), a ideia básica é comparar coisas (objetos, variáveis, etc. ) em Java. Em Java, é possível usar os operadores de comparação para verificar a igualdade, a desigualdade, o maior que, o maior que ou igual a, o menor que e o menor que ou igual a. ``` 1. Igual a: == 2. Não igual a: ! = 3. Maior que: > 4. Maior que ou igual a: >= 5. Menor que: < 6. Menor que ou igual a: <= ``` Aqui está um programa de exemplo que demonstra a utilização de operadores de igualdade e relacionais: ```java public class OperadoresComparacao { public static void main(String[] args) { int valorUm = 1; int valorDois = 2; if (valorUm == valorDois) { System. out. println("Valor um é igual a valor dois. "); } if (valorUm ! = valorDois) { System. out. println("Valor um é diferente de valor dois. "); } if (valorUm > valorDois) { System. out. println("Valor um é maior que valor dois. "); } if (valorUm >= valorDois) { System. out. println("Valor um é maior ou igual a valor dois. "); } if (valorUm < valorDois) { System. out. println("Valor um é menor que valor dois. "); } if (valorUm <= valorDois) { System. out. println("Valor um é menor ou igual a valor dois. "); } } } ``` Neste exemplo, o programa imprime "Valor um é diferente de valor dois. " porque valorUm não é igual a valorDois. # Comparação de Operadores e Operadores Bit-a-bit (Lendológia) ## Operadores de Comparação **Explicação das condições** NJava, os operadores de comparação são utilizados para comparar dois valores. Se uma das condições se tornar verdadeira, a expressão inteira se torna verdadeira, e se ambas as condições ficam falsas, a expressão permanece falsa. ``` Operação OR (|): se uma das partes for verdadeira, a expressão inteira se torna verdadeira. exemplo: valor 1 ! = 4 && valor 2 ! = 5 se o valor 1 não for igual a 4 ou o valor 2 não for igual a 5, a expressão se torna verdadeira. & Operação: ambas as partes precisam ser verdadeiras para que a expressão inteira se torne verdadeira. exemplo: valor 1 == 4 && valor 2 == 5 se tanto o valor 1 for igual a 4 e o valor 2 for igual a 5, a expressão se torna verdadeira. & & (operador de circuito curto): Se a parte esquerda for falsa, a parte direita não será avaliada. Ajudando a economizar o poder de processamento de seu computador. exemplo: se (condição1 && condição2) { // código } se a condição1 for falsa, a condição2 não será avaliada. ``` **Formatação e Estrutura** ``` Título e Subtítulo: Usar # para títulos principais (exemplo: # Comparadores de Operadores) e ## para subtítulos (exemplo: ## Explicação das Condições). Exemplos de Código: ``` ```python # exemplo de código aqui ``` ## Operadores Bit-a-bit **Entendendo os Bits** O bit (digito binário) é a unidade mínima de armazenamento em computação, capaz de armazenar um valor de 0 ou 1. Um grupo de 8 bits é um byte, que é a unidade mínima de armazenamento em memória. **Operadores Bit-a-bit** Em Java, existem vários operadores bit-a-bit que permitem a manipulação de bits individuais. Estes incluem AND (&), OR (|), XOR (^), e NOT (~). ``` & Operador: definir o bit para 1 se ambos os bits correspondentes forem 1; caso contrário, defina o bit para 0. exemplo: int a = 5, b = 7; a & b = 4 porque apenas o segundo bit desde a direita (2^1) é definido como 1 para tanto a como b. | Operador: definir o bit para 1 se um dos bit correspondentes for 1; caso contrário, defina o bit para 0. XOR Operador: definir o bit para 1 se apenas um dos bit correspondentes for 1; caso contrário, defina o bit para 0. NOT Operador: reverter o valor de cada bit no número. exemplo: ~5 = -6 ``` **Operadores de Deslocamento à Esquerda e Direita** O operador de deslocamento à esquerda (<<) e o operador de deslocamento à direita (>>) podem ser usados para mover os bits para a esquerda ou direita, respectivamente. ``` exemplo: int a = 5; a << 2 = 20 (bits são deslocados dois lugares para a esquerda) ``` **Instruções de Controle da Fluxo** As instruções de controle de fluxo permitem que você controlled e defina o fluxo de execução em seu programa. Exemplos comuns incluem `se-outro` instruções e instruções `switch`. Ajudam a criar ramificações condicionais de execução baseadas em condições dadas. Para discutir em nosso próximo lendógia. --- # Tutorial de Java - Entendendo a declaração `if` e as declarações `else-if` em Java Nesta série, vamos abordar diversas estruturas de controle em Java, começando com a declaração `if`. ## Declaração `if` A declaração `if` é usada para avaliar uma condição. Se a condição for verdadeira, o bloco de código após a declaração `if` será executado. Se a condição for falsa, o bloco de código será ignorado. Aqui está um exemplo: ```java public class IfExample { public static void main(String[] args) { int testScore = 76; if(testScore >= 90) { String grade = "A"; System. out. println("Nota: " + grade); } } } ``` No exemplo acima, temos uma variável inteira `testScore` com um valor de 76. Usamos a declaração `if` para verificar se a `testScore` é maior ou igual a 90. Se a condição for verdadeira, atribuímos o valor "A" à variável `grade` e exibimos-o. ## Declaração `else` Se desejar executar um bloco de código quando a condição da declaração `if` for falsa, você pode usar a declaração `else`. ```java public class IfElseExample { public static void main(String[] args) { int testScore = 76; if(testScore >= 90) { String grade = "A"; System. out. println("Nota: " + grade); } else { String grade = "F"; System. out. println("Nota: " + grade); } } } ``` No exemplo acima, adicionamos um bloco `else` para exibir a nota "F" quando a `testScore` não for maior ou igual a 90. ## Declaração `else-if` O Java também fornece a declaração `else if`, que é uma continuação da declaração `if`. Se a condição na declaração `if` for falsa, Java vai avaliar as condições nas declarações `else if` uma a uma, na ordem em que aparecem, até encontrar um bloco verdadeiro. ```java public class ElseIfExample { public static void main(String[] args) { int testScore = 76; if(testScore >= 90) { String grade = "A"; System. out. println("Nota: " + grade); } else if(testScore >= 80) { String grade = "B"; System. out. println("Nota: " + grade); } else if(testScore >= 70) { String grade = "C"; System. out. println("Nota: " + grade); } else if(testScore >= 60) { String grade = "D"; System. out. println("Nota: " + grade); } else { String grade = "F"; System. out. println("Nota: " + grade); } } } ``` No exemplo acima, temos várias declarações `else if` para verificar notas diferentes baseado na `testScore`. Se a `testScore` for maior ou igual a 90, a nota "A" é atribuída e exibida. Se não, o Java vai avaliar as próximas declarações `else if` até encontrar uma condição verdadeira ou chegar no último `else` bloco, que é exibido caso nenhuma condição seja verdadeira. ## Declarações `if` aninhadas As declarações `if` aninhadas são usadas quando o resultado de uma declaração `if` é o entrada para outra declaração `if`. ```java public class NestedIfExample { public static void main(String[] args) { int i = 50; if(i == 50) { if(i < 75) { if(i < 55) { System. out. println("i é menor que 55"); } } } } } ``` No exemplo acima, temos três declarações `if` aninhadas. Se o valor de `i` for 50, então verifique se `i` é menor que 75, e se `i` for menor que 75, verifique se `i` é menor que 55. Se todas as condições forem verdadeiras, a mensagem "i é menor que 55" é impressa. ## Operadores Ternários Os operadores ternários são uma forma abreviada de escrever declarações `if-else`. ```java public class TernaryOperatorExample { public static void main(String[] args) { int a = 1; int b = 2; int result = (a > b) ? a : b; System. out. println("Resultado: " + result); } } ``` No exemplo acima, usamos um operador ternário para atribuir o valor máximo entre `a` e `b` à variável `result`. Se `a` for maior que `b`, `a` é atribuído à `result`, caso contrário, `b` é atribuído à `result`. O resultado é então impresso. # Usando Operadores Ternários em Java Este tutorial revela o uso de operadores ternários em Java para escrever instruções if-else curtas, além de uma explicação de quando utilizar operadores ternários e quando utilizar instruções if-else aninhadas. ## Entendendo Operadores Ternários Os operadores ternários fornecem uma maneira de escrever instruções if-else em uma linha de código. A sintaxe para um operador ternário é como o seguinte: ``` expression (Interrogação) ? statement se verdadeiro (Virgula) : statement se falso ``` Aqui está um exemplo: ```java int a = 1; int b = 2; int result = (a < b) ? a : b; ``` Neste exemplo, a expressão é `a < b`, e a instrução a ser executada se a expressão for verdadeira é `a`. A instrução a ser executada se a expressão for falsa é `b`. O valor resultante de `result` é `1` porque `a` é menor que `b`. ### Avaliações - Operadores ternários podem ser utilizados apenas quando existe apenas uma instrução a ser executada em ambos os blocos if e else. - Operadores ternários não podem lidar com múltiplas instruções em ambos os blocos if ou else, pois eles podem apenas acompanhar uma instrução de vez. ### Versão Abstrata de If-Else Você pode escrever a mesma expressão utilizando uma instrução if-else declarativa: ```java if (a < b) { result = a; } else { result = b; } ``` ## Prática com Operadores Ternários Aqui está um exemplo simples de utilização de operadores ternários para imprimir o nome correspondente ao mês, baseado no número do mês de entrada: ```java int month = 6; String monthName; monthName = (month == 1) ? "Janeiro" : (month == 2) ? "Fevereiro" : (month == 3) ? "Março" : (month == 4) ? "Abril" : ( month == 5) ? "Maio" : ( month == 6) ? "Junho" : ( month == 7) ? "Julho" : ( month == 8) ? "Agosto" : ( month == 9) ? "Setembro" : ( month == 10) ? "Outubro" : ( month == 11) ? "Novembro" : ( month == 12) ? "Dezembro" : "Mês Inválido"; System. out. println(monthName); ``` Neste exemplo, utilizamos operadores ternários para atribuir ao `monthName` o nome correspondente do mês. Se o número do mês de entrada corresponder a qualquer uma das casas dadas, o operador ternário retornará o nome do mês correspondente, e, se nenhuma das casas coincidir, será impresso o texto "Mês Inválido". ## Instruções If-Else Aninhadas Embora os operadores ternários sejam úteis para lidar com condições if-else simples, eles podem se tornar difíceis de gerenciar quando lidam com condições mais complexas. Nessas situações, a utilização de instruções if-else aninhadas é uma melhor abordagem. ## Conclusão Operadores ternários são uma maneira potente e concisa para escrever instruções if-else, mas é importante saber quando utiliza-los e quando se manter com instruções if-else aninhadas. Pratique para compreender as vantagens e desvantagens de ambas as abordagens, e encontre a que funciona melhor para você em diferentes cenários. # Arrays de Um Dimensão Recebe uma breve passagem sobre arrays de uma dimensão. Aqui segue um exemplo de programa para demonstrar arrays de uma dimensão. Caso lembre, para criarmos arrays utilizamos o tipo de dado desejado e os caracteres if story Londres, denominando aí que é um array de inteiros. Atribuímos a uma variável e depois inicializamos o tamanho com 4. `new` é a palavra-chave utilizada para inicializar qualquer coisa em Java e seremos obrigados a utilizar esta palavra-chave quando falarmos sobre classes, objetos, e até mesmo coleções. Neste caso estou escrevendo `new`, seguido por `int[4]`, que significa criar um array de tamanho 4. Observem que preenchemos os valores nas posições que criamos no array. Observe também que existe a regra de que os arrays começam por posição 0 e não por 1. Após isso, imprimimos todos os valores individuais das posições nos elementos do array. Se executarmos este programa, todos os elementos deste array específico devem ser impressos um a um. A seguir está a saída completa da console, mostrando o conteúdo dos elementos do array em Índice 0, Índice 1, Índice 2, e Índice 3. ``` Elemento em Índice 0 foi 10 Elemento em Índice 1 foi 20 Elemento em Índice 2 foi 30 Elemento em Índice 3 foi 40 ``` Como regra geral, arrays de uma dimensão serão geralmente declarados de uma forma simples. Agora, vamos ver como escrever arrays de dois dimensões e quando as utilizamos para isso, criei outro exemplo, a seguir chamado "Arrays de dois dimensões". Neste exemplo estou apenas criado uma classe e possui um método public static void main. Criei um array de dois dimensões neste momento. (Vou fazer uma pausa aqui para que eu possa explicar alguns aspectos de arrays de duas dimensões em termos mais detalhados) ## Arrays de Dois Dimensões Utilizamos arrays de duas dimensões quando forem necessárias manipulações matriciais. Matrizes são escassas alguns quadros 2x2 que aloje os valores em formato de linhas e colunas, logo, se quiser armazenar uma tabela neste formato em um programa Java, precisará de matriz de duas dimensões. O recurso e procedure para isto, é praticamente idêntico ao que empregam com arrays de um dimensão, com ligeiras mudança. A principal alteração repete-se: ao invés de um par de colchetes apenas, vai utilizar dois colchetes, após isso começam-se com chaves `{}`, seguidas de colchetes aninhados, que correspondem a cada uma das linhas. ```java public class array_multidimensional { public static void main(String[] args) { int array[2][3] = new int[2][3]; // Declaração de um array de duas dimensões. array[0][0] = 237; // Este armazena no arquivo index 0 e primeira coluna; array[0][1] = 0; array[0][2] = 0; array[1][0] = 0; array[1][1] = 3; array[1][2] = 3; // Imprime todas as linhas do array for (int i = 0; i < array. length; i++) { for (int j = 0; j < array[i]. length; j++) { System. out. print(array[i][j] + " "); } System. out. println(); // Vai imprimir uma linha em branco após cada linha. } } } ``` ## Saída esperada: ``` 237 0 0 0 3 3 ``` # ArraysTridimensionais e laços do-while em Java Este guide explica a utilização de Arrays Tridimensionais e laços do-while em Java. ## Arrays Tridimensionais Os Arrays Tridimensionais são uma extensão dos Arrays Bidimensionais, proporcionando uma maneira de guardar vários Arrays. A seguir está um exemplo de definição de um Array Tridimensional: ```java int[][][] array3D = new int[x][y][z]; ``` Neste exemplo, `x` representa o número de primeiro nível de Arrays, `y` representa o número de segundo nível de Arrays dentro de cada primeiro nível de Arrays e `z` representa o número de elementos no segundo nível de Arrays. ### Estrutura - Cada elemento em um Array Tridimensional pode ser acessado utilizando três índices. - A acessação começa com 0, assim, o primeiro elemento em um Array Tridimensional fica localizado no índice [0][0][0]. - O número de dimensões, no caso, é três. - Tenha cuidado com a estrutura do Array, uma estrutura incorreta pode levar a saídas inesperadas e erros. ## Laços do-while O laço do-while é uma estrutura de controle que verifica a condição depois de executar o bloco de código. Certifique-se de que o bloco de código é executado pelo menos uma vez, mesmo se a condição for falsa. ### Sintaxe A sintaxe para um laço do-while é a seguinte: ```java do { // Instruções Executáveis } while (expressão); ``` ### Exemplo Aqui está um exemplo que demonstra a estrutura de um laço do-while: ```java public class DoWhileDemo { public static void main(String[] args) { int count = 1; do { System. out. println("Count é: " + count); count++; } while (count <= 10); } } ``` Neste exemplo, o bloco de código será executado à lo menos uma vez, impressão o valor inicial de `count`. Então, irá incrementar o valor de `count` e verificar a condição. Se a condição for verdadeira, o loop continuará a executar. Se a condição se tornar falsa, o loop terminará. ### Utilização Use um laço do-while quando desejar executar algum código de inicialização antes de verificar a condição. Em contrapartida, use um laço while se não necessitar de código de inicialização antes da verificação da condição. Agora que entendido os conceitos básicos de Arrays Tridimensionais e do-while loops, pode utilizar esta informação para construir programas Java mais complexos. A medida em que avança, pode expandir os Arrays para dimensões maiores se necessário. # Laço While no Java Organize este exemplo para uma compreensão clara do laço while no Java. ## Resumo Este exemplo demonstra o uso do laço while no Java, ilustrando como executar ações repetidas enquanto uma condição é verdadeira. ## Exemplo de Classe WildDemo ```java public class WildDemo { public static void main(String[] args) { int count = 1; while (count < 10) { System. out. println(count); count++; } } } ``` ### Explicação 1. Inicialize uma variável `count` com o valor `1`. 2. Defina a condição `while count < 10`. 3. Execute a ação `System. out. println(count)` e incremente `count` com `count++`. 4. Repita passos 2 e 3 até que a condição `count < 10` seja falsa. ## Dicas - Use `count++` para o operador unário de incremento pós-incremento. - Lemmbre-se de que um laço infinito ocorrerá se a condição não muda e o código para mudar o estado da condição não for fornecido. ## Saída A saída deste código será os números de 1 a 9 impressos em linhas separadas quando a condição é `count < 10`: ``` 1 2 3 4 5 6 7 8 9 ``` --- # Laço For no Java Agora, vamos entrar em detalhes com o uso dos `for` loops no Java, um meio conveniente para iterar sobre coleções. ## Visão Geral 1. Entenda a sintaxe do `for` loop e compare-a com uma `while` loop para entender as semelhanças e diferenças. 2. Veja um exemplo do `for` loop em ação no Ambiente de Desenvolvimento Integrado Eclipse (IDE). ## Sintaxe do Laço For De acordo com os Docs oficiais do Java, a sintaxe de um `for` loop tem a seguinte aparência: ```java for (initialize; condition; update) { // ações dentro da iteração aqui! } ``` 1. `initialize`: Inicialize as variáveis usadas em cada iteração. 2. `condition`: A condição a ser testada no começo de cada iteração da loop. Se a condição é verdadeira, a loop iterará. 3. `update`: a variável(s) devem ser atualizadas após cada iteração de modo a modificar a condição. ### Comparando os laços `for` e `while` Aqui está uma comparação da sintaxe de um `for` loop e de um `while` loop para ajudar a mostrar suas semelhanças e diferenças: - Sintaxe: `for (initialize; condition; update) { /* ações */ } vs `while (condition) { /* ações */ } - Inicialização: Fazem-se uma vez com um `for` loop e manualmente feitas quando usando um `while` loop. - Condição: Fazem-se os dois para `for` e `while` loops. - Atualizações/Incremento: Fazem-se automaticamente no `for` loop com o código de atualização fornecido. Em um `while` loop, devem ser feitas manualmente dentro da loop. ## Exemplo ```java public class ForDemo { public static void main(String[] args) { for (int i = 1; i < 10; i++) { System. out. println("count é " + i); } } } ``` ### Explicação 1. Inicialize `int i = 1`. 2. A condição é `i < 10`. 3. O `i++` atualização acontece depois de cada iteração da loop. 4. Executa `System. out. println("count é " + i)` para cada iteração. 5. Continua iterando até que a condição `i < 10` se torne falsa. --- Com este exemplo semelhante, você explorou um recurso básico mas potente do Java programação: o `for` loop. Experimente outros usos de loops, como o `for-each` loop, para situações de programação avançadas. ``` Formatação: - Preserver todos os elementos Markdown (# ** ` [] () etc) - Manter a estrutura de títulos e seções - Preservar blocos de código sem traduzir Tradição: - Use português europeu (não brasileiro) - Manter termos técnicos em inglês - Preservar comandos e códigos inalterados - Manter URLs intactas Retorno do texto traduzido com formatação Markdown. Corrija e formeate este texto: ``` Java For Loops melhorados e Nested Loops aninhados =============== 10. O código a seguir imprime os valores e decrementa o valor após impressão. Não se faz o incremento do valor, apenas o decremento. Daí assim, o valor final sempre será menor que 10 e esse loop irá ser executado sem interromper indiferentemente. Iso apenas ilustra para mostrar aquilo que não deverás fazer no teu programa Java interno. Poderás ver que imprimiu os valores continuamente ate que o programa consumir a memória disponível continuamente. Isso não cessará por si proprio pois a condição nunca será falsa. O loop irá se executar indefinidmente, portanto, ser-lhe necessário interrompê-lo manualmente. Avoid thee this sort of loop in teu java code. Esse problema acontece muitas vezes com os desenvolvedores principiantes. Agora, vamos talkar sobre as melhoras do Java enquanto numa for do Enhaced, chamadas de `loops enhencados`. Em Anterior Topicos, falomos sobre `loops e sua estrutura e também sobre fluxo de comando. Agora, aperenas iríamos falkar sobre uma nova forma de escrever loops, de uma maneira leve um pouco mais inteligente doe que os antigos loops e que chamamos de melhorados e que conhecemos as melhoradas do For Each ou de los `enhaced for loops` e usada muitos de volta ainda quendos tem necessidade de seguir itens numa collecton de um array de um objeto disponível com java. Já diziram, a syntax tem sido mais ligeira nao ter assim o desafio complexo da utilização dos seus antigos antigos loops onde tem muito escuro o noso noso processo e estamos no Java a ir no seguinte utilizando loops mejorados de leve um jeito para simplificar numa collecton de objetos que seguís e ter un output no padrão requisito ou como esperamoos, os `loops mejorados usam com for de java ou um caracter familiar com uma referencia da Collection de Direita no Character principal e esta Coletion pode ser por exemplo a uma ArrayListe ou un Collection que te irá definireis para armazena uma sequncia de caracteres. No case seguinte uso un Character stream. O ponto dos lembramentos destas loops, diziam, apresentarei os meios mais rapiditos para se conseguir apresentar caracteres sem as tedium dos tabelas tradicas e na syntaxe nao ser ter que digar para elos onde ela esta no for como `forEach(numb -> num++); `. Então porquê utilizados `for()` num place do nosso java e quaisquer objectos. Mas primeiram primeiro porquém. . . Porque existem uns arrays com algunha necessidade duma maneira rapida e um espaço reservados dele os objectos não possui todos uma coolecton API disponivel dos for enchaced ou quando é utilizadas a forma semanticamente incoerenta ou que apesar da manerá traditial da insercação dá certo quando esta for realizado na linguage. Seguintamente eximinhos. Por que eles simplifica os seus programs java quando há um grupo completo do java? As razoes falkas nesta solúcao seguintem - **simplicidade das tabelas**. Em resumo simples os objetos a coleção `Collection` # Laços Aninhados em Programação JavaScript Inicialize `i` novamente com 0 e execute a mesma operação para a linha 2 e coluna 0, 1, 2. Isso fará com que ele saia do loop neste momento novamente. Quando entra no loop novamente, o valor passará de 2 para 3, e 3 não é menor que 3, então ele sairá do laço exterior. A ideia é executar o laço interno para cada valor do laço exterior, acima é o que irá aplicar seu conhecimento de laços aninhados em condições específicas. Você pode utilizar laços aninhados em cenários em que precisa iterar sobre uma coleção baseada em um valor específico de outra coleção. Por exemplo, se estivéssemos lidando com arrays em 3D, você teria visto três laços aninhados aqui. Na essencia, a lógrica se aplicará para todas as coleções, e os valores do laço interno serão baseados em um valor fixo do laço exterior, enquanto incrementa o valor do laço externo e repete o processo. Aqui a seguir está o código: ```javascript for (let i = 0; i < 3; i++) { for (let j = 0; j < 3; j++) { // Seu código aqui } // Incremente `i` antes da próxima iteração } ``` Agora, execute este programa e veja a saída: Como o mencionei anteriormente, o nosso propósito é imprimir uma representação em forma de matriz, e você pode ver que está sendo impresso assim: ``` 0 0, 0 0 1, 7 0 2, 9 ``` Se você decifrar, deve funcionar de forma semelhante: ``` i = 0 j = 0 0 < 3, entra aqui j = 0 0 < 3, entra aqui Imprime o array [0, 0] que é "2" Imprime o array [0, 1] que é "7" Imprime o array [0, 2] que é "9" j se torna 3, sai do loop e sube i torna-se 1 1 < 3, sim Reinicia um laço de entrada novo com um novo j sendo 0 Imprime o array [1, 0], [1, 1], [1, 2] . . . e assim por diante. Você pode fazer isso para qualquer tipo de array em n-dimensionais ou uma coleção em geral. ``` Agora, vamos passar para as Coleções em Java: Esta é uma das conceitos mais importantes da linguagem de programação Java, especialmente para trabalhar em qualquer aplicação de produção. Vamos entender o Framework de Coleções e suas classes e ferramentas disponíveis. Segue uma introdução às classes e interfaces do Framework de Coleções: - O `interface` é usado para definir interfaces, que servem como um esboço genérico para implementações específicas de classes. Por exemplo, você pode criar uma interface para veículos e depois criar classes como carros, motos e caminhões sob esta interface. - O `abstract` é usado para definir classes abstratas, que fornecem tanto uma generalização como uma maneira de escrever alguma implementação concreta para uma coleção de itens. - Uma classe tem a função de manter os dados e lógica juntos. Nesta aula, iremos se concentrar em entender o relacionamento entre as classes, por que estas são criadas, e sua hierarquia. iremos discutir interfaces e classes abstratas em uma visão geral em aulas posteriores. Para agora, vamos se por dois passos mais: O pacote `java. util` contém uma série de classes e interfaces usadas para implementar a interface de coleção. Essas classes são divididas em várias categorias diferentes, as quais discutiremos a seguir. 1. Interface de Conjunto A interface de Conjunto descreve uma coleção que não pode contê-lo elementos duplicados. Ela modela a abstração matemática do conjunto. As operações principais apoiadas pela interface de Conjunto são as necessárias para um conjunto, como `adicionar()`, `remover()`, `conteins()`, `size()`, e `iterator()`. 2. Lista Interface A interface de Lista modela uma estrutura de dados sequencial. Ela extend java. util. Collection e fornece métodos para obter referências a elementos em posições específicas. A ordem dos elementos em uma lista é preservada. 3. Interface de Fila A interface de Fila fornece uma interface simples para gerenciar filas de coda única ou dupla. Ela estende a interface java. util. Collection e adiciona a capacidade de inserir e remover elementos em uma ordem específica. Os elementos inseridos pelo método `offer()` serão removidos pelo método `poll()`. Além dessas interfaces principais, existe outras interfaces como `SortedSet`, `NavigableSet`, `Deque`, e `BlockingQueue` que fornecem diversas propriedades adicionais. Agora, vamos criar um exemplo utilizando algumas dessas coleções: ```java import java. util. *; public class CollectionsExample { public static void main(String[] args) { // Conjunto de exemplo Set<Integer> set = new HashSet<>(); set. add(1); set. add(2); set. add(3); System. out. println("Conjunto de exemplo: " + set); // Lista de exemplo List<String> list = new ArrayList<>(); list. add("Apple"); list. add("Banana"); list. add("Orange"); System. out. println("Lista de exemplo: " + list); // Fila de exemplo Queue<String> queue = new LinkedList<>(); queue. offer("Pineapple"); queue. offer("Mango"); System. out. println("Fila de exemplo: " + queue); System. out. println("Primeiro elemento: " + queue. poll()); System. out. println("Fila atualizada de exemplo: " + queue); } } ``` Esta amostra demonstra o uso de um conjunto, uma lista, e uma fila em Java. Após executar o código, você verá a saída: ```css Conjunto de exemplo: [1, 2, 3] Lista de exemplo: [Apple, Banana, Orange] Fila de exemplo: [Pineapple, Mango] Primeiro elemento: Pineapple Fila atualizada de exemplo: [Mango] ``` # Documentação Técnica: Java Collections Framework - Classe Array List A classe Array List abstraída da classe AbstractSequentialList fornece relações complexas semelhantes. Aqui você pode ver diversos tipos de coleções, como listas, conjuntos e filas, e entender cada uma de suas propriedades. Vamos aprofundar em cada tipo de coleção. ## Lista ### Array Lista A classe Array List, como uma implementação indexada da interface List, compartilha algumas semelhanças com arrays. É uma coleção ordenada, onde você pode armazenar e acessar elementos com base em sua posição de índice, começando com 0 até o índice - 1. É um array dinâmico, o que significa que ele se adapta ao tamanho sensors de acordo com o número de elementos armazenados. Contrariamente aos arrays, você pode inicializar o tamanho dela, mas ele vai se expandir automaticamente ao adicionar mais elementos. ``` Quando o tamanho inicial não é especificado, a Array List usa uma capacidade de inicialização padrão de 10 elementos. ``` #### Propriedades 1. Coleção ordenada: Você pode acessar os elementos somente em uma sequência pré-definida. 2. Pode aceitar duplicados. 3. Não é seguro thread-safe em sua implementação padrão, pois várias threads podem produzir comportamentos inconsistentes ao acessar ou modificar a coleção simultaneamente. ### Lista Encadeada A Lista Encadeada é outro tipo de lista com propriedades ligeiramente diferentes da Array List. Na Lista Encadeada, você acessa os elementos com base nas referências de elementos anteriores e seguintes. Você pode acessar apenas os elementos em uma sequência determinta começando da cabeça para a cauda. ``` Para acessar o quarto elemento, não pode facilmente digitar `linkedList[4]` como na Array List. Em vez disso, terá que começar do primeiro elemento e continuar saltando referências até chegar na posição desejada. ``` ## Conjunto ### Conjunto Hash O Conjunto Hash geralmente tem duas implementações populares: Conjunto Hash e Conjunto Árvore. Discutiremos a possibilidade de Conjunto Hash, se falarmos sobre Conjunto Hash, ele herdará propriedades já existentes de um Conjunto, o que significa que os elementos devem ser únicos. No entanto, não belhonrá a ordem em que os elementos são inseridos. A ordem de acesso aos elementos varia sempre que tenta iterar sobre o Conjunto de Hash devido à ordem de acesso diferente em cada iteração. ### Conjunto Árvore Em contraste, um Conjunto Árvore fornece uma ordem fixa e uma hierarquia de árvore. É um tipo de estrutura de dados comumente utilizada na navegação entre nós pais e filhos. ## Vector Os Vectors são semelhantes à lista e fornecem a mesma funcionalidade, mas com uma diferença principal: eles são thread-safe. Quando você tem um programa em que precisa acessar uma coleção de forma segura, onde várias threads não podem modificar o mesmo elemento ao mesmo tempo, use Vectors. Vamos abordar a segurança thread em implementações de lista mais tarde. ## Fila Prioritária Uma Fila Prioritária é útil quando você precisa de uma organização First In, First Out (FIFO) mas quer permitir que alguns elementos sejam processados à frente de seus turnos baseados na prioridade. É útil em cenários em que você tem tarefas que precisam de atenção imediata. ## Pilha As Pilhas fornecem uma organização Last In, First Out (LIFO). Você pode pensar em uma pilha como várias prates elas umas sobre as outras em sua casa; a prata colocada pela primeira vez será tomada última, e a última prata colocada será a primeira tomada. É útil em carregar uma organização LIFO em seu programa para armazenar coleções. Em resumo, este documento fornece uma visão geral das classes da Java Collections Framework, incluindo suas interfaces e classes abstratas. Agora você deveria ter uma boa compreensão de quando utilizar Array List, Lista Encadeada, Conjunto Hash, Conjunto Árvore, Vector, Fila Prioritária e Pilha. Vamos explorar a classe Array List em Java. Quando falarmos sobre Array List, estamos principalmente falando sobre a classe List, a qual já conhecemos em detalhes. Agora vamos concentrar-nos nesta sessão. Abaixo, abra a documentação API da classe Array List. Baixe até encontrar uma descrição, tal como a seguinte: ``` A Array List é uma implementação básica e resizeable de array dos List interface. Fornece Array List como uma implementação indexada, portanto pode acessar elementos com base em sua posição indexada. Pode permitir qualquer tipo de duplicado, e por padrão não é thread-safe. ``` A Array List oferece vários métodos interessantes de adição, remoção e obtenção de elementos, que vamos abordar em detalhes no demo. Agora, vamos mudar para o demo. ```java public class ArrayListDemo { public static void main(String[] args) { // Inicialização da Array List List<Integer> arrayList = new ArrayList<>(); // Adição de elementos arrayList. add(1); arrayList. add(2); arrayList. add(3); // Acesso dos elementos System. out. println(arrayList. get(0)); // Saída: 1 // Remoção de elementos arrayList. remove(0); // Consulta do tamanho do Array List System. out. println(arrayList. size()); // Saída: 2 } } ``` Neste exemplo, inicializamos a Array List com o tipo de elemento `Integer`. Você também pode inicializar ela com outros tipos, como `String`, `Character`, `Float`, etc. No entanto, lembre-se de que Java é uma linguagem fortemente tipada, portanto você precisará especificar o tipo de objeto, e o tipo que você especificar, apenas os objetos desse tipo os armazenará dentro da Array List. Isso ajuda a evitar problemas não previstos durante a execução. # Interface de Lista em Java Este artigo abordará a especificação da interface de lista e um exemplo de bloqueio de listas. ## Interface de Lista Definida A interface de lista é um modelo de programação comum para gerenciar uma coleção de elementos de forma ordenada. Neste artigo, vamos considerar o tipo de lista ListaA como implementação de exemplo. Primeiro, vamos especificar a interface ListA e declarar que esta variável deverá conter uma lista de inteiros. Em seguida, especificaremos que esta ListaA será do tipo ArrayList. ``` List<Integer> lista; // Declaração da lista de inteiros lista = new ArrayList<>(5); // Lista de tipo ArrayList, com tamanho inicial de 5 ``` ## Inicializando a ListaA Se a ListaA for inicializada sem especificar um tamanho, será inicializada com tamanho padrão dependendo da implementação da JVM. Em vez disso, é uma boa prática especificar um tamanho inicial conhecido para evitar desperdício de memória, se o tamanho for menor que o que é necessário. ``` lista = new ArrayList<>(2); // Lista de tipo ArrayList, com tamanho inicial de 2 ``` ## Adicionando elementos à ListaA Para adicionar um elemento à ListaA, você precisará utilizar o método add(). ``` for (int i = 1; i <= 5; i++) { lista. add(i); } ``` ## Removendo elementos da ListaA Para remover um elemento da ListaA, basta chamar o método remove() e especificar o índice do elemento a ser removido. Neste caso, `lista. remove(3)` removeria o elemento na posição 4 (pois indexações começam em 0). ``` System. out. println(lista); // [1, 2, 3, 4, 5] lista. remove(3); System. out. println(lista); // [1, 2, 3, 5] ``` ## Acessando elementos da ListaA Para acessar um elemento da ListaA, basta utilizar o método get() e especificar o índice do elemento a ser acessado. ``` System. out. println(lista. get(3)); // 5 ``` ## Lista Ligada em Java Nos nossos artigos anteriores, falamos sobre Arrays e mencionamos alguns de seus recursos. Agora, vamos abordar outro tipo de implementação da interface List, chamada Lista Ligada. Uma lista ligada pode ser usada em situações onde a ordem entre as informações é fundamental, e cada elemento pode ser acessado por meio de um ponteiro para o próximo elemento. Uma lista ligada não pode ser acessada diretamente por posição como arrays. ``` LinkedList<Integer> listaLigada; ``` ### Acessando elementos da Lista Ligada Para acessar um elemento de uma Lista Ligada, é necessário percorrer a lista a partir do começo até a posição desejada. ``` for (int i = 0; i < listaLigada. size(); i++) { System. out. println(listaLigada. get(i)); } ``` ### Adicionando elementos à Lista Ligada Para adicionar um elemento à Lista Ligada, é necessário percorrer a lista durante a inserção para atualizar os ponteiros de todos mais o elemento a ser adicionado. ``` noDoNode lista. . . ``` ### Removendo elementos da Lista Ligada Para remover um elemento da Lista Ligada, é necessário percorrer a lista e atualizar o ponteiro de todos menos o elemento a ser removido. ``` noDoNode lista. . . ``` ## Referências - [Documentação Oracle - Framework de Coleções](https://docs.oracle.com/javase/7/docs/technotes/guides/collections/) - [Documentação Oracle - Implementação da Interface List em Java](https://docs.oracle.com/javase/7/docs/api/java/util/List.html) - [Documentação Oracle - Classe LinkedList](https://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html) - [Effective Java - Joshua Bloch](https://www.amazon.com/Effective-Java-3rd-Joshua-Bloch/dp/013468599X) - [Java Docs](https://docs.oracle.com/javase/10/) # Documentação Técnica ## Operações em Java em Lista Encadeada Neste exemplo, demonstraremos várias operações em uma Lista Encadeada utilizando Java. ### Adicionando Elementos Começamos por verificar a lista que receberemos como saída: ``` d, a, b, c ``` Neste método particular, chamado `addFirst`, adicionaremos elementos à lista. Primeiro, descomentemos o método `addFirst` e comentemos o método anterior. Agora, no nostrado resta apenas um método `addFirst`. Aqui, estamos adicionando dois elementos: `c` ao fim e `b` no início. A lista atualizada é: ``` d, b, c ``` ### Inserindo Elementos Agora vamos mover para a inserção de um elemento chamado `e` à segunda posição: ``` Após executar o programa, teremos: d, a, e, e (Note: `e` é inserido na posição 2) ``` ### Removendo Elementos Agora, vamos observar o que acontece quando tentamos remover elementos desta lista: ``` 1. Para remover um elemento explicitamente, podemos usar o método `remove(Object o)`. Aqui, removemos o elemento `b`: Por exemplo: list. remove('b') Isso retorna um boolean indicando se a remoção foi bem-sucedida ou não. 2. Para remover elementos dependendo da sua posição, podemos usar `remove(int index)`. Vamos ver o que acontece se removemos o elemento na localização terceira: Por exemplo: list. remove(3) Isso remove o elemento na localização especificada (em nosso caso, `c` desde que está na terceira posição) e o retorna. Podes encontrar mais operações interessantes sobre remoção na documentação API para LinkedList. ## Set de Hash em Java Na sessão Framework de Coleções, discorremos de que o Set de Hash faz parte da hierarquia de Set e mantém os elementos da sua Coleção únicos. Se tentar adicionar um duplicado elemento, esta não vai aceitar. O Set de Hash oferece características adicionais em relação a sets, como o acesso aos elementos em ordem aleatória (Set de Hash) em vez de uma sequência fixa. Set de Hash aceita elementos nulos, mas é importante lembrar dos motivos para não inserir nulo. Esta classe oferece semelhantes métodos de utilidade à interface de coleção do tidyMethods to add, remove, check o tamanho e check se um elemento existe na coleção ou não. Esta não é uma coleção protegida em vários bilhetes; portanto, deve ser consciente disso ao usá-lo em um ambiente multithreaded. Aqui está uma demonstração de Set de Hash e como operar com ele utilizando diferentes métodos de utilidade: ``` public class HashSetDemo { public static void main(String[] args) { // Criando um Set de String tipado Set<String> set = new HashSet<>(); // Adicionando elementos ao Set de Hash set. add("a"); set. add("b"); set. add("c"); set. add("c"); // Como os sets são supostos para acabarem únicos, duplicatos não são adicionados // Verificando se um elemento existe no Set de Hash System. out. println("O Set de Hash contém 'c'? " + set. contains("c")); // Removendo um elemento do Set de Hash set. remove("a"); // Iterando sobre o Set de Hash para mostrar o efeito da remoção for (String s : set) { System. out. print(s + " "); } } } ``` Neste demo, aprenderemos como o Set de Hash manteve a unicidade, como remover e adicionar elementos, como verificar se um elemento existir utilizando o método `contains`, e mais. Podes consultar a documentação API para mais métodos. ## Árvore de Sets em Java Utent recuperaremos a discussão do TreeSet quando introduzirmos as interfaces Comparable e Comparator. Por enquanto, deve saber que ao manter a ordem natural dos elementos automaticamente deve usar TreeSet. NB: TreeSet, como o Set de Hash, não pode ter elementos duplicados e não é uma coleção protegida. # Demonstração de conjunto de árvore Passando à demonstração da classe Conjunto de árvore, preparei uma classe denominada `resetDemo`. Pode ver que possui um método `public static void main`. No número de linha 8, estou inicializando um `Conjunto de árvore` denominado `preset`. Este preset armazenará apenas elementos de cadeia de caracteres. ```java public static void main(String[] args) { TreeSet<String> preset = new TreeSet<>(); ``` No lado direito, estou inicializando um `Conjunto de árvore`. Isso não é obrigatório; o `Conjunto de árvore` ainda funcionará mesmo se remover a instrução de inicialização. Pode especificar o tamanho sempre que conhecer a extensão da coleção. ```java TreeSet<String> preset = new TreeSet<>(5); // (Opcional) ``` De número de linha 10 até linha 13, estou adicionando elementos em ordem aleatória. Estou adicionando `b`, depois `a`, depois `c` duas vezes para demonstrar a propriedade de unicidade do `Conjunto de árvore`. ```java preset. add("b"); preset. add("a"); preset. add("c"); preset. add("c"); ``` O segundo intento de adicionar `c` retornou falso e o `Conjunto de árvore` o rejeitou, porque pode ver que `c` já se encontrava presente na coleção. `c` é acrescentado apenas uma vez. É interessante observar que `b` é acrescentado primeiro, mas é impresso após `a`. Isso é porque a ordem natural dos elementos neste `Conjunto de árvore` é automaticamente mantida pelo `Conjunto de árvore`. Ele olha para o tipo, que é um tipo predefinido em Java (cadeia de caracteres neste caso), e utiliza seu próprio algoritmo de classificação para classificar as cadeias de caracteres com base na sua ordem natural. No futuro sessões, iremos abordar a implementação de `Comparable` e `Comparator` para classes personalizadas quando se utiliza uma classe personalizada como o tipo num `Conjunto de árvore`. Por enquanto, se tentar utilizar uma classe personalizada como tipo neste exemplo específico, estou utilizando `String` aqui, e ele aplicará a ordem natural. Estabelecemos `c` no começo para ver o que acontece: ```java preset. add("c"); preset. add("b"); preset. add("a"); ``` Ainda conseguimos ver `abc` pois a ordem natural é implementada. Em contraste, quando falamos sobre `HashSet`, era uma lista de coleção de elementos aleatórios, então se executar o `HashSet` várias vezes, pode ver uma ordem diferente algumas vezes. Na próxima sessão, falaremos sobre um interessante framework chamado `Maps` em Java. Iniciaremos com os `Maps` em Java. ☜(°ロ°)☞ ```markdown # Hash Maps em Java Nesta sessão, vamos abordar o tema das Hash Maps em Java com mais profundidade. No último módulo, abordei os conceitos teóricos de Map, a organização em pares chave-valor, e o papel das chaves como um conjunto e dos valores como uma lista. Nesta sessão, vamos olhar para a documentação da API do HashMap. ## Visão geral do HashMap Aqui está uma visão geral rápida do que é Hash Map: - É improvável encontrar o termo "Tabela de Hashing", mas como possuimos métodos para sincronizá-las, não vê-lo-ás muito à sua volta. Vamos começar então com Hash Maps em Java! - Na sessão anterior, fiquei claro que as chaves são armazenadas numa forma semelhante a de um conjunto e os valores são armazenados numa forma semelhante a de uma coleção. Por padrão, é não sincronizada. Se necessitar de uma coleção线程-safe, precisará implementar medidas adicionais, que abordarei em sessões futuras. ## Demonstração de exemplo: HashMap Agora, vamos olhar para um exemplo, uma classe chamada `HashMapDemo`. ```java import java. util. HashMap; // Importa a classe necessária public class HashMapDemo { public static void main(String[] args) { // Inicializando o mapa HashMap<String, Integer> map = new HashMap<String, Integer>(); // O nome do mapa é apenas 'map' // Pode specificar um tamanho ou omitir este, de acordo com as necessidades de memória e do programa // Adicionando elementos ao mapa map. put("a", 10); map. put("b", 20); map. put("c", 30); // Exemplo do uso dos métodos containsKey e get System. out. println("A chave 'a' está presente no mapa? " + map. containsKey("a")); // true System. out. println("o valor da chave 'a': " + map. get("a")); // 10 // Exemplo de iteração sobre os pares chave-valor usando o laço for aprimorado for (Map. Entry<String, Integer> entry : map. entrySet()) { System. out. println("Chave: " + entry. getKey() + ", Valor: " + entry. getValue()); } } } ``` Neste exemplo, inicializamos um HashMap, adicionamos algumas entradas (pares chave-valor), e demonstramos o uso do método `containsKey`, `get` método, e a iteração sobre os pares chave-valor. ## Resultados finais - Hash Maps em Java são uma implementação da interface Map. - As chaves estão armazenadas como chaves exclusivas numa forma semelhante a de um conjunto, ao mesmo tempo que os valores estão armazenados como objetos numa forma semelhante a de uma coleção. - HashMap não é sincronizada por padrão. - Para iteração sobre o mapa, pode usar o método `entrySet()`, ou se for necessário só os keys ou valores, pode usar os métodos `keySet()` ou `values()`. - Nunca esqueça de importar a classe necessária: `import java. util. HashMap; `. Em sessões futuras, veremos conceitos adicionais relacionados a Hash Maps e outras implementações de Map em Java. ``` # Árvores de Mapas em Java O TreeMap é um tipo de estrutura de dados que mantém os seus elementos organizados de forma ordenada. As suas chaves devem implementar a interface `Comparable`, para que o TreeMap possa determinar a ordem do seu conteúdo. ```java import java. util. TreeMap; public class Main { public static void main(String[] args) { // Criação de um TreeMap TreeMap<Integer, String> meuMapa = new TreeMap<>(); // Adição de elementos no TreeMap meuMapa. put(3, "a"); meuMapa. put(2, "b"); meuMapa. put(1, "c"); // Impressão do TreeMap System. out. println(meuMapa); } } ``` Quando você executar o programa, o TreeMap será impresso em uma ordem ordenada, baseada na sua implementação da interface `Comparable`: ``` {1=c, 2=b, 3=a} ``` Você também pode trocar as chaves com os valores de uma maneira similar, assim: ```java TreeMap<String, Integer> meuMapa = new TreeMap<>(); meuMapa. put("a", 3); meuMapa. put("b", 2); meuMapa. put("c", 1); ``` Como o TreeMap compare as chaves com base no seu comportamento natural de ordenação, as chaves serão ordenadas de acordo com a sequência "a" até "z". ``` {a=3, b=2, c=1} ``` ## Acesso aos Modificadores em Java Os acessos aos modificadores são conceitos centrais em Java para proporcionar segurança para o seu programa. A ideia é que você crie várias classes e variáveis enquanto escreve seu programa e que apenas as classes, pacotes, módulos ou aplicativos apropriados possam acessar somente o que eles devem acessar. O Java oferece três modificadores de acesso: público, protegido e privado. - **Público** (em português: público): Com o uso dessa palavra-chave, a classe ou variável é visualizada toda pelo programa. Qualquer subclasse, pacote ou outra classe que tenha sido escrita em seu programa poderá acessar essa particular classe ou variável ou método. - **Protegido** (em português: protegido): Uma vez que você escreva "protected" em frente de uma classe ou método, todos os componentes dentro da mesma classe continuarão a ter acesso a eles. Além disso, todos os componentes dentro do mesmo pacote ainda possuirão acesso a eles. Ainda não abrimos a discussão sobre os pacotes, mas você pode considerá-lo como um agrupamento lógico de classes. Se você tiver uma classe pai (base), qualquer subclasse dessa classe também terá acesso a eles. - **Pacote padrão (sem nenhum modificador)** (em português: indefinido ou com *package*): Quando você não não provê nenhum modificador, a sua classe ou método será de acesso privado somente para o mesmo pacote. As variáveis serão visíveis para todos aqueles dentro do mesmo pacote, incluindo subclasses do pacote onde a variável foi declarada, mas elas não serão visíveis para nenhum pacote exterior. - **Privado** (em português: privado): Quando você utiliza "private" diante de uma classe ou método ou variável, acompanhada pelo símbolo de vírgula será respectivamente privado para a própria classe. Nenhum pacote, pacote exterior ou subclasse terá acesso a ela. # Entendendo Modificadores de Acesso em Java, com um Exemplo Detalhado Este documento explica os diferentes modificadores de acesso em Java, se concentrando nos modificadores públicos, padrão (default) e privados, e mostra como eles são utilizados. ## Introdução Neste tutorial, vamos explorar os três modificadores de acesso primários em Java – public, padrão e private – e suas implicações para a visibilidade de classes e métodos dentro de um projeto Java. Também vamos fornecer um exemplo prático para melhor entendimento do modificador de acesso padrão. ## Público O modificador `public` fornece acesso não restrito a uma classe, método ou variável de qualquer lugar dentro da aplicação, bem como de código externo. ## Modificador de Acesso Padrão Sem especificar explicitamente qualquer modificador de acesso, uma classe, método ou variável terá nível de acesso padrão, o que significa que é acessível apenas dentro do pacote em que reside. ## Privado O modificador `private` restrição de acesso a uma classe, método ou variável dentro da mesma classe somente. Outras classes no pacote ou classes externas não podem acessar membros privados. ### Exemplo do Modificador de Acesso Padrão Vamos criar um exemplo simples para melhor entender o modificador de acesso padrão em Java: 1. Abra o IDE Eclipse e crie um novo pacote chamado `com. example`. 2. Em seguida, crie uma nova classe chamada `TestClass` dentro do pacote `com. example` com o modificador de acesso padrão: ```java package com. example; public class TestClass { // Método de acesso padrão sem qualquer modificador public void testMethod() { System. out. println("Olá Mundo! "); } public static void main(String[] args) { TestClass testObject = new TestClass(); testObject. testMethod(); } } ``` 3. Agora, crie outra classe chamada `TestDemo` no mesmo pacote `com. example`, e tente acessar a `TestClass` dentro do mesmo pacote: ```java package com. example; public class TestDemo { public static void main(String[] args) { try { // Inicialização da classe TestClass deve funcionar pois ambas estão no mesmo pacote TestClass testObject = new TestClass(); } catch (Exception e) { System. out. println("Erro ao inicializar TestClass: " + e. getMessage()); } } } ``` 4. Execute a classe `TestDemo` para verificar se o acesso padrão se comporta como esperado: ```bash Gradle: gradlew run Maven: mvn exec: java -Dexec. mainClass="com. example. TestDemo" ``` ## Método Privado de Exemplo Vamos modificar a classe `TestClass` conforme a seguir para testar o modificador `private`: ```java package com. example; public class TestClass { // Método privado de acesso private void privateMethod() { System. out. println("Olá Mundo! "); } // Método público para invocar o método privado public void publicMethod() { this. privateMethod(); } public static void main(String[] args) { TestClass testObject = new TestClass(); testObject. publicMethod(); } } ``` Agora declare e tente invocar a `privateMethod` a partir da classe `TestDemo`: ```java package com. example; public class TestDemo { public static void main(String[] args) { TestClass testObject = new TestClass(); // Falha pois o método privateMethod não é acessível pela TestDemo testObject. privateMethod(); } } ``` Quando tentar executar a classe `TestDemo`, você receberá uma mensagem de erro de compilação: ```bash error: TestDemo. java: 10: error: testClass. privateMethod() has private access in TestClass testObject. privateMethod(); ``` ## Herança A herança é um conceito essencial em linguagens de programação orientadas a objetos, onde uma classe herda as propriedades e comportamentos de uma classe pai (ou base). Você pode verificar a utilização da herança olhando pela relação "é" entre diferentes objetos ou entidades. Por exemplo, "Um carro é um veículo, " "Uma conta de poupança é um tipo de conta. " A hierarquia é organizada utilizando uma relação pai-filho, onde a classe pai também é chamada de classe base, e a classe filha é a classe que estende. Não esqueça do sinal `extends` ao definir relações de herança. ## Conclusão Neste tutorial, abordamos os fundamentos de modificadores de acesso, suas implicações e seus usos em Java. Demonstramos o uso do acesso padrão através de um exemplo e brevemente tocamos no conceito de herança. A compreensão dos modificadores de acesso e seu uso correto é essencial para a segurança de suas aplicações Java. # Sessão de Herança Nesta sessão, revearemos conceitos de herança em Java: No Java, utilizando herança, uma _classe filha_ pode acessar _propriedades_ (atributos) da sua _classe mãe_ se estendê-la ou herdá-las. ```java // Consideremos a seguinte relação entre Bicycle e MountainBike classes: // - Bicycle é a classe mãe // - MountainBike é a classe filha (deriva) ## No construtor da classe MountainBike: **Certifique-se da construção correta de um objeto de MountainBike**, pois **o Java não compilará o programa se não o fizer**: **- Inicialize** a variável local `i`, **chame `this`* **(como já discutimos nessa sessão de** **Classes)**, pois faz** o objeto chamante ciente de seu construtor específico**. O objeto de MountainBike requer determinadas propriedades quando criado. Isto será necessário para chamar construtores de classes filhas e então herdar propriedades (não necessariamente métodos! ) da Classe-Base. ```java // Construtor da classe MountainBike para a inicialização correta (classe mãe necessária para herança) public MountainBike() { super(); // A classe mãe requer a inicialização } ``` A classe MountainBike vem com suas características adicionais, o que significa que estarão disponíveis propriedades além das herdadas (velocidade e engrenagens). Enquanto existem propriedades (como as citadas acima para velocidade e altura, ) que não devem ser inicializadas pelo construtor, que podem ser transmitidas da superclasse, propriedades (como a velocidade de partida, engrenagens, altura do volante ou outras correções específicas) **precisam** de suas respectivas configurações iniciais quando criarem suas instâncias. Assim, é melhor chamar explicitamente o construtor da classe-pai no instanciamento na classe-filha, como visto abaixo, e executar a configuração conforme desejado. ```java public MountainBike(double startHeight, int startGear, double startSpeed){ setHeight(startHeight); // Setters das propriedades que precisam de tratamento adicional setGears(startGear); // Defina as engrenagens corretamente setSpeed(startSpeed); // Além disso, defina outras propriedades necessárias, por exemplo - velocidade de partida dos argumentos } ``` ## Execute o programa da seguinte maneira, usando `InheritanceDemo` : ```java // Principal para execução public static void main(String [] args){ MountainBike mountain = new MountainBike( 20d, 10, 1); // Inicialize os parâmetros para definir velocidades, engrenagens e alturas de bicicleta off-road ``` **Chamando métodos (métodos), propriedades e interagindo com construtores**: Utilize estes métodos & propriedades para construir operações necessárias para utilizar a herança corretamente em Java para testar o comportamento do sistema. Pode-se chamar propriedades e propriedades de mesmo nome de várias heranças ou classes aninhadas, junto com seus métodos de classe e métodos da superclasse. Por outro lado, ao chamar diretamente métodos específicos para classes aninhadas, como métodos específicos da Bicycle diretamente em objetos MountainBike criados, causa erros de compilação, pois **o método referenciado não pode ser atingido**, já que não foi instanciado nenhum objeto de **classe específica diretamente**. Certifique-se de chamá-los através de métodos ou subclasses **se estiverem disponíveis na classe-pai**, ou melhor, **herdar e sobrescrever com alterações necessárias sempre que possível**. Também lembre-se que *propriedades locais têm as mesmas regra aplicadas para evitar colisões de nomes, mas isso será detalhado em diferentes seções. * # Documentação para Configuradores e Accesores em IDEs Inteligentes Esta documentação explica como utilizar configuradores e accesores (getters e setters) em IDEs Inteligentes, como o Eclipse, e demonstra como implementar encapsulamento e abstração em Java. ## Configuradores e Accesores Configuradores e accesores permitem acesso às propriedades internas de uma classe enquanto garantindo encapsulamento. ``` Representa a propriedade atual da classe porque `this` representa a propriedade atual da classe. Por favor, atribuia esse valor com o valor do argumento que está a entrar. Faça o mesmo para `age` e o método `setAge`. Faça o mesmo para `set address` no método `set address`. Assim é como pretende fornecer os configuradores e os accesores, para que os configuradores e os accesores possam ainda ser gerados em IDEs inteligentes. O processo para criar accesores e configuradores em IDEs inteligentes é o seguinte: 1. Clica com o botão direito na classe no Explorador de Pacotes 2. Vai para "Fonte" 3. Selecione "Gerar Accesores e Configuradores" 4. Selecione os campos para os quais deseja gerar accesores e configuradores 5. Clique em "Gerar" ``` ## Encapsulamento O encapsulamento é a prática de ocultar os detalhes internos de um objeto do mundo externo. ``` Neste exemplo, vamos instanciar uma classe com propriedades privadas e configuradores para controlar a configuração e a recuperação dessas propriedades. Por utilizando configuradores e encapsulamento, tem o controle total da classe. ``` ## Abstração A abstração é o processo de ocultar a complexidade e apenas revelar informação relevante. Em Java, a abstração é alcançada utilizando a palavra-chave `abstract`. ``` A palavra-chave `abstract` pode ser utilizada para criar classes abstratas e métodos abstratos. Uma classe abstrata não pode ser instanciada, mas pode ser subclassada. Por outro lado, um método abstrato só é declarado sem implementação e a responsabilidade de parar uma implementação concreta é deixada à classe de subclassificação. Por exemplo, considere a classe GraphicObject: ``` public abstract class GraphicObject { // Métodos abstratos que devem ser implementados por subclasses public abstract void drawing(); public abstract void resizing(); } ``` Então crie subclasses como Circle e Rectangle que implementam os métodos `drawing` e `resizing`: ``` public class Circle extends GraphicObject { // Implementação dos métodos abstratos @Override public void drawing() { System. out. println("A desenhando um círculo"); } @Override public void resizing() { System. out. println("A redimensionando um círculo"); } } public class Rectangle extends GraphicObject { // Implementação dos métodos abstratos @Override public void drawing() { System. out. println("A desenhando um retângulo"); } @Override public void resizing() { System. out. println("A redimensionando um retângulo"); } } ``` Nesta classe principal: ``` public static void main(String[] args) { GraphicObject circle = new Circle(); GraphicObject rectangle = new Rectangle(); circle. drawing(); circle. resizing(); rectangle. drawing(); rectangle. resizing(); } ``` Este exemplo mostra como as classes abstratas e os métodos abstratos podem ser utilizados para implementar abstração em Java. # Entendendo a Herança e as Interfaces em Java Esta sessão tem como foco os conceitos de herança e interfaces em Java. ## Java e o Construtor Padrão Java fornece o construtor padrão automaticamente se o usuário não definir um construtor. Isso é demonstrado pela classe `Circle`, pois a mesma estende a classe `GraphicObject`. ``` O construtor padrão de `Circle` é chamado, mas Java vê que você estão escrevendo este código, o que diz que `Circle` estende `GraphicObject`. Assim, Java chama automaticamente o construtor da classe mãe e inicializa-a também, pois é assim que ele pode ver estes métodos e assim por diante. Portanto, chamar o construtor da base classe será feito automaticamente, mesmo se você não o chamar explicitamente. Na verdade, você não pode chamá-lo explicitamente; Java não o permitirá inicializar a classe `GraphicObject` explicitamente. Ele só pode ser chamado por Java próprio indiretamente, através do conceito de herança. ``` ## Tentativa de Instanciar uma Classe Abstrata Quando tenta instanciar uma classe abstrata, isso não pode ser feito não explicitamente, pois as classes abstratas não podem ser instanciadas diretamente. Eles podem ser instanciados apenas pelas classes filhas. Por exemplo, se tentarmos instanciar a classe abstrata `GraphicObject`, recebemos um erro: ``` GraphicObject go = new GraphicObject(); // Isto dá um erro porque não é possível localizar o construtor da classe GraphicObject class. ``` ## Herança Múltipla e o Problema da Pedra na Cabeça em Java Em Java, uma subclasse pode apenas estender de uma classe mas pode implementar múltiplas interfaces. A herança múltipla diretamente de classes (i. e. , uma subclasse herdando de duas bases classes) não é suportada em Java por causa do problema da Pedra na Cabeça. Em termos simples, a subclasse não pode determinar se seguir o caminho da base 1 ou a base 2 classe: ``` Uma classe só pode estender de uma classe em Java, mas podemos encontrar um caminho reduto deste problema usando a ideia de interfaces. ``` ## Compreendendo as Interfaces em Java As interfaces definem um contrato que uma classe deve totalizar. Em outras palavras, as interfaces fornecem um conjunto comum de métodos e constantes entre várias classes. ``` Imagine uma indústria automobilística em que todos os fabricantes de carros estão criando seus carros de várias maneiras. Se todos os carros têm direção, freio e semelhantes componentes, mas diferenças entre fabricantes fazem com que os usuários tenham dificuldade em usar automóveis de diferentes fabricantes. Esse problema é resolvido por interfaces no mundo daprogramação. ``` Em Java, `Interface` é uma palavra-chave e, as interfaces são sua própria tipagem. Eles só podem conter constantes, declarações de métodos, métodos padrão, métodos estáticos ou tipos aninhados. ``` As interfaces não podem definir uma implementação concreta dos métodos; elas apenas declaram métodos. quando se cria uma interface em Java, não é possível escrever nada concreto sobre o conteúdo da interface. ``` ### Um exemplo de interface Aqui está um exemplo de uma interface: ``` public interface Veículo { public static final int VELOCIDADE_MAXIMA = 200; void frear(); void acelerar(int velocidade); } ``` ### Implementando uma interface Quando uma classe implementa uma interface, ela deve fornecer a implementação para todos os métodos declarados na interface. No caso de declarações de métodos que têm alguma implementação pré-definida, a classe implementada pode sobrepor esses métodos para fornecer a sua própria implementação. ``` class MountainBike implements Veículo { private int altura_assento; private int velocidade_oitaiña; // Construtor public MountainBike(int altura_assento, int velocidade_oitaiña) { this. altura_assento = altura_assento; this. velocidade_oitaiña = velocidade_oitaiña; } // Métodos da interface Veiculo @Override public void frear() { // Reduzir a velocidade } @Override public void acelerar(int velocidade) { // Aumentar a velocidade } // Métodos getter e setter para as propriedades public int getVelocidade_oitaiña() { return velocidade_oitaiña; } public void setVelocidade_oitaiña(int velocidade_oitaiña) { this. velocidade_oitaiña = velocidade_oitaiña; } . . . } ``` No método principal, crie uma instância da classe `MountainBike` e use seus métodos: ``` public class DemoInterface { public static void main(String[] args) { MountainBike mtb = new MountainBike(30, 1); System. out. println(mtb. getVelocidade_oitaiña()); mtb. frear(); System. out. println(mtb. getVelocidade_oitaiña()); mtb. acelerar(10); System. out. println(mtb. getVelocidade_oitaiña()); } } ``` # Herança Múltiple em Java através de Interfaces Este demonstrativo justifica por que a herança múltiple não é possível em Java e mostra como as interfaces podem ser usadas para resolver o problema. ## O "Problema do Diamante" em Java O Java não suporta herança múltiple por meio de classes porque do problema do diamante, que surge quando uma classe filha tenta acessar propriedades de suas duas classes-mãe que compartilham uma superclasse. Nos seguintes exemplos, mostramos o problema do diamante utilizando uma visão simplificada: ```markdown class SuperClass { // Propriedades e métodos aqui } class ClassA extends SuperClass { // Propriedades e métodos aqui } class ClassB extends SuperClass { // Propriedades e métodos aqui } class ClassC extends ClassA, ClassB { // Propriedades e métodos aqui } ``` O problema do diamante surge porque ClassC tem duas classes-mãe (ClassA e ClassB), ambas o qual extendem a mesma superclasse (SuperClass). Quando classC quer acessar uma propriedade da superclasse, torna-se não claro qual da implementação das suas classes-mãe deve ser usada, o que leva à ambiguidade e possíveis conflitos. ## Resolvendo o Problema do Diamante usando Interfaces Para resolver o problema de herança múltiple em Java, podemos usar interfaces em vez de classes. As interfaces fornecem uma maneira de realizar a herança múltiple sem as complicações do problema do diamante. A seguir, um exemplo que utiliza a ilustração de bicicleta e bicicleta de montanha: ```markdown interface Bicycle { void applyBrake(); void speedUp(); } class MountainBike implements Bicycle { // Implementação dos métodos applyBrake e speedUp // Guardando getters e setters // Inicializando o objeto } interface Vehicle { boolean canDrive(); // Outros métodos e propriedades relacionados à veículo } class MountainBike extends MountainBike implements Vehicle { // Implementação do método canDrive // Outras propriedades e métodos relacionados à veículo } ``` Neste código, a classe MountainBike já implementa a interface Bicycle e agora se estende para também implementar a interface Vehicle. Para manter o método `canDrive()`, simplesmente providenciamos sua implementação na classe MountainBike. Se você convertesse as interfaces Bicycle e Vehicle em classes em vez, entrarias em conflito porque Java não suporta herança múltiple de classes, mas as interfaces nos ajudam a superar esta limitação. ## Polimorfismo por sobrecarga de métodos em Java Neste exemplo, demonstramos a herança múltiple através de interfaces. Em outra sessão, aprenderemos sobre polimorfismo por sobrecarga de métodos, onde um mesmo método pode tomar várias formas com diferentes lógicas mas continua tendo o mesmo nome em Java. No polimorfismo por sobrecarga de métodos, existem duas regras principais que devem ser seguidas: 1. O nome do método deve permanecer o mesmo. 2. Um método sem retorno (void) pode ser sobrecarregado apenas por outros métodos sem retorno que tenham um número e/ou tipos de argumentos diferentes. 3. Métodos com retorno não podem ser sobrecarregados por métodos com o mesmo nome sem retorno. Os métodos com retorno podem ser sobrecarregados por métodos com o mesmo nome, mas com diferentes retornos, números e/ou tipos de argumentos. 4. Na sobrecarga de métodos, a ordem dos argumentos matters. Se dois métodos tiverem os mesmos argumentos, mas com ordem differentest, Java os tratará como métodos separados, não como um método sobrecarregado. Seguindo estas regras, você pode implementar o polimorfismo por sobrecarga de métodos em Java. # Introdução à Method Overriding em Java Este é um exemplo de como implementar o *Method Overriding* em Java. ```java public class MethodOverridingDemo { public static void main(String[] args) { Dog dog = new GoldenRetriever(); dog. bark(); cat. bark(); // irá gerar um erro de compilação, pois Cat não possui a implementação de bark() } class Animal { public void bark() { System. out. println("Animal faz um som ruivo. "); } } class Dog extends Animal { @Override public void bark() { System. out. println("Cachorro au-au-au. "); } } class Cat extends Animal { // Não possui implementação de bark() } } ``` ## Conceito básico O Method Overriding consiste em possuir métodos com o mesmo nome e tipo de retorno, mas em uma subclasse, que irá substituir o comportamento do método na classe pai (superclasse). ### Aviso Ao utilizar o *Method Overriding*, é recomendado que sejam utilizados com cuidado, pois pode causar confusão. Alguns programadores experientes não recomendam sua utilização. É melhor usar method overriding somente quando não há outra maneira de escrever métodos com nomes claros e legíveis. ```markdown Atenção: Utilize o Method Overriding com cautela. ``` ### O que acontece ao invocar um método que não está disponível na subclasse Quando invocamos um método que não está disponível na subclasse, ele será desviado para a implementação na superclasse. No entanto, se o método não existe na superclasse, ou seja, se o método for abstract, obtém-se um erro de compilação. Isso acontece antes mesmo de você tentar executar o programa. Por exemplo, se copiasse o código a seguir e tivesse tentado chamar o método `abstractMethod()` em um objeto do tipo `SubClass`, receberia um erro de compilação: ```java // Método abstrato abstract class SuperClass { public abstract void abstractMethod(); } class SubClass extends SuperClass { // Não possui implementação de abstractMethod() } ``` ```java SubClass subClass = new SubClass(); subClass. abstractMethod(); ``` O Method Overriding pode ser usado com diferentes tipos e quantidades de variáveis. Este é um exemplo simples, mas pode ser feito para qualquer nível de complexidade. --- ## Introdução à Method Overriding em Python ### Conceito básico Em Python, method overriding não é formalmente suportado, no sentido da herança de classes tradicional. O conceito em Python é, em vez disso, uma forma de herança funcional, através do uso de atributos dinâmicos. ### Aplicando o method overriding em Python Por exemplo, considere uma classe `Base` com um método: ```python class Base: def method(self): print("Esse é um método na classe Base") ``` Uma classe filha `Child` pode usar o conceito de *method overriding* alterando o método da superclasse e adicionando um comportamento personalizado. ```python class Child(Base): def method(self): super(). method() print("Esse é um método na classe Child") ``` Quando chamarmos o método `method()` na instância `child`, observaremos ambos os prints: ```python child = Child() child. method() ``` ```bash Esse é um método na classe Base Esse é um método na classe Child ``` Mas # Construtor de Bicicleta Um exemplo de código demonstrando o uso do construtor de bicicleta e como revolver métodos em Java. ## Consolidando o código do construtor ``` bicicleta se passa um objeto que contém os valores pro fornecer na construção; ovo a velocidade inicial é definida como 10; a aplicação do freio trata a lógica a seguir: A velocidade atual é 10, portanto, quando o freio é aplicado, a velocidade atual é 10 - 1 = 9 Após aplicação do freio, a velocidade atingida é 9, como está imprimindo Agora, vamos prosseguir para a próxima seção, para facilitar, estou comentando a seção inicial, e descomentando esta seção. ``` ## Atribuição de dados para uma moto-bicicleta ``` Aqui tenho um objeto de bicicleta de montanha (reference), mas o tipo do objeto é montanha-bicicleta. É importante manter este conceito, ele é chamado de *container binding* ou *binding dinâmico*. Neste exemplo, estou inicializando uma moto-bicicleta de montanha com uma referência de bicicleta, logo, qualquer valor definido na classe do pai será aplicável aos dados desta classe filha. Em seguida, forneço três valores: 50, 50 e 3, no moto-bicicleta. Se eu vais ver no moto-bicicleta construtor, os valores de altura inicial, velocidade inicial e o linha-dentre (gear) são os três valores que fornecesmos com código 50, 50 e 3, respectivamente. Agora, estou acessando o gear e a velocidade, lembre-se que o gear e a velocidade são declados na classe do pai, mas são acessíveis na classe filha devido a herança que já já abordamos. Se eu imprimir apenas esta parte devemos apresentar os valores esperados de gear e velocidade: velocidade montanha é três, que é o valor que forneci aqui velocidade montanha é cinquenta, que é inicialmente o valor que forneci aqui. Agora que aplicamos o freio, vamos para a próxima seção ``` ## Aplicação do freio ``` Se eu aplicarmos o freio com o valor de 1, dá-se a seguinte lógica: O valor da velocidade antes de aplicar o freio era 50. Em seguida, é aplicado o freio em 50, que resulta em 50 - 1 = 49, Mas a velocidade da moto-bicicleta foi reduzida pela lógica que se encontra no seu construtor previamente definida- introduced equivalent logic 10 - 1 = 9, Portanto, a velocidade final devido ao freio será 49 - 10 = 39, que é o valor que está a ser impresso aqui. Bem, se quiseres testar ainda outra função, podemos testar a função `speedUp(), ` que foi definida aqui onde estou dizendo que a velocidade será aumentada com base no argumento mais 10, portanto, a velocidade atual é 39, se aumentarmos em 10 + 10 = 59, de modo que a velocidade após a aceleração será 59. ``` ## Demonstração "Demonstração da potência do superclassing e como você pode override o comportamento definido na classe pai. Para começar a entender sobre o keyword estático em Java, agora vamos compreender a necessidade deste keyword e depois falaremos sobre como Java implementa este keyword. " ## O keyword estático em Java ``` Na prática, o keyword "estático" é usado para declarar membro de classe, o que significa que esses membros pertencem à classe e não ao objeto. Isso pode ser útil quando você tem um valor que não muda para todas as instâncias da classe. Em seguida, você pode definir uma única cópia desse valor para todos os objetos. Como exemplo, considere a classe Student que muitas vezes usamos em nossas lições anteriores em um sistema de gerenciamento de estudantes. Suponha que a classe tenha uma propriedade que armazena o nome da faculdade. Neste cenário, o nome da faculdade é o mesmo para todos os estudantes. Então, ao invés de criar várias cópias desse valor para cada objeto, você pode simplesmente declarar esse membro utilizando o modificador "estático". ``` Para melhor ilustrar as vantagens, previamente cada vez que você cria um objeto `Student`, a propriedade "college" será reiniciada, o que significa que você está criando uma cópia inadvertida gastando memória desnecessariamente. O que aconteceria se definirmos o "college" como um membro estático seria algo assim: ```java class Student { private String name; private int age; private Address address; static private String college; //. . . } ``` Agora, ao carregar a classe Student a primeira vez, o "college" será inicializado uma única vez, e todos os `Student` que forem criados futuramente usarão a mesma referência para accessar esse "college". Isso é muito eficiente em termos de memória e melhora notablemente a performance no seu sistema. É importante notar que, quando você define um valor como estático em vez de instanciado, você deve sempre acessar o comando estático para obter o valor. Isso é, em vez de `studentObject. college`, você deve escrever `Student. college`. ``` ## Acesso à propriedade "college" ```java // . . . outro código aqui public static void main(String[] args) { Student john = new Student(); john. setName("john"); john. setAge(28); john. setAddress(address); System. out. println("College: " + Student. college); } ``` Lembra-se que o estático é usado geralmente quando a informação passada é a mesma para todas as instâncias de uma classe. ``` # Acessando Variáveis Membros Estáticos em Java Este conteúdo explica como acessar variáveis membros estáticos em uma classe e o conceito de blocos estáticos em Java. --- ## Acessando Variáveis Membros Estáticos As variáveis membros estáticas podem ser acessadas por qualquer método na classe, tanto estáticos como não-estáticos. No entanto, as variáveis não-estáticas não podem ser acessadas por métodos estáticos. ```markdown `count` é uma variável não-estática, portanto, uma variável membro normal para essa matéria. Nome ou idade ou endereço, nada poderia ser acessível aqui se eu tentasse acessar, por exemplo, se eu tentasse acessar 'nome' aqui. Assim, se eu apenas fizer "nome", ela também me dará o mesmo tipo de erro. Se eu vou para aqui, ele me dá o mesmo erro exato porque um método estático não pode acessar as variáveis membro não-estáticas da classe. Tem que tornar esta variável `count` como estática também e então somente este erro de compilação será corrigido. Posso remover esta uma agora, e este método está correto. Posso aumentar o contador todo o tempo que esse objeto é criado, e é um dos casos de uso do métoodo estático - para partilhar o estado em objetos diferentes. Se desejar obter esta variável específica, pode simplesmente escrever um *getter* para ela: ```java public static int getCount() { return count; } ``` --- ## Blocos Estáticos um bloco estático é utilizado para executar um bloco de código apenas uma vez quando a classe é carregada no tempo de execução. Você pode escrever um bloco estático no início da classe: ```java static { // Seu código inicializador aqui } ``` Neste bloco, você pode escrever qualquer lógica que deseja executar apenas uma vez durante a execução do seu programa. O noje irrelevante é que pode somente acessar variáveis membro estáticas em um bloco estático. --- ## Exceções em Java As exceções acontecem quando há um erro ou exceção no código. A finalidade geral das exceções é gerenciar erros e bugs no programa. Java fornece um sistema de exceções para ajudar os desenvolvedores a detectar e corrigir erros. O sistema de exceções é baseado em uma hierarquia de classes: - `Throwable`: A classe raiz ou pai para tratamento de todas as tipos de exceções e erros. - `Exception`: Um tipo de problema que pode ser recuperado, para o qual os desenvolvedores devem tratar. - `Error`: Um tipo de problema que o desenvolvedor não pode fazer nada, como erros do JVM, erros de memória ou erros do framework. --- ### Exemplos de exceções #### ArithmeticException Essa exceção ocorre quando o programa tenta executar uma operação que não é permitida, como dividir por zero. ```java int result = 100 / 0; ``` #### NullPointerException Essa exceção ocorre quando o programa tenta acessar ou executar uma operação em um objeto nulo. ```java String nullStr = null; System. out. println(nullStr. charAt(0)); ``` --- Os desenvolvedores são responsáveis pelo tratamento das exceções, particularmente as exceções responsáveis dos desenvolvedores, isto é, as exceções que podem ser recuperadas e o programa pode seguir rodando. Eles podem usar várias técnicas para tratar exceções, que serão cobertas em detalhes em sessões futuras. # Demonstração de Exceção Verificada e Estou Realizando Algumas Operações em Arquivos Este exemplo demonstra a manipulação de exceções verificadas, principalmente a `FileNotFoundException`. Aqui, estou fazendo operações em arquivos, principalmente leitura de arquivo, escrita em arquivo e assim por diante. Estou utilizando algumas classes do Java, nomeadas como `FileReader` e alguns métodos como `readLine` e `close`. ## Exceções Verificadas Ao tentar ler um arquivo, constate que esta linha tem um marcador vermelho com uma mensagem de erro de compilação. Se você passar o caminho do mouse por cima, ela diz `tipo de exceção não manipulado: FileNotFoundException`. O Java é forçado a que você manipule este erro porque `FileNotFoundException` é uma **exceção verificada**. No Java, quando sua expressão ou linha de código lança uma **exceção verificada**, o Java força você a fazer algo sobre ela. Ele não compilará o código até você either lidar com a exceção ou novamente lançar a exceção novamente. ### Manipulação de Exceções Verificadas Vamos esclarece-lo sobre como lidar com exceções verificadas em uma próxima sessão, mas por enquanto, você pode escolher algum dos seguintes: 1. Lance a exceção novamente, mas você deve fazer algo sobre ela. Você não pode apenas omiti-la. 2. Passar a responsabilidade de manipular a exceção para o programa que chama este método. Agora, quem chama este método terá a responsabilidade de lidar com a `FileNotFoundException` ou qualquer outra exceção especificada. ### Exemplo Aqui está um exemplo de passar a responsabilidade de manipular a exceção: ```java // Um método sem manipular a exceção public void readFile(String fileName) throws FileNotFoundException { FileReader file = new FileReader(fileName); // Seu código aqui. . . } ``` No caso, o chamador do método `readFile` terá que lidar com a `FileNotFoundException`: ```java try { readFile("exemplo. txt"); } catch (FileNotFoundException e) { // Manipular a exceção aqui. . . } ``` ## Exceções Não Verificadas Existe também as exceções **não verificadas** (conhecidas como execções de tempo de execução) que ocorrem por erros do programador no programa, como nosso exemplo. O Java não se importa com exceções não verificadas durante o tempo de compilação, pois apenas encontrará as execuções de tempo de execução não verificadas durante o tempo de execução. ## Exceções Personalizadas Pode criar sua própria exceção se quiser. A seguir está uma classe de exceção simples personalizada: ```java public class MinhaExcecao extends Exception { // Construtor, se necessário } ``` Lembre-se, os tipos de exceção personalizados são exceções verificadas de forma padrão. Quando você lança explicitamente suas próprias exceções personalizadas, você novamente deve lidar com a exceção dentro do seu código envolvente ou pode optar por novamente lançar a exceção e deixar que o chamador a maneje. ## Manipulação de Exceções no Java Agora que ruamos sobre os tipos diferentes de exceções e sua hierarquia, vamos começar com a manipulação de exceções no Java. Vamos utilizar `try` e `catch` blocks. ### Manipulação de Exceções Vimos as situações em que uma exceção pode ocorrer, mas não falamos sobre como as manipular. Agora, vamos nos concentrar no lado de manipulação: 1. Use os `try` e `catch` blocks para manipular as exceções. 2. Escreva o código que você deseja executar no `try` block, o código que pode lançar uma exceção. 3. Se uma exceção ocorrer no `try` block, o `catch` block capturará a exceção, e você pode decidir o que fazer com ela, como registrar um erro, re-lançar a exceção ou convertê-la em uma exceção de negócio. 4. Utilize vários `catch` blocks se você quiser tratá-las de forma diferente. Os `catch` blocks funcionam de forma sequencial, o que significa que se uma exceção ocorrer, ela irá primeiro para o `catch` block mais específico que a pode tratar. 5. Você também pode utilizar um `finally` block para garantir operações de limpeza sejam feitas, independente de se uma exceção ocorrer ou não, como fechar recursos. Aqui está um exemplo: ```java try { // Seu código aqui. . . int result = 10 / 0; } catch (ArithmeticException e) { // Manipular ArithmeticException. . . } catch (IndexOutOfBoundsException e) { // Manipular IndexOutOfBoundsException. . . } finally { // Código de limpeza. . . } ``` Para melhorar a documentação deste texto no Markdown, utilizarei a marcação seguinte para formatá-la de acordo com os requisitos estabelecidos. Vou manter a hierarquia dos títulos, as listas, os códigos e as citas intactas. Drast copyright 2022. Fim de semana de Java I - Conceitos básicos. ================================================================= Entrando no bloco try e chamando o método ------------------------------------------ Ocorre a execução do bloco try, devolvendo a seguinte mensagem: ``` Entrando no bloco try ``` Tente acessar o segundo elemento na lista ----------------------------------------- Tenta acessar o segundo elemento na lista, utilizando o posicionamento `1`. Ao fazer isso, recebe a seguinte mensagem de erro: ``` Erro: index out of bounds exception: index 1 for length 1 ``` Porque a lista contém apenas um elemento e esse elemento está localizado na posição `0`. Assim, o total da lista é de `1`, pois possui apenas um elemento. Enquanto isso, o bloqueio do erro, `IndexOutOfBoundsException`, não é tratado pelas minhas linhas, sendo tratado por um bloqueio de tratamento `catch`. O comando `System. err. println` é executado, resultando na seguinte linha: ``` Entrando no bloco try ``` A continuedora, a execução do blocofinal é executada, independentemente de sucesso ou não na execução do bloco try. Como verificar se o bloqueio final é executado mesmo sem um erro? ---------------------------------------------------------------- Acessando o elemento com o índice `0` e verificando se o bloco final é executado. Sim, executou o blocofinal, acessando o elemento com o valor `10`. Adicionalmente, o bloco final continua sendo executado mesmo que não seja gerado um erro. Isto confirma que o bloco final é sempre executado, independentemente de sucesso ou não no bloco try. Nestes blocos try aninhados --------------------------- Pode-se formar blocos try aninhados, se quiser. Por exemplo, é possível colocar um try dentro de um outro try, de acordo com a necessidade. Ao fazer isso, remeata em indicar o nível na hierarquia de indentação aos seus blocos. Atendo a isso, lembre-se de que possui um importante critério de troca de complexidade: quanto maior o nível de aninhamento, mais complexo tornará o seu programa. Por isso, carregue com medida os aninhamentos de bloqueios try. Eu iniciei um array e imprimi o número `10`, decidido incluir um índice fora dos limites para fazer a execução plotar um erro. Neste exemplo, utilizamos uma exceção `ArrayIndexOutOfBoundsException` que foi tratada imediatamente pelo bloqueio `catch`. Depois disso, é possível ler o erro através do comando `throw`. Ao utilizar o comando `throw` no `catch`, a exceção poderá ser tratada por um bloqueio `try` enclosing, se ocorrer. Exemplo de tratamento de exceções aninhadas ------------------------------------------- ```java import java. util. Arrays; // Portanto, inclui a biblioteca Arrays para uso try { String[] array = { "correção", "gramática", "artigos", "verbos" }; try { String elemento = array[5]; // Imprime um erro `ArrayIndexOutOfBoundsException`, pois a posição 5 no array é fora dos seus limites System. out. println(elemento); } catch (ArrayIndexOutOfBoundsException exception) { System. out. println("Tentativa de acessar posição inexistente emaden array"); // O tratamento é utilizado aqui, mas pode cavalcar para um bloqueio `catch` mais externo throw exception; // Comando `throw` que re-lança a exceção para um bloqueio `catch` mais externo } try { String[] array2 = { "resultou" }; String elemento2 = array2[5]; // Imprime um erro `ArrayIndexOutOfBoundsException`, pois a posição 5 no array é fora dos seus limites System. out. println(elemento2); } catch (ArrayIndexOutOfBoundsException exceção) { System. out. println("Tentativa de acessar posição inexistente em outro array"); // Novo tratamento para outro exemplo de acesso fora dos limites } } catch (ArrayIndexOutOfBoundsException erro) { System. out. println("Erro encontrado neste spécific block"); } ``` Existem três blocos try no exemplo acima, a serem nos depurados a seguir. Esta é a descrição do output resulting desses experimentos: ```shell Tentativa de acessar posição inexistente em um array Erro encontrado neste spécific block ``` Qual a diferença entre `throw` e `throws`? ----------------------------------------- O `throw` é utilizado para lançar uma nova exceção no código ao seguinte sintaxe: ```java throw new Exceção(); ``` A `throws`, por sua vez, é um mecanismo de trato de exceção declarativo, que permite que um método declare que pode lancar um determinado tipo de exceção. Exemplo de declaração de tratamento de exceção na sintaxe `throws`: ```java void lancarExceção() throws Exception { // codigo aqui throw new Exception(); } ``` Aqui, método "lancarExceção()" está declarando que pode lançar a exceção `Exception`. Como implementar o método `equals()` e o método `hashCode()` em Java? -------------------------------------------------------------------- A implementação de ambos os métodos é importante para governar a igualdade e os valores de hash de seus objetos personalizados em Java. ### Implementação do método `equals()` Primeiro, você deve verificar a igualdade do do objeto recebido com seu objeto de instância utilizando a sintaxe: ```java this. método == método inserido através do objeto passado ``` Segundamente, verificar se o objeto passado possui um valor `null` ou se de um tipo diferente da classe atual. Neste caso, retorne false: ```java objetopassado ! = null && obejtopassado. getClass() == this. getClass() ``` Uma terceira etapa é fazer a comparação explicitamente entre as propriedades da classe. Por exemplo, tratando de um objeto Student: ```java this. nome. equals(obetoPassado. nome) && this. idade == obetoPassado. idade ``` Aqui, este exemplo compara os campos `nome` e `idade` entre os objetos objetoPassado e o objeto atual. ### Implementação do método `hashCode()` O método de hash deve retornar um hashCode igual para objetos que são iguais pela implementação do método `equals()`. Os objetos diferentes também devem possuir hash codes diferentes. O algoritmo mais simples é utilizar os códigos inteiros das propriedades. Por exemplo, ao utilizar o método `String. hashCode()` por cada propriedade: ```java return nome. hashCode() ^ idade. hashCode(); ``` O resultante fornecido pela expressão acima deve ser distinto para objetos diferentes. ### Implementação do método `equals()` e do método `hashCode()` para um objeto `Student` hipotético ```java @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() ! = o. getClass()) return false; Student student = (Student) o; return this. nome. equals(student. nome) && this. email. equals(student. email); } @Override public int hashCode() { return this. nome. hashCode() ^ this. email. hashCode(); } ``` No exemplo acima, utilizo o `nome` e `email` como base para os cálculos de hashcode e comparação. Adicione aos seus campos aqui, se existirem mais campos pera implementar. Nesta guide apresentamos como implementar a igualdade e `hashCode` numa classe personalizada (`Student`, em particular) para manter a unicidade em coleções como `HashMap` e HashSet em Java. ## Casting para outros tipos de dados Após converter o objeto em um objeto `student`, precisamos definir nossa própria lógica de negócios para determinar a unicidade. Neste exemplo, identificaremos um aluno com base num número de matrícula única. Caso dois alunos tenham os mesmos detalhes mas número de matrícula diferente, consideraremos-os objetos diferentes. No entanto, se dois objetos tiverem o mesmo número de matrícula e nomes e endereços diferentes, consideraremos-os duplicados. ```markdown - Número de matrícula determina a unicidade e a duplicidade - Se números de matrícula são iguais, os objetos são iguais (ou duplicados) - Se números de matrícula são diferentes, os objetos são diferentes ``` ## Implementando Igualdade e hashCode ### Igualdade (método equals) Implemente o método `equals` para estabelecer como usar o contrato de igualdade para manter a unicidade. ```java public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null || getClass() ! = obj. getClass()) { return false; } Student other = (Student) obj; return this. rollNumber == other. rollNumber; } ``` ### Hashcode (método hashCode) O Java mantém a unicidade em `HashSet` e `HashMap` utilizando tanto o `equals` como o `hashCode`. O hashcode é um local de armazenamento de memória do objeto em memória Java. Cada objeto tem um código hash único, servindo como um nuclear de múrcia. ```java @Override public int hashCode() { return Objects. hash(rollNumber); } ``` ## Consultar em `HashSet` Ao tentar consultar um elemento de um `HashSet`, o método `hashCode` é usado para encontrar a localidade de memória apropriada, ao qual, em seguida, o método `equals` é usado para encontrar o objeto exacto correspondente. ## Manutenção de Consistência Verifique se utilizar o mesmoas as propriedades no método `hashCode` vez como utilizado no método `equals` para evitar resultados imprevisíveis. ### Utilização Ao utilizar a classe `Student` num `HashSet`, todos os objetos serão armazenados num local de memória comum, o que pode resultar no comportamento inesperado quando utiliza-se o método equals para encontrar o objeto correto. Para prevenir isto, utilize um local de memória único para todos os objetos de estudantes. ```java public class HashSetDemo { public static void main(String[] args) { StudentHashSet studentSet = new StudentHashSet(); Student john = new Student(1, "John", 25); Student jane = new Student(1, "Jane", 26); Student tom = new Student(2, "Tom", 27); studentSet. add(john); studentSet. add(jane); studentSet. add(tom); System. out. println(studentSet. contains(john)); // true System. out. println(studentSet. contains(new Student(1, "John", 25))); // true System. out. println(studentSet. contains(new Student(1, "Jane", 26))); // true System. out. println(studentSet. contains(new Student(2, "Tom", 27))); // true System. out. println(studentSet. contains(new Student(3, "Alex", 28))); // false } } ``` ## Comparable em Java Quando precisar de ordenar a sua coleção, o Java provê a interface `Comparable`. Para entender como funciona, avancemo para o Java docs. ### A Interface Comparable A interface Comparable permite ordenar objetos personalizados. Ela fornece um método `compareTo`, o qual deverá implementar na classe em que quer ordenar. ```java public int compareTo(Student other) { int rollNumberDiff = this. rollNumber - other. rollNumber; return rollNumberDiff == 0 ? this. name. compareTo(other. name) : rollNumberDiff; } ``` No `compareTo` método, o comparador predefinido é baseado no [Java Docs](https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html) para mais detalhes. # Ordenação de uma Coleção de Alunos Este exemplo demonstra como implementar lógica de comparação personalizada para ordenar uma coleção de alunos com base em seus números de matrícula. ## Implementando a Interface Comparável Para permitir a ordenação de uma coleção, primeiro, implemente a `Comparable<Aluno>` interface na classe `Aluno`. Aqui está a classe `Aluno` modificada: ```java public class Aluno implements Comparable<Aluno> { // Atributos do Aluno @Override public int compareTo(Aluno outro) { return this. matricula - outro. matricula; } } ``` ## Ordenando a Coleção Agora que a classe `Aluno` implementa a interface `Comparable`, você pode ordenar a coleção usando o método `Collections. sort()` do Java: ```java ArrayList<Aluno> alunos = new ArrayList<>(); // Adicione alunos à lista Collections. sort(alunos); ``` ## Lógica de Comparação Personalizada Quando não desejar ordenar com uma ordem pré-definida, você pode implementar o método `compareTo` e fornecer uma lógica de comparação personalizada. Neste exemplo, estamos ordenando alunos com base em seus números de matrícula. ## Executando o Programa Ao executar o programa, a coleção será ordenada com base nos números de matrícula, e os alunos serão impressos na ordem ordenada. Se você comentar a implementação do método `compareTo` ou remover a declaração `implements Comparable<Aluno>`, receberá um erro ao tentar ordenar a coleção, pois o Java não saberá como ordená-la sem uma lógica de comparação fornecida. ## Projeto Java Básico Este exemplo faz parte de um projeto de Java Básico onde aprenderemos a construir uma aplicação de cálculo que suporte operações de adição, subtração, multiplicação e divisão. ### Classe de Leitura de Entrada Para capturar as entradas da linha de comando, usaremos a classe `Scanner`. Na classe de leitura de entrada, um método estático `read` é usado para capturar a entrada do usuário: ```java public final class LeituraEntrada { public static String read() { Scanner scanner = new Scanner(System. in); return scanner. nextLine(); } } ``` ### Divisão da Entrada da Expressão A expressão de entrada é dividida em dois arrays de strings contendo números e operadores: ```java List<String> numeros = new ArrayList<>(); List<String> operadores = new ArrayList<>(); String expressaoEntrada = LeituraEntrada. read(); // Obtenha a entrada da linha de comando String[] expressaoSplit = expressaoEntrada. split("\\s+"); // Divida a expressão for (String token : expressaoSplit) { if (token. matches("\\d+")) { numeros. add(token); } else if (! token. isEmpty()) { operadores. add(token); } } ``` ### Conversão das Strings em Listas e Fila Converter as arrays em listas e armazená-las em filas: ```java Queue<Integer> numerosFila = new LinkedList<>(Arrays. stream(numeros. toArray()). map(Integer: : parseInt). collect(Collectors. toList())); Queue<String> operadoresFila = new LinkedList<>(operadores); ``` ### Retirando Elementos das Filas Retire elementos de ambas as filas usando o método `poll()`: ```java int primeiroNumero = numerosFila. poll(); String operador = operadoresFila. poll(); # Aplicativo de Calculadora de Consola de Exemplo (Java) Utilize este programa Java como exemplo básico de como construir uma aplicação de interface de linha de comando simples (CLI - Command-Line Interface) usando conceitos básicos da Java. Esse exemplo é uma calculadora interativa que aceita dois inputs: números e operações. ## Avaliação de Expressões Ao executar a expressão digitada, como `4 + 5 * 3 / 2`, a seguinte acontece: 1. A expressão é dividida em dois arrays (ou filas) contendo números e operações. 2. O primeiro número é pego do array, e o laço de repetição continua a avaliar cada passo até que não hajam mais números no array. 3. Para cada iteração, a primeira operação (ou expressão) é pega do array, e uma correspondente classe da operação é inicializada. 4. O próximo valor no array é pego para a execução da operação, e o resultado é gravado de volta no váriavel `rest`. 5. Esse processo se repete até que todas as operações na expressão tenham sido avaliadas, e o resultado final é gravado. ## Enum (Tipos Enumerados) em Java Los Enum's em Java são construções da linguagem utilizadas para definir tipos de variáveis seguras. Essas variáveis ficam constantes e são imutáveis por padrão, são interpretadas de forma identica por várias aplicações e componentes. ### Criando Enum's Para criar um enum, use o operador `enum` em vez do operador `class`. Em seguida, defina o nome do tipo de enum e suas possíveis opções, separadas por vírgulas. Os valores são em maiúsculas por padrão. Por exemplo: ```java public enum Cores { AZUL, VERDE, VERMELHO; } ``` Neste exemplo, criamos um `Enum` de cores simples chamado `Cores` com três opções pré-definidas: AZUL, VERDE, e VERMELHO. ### Usando os valores dos Enum's Para usar um enum, você pode referenciar seus valores constantes em seu aplicativo. Por exemplo: ```java Cores cor = Cores. AZUL; ``` Essa linha de código cria um objeto `Enum` de cores chamado `cor` com o valor AZUL. Caso queira acessar apenas o nome do enum constante, você pode chamar o método `name()` do objeto enum, assim: ```java System. out. println(cor. name()); // imprime AZUL (em maiúsculas) ``` Se você quiser acessar o valor real do enum constante, você deve previamente definir uma variável privada e um método getter no enum para recuperar o valor. Por exemplo: ```java public enum Cores { AZUL("azul"), VERDE("verde"), VERMELHO("vermelho"); private String valor; Cores(String valor) { this. valor = valor; } public String getValor() { return valor; } } ``` Com o `Enum` de cores atualizado, você pode recuperar o valor real de cada constante usando o método getter. Por exemplo: ```java System. out. println(cor. getValor()); // imprime azul (em minúsculas) ``` ## Percorrendo os valores dos Enum's Para percorrer os valores dos tipos enumerados, use o método `. values()`, depois use um laço de repetição para iteraar sobre o array de constantes do enum retornado. ```java for (Cores cor : Cores. values()) { System. out. println(cor. getValor()); } ``` ## Anotações em Java As anotações em Java fornecem informações de metadata para o compilador Java. As anotações podem evitar ao engltreamento excessivo de código, fornecer lógica adicional para o código, e optimizar sua operação ou implantação. # Começando com as Anotações em Java Utilize anotações para fornecer informações de metadata compactas para o compilador Java, aprimorando seus programas com instruções smart. Este artigo irá guiar você através da criação e utilização de anotações em Java. ## Por que usar anotações? As anotações ajudam a simplificar seu código diminuindo o número de linhas necessárias para obter especificos resultados. Fornecem informações ao compilador de código útil que pode não ser aparente no código, permitindo uma compilação mais eficiente, processamento dinâmico ou implantação. Um exemplo de uso de anotações é a anotação `@Override` aplicada aos métodos, que permite ao compilador identificar se um método está sendo overrideado ou não. ## Criando Suas Properias de Anotação Para criar uma anotação, use o símbolo `@` seguido pelo nome da anotação. Vamos criar uma simples anotação chamada `@Propriedade`. ### Exemplo: MyClass. java ```java @Propriedade public class MyClass { // Seu código aqui } ``` Neste exemplo, a classe `MyClass` está marcada como uma propriedade usando a anotação `@Propriedade`. ## Aplicando Sua Anotação Personalizada Para aplicar a anotação, inclua-a no seu arquivo Java e defina um valor para ela. Esse tutorial vai mostrar como criar uma anotação personalizada e usar ela para marcar uma propriedade. Primeiro, crie a sua interface de anotação: ```java import java. lang. annotation. *; @Target(ElementType. FIELD) @Retention(RetentionPolicy. RUNTIME) public @interface Propriedade { String value() default ""; } ``` Neste código, definimos a anotação `Propriedade` e a marcamos como aplicada para variáveis com o método `@Target(ElementType. FIELD)`. Definimos que a anotação deve ser mantida no tempo de execução do sistema `@Retention(RetentionPolicy. RUNTIME)`. Também definimos um valor padrão use `@DefaultValue("")` se o valor não for definido. Agora que temos a anotação, podemos usar em nossa propriedade, parecido com a anotação nativa `@Override`. ```java public class MyClass { @Propriedade private final String propriedade; // Construtor, getters e setters, o que for necessário. . . } ``` Neste exemplo, definimos uma classe `MyClass` com uma propriedade marcada com a anotação `Propriedade`. À medida que o código evoluirá, você provavelmente irá optar por escrever um agente Java personalizado para ler suas classes no tempo de execução e ler os valores das anotações. No exemplo anterior, escrever um recurso de configuração seria uma boa abordagem para que você possa modificar que propriedades aceitas pela formação sem recompilar todo o programa. # Anotações em Java As anotações fornecem instruções para o compilador, permitindo-o ver exatamente o que você está falando. Neste texto, vamos discutir algumas anotações comumente utilizadas e a construção de uma anotação personalizada em Java. ## Anotação Personalizada de Marcador As anotações de marcador não possuem lógica de metadados, fornecendo somente instruções de nível superior ao compilador. Veja abaixo como definir uma anotação personalizada de marcador: ```java // Definição da anotação de marcador public @interface MinhaAnotaçãoPersonalizada { } // Público alvo da anotação (aplicável a métodos) @MinhaAnotaçãoPersonalizada public void minhaMétodo() { // Lógica da anotação personalizada aqui } ``` Para utilizar a anotação, você pode aplicá-la a um método, como demonstrado no exemplo acima. ## Anotação Personalizada com Valor Em alguns casos, você pode desejar fornecer um valor para sua anotação personalizada. ```java // Definição da anotação personalizada com valor public @interface MinhaAnotaçãoPersonalizada { int valor(); } @MinhaAnotaçãoPersonalizada(valor = 10) public void minhaMétodoComValor() { // Valor da anotação pode ser acessado dentro do método } ``` ## Serialização em Java A serialização é o processo de convertê-lo um objeto em uma stream de bytes que pode ser enviada por uma rede. Para implementar a serialização, seu objeto precisa estender a interface `Serializable`. Vamos tomar o exemplo de uma classe `Aluno`: ```java // Classe de estudante serializável public class Aluno implements Serializable { private static final long serialVersionUID = 1L; private String nome; private int idade; private Endereço endereço; // Construtores, setters, getters e método toString } ``` Ao estender a interface `Serializable`, o IDE irá solicitar que você adicione a `serialVersionUID` para identificar o objeto de forma única quando serializado e desserializado. As IDEs modernas também podem gerenciar o rastreamento de versão para você, incrementando isso em caso de mutação do objeto antes de deserializá-lo. Na classe principal, você pode serializar e deserializar o objeto de aluno da seguinte forma: ```java // Classe principal para a serialização e desserialização public class Principal { public static void main(String[] args) throws IOException, ClassNotFoundException { Aluno aluno = new Aluno("João da Silva", 25, new Endereço("123, Rua Principal", "Lisboa", "Portugal", "1234-567")); //Serializar o objeto de aluno FileOutputStream arquivoSaida = new FileOutputStream("estudante. ser"); ObjectOutputStream saida = new ObjectOutputStream(arquivoSaida); saida. writeObject(aluno); saida. close(); arquivoSaida. close(); //Desserializar o objeto de aluno FileInputStream arquivoEntrada = new FileInputStream("estudante. ser"); ObjectInputStream entrada = new ObjectInputStream(arquivoEntrada); Aluno aluno2 = (Aluno) entrada. readObject(); entrada. close(); arquivoEntrada. close(); //Imprimir o objeto deserializado de aluno System. out. println(aluno2); } } ``` Este exemplo mostra como serializar e deserializar o objeto de aluno, armazenando-o como arquivo (neste caso) e recuperando-o após a deserialização. Nos cenários de produção, você iria regularmente enviar as informações serializadas por uma rede. Como você pode ver, o uso de anotações fornece uma meta-informação e flexibilidade a seu código Java, especialmente quando trabalha com serialização e desserialização. # Gestão de Arquivos e Serialização em Java Este texto fornece uma explicação da gestão de arquivos e serialização em Java. Ele abrange o processo de serialização e deserialização de objetos, o uso dos fluxos `ObjectOutput` e `ObjectInput`, e o uso do palavra-chave `transient` para omitir determinadas propriedades durante a serialização. ## Serialização de um Objeto Para serializar um objeto, ele deve ser criado primeiro e depois armazenado em um arquivo. Neste exemplo, o objeto é um objeto `Student` com propriedades `nome`, `idade` e `endereço`. ``` Student student = new Student("John", 25, "23 East California"); // (Supondo que a classe Student tenha um construtor adequado) // Especificar o nome do arquivo String fileName = "student. ser"; // Criar duas classes diferentes para escrever no arquivo e criar uma classe para ele ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(fileName)); outputStream. writeObject(student); outputStream. close(); ``` Java serializa automaticamente o objeto quando o grava no arquivo. A informação do tipo de classe é perdida durante a serialização, e o método `readObject` retorna um objeto genérico Java. Para convertê-lo de volta ao tipo `Student`, é necessário um cast explícito: ``` ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(fileName)); Student deserializadoStudent = (Student) inputStream. readObject(); ``` ## Usando o `transient` Palavra-Chave Quando determinadas propriedades não devem ser serializadas, o `transient` palavra-chave pode ser utilizada para impedir que elas sejam serializadas e deserializadas. Por exemplo: ``` class Student { private String nome; private int idade; private String endereço; private transient int x; // Esta propriedade não será serializada // Getters e setters para todas as propriedades } ``` Quando o objeto `Student` for deserializado, a propriedade transiente `x` terá o seu valor inicial, pois não é salvo durante a serialização. Para demonstrar isto, crie um objeto `Student` com uma propriedade transiente, serialize-o e deserialize-o: ``` Student student = new Student("John", 25, "23 East California"); student. setX(10); // Define a propriedade transiente // Serializar o objeto de estudante ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("student. ser")); outputStream. writeObject(student); outputStream. close(); // Deserializar e verificar se a propriedade transiente foi mantida ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("student. ser")); Student deserializadoStudent = (Student) inputStream. readObject(); System. out. println("Deserializado estudante valor de x: " + deserializadoStudent. getX()); // Deve imprimir 0 ``` ## Concurrencia e Ferramentas de Thread A concurrencia em Java é concernente com a habilidade de um programa rodar várias tarefas simultâneas. O Ambiente Virtual Java (JVM) cria múltiplas threads para executar estas tarefas, que são leves em relação às processos. Um `Process` é um ambiente de execução autônomo com seu conjunto de recursos, enquanto uma `Thread` é uma tarefa que opera dentro de um processo. Um processo normalmente é inicializado com pelo menos uma thread chamada main thread, e mais threads podem ser criadas para rodar outras tarefas de forma concorrente. Em Java, as threads podem ser criadas extending `Thread` ou implementando a `Runnable` interface. A thread criada deve sobrepor o método `run()`, contendo o código a ser executado de forma concorrente. Para iniciar uma thread, o método `start()` deve ser chamado: ``` class ThreadExample implements Runnable { @Override public void run() { // Código concorrente } } ThreadExample thread = new ThreadExample(); thread. start(); ``` Exemplos adicionais de utilização de threads em Java podem ser encontrados na documentação Java. ■ # Threading em Java Este exemplo mostra como criar e executar threads em Java. ## Extendendo a classe `Thread` Se você é Java, você pode estender sua classe normal para a classe `Thread` para criar uma nova thread. Isso requer que você sobreponha o método `run`. A anotação `@Override` será usada aqui para indicar que estamos sobrepondo o método. ```markdown Dendo do Java, portanto do JDK básicamente, logo quando você estender sua classe padrão de um dos seus próprios classes de um Java `Thread`, depois deverá sobreposição do método `run`. Se você mostrar-me a `Thread` classe aqui, essa é a implementação da `Thread` classe disponível dentro do JDK, e é esta que está a ser chamada quando se estende. A `@Override` annotation faltava, então ajustei esta aqui para uma compreensão mais fácil: ``` ```java public class MinhaThread extends Thread { @Override public void run() { // código de sua thread aqui } } ``` Observação: Haverá um mudecimento do estado da thread quando o método `run` for executado. Neste exemplo, estamos apresentando um lugar reservado para um código que será executado pelas threads. ### Estados da Thread 1. **Ready**: A thread está pronta para ser executada. 2. **Running**: A thread está atualmente a ser executada. 3. **Espera pelo entrada do usuário**: A thread está esperando a entrada do usuário pela console ou pela linha de comando. 4. **Dead**: A thread concluiu a sua tarefa e parou. 5. **State de Suspensão**: A thread está pausada. Neste exemplo, nos vamos focar principalmente nos estados `Ready`, `Running` e `Dead`. ## Criando e Inicializando Threads 1. Pode-se criar uma thread com o método estático `Thread. start()` para iniciar uma thread que estende a classe `Thread`. Isto mudará o estado da thread para `Ready`, e em seguida, para `Running`. ```java MinhaThread t1 = new MinhaThread(); t1. start(); ``` 2. Pode-se também criar uma thread que implementa a interface `Runnable`: ```java public class MinhaThread2 implements Runnable { @Override public void run() { // código de sua thread aqui } } ``` Em termos de código de exemplo, é aplicada aqui alternativa para a criação de threads em Java, tornando a herança múltipla possível se necessário. ```markdown Portanto, em Java, haverá uma das duas maneiras de criar threads porque existem cenários onde deverá extender sua classe thread de um dos seus classes personalizadas do Java. ``` ```java public class Estudante implements Runnable { // classe Estudante com métodos. . . } public class MinhaThread2 implements Runnable { @Override public void run() { // código de sua thread aqui } } Thread2 t2 = new Thread(new MinhaThread2()); t2. start(); ``` ## Sincronização entre Threads Quando estiver trabalhando com objetos em múltiplas threads, você pode encontrar situações em que duas threads tentam modificar o estado ou as propriedades de um objeto ao mesmo tempo. A documentação Oracle [apresenta mais informações sobre a sincronização](https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html) em Java. Este exemplo apresenta a sincronização das threads de uma forma simples usando a palavra-chave `synchronized`: # Multiple Threads Accessing the Same Object e Sincronização Neste exemplo, discutiremos um cenário em que dois threads estão acessando o mesmo objeto e a saída aleatória que pode resultar da sequência de execução previsível. Exploraremos o uso da sincronização para garantir que um thread está acessando o objeto ao mesmo tempo. ## Declaração do Problema Esta classe é projetada para imprimir os múltiplos de um número até 20, com uma pausa de 400 milissegundos entre cada iteração. Dois threads estão acessando o mesmo objeto da classe MathUtils, a pedido para imprimir os múltiplos de diferentes números. A saída produzida sem sincronização é aleatória, que pode ser melhorada com a utilização da sincronização. ## Solução com Sincronização O método getMultiples é a fonte de contestas aqui. Para resolver o problema, podemos sincronizar o método utilizando a palavra-chave `synchronized`. Isso garante que um thread executará o método ao mesmo tempo, impedindo uma cena em que dois threads executam simultaneamente o método ou o captam. ```java public synchronized void getMultiples(int num, int count) { // . . . } ``` Com o método sincronizado, obterá uma saída mais linear, sem randomness na execução. ``` 2 4 6 8 10 3 6 9 12 15 ``` ## Bloqueios Sincronizados Se não quiser bloquear todo o método inteiro, pode bloquear blocos de código específicos que são sensíveis aos threads. Para isso, pode utilizar um bloco `synchronized`. Inserindo `synchronized` antes do bloco de código, limita o acesso ao bloco de código sincronizado a um thread ao mesmo tempo. ```java public void getMultiples(int num, int count) { // Código antes do ponto de contenda synchronized (this) { // Código a que os threads têm acesso simultâneo } // Código após o ponto de contenda } ``` O uso de blocos Sincronizados ajudará a garantir que um thread está acessando um objeto sensível ao mesmo tempo e há nunca uma cena em que dois threads modificam simultaneamente o mesmo objeto concorrentemente. ## Cuidados Tenha cuidado ao utilizar métodos Sincronizados ou blocos Sincronizados, pois os threads têm seqüências de execução inesperadas, e blocos Sincronizados podem criar problemas de desempenho, especialmente em aplicações com milhares de threads. É crucial ter experiência para identificar o código que está a causar o problema e decidir quando e onde utilizar métodos e blocos Sincronizados. --- # Auto Boxing e Unboxing em Java Neste exemplo, exploraremos o Auto boxing e Unboxing em Java, que é a conversão automática a que a compiladora Java make entre os tipos de dados primários e suas correspondentes classes de objeto wraper. ## Visão Geral Auto boxing é a conversão automática que acompanha a conversão entre o tipo de dados primário e a classe de objeto correspondente wraper. Por exemplo, convertendo um `int` tipo de dados primário para a classe de objeto `Integer` ou vice versa. ## Auto Boxing Auto boxing envolve a conversão de um tipo de dados primário para uma classe de objeto wraper. ```java int i = 10; Integer iObj = new Integer(i); // Manual boxing Integer iObj = Integer. valueOf(i); // Auto boxing ``` Para verificar se a conversão de auto boxing foi bem sucedida, pode imprimir o objeto para observar o seu valor. ## Auto Unboxing Auto unboxing envolve a conversão de uma classe de objeto wraper para um tipo de dados primário. ```java Integer iObj = new Integer(10); int i = iObj; // Auto unboxing ``` A conversão pode ser feita por meio de atribuição simples. Este recurso pode ser utilizado para outros tipos primários e classes de objeto wraper como `Character`, `Boolean`, `Float` e `Double`. Quando tiver que fazer auto boxing, você chama o método `value` e para auto unboxing, basta atribuir o objeto a um tipo de dados primário. ```java Double objDouble = 3. 14; // Auto boxing float f = objDouble; // Auto unboxing ``` ## Exemplos ```java public class AutoBoxingDemo { public static void main(String[] args) { int i = 10; Integer iObj = i; // Auto boxing System. out. println(iObj); double d = 3. 14; Double dObj = d; // Auto boxing System. out. println(dObj); Character c = 'a'; Character cObj = c; // Auto boxing System. out. println(cObj); } } ``` Neste exemplo, demonstramos auto boxing e unboxing para diferentes conversões primárias a objetos wraper, incluindo `int` para `Integer`, `double` para `Double`, e `char` para `Character`. # Auto Boxing e Auto Unboxing em Java O Auto boxing converte tipos primitivos em classes wrapper objetos e o auto unboxing converte classes wrapper objetos de volta em tipos primitivos. Este tutorial explica como utilizar o auto boxing e auto unboxing em Java e como se conectar a um banco de dados utilizando JDBC com um exemplo usando o PostgreSQL. ## Auto Boxing e Auto Unboxing Para ilustrar o conceito de auto boxing e auto unboxing, considere o seguinte código: ```java Integer i1 = 10; // Auto-boxing char ch = 'A'; Character objCh = ch; // Auto-unboxing ``` No primeiro linha, o valor primitivo `int` `10` é automaticamente convertido para uma `Integer` objeto (auto-boxing). No segundo linha, definimos uma variável `char`. No terceiro linha, criamos um objeto `Character` da `char` valor, e isso é auto-unboxing. ## JDBC em Java Esta secção mostra como se conectar a um banco de dados usando JDBC em Java, utilizando o PostgreSQL como exemplo. Lembrete que você pode utilizar quaisquer fornecedores de base de dados da sua escolha. ### Pré-requisitos 1. Baixe a edição de software livre de origem para o Windows do PostgreSQL [do website oficial do postgresql. org](https://www.postgresql.org/download/) 2. Baixe o motor de base de dados do PostgreSQL JDBC [do website oficial JDBC para PostgreSQL](https://jdbc.postgresql.org/) ### Instalação e Configuração 1. Instale o PostgreSQL na sua máquina 2. Abra o pgAdmin para falar com o banco de dados (instalado automaticamente com o PostgreSQL) 3. Crie uma nova base de dados e um usuário de banco de dados e uma senha 4. Encontre o URL de conexão do banco de dados na documentação oficial para o provedor de banco de dados específico 5. Em Java, utilize a `java. sql. Connection` classe para se conectar ao banco de dados, utilizando as especificações do JDBC e a implementação da camada JDBC do fornecedor de banco de dados fornecida pelo arquivo . jar do motor JDBC do PostgreSQL ### Exemplo Aqui está um exemplo de uma classe Java, `JdbcDemo`, que cria uma conexão com o banco de dados de teste e insere um registro numa tabela `student`. ```java import java. sql. Connection; import java. sql. DriverManager; import java. sql. Statement; public class JdbcDemo { public static void main(String[] args) { // Instantiate the connection object Connection con = null; try { // Load the PostgreSQL JDBC driver Class. forName("org. postgresql. Driver"); // Establish the connection String url = "jdbc: postgresql: //localhost: 5432/test"; con = DriverManager. getConnection(url, "postgres", "postgres"); // Create a statement and execute the SQL query Statement stmt = con. createStatement(); String sql = "INSERT INTO student (roll_number, name, age) VALUES (1, 'John Doe', 20)"; stmt. executeUpdate(sql); // Close the resources stmt. close(); con. close(); } catch (Exception e) { e. printStackTrace(); } System. out. println("Record inserted successfully! "); } } ``` Esse exemplo conecta-se ao banco de dados de `teste` e insere um registro na tabela `student`. A tabela `student` possui três colunas: `roll_number`, `name` e `age`. Replace # Conexão com Banco de Dados usando JDBC (Java Database Connectivity) ## Introdução Neste exemplo, demonstraremos como criar uma conexão com um banco de dados usando a API Java Database Connectivity (JDBC). Este tutorial guiará você através de preparar uma consulta SQL, executá-la e lidar com os resultados. ### Pré-Requisitos - Um Kit de Desenvolvimento Java (JDK) instalado em sua máquina - Um servidor de banco de dados (por exemplo, PostgreSQL, MySQL ou Oracle) com uma tabela de estudante - Driver JDBC para seu provedor de banco de dados (por exemplo, `postgresql-42. 2. 21. jar` para PostgreSQL) ### Passo 1: Importar pacotes necessários ```java import java. sql. *; ``` ### Passo 2: Preparar a URL, usuário, senha e o driver JDBC ```java String url = "jdbc: sua_banco_de_dados: nome_do_banco"; String username = "seu_usuário"; String password = "seua_senha"; String driver = "com. sua_banco_de_dados. JDBC_Driver"; ``` ### Passo 3: Carregar o driver JDBC ```java Class. forName(driver); ``` ### Passo 4: Estabelecer uma conexão com o banco de dados ```java Connection connection = DriverManager. getConnection(url, username, password); ``` ### Passo 5: Preparar a declaração SQL ```java String sql = "INSERT INTO student (roll_number, name, age) VALUES (? , ? , ? )"; PreparedStatement statement = connection. prepareStatement(sql); ``` ### Passo 6: Definir os valores para os parâmetros ```java statement. setInt(1, 2); statement. setString(2, "Jane"); statement. setInt(3, 22); ``` ### Passo 7: Executar a declaração SQL ```java int linhasAfectadas = statement. executeUpdate(); ``` ### Passo 8: Verificar o número de linhas afectadas para verificar a execução ```java if (linhasAfectadas > 0) { System. out. println("Processamento com sucesso. "); } else { System. out. println("Processamento falhou. "); } ``` ### Passo 9: Capturar e lidar com quaisquer erros ```java catch (SQLException e) { System. out. println("Erro: " + e. getMessage()); } ``` ### Passo 10: Fechar a conexão ```java finally { if (connection ! = null) { connection. close(); } } ``` ### Passo 11: Verificar a tabela de estudante antes e depois da operação Antes de executar o programa, você pode usar um cliente de banco de dados como pgAdmin ou MySQL Workbench para verificar os dados da tabela de estudo antes da execução. Depois de executar o programa, re-verifique a tabela para garantir que o novo registro tenha sido inserido. ## Adicionando o driver JDBC Para adicionar o driver JDBC, use as seguintes etapas: 1. Clique com o botão direito do mouse em seu projeto no Explorador de Projectos. 2. Vá para `Construir Caminho > Configurar Caminho de Construção`. 3. Vá para a guia `Libraries` e selecione a `Entrada de Classe` opção. 4. Selecione a opção `Adicionar Arquivos Externos` . 5. Carregue seu arquivo JDBC driver JAR (por exemplo, `postgresql-42. 2. 21. jar` para PostgreSQL) e clique em `Abrir`. 6. Clique em `Aplicar` e `Fechar`. Certifique-se de que você tem o arquivo JDBC driver JAR corretos para o seu provedor de banco de dados. O falha em adicionar o driver JDBC pode resultar em problemas de conexão. ## Sobre os Generics em Java Os Generics são uma característica de Java que permite reutilizar código com diferentes tipos de entrada. Esta característica foi introduzida para eliminar a necessidade de criar várias classes com a mesma funcionalidade para diferentes tipos de dados. Com os generics, você pode criar uma classe que aceite vários tipos de tipos genéricos genéricos. Neste exemplo, criaremos uma classe simples de inteira genérica que pode conter qualquer tipo de objeto. ```java public class SingleGenericHolder<T> { private T obj; public SingleGenericHolder(T obj) { this. obj = obj; } public T getObject() { return obj; } } ``` # Exemplo de HashMap e Generics Java Neste artigo, estaremos discutindo sobre o `HashMap`, que temos a mesma situação onde temos chave e valor. Neste caso, a chave pode ser de qualquer tipo de dados (string, inteiro, etc. ) e o valor também pode ser de qualquer tipo (incluindo tipos de dados personalizados). Por exemplo, a chave pode se tornar `roll_numbers` e o valor pode se tornar um `student_object`. `Map` é uma situação onde você tem dois tipos genéricos. Fornecendo uma vírgula, você pode usar vários tipos genéricos conforme necessário neste exemplo. Estou utilizando dois tipos genéricos: `D` para a chave e `U` para o valor. Aqui está uma classe simples que aceita dois tipos de genéricos diferentes e chama o método `display`: ```java public class GenericClass<D, U> { private D key; private U value; public GenericClass(D key, U value) { this. key = key; this. value = value; } public void display() { System. out. println("Chave: " + key + ", Valor: " + value); } } ``` Aqui está o método `public static void main()` para o mesmo: ```java public static void main(String[] args) { GenericClass<String, Integer> obj = new GenericClass<>("simplesmente código", 10); obj. display(); } ``` Neste exemplo, `t` é uma String e `u` é um Inteiro. Nós atribuímos estes tipos e fornecemos valores corretamente. Quando o construtor é chamado, `obj1` recebe o valor "simplesmente código", enquanto `obj2` recebe o valor 10. Então, chamamos o método `display()`, onde imprimimos `obj1` e `obj2`. Quando executei o método, recebei: ``` Chave: simplesmente código, Valor: 10 ``` Você pode usar genéricos em tipos de variáveis e tipos de argumentos de métodos onde você deseja reutilizar funcionalidades e não deseja uma verificação de tipos de dados estrita. Consulte a biblioteca de coleção como ela é completamente construída em torno do conceito de genéricos. ## Pacote java. lang O pacote `java. lang` é um pacote muito importante e fundamental em Java, que é fornecido de forma automática para o desenvolvedor. Você nunca precisará importar explicitamente o pacote no seu programa Java, pois Java o fornece automaticamente. Exemplos de classes dentro do pacote `java. lang` incluem: - `String` (utilizado no exemplo de manipulação de cadeias de caracteres, importado automaticamente) - `Boolean`, `Byte`, `Character`, `ClassLoader`, `Compiler`, `Enum`, `Float`, `Integer`, `Long`, `Math`, `Thread`, `ThreadState` (parte das classes de excessão, etc. ) - Outras classes de tipos de dados comuns que você diz frequentemente usar ## Pacote java. util O pacote `java. util` contém o framework de coleção, incluindo todas as interfaces como `Collection`, `List`, `Set`, `Map`, etc. , bem como as classes concretas como `ArrayList`, `LinkedList`, `HashMap`, `HashSet`, `TreeMap`, `Stack`, `Scanner`, etc. Você precisará importar o pacote `java. util` explicitamente para usar suas classes em seu programa Java. # Programação Concorrente em Java: Entendendo Executors, ExecutorService e Future A programação concorrente é um aspecto crucial do desenvolvimento em Java e neste documento, abordaremos as classes centrais que apoiam este paradigma: Executor, ExecutorService e Future. Essas classes foram introduzidas em Java 8 e têm sido parte integral da biblioteca Java desde então. ## Visão Geral ### Executor Um Executor é uma interface, embora seja frequentemente confundido com uma classe. Ele serve como um frame de trabalho simples para ajudar você a criar subsistemas, como pools de thread, para operações de I/O assíncronos ou sequências de tarefas utilizando threads. O Executor brilha principalmente quando vem ao thread pooling e operações I/O assíncronas. ```markdown // Criando um Executor Executor executor = new Caller(); // Aqui estamos usando uma classe personalizada Caller que implementa Executor executor. execute(() -> { // Seu código de thread aqui }); ``` ### ExecutorService O ExecutorService oferece um frame de trabalho mais robusto para a execução de tarefas assíncronas, sendo a classe principal para abordar o programação assíncrono em Java. Permite aos usuários enviar tarefas e pesquisar seus resultados de forma assíncrona. ```markdown // Criando um ExecutorService ExecutorService executorService = Executors. newFixedThreadPool(10); executorService. submit(() -> { // Calhe seu código assíncrono aqui }); ``` ### Future A classe Future é usada para pesquisar o resultado de uma tarefa enviada de forma assíncrona. Ela atua como um transportador do resultado, permitindo aos usuários verificar o status da tarefa e pesquisar seu resultado assim que ela for concluída. ```markdown Future<String> future = executorService. submit(() -> { // Seu código assíncrono aqui return "Resultado"; }); if(future. isDone()) { System. out. println(future. get()); // Quando a tarefa for concluída, imprima o resultado } else { // Mante normalmente a verificação do status da tarefa e a imprime conforme a necessidade } ``` Lembre-se, ExecutorService e Future operarão de mãos dadas, com ExecutorService sendo usado para enviar tarefas e Future para pesquisar seus resultados de forma assíncrona. Para entender melhor essas classes, fornecemos, a seguir, um exemplo prático. ## Exemplo Começaremos, primeiramente, demonstrando o uso do Executor e do ExecutorService: ```markdown // A classe Caller, que implementa a interface Executor class Caller implements Executor { @Override public void execute(Runnable comando) { comando. run(); } // Métodos adicionais, se necessário } ``` ```markdown // Classe principal com o método público estático void main public class DemoConcorrente { public static void main(String[] args) { // Demonstração do uso de Executor Executor executor = new Caller(); executor. execute(() -> System. out. println("Executando com Executor. . . ")); // Demonstração do uso do ExecutorService ExecutorService executorService = Executors. newFixedThreadPool(10); executorService. execute(() -> System. out. println("Executando com ExecutorService. . . ")); } } ``` Para uma demonstração da classe Future, veja o exemplo separado fornecido chamado `FutureDemo. java`. Depois de se familiarizar com as bases, experimente com exemplos mais complexos em suas aplicações. Felizes códigos! # Programação Assíncrona em Java usando Executor Service e Objeto Futuro Ao executar programas, a execução ocorre de forma sequencial. No entanto, na programação assíncrona, o poder do Executor Service e dos Objetos Futuro permite-nos executar tarefas em outro thread. Isso significa que a execução poderá continuar sem aguardar que todas as tarefas anteriores tenham terminado. Vamos entender este conceito com um exemplo: ```java // Submete uma tarefa para ser executada Future<String> future = executor. submit(() -> { // Tarefa aqui // . . . // Retorna um resultado return "Concluído"; }); // Continua a execução aqui // . . . // Verifica o estado da tarefa if (future. isDone()) { try { // Obtém o resultado da tarefa String resultado = future. get(); System. out. println(resultado); // Deve imprimir "Concluído" } catch (InterruptedException | ExecutionException e) { // Trata as exceções } } // Lembra-se de encerrar seu Executor Service // . . . ``` No exemplo acima, a tarefa é submetida ao serviço do executor e seu estado é verificado usando o método `isDone()` do Future. Se a tarefa estiver concluída, o resultado pode ser recuperado usando o `get()` método. Isso garante que seu programa possa continuar executando sem aguardar a tarefa terminar. A programação assíncrona pode tornar o depurador um pouco mais difícil de vez em quando, mas é um conceito muito interessante para ser usado em aplicações concorrentes. ## Expressões Regulares (regex) em Java As expressões regulares (ou regex) ajudam a encontrar padrões dentro de texto. Se você tiver um grande número de cadeias disponíveis e deseja encontrar um determinado padrão, as expressões regulares podem ser úteis. Por exemplo, você poderá procurarQualquer caractere, qualquer número ou qualquer caractere especial dentro do seu texto. O Java fornece suporte a encontrar expressões regulares através do pacote `java. util. regex`. Este pacote pode ajudá-lo a encontrar padrões em seu corpo de texto que não estão limitados a manipulação básica de cadeias de caracteres. ### Classe de Padrões A `Pattern` classe representa um padrão regular compilationado. Você escreve o seu padrão regular em uma determinada forma e usa o método estático `compile()` para compilar o padrão, o que retorna um objeto de padrão. ```java Pattern pattern = Pattern. compile("seu padrão"); ``` ### Classe Matcher A `Matcher` classe fornece a estrutura de motor que entende e interpreta o padrão e tenta encontrar o padrão no texto fornecido. Ele retorna `true` se ele encontrar o padrão e `false` se não o encontrar. Para obter um objeto `Matcher`, chame o método `matcher()` na objeto de padrão. ```java Matcher matcher = pattern. matcher("seu texto"); ``` ### Síntaxe de Expressão de Padrão Exception Uma exceção `PatternSyntaxException` é lançada quando você escreve a sintaxe de expressão regular incorretamente. **Observação: ** Este post apenas toca a superfície das expressões regulares em Java. Recomendo ler a documentação e aprender mais sobre cada classe e propriedades delas. # Expressões Regulares (regex) As Expressões Regulares (regex) ou regular expressions, são uma ferramenta poderosas utilizadas para a correspondência de padrões em strings. Elas são pré-definidas com classes de caracteres e certos caracteres especiais têm significados específicos. Aqui estão algumas illustrativas: - `. ` significa qualquer caractere - `\d` é utilizado para encontrar um dígito em uma string ou corpus de texto - `\D` é para não-dígitos - `\s` é para um caractere de espaçamento (white space) - `\S` é para um não-white space (não-espaçamento) caractere - `word non-word` para a correspondência de palavras e não-palavras Com estandes compilados e um correspondente, poderá procurar por padrões específicos em texto. ## Demonstração Simples Vamos ilustrar isso com um exemplo simples. Em seguida, criaremos uma string do padrão regex e especificaremos o padrão: ``` padrão: qualquer caractere (`*`) no início, seguido por uma string alfa-qualificada ou seção alfa. Depois disso, a seção alfa deve ser seguida por uma seção numérica, e depois da seção numérica, é possível ser qualquer caractere (`*`). String de exemplo: Qualquer string alfa-qualificada ou número (Pode ser uma mistura) ``` Depois de compilar a expressão regular utilizando `pattern. compile()`, recebemos uma `Pattern` objeto. Em seguida, chamamos o método `matcher` no objeto de padrão para obter um objeto de correspondência. Em seguida, verificamos se o correspondente encontrou um acerto no corpus de texto ou não utilizando o método `matcher. find()`. ```python String regexPattern = ". *[A-Za-z]+\\d. *"; String exampleString = "a1b2c3d4e5f6"; Pattern pattern = Pattern. compile(regexPattern); Matcher matcher = pattern. matcher(exampleString); if (matcher. find()) { System. out. println("Achar encontrado"); } else { System. out. println("Achar não encontrado"); } ``` Neste exemplo, pois o padrão de expressão regular corresponde a qualquer string que começa com qualquer caractere, contém letras e termina com números, ele irá exibir `Match found`. Se desejar encontrar padrões mais complexos, você pode usar grupos para agrupar seus padrões. ## Spring Framework O Spring Framework é a ferramenta web mais popular utilizada por empresas como a Netflix e outras para construir aplicações modernas Java. Vamos entender por que precisamos de um framework. [Diagrama do Spring Framework pode ser adicionado aqui] Um framework ajuda a criar a estrutura para a construção das três camadas de uma aplicação web: 1. Front-end: HTML, JavaScript, ou outras tecnologias de front-end como AngularJS, React. js, ou Amber. js. 2. Back-end: Contém classes de Java com lógica de negócios. 3. Banco de Dados: Utilizado para armazenar dados. O Spring oferece suporte para todas essas camadas, facilitando e acelerando a criação de aplicações complexas de nível corporativo. Ele oferece uma variedade de componentes e tecnologias, incluindo: - Módulo Core: Contém o IoC (Inversão de Controle) containers, recursos, eventos, e componentes de teste. - Acesso a Dados: Fornece conexões e utilitários para bancos de dados. - Web Servlet: Oferece suporte para Spring MVC, WebSockets, STOMP, e marcos de mensagem. - Integração: Apoya GMS, JMX, correio eletrónico, marqueting automático, e outras integrações. - Internationalization: Oferece apoio para a internacionalização de aplicações. O Spring também oferece a Inversão de Controle por criar um container de IoC, permitindo que o framework crie e gerencie os objetos em vez do módulo de classe um. Isso elimina a necessidade de uma classe para criar seus próprios objetos. # Visualização da Página inicial do Framework Spring Este documento fornece uma introdução rápida ao Framework Spring, com um foco em suas principais concepções e recursos. Para uma compreensão mais completa, recomendamos ler a documentação oficial e os tutoriais de apoio disponíveis [na página do Framework Spring](https://spring.io/guides). ## Introdução O Framework Spring é uma popular estrutura de código aberto para a construção de aplicações Java para empresas. Ele oferece uma variedade vastíssima de módulos, incluindo Injeção de Dependência (DI), Componentes de módulo, Suporte a Recursos, Validação, Linguagem de Expressão, Programação Orientada a Aspectos (AOP) e Recursos de registro. ### Injeção de Dependência O conceito da Injeção de Dependência (DI) é central no contexto da Inversão de Controle (IoC) e mecanismo de DI do Spring. Com este mecanismo, é possível injetar o objeto de qualquer classe em outra classe. ```markdown Usando o mecanismo de DI do Spring, é possível injetar o objeto de qualquer classe em qualquer outra classe. . . ``` ### Recursos O módulo de `Resources` fornece uma maneira de se referenciar diferentes arquivos e propriedades. ### Validação O módulo de `Validação` oferece várias constructos de validação para facilitar o processo de validação dos dados. A escrita de sua própria validação pode ser um processo demorado, portanto o framework fornece um framework de validação. ```markdown . . . ele também fornece um framework de validação, oferecendo a interface Validator que pode ser usada para escrever os regras de validação. . . ``` O Framework também suporta uma Linguagem de Expressão para fins de validação. ### Programação Orienta a Aspectos O Spring suporta a Programação Orienta a Aspectos (AOP) para alcançar a separação dos interesses em sua aplicação. ### Aprendendo mais Embora este documento forneça uma visão geral dos principais conceitos e recursos do Framework Spring, mais estudos são necessários para compreender o porquê por trás deles. Estes conceitos não são específicos do Java e são aplicáveis a qualquer linguagem de programação. ```markdown . . . então qualquer aplicação empresarial que você construir em qualquer linguagem de programação, será necessária a validação, gerenciamento de referência de recursos, uma linguagem de expressão, e suporte à programação orientada a aspectos. . . ``` ### Example e Documentação O Framework Spring fornece uma vasta variedade de exemplos e documentação detalhada na sua própria página oficial. ```markdown . . . fique à vontade para verificar a documentação. Há uma vasta variedade de exemplos disponíveis, de fato, na própria página oficial do Framework Spring. . . ``` ## Implementação da Arquitetura MVC no Spring ### Arquitetura Model-View-Controller (MVC) A Arquitetura MVC (Model-View-Controller) é um padrão de design para a criação de aplicações web. Ele divide a aplicação em três componentes interconectados: Model, Visualização e Controlador. ```markdown . . . . a ideia era que estes três componentes juntos poderiam renderizar uma aplicação web e que eles renderizariam a aplicação da seguinte maneira: o controlador é quem receberá a requisição que é vem do navegador web, como. . . ``` ### Implementação no Spring MVC O Framework Spring implementa a arquitetura MVC ao usar o Servlet Dispatcher como ponto de entrada para todas as requisições web. O Servlet Dispatcher dirige as requisições para os controladores correspondentes, models e views. ```markdown . . . primeiro a requisição chega do navegador web e o Spring tem um servlet chamado dispatcher servlet que é um dos primeiros servlets que você encontra. . . ``` ### Criação de uma Aplicação Spring MVC Para criar uma aplicação Spring MVC, pode-se utilizar o Initializr do Spring. Este utilitário ajuda a gerar um esqueleto básico do seu projeto de forma fácil. ```markdown . . . se você ir à documentação do Spring, verá que eles recomendam a criação de um novo projeto a partir do zero usando o Initializr do Spring. . . ``` Uma vez gerado seu projeto, você pode importar-lo em um ambiente de desenvolvimento IDE como Eclipse e começar a trabalhar com os exemplos fornecidos. ```markdown . . . exatamente isso é o que eu fiz para este projeto inicial. . . ``` # Documentação da Aplicação Spring MVC Este documento fornece uma visão geral de uma aplicação Spring MVC utilizando os modelos Dymmelaf. ## Dependências - É necessário incluir os seguintes dependências: - Spring Boot Starter Web - (Opcional) Dependência de tecnologia de visualização desejada, caso não seja usado Dymmelaf Com a incorporação destas dependências, sua aplicação pode se transformar em uma aplicação web e poderá implementar mudanças dinamicamente durante a execução do servidor sem precisar recarregar o mesmo. ## Estrutura do Projeto A estrutura do projeto encontra-se organizada da seguinte forma: - `src/main/java`: - `Classe principal`: O ponto de entrada da aplicação Spring, com uma `public static void main()` método. - `Classe de controlador`: Gerencia as solicitações web e mapeia URLs para métodos específicos do controlador. - `src/main/resources`: - `dados da tecnologia de visualização`: Contém os ficheiros de visualização (atualmente usando os modelos Dymmelaf) e o ficheiro `application. properties` para fornecer propriedades específicas do ambiente. - Um `pastam templates` é automaticamente gerado pelo Spring Initializer e contém ficheiros HTML com dados dinâmicos. - `src/test/java`: Contém testes unitários para a aplicação, juntamente com a biblioteca do sistema fornecida pelo Eclipse. - `pom. xml`: Contém detalhes de configuração para Maven. - (Opcional, caso não seja usado Gradle) `gradle`: Ignorar, como estamos a usar Maven e não Gradle. ## Controladores Os controladores recebem as solicitações web após o Dispatcher Servlet, e deve haver uma correspondência para cada URL na aplicação. Para criar um controlador para uma determinada URL, siga estes passos: 1. Adicione a anotação @Controller a uma classe. Essa classe será tratada como controlador pela Spring. 2. Crie um método com a anotação @GetMapping para a URL desejada. 3. Use a anotação @RequestParam para fornecer um espaço reservado para parâmetros de consulta. 4. Use a variável do modelo para manter a lógica de negócio, e devolva o nome da visualização a ser renderizada. Aqui está um exemplo de um controlador de saudações simples: ```java @Controller public class GreetingController { @GetMapping("/greeting") public String greeting(@RequestParam(value = "name", required = false, defaultValue = "World") String name, Model model) { model. addAttribute("name", name); return "greeting"; } } ``` ## Executando a Aplicação Para executar a aplicação, utilize um dos seguintes métodos: 1. Execute o projeto com uma configuração Spring Boot Run em um IDE. 2. Execute a classe Spring WebMVCApplication da linha de comando com `mvn spring-boot: run`. Abra uma janela do terminal, navegue até o diretório do projeto, e execute: ```sh mvn spring-boot: run ``` Quando a aplicação começar, acesse-a emitindo `http://localhost:8080/greeting?name=SeuNome` para visualizar a mensagem de saudação. # Spring Boot: Construindo uma Aplicação Simples Entenda a necessidade e o conceito do Spring Boot, pois principalmente é utilizado para construir serviços RESTful web. Leia para seguir sobre como criar uma aplicação simples usando Spring Boot. ## Por que Spring Boot? O Spring Boot simplifica o processo de criar serviços RESTful web. Se você estiver interessado em saber mais sobre serviços REST, pode ler sobre o conceito de REST, mas a ideia básica é que qualquer componente acessível por HTTP pode ser construído como um componente RESTful. Hoje, o Spring Boot é um dos mais populares escolhas para construir serviços RESTful web, incluindo microserviços que executam sobre HTTPS. Com o Spring Boot, você pode construir microserviços que também executam sobre HTTPS. Se você for novo no termo, os microserviços são serviços menores, de couples feixados que servem funções específicas dentro de uma aplicação. ## Guia Oficial do Spring Boot Este guia é baseado no guia oficial do Spring Boot, que você pode usar para criar uma aplicação usando o Spring Boot. Ele fornecerá as necessárias requisitos, como a instalação do JDK, configuração de Maven e completar o guia. ## Spring Initializr Você também pode usar o Spring Initializr para gerar um projeto do Spring Boot adaptado às suas necessidades. ## Estrutura do Projeto Em um projeto do Spring Boot, não existirá uma pasta `src/main/resources/html` como na MVC do Spring. Isso é porque em serviços RESTful web, você não renderiza HTML, mas sim retorna o corpo da resposta em forma pura de XML ou JSON. A diferença principal entre a MVC do Spring e o Spring Boot é que na MVC do Spring, é necessário retornar uma tecnologia visual, como HTML ou GSP. Por outro lado, com o Spring Boot, não precisa se preocupar com como a resposta será renderizada na página web, pois apenas a precisó concentrar-se em retornar o corpo da resposta correto. ## Executar a Aplicação Para executar a aplicação, use o seguinte comando no terminal: ``` mvn spring-boot: run ``` Isso iniciará a aplicação do Spring Boot. Na classe principal, estamos impresso as bean fornecidas pelo Spring e a execução da aplicação com a classe `SpringApplication`. Você pode inspecionar as beans fornecidas pelo Spring Boot visitando a URL `<seu-url>/let's-inspecionar-as-beans`. Isso exibirá todas as bean disponíveis no contexto da aplicação. Este é tudo para esta sessão. Na próxima sessão, entraremos em projetos Java avançados com os conceitos aprendidos nesta série de tutoriais. # Conheça como criar seu projeto como um filho deste particular parente, de modo que todas essas plataformas de avaliação Spring Boot possam isso como um padrão prática. Em seguida, forneça seus detalhes cancelados em termos de qual o nome do pacote, como você gostaria de ver o nome do Jar, qual é o nome do Jar real e qual é a versão do Jar, entre outras informações. Também defina a versão mínima de Java necessária para executar a aplicação, entre outras dependências. Nesta seção, adicione todas as dependências necessárias para compilar e executar seu projeto com êxito, como o Spring Boot Starter Web. Este pacote basicamente traz todas as dependências necessárias para criar um controlador ou um repositório, além de incluir a escanagem automática de componentes de contexto com todas as características interessantes que o Spring fornece. O pacote ficará embalado dentro do Spring Boot Starter Jar e você pode ver o que ele provê ao visitar o repositório Maven e estará aquém dos recursos RESTful. Após isso, adicionaremos o próximo pacote de dependência, o Spring Boot Starter Data JPA, que permitirá que o seu projeto também tenha um banco de dados. Se houver um banco de dados, você precisará que o Java faça com que o Java se comunique com o banco de dados e a maneira que o Spring sugere para fazer isso é usando a biblioteca Spring Boot Data JPA. Você verá isso em ação neste tutorial. Como essa biblioteca permite representar objetos Java no banco de dados e, entr loco, você precisará adicionar a dependência real do banco de dados. Neste caso, estamos usando um banco de dados em memória H2, pois não quero mais complicações com bancos de dados mais complexos, como MySQL, Oracle ou PostSQL. Adiciona isso e ele criará um banco de dados em memória para você. Por último, adicionaremos o pacote de teste Spring Boot Starter Test que será usado sempre que você estiver escrevendo testes de unidade. Em seguida, adicionaremos um plugin para que Spring Boot possa executar seu projeto. Agora, leamos a parte interessante, a seção da linguagem Java. Vamos começar pela classe principal. Isso é como isso se enrola. Você pode chamá-lo de qualquer nome, mas deverá ter a classe e depois adicionar um método público estático void main(). Este método será chamado de spring. application. run e isso iniciará seu aplicativo. Você poderá fornecer argumentos de linha de comando se desejado. Porém, sempre precisará de um ponto de entrada em uma aplicação e isso é o ponto de entrada que o Spring Boot aceita. Se vocês olharem esse código, este é apenas código normal para fazer com que o Spring seja consciente desta classe como um ponto de entrada. É necessário adicionar a anotação @SpringBootApplication nessa posição para que o Spring reconheça esta classe como um ponto de entrada. Sem essa anotação, o Spring não saberá onde iniciar a aplicação. Quando você executar Spring, ele irá provar encontrar uma classe com a anotação @SpringBootApplication e depois dentro da classe ele irá procurar um método público estático void main(), e uma vez encontrados ambos, ele irá apenas executar a aplicação. Então, é muito simples e não há nada especial aqui. Aquele que estamos lidando é um objeto de estudante, então vamos tentar inserir um objeto de estudante e tentaremos recuperá-lo. Ignoramos essas anotações se você ignora aqui e são apenas objetos POJO de Java tradicionais. Crie um objeto de estudante chamado Student e faça uma cursory ignore das anotações aqui feitas - é apenas um POJO completo. Ele tem três campos: nome, idade e endereço. Tem um construtor vazio e um construtor parametrizado, e vários getters. Eu revi os setters por acaso porque geralmente quando você está desenvolvendo um aplicativo para empresas, gostaria de manter o código imutável, em outras palavras, após a criação, você não deseja que alguém possa alterar os valores dos objetos. É apenas uma boa prática. Além disso, há duas coisas que queria falar. Primeiro, a anotação @Entity é a anotação que veio do pacote Java Persistence e essa anotação informa que a SpringBoot armazenará esse objeto no banco de dados. É a anotação que você deve definir em sua classe para que a SpringBoot saiba que essa classe representa uma tabela no banco. Por outro lado, a tabela terá um ID - um tipo de chave primária. Criei uma coluna chamada de id que representa o ID (identificador), com algumas anotações adicionais do pacote Java Persistence. Essas anotações vão permitir que uma nova ID seja criada automaticamente para cada objeto criado. O valor dessa variável ID será criado automaticamente pelo SpringBoot. Você pode fornecer o tipo de geração como serial. Neste momento, coloquei automaticamente, mas você pode especificar tipos de tipo como identity, sequence, auto etc. É isso que o objeto de entidade se sente. Vamos chamá-lo de Classe de Entidade. Agora, vamos para o Repositório. Precisamos sempre ter uma camada de repositório ou uma camada de Repositório para armazenar nossas entidades no banco de dados. Portanto, podemos armazenar nossas entidades agora que podem ser salvos, mas precisamos de uma camada que pode armazenar nossas entidades no banco de dados e camadas de repositório são as classes que você pode criar e chamar com qualquer nome que você desejar. Além disso, você deve herdar da Repository, tipificar o tipo do objeto e o tipo de chave primária. Se você olhar o código do Spring Boot Starter, você verá que ele permite que você herde de interface. Assim, você pode criar uma interface chamada studentRepository que herda de Repository para o tipo de objeto student e o tipo de chave primária long(tipo ID). Você precisa adicionar a anotação Spring Data para que essa classe seja recomendada como uma classe de Repository. Como o Spring amplamente emprega a ideia de anotações, essa anotação ajuda a Spring compreender que essa é uma classe de camada de Repository e que aplicará mais metadados a essa classe enquanto essa classe está em execução no JVM. Portanto, você deverá criar um interface, herdar de JpaRepository e certificar-se de que você adiciona esta anotação: @Spring Data. Por motivos de convencionalização, é tão coisa simples e funciona e não é preciso fornecer nenhuma implementação de nenhum método para criar ou editar objetos existentes no banco de dados. Após isso, ao executar o aplicativo, o Spring irá ler todos os métodos que ele precisa para gerar todos esses métodos para você, incluindo métodos findAll() e findAllById(). Agora, vamos para a camada de controle HTTP (Endpoint). Pode-se criar isso usando uma classe comumente que você tenta sufixar com Controller. Assim, crie uma classe chamada studentController que é responsável por lidar com as operações HTTP. Depois de definir uma anotação @RestController nessa classe, você pode girar o StudentRepository usando o auto-wire. Após isso, compile a classe e você já definiu tudo para as operações RESTful de seu Repositório CRUD. Isso significa que você poderá criar, listar, editar e excluir através de operações HTTP RESTful. Em seguida, vamos para o banco de dados. Nesta seção, definiremos as informações do banco de dados para o qual nosso aplicativo vinculará. Primeiro vamos configurar o banco de dados de memória H2 que iremos usar. Adicione o seguinte bloco de código à sua classe StudentRepository: ```java import org. springframework. data. jpa. repository. support. Jackson2RepositoryFactoryBean; import org. springframework. context. annotation. Bean; import org. springframework. context. annotation. Configuration; import org. springframework. data. jpa. repository. config. EnableJpaRepositories; import javax. sql. DataSource; @Configuration @EnableJpaRepositories(basePackages = "br. com. [nome do seu pacote]. repositorio", entityManagerFactoryRef = "entityManagerFactory", transactionManagerRef = "transactionManager") public class PersistenciaConfiguração { @Bean public DataSource dataSource() { org. h2. jndi. H2DataSource dataSource = new org. h2. jndi. H2DataSource(); dataSource. setUrl("jdbc: h2: mem: testdb"); return dataSource; } @Bean(name = "entityManagerFactory") public LocalContainerEntityManagerFactoryBean entityManagerFactory() { LocalContainerEntityManagerFactoryBean entityManagerFactory = new LocalContainerEntityManagerFactoryBean(); entityManagerFactory. setDataSource(dataSource()); entityManagerFactory. setPackagesToScan("br. com. [nome do seu pacote]. model"); entityManagerFactory. setJpaVendorAdapter(new H2JpaVendorAdapter()); entityManagerFactory. setJpaProperties(hibernateProperties()); return entityManagerFactory; } @Bean public Properties hibernateProperties() { Properties properties = new Properties(); properties. setProperty("hibernate. dialect", "org. hibernate. dialect. H2Dialect"); properties. setProperty("hibernate. hbm2ddl. auto", "update"); return properties; } @Bean(name = "transactionManager") public PlatformTransactionManager transactionManager() { return new JpaTransactionManager(entityManagerFactory(). getObject()); } } ``` Coloque `nome do seu pacote` para substituir o caminho do pacote onde você criou suas entidades, models. Como este código configura o Spring Boot para trabalhar com o banco de dados H2 em memória, quando você iniciar o seu aplicativo, o Spring criará o banco de dados automaticamente para você. Em seguida, vamos para o método principal para iniciar a aplicação. Adicione os seguintes pacotes e classes à sua classe principal: ```java import org. springframework. boot. SpringApplication; import org. springframework. boot. autoconfigure. SpringBootApplication; import java. util. Random; @SpringBootApplication public class Application { public static void main(String[] args) { Application app = new Application(); Student student = new Student(app. generateRandomName(), 25, "Rua dos Bobos, 0"); app. saveStudent(student); System. out. println(app. findStudentById(1)); } public Random random = new Random(); public String generateRandomName() { int firstNameLength = 10; char[] chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ". toCharArray(); String firstName = ""; for (int i = 0; i < firstNameLength; i++) { firstName += chars[random. nextInt(chars. length)]; } int lastNameLength = 10; for (int i = 0; i < lastNameLength; i++) { firstName += " " + chars[random. nextInt(chars. length)]; } return firstName; } public Student saveStudent(Student student) { Student studentSaved = studentRepository. save(student); return studentSaved; } public Student findStudentById(int studentId) { return studentRepository. findById(studentId). orElse(null); } @Autowired private StudentRepository studentRepository; } ``` Certifique-se de fazer `import` para as classes necessárias, incluindo `org. springframework. boot. SpringApplication`, `org. springframework. boot. autoconfigure. SpringBootApplication` na classe principal. As classes necessárias também podem ser adicionadas com o seguinte comando (substitua `nome do seu pacote`): ``` mvn dependency: add-source -Ddependency=org. springframework. data: spring-data-jpa -Dscope=compile mvn dependency: add-source -Ddependency=org. springframework. data: spring-data-commons -Dscope=compile ``` Como você possui sua implementação compilada, você deverá executar: ``` mvn clean package ``` Em seguida, para executar com Spring Boot: ``` java -jar target/ DemoApplication. jar ``` # Gestão de Alunos RESTful Web Service Este guia demonstra a criação de um serviço web RESTful simples em Spring Boot que gerencia dados de alunos. O serviço permite a criação, recuperação e exclusão de registros de alunos usando solicitações HTTP. ## Pré-requisitos - Java 8 ou superior - Sistema de construção de Maven ou Gradle - Interface de linha de comando (CLI) do Spring Boot ou IDE (por exemplo, IntelliJ IDEA, Eclipse, ou STS) ## Compras a fazer 1. **Criar um novo projeto do Spring Boot** - Use a [Inicializador do Spring](https://start.spring.io/) para criar um novo projeto do Spring Boot com dependências de Web, JPA e H2. 2. **Gerar a entidade do Aluno** - Criar uma nova classe Java chamada `Aluno` no pacote `model`. - Defina as propriedades e anotagens para os atributos do aluno (por exemplo, `id`, `nome`, `idade` e `endereço`). - Marque a classe com `@Entity` e as propriedades com `@Id`, `@Column` e `@GeneratedValue`. 3. **Criar o Repositório de Alunos** - Criar uma nova interface chamada `AlunoRepository` no pacote `repository` que extenda `JpaRepository<Aluno, Long>`. - Essa interface vai lidar com os operações CRUD do `Aluno` entity usando Spring Data JPA. 4. **Criar o Controlador de Alunos** - Criar uma nova classe chamada `AlunoController` no pacote `controller`. - Marque a classe com `@RestController` e os métodos com `@RequestMapping`. - Implemente os métodos HTTP (GET, POST, PUT, DELETE) para lidar com as solicitações relacionadas ao dados do aluno. 5. **Executar a Aplicação** - Abre um terminal ou prompt de comando, navega para o diretório do projeto e execute a aplicação usando o comando `mvn spring-boot: run`. ## Pontos de extremidade Os seguintes pontos de extremidade estão disponíveis no serviço web criado: - **POST /alunos** - Crie um novo registro de aluno (solicitação HTTP POST com conteúdo tipo application/json). - **GET /alunos** - Retorne todos os alunos (solicitação HTTP GET). - **GET /alunos/{id}** - Retorne um aluno específico pelo ID (solicitação HTTP GET). - **PUT /alunos/{id}** - Atualize um aluno específico pelo ID (solicitação HTTP PUT com conteúdo tipo application/json). - **DELETE /alunos/{id}** - Exclua um aluno específico pelo ID (solicitação HTTP DELETE). ## Dicas e práticas recomendadas - Use nomes claros e descritivos para métodos e variáveis. - Organize o seu código em pacotes separados (por exemplo, `model`, `repository`, `controller`, e `service`). - Valide os dados de entrada usando a anotação `@Valid` ou validadores personalizados. - Faça a lidar com exceções e erros de maneira adequada, retornando códigos de estado HTTP significativos e mensagens de erro. - Documente a sua API usando Javadoc ou Swagger. - Teste o serviço usando ferramentas como Postman, curl ou JUnit. Assim é! Agora você tem uma compreensão básica de como criar um serviço web RESTful usando Spring Boot e JPA. Você pode estender este exemplo adicionando mais recursos, como páginação, ordenação, filtragem e autenticação. Feliz a coding! # Documentação Técnica em Markdown ## Funcionalidade do Carregador de Classe no Java Virtual Machine A função principal do `carregador de classe` é carregar a classe no Java Virtual Machine (JVM) quando ela for solicitada para executar uma classe. O Java possui dois carregadores de classe: Bootstrap e Extensão de Aplicação. A terceira pergunta no bolístero trata da alocação de memória disponível em Java. ## Alocação de Memória em Java O Java fornece vários tipos de alocações de memória, mas os cinco tipos principais mais comumente usados são: 1. Memória de Classe 2. Memória de Heap 3. Memória de Pilo 4. Memória Contador de Programa 5. Memória de Pilha de Métodos Nativos ## Execution of `static public void main` in Java A pergunta diz respeito à execução de um programa quando `static public void main` é escrito como `static public void main`. A resposta é que o programa executará corretamente, pois o Java não segue nenhuma regra específica na ordem dos especificadores no programa. ## Valor Padrão das Variáveis Locais em Java Nenhuma variável local, global, nem nenhuma primitiva nem qualquer referência para objeto tem valores padrão armazenados nela em Java. ## Saída de Segmento de Código Dado A sexta pergunta diz respeito à saída do segmento de código seguinte: ``` printf("100 + 100 + learn"); printf("e-learning company + 100 + 100"); ``` A resposta é que a primeira saída será `200 simply learn`, e a segunda saída será `e-learning company 1 0 0 1 0 0`. ## Relação Uma associação pode ser definida como uma relação que não possue propriedade sobre o outro. ## Construtor de Instância em Java O construtor de instância em Java é um construtor que inicializa um objeto através de outro objeto da mesma classe. É útil quando você quer copy um objeto complexo que tem vários campos ou quando você quer fazer uma cópia profunda de um objeto existente. ## Interface Baixo-Linha em Java Uma interface vazia em Java é referenciada como uma interface marcadora. Alguns exemplos de interfaces marcadoras são `Serializable` e `Cloneable`. Uma interface marcadora não possui nenhuma assinatura de métodos manipulando dados ou qualquer membro de dados. ## Clonagem de Objeto em Java A clonagem de objeto é a habilidade de recriar um objeto juntamente com características semelhantes à existente objeto. O Java fornece uma função interna ou método chamado `clone()` para clonar um objeto existente, oferecendo a mesma funcionalidade que o objeto original. ## Java Não sendo Por inteiro Oriented O Java é considerado uma linguagem de programação não por inteiro orientada porque ainda faz uso de oito ou mais tipos de dados primitivos. ## Classe Encapuladora em Java Quando você declarar tipos de dados primitivos em Java, as classes embarcadas são responsáveis pela conversão deles em objetos ou tipos de referência para o fácil compilamento e execução de programas sem problemas. ## Classes Singleton em Java Quando você faça o construtor de uma classe privado, a classe especial pode gerar apenas um único objeto único. Tais classes são chamadas de classes Singleton. ## Pacote em Java Um pacote é um conjunto de classes e interfaces e quaisquer arquivos de biblioteca e jar necessários. O uso de pacotes ajuda na reutilizabilidade do código. ## Implementação de Ponteiros em Java Ponteiros não podem ser implementados em programas Java porque a memória é gerenciada implicitamente pelo Java Virtual Machine. ## Diferença entre Variáveis Instância e Locais As variáveis instância são declaradas dentro de uma classe e têm scope limitado a um objeto específico, enquanto que as variáveis locais têm scope limitado a um bloco de código. ## Piscina de Strings em Java A coleção de strings em Java's heap memory é referenciada como Piscina de Strings em Java. ## Exceções em Java Uma exceção em Java é considerada um evento inesperado que pode interromper o fluxo usual do programa. ## Diferenciar entre Variáveis Instância e Locais As variáveis instância são declaradas dentro de uma classe e têm scope limitado a um objeto específico, enquanto que as variáveis locais têm scope limitado a um bloco de código. ## Explica a Piscina de Strings em Java A Piscina de Strings em Java é uma coleção de strings em Java's heap memory. Quando você criar uma nova string, a JVM primeiro verifica se ela existe na piscina. Se não existir, a JVM cria uma nova string. Título: Documentação Técnica em Java ---------------------------------- Gestão de Exceções em Java --------------------------- A palavra reservada final é uma palavra reservada pré-definida em Java utilizada durante a declaração de valores para variáveis. Quando um valor é declarado usando a palavra-chave final, esse valor particular de uma variável específica terá um valor constante durante a execução do programa. Às vezes se incluir uma variável normal e operação sobre ela, então o valor da variável específica será alterado após a execução do programa. No entanto, quando declarar a mesma variável utilizando a palavra-chave final, nenhuma quantidade de operações ou manipulações aplicadas sobre a variável serão capazes de mudar o valor da variável específica. Isso é especialidade da palavra-chave final em Java. Quando a função principal não é declarado como estático, o programa pode ser compilado perfeitamente, mas acaba com uma grande ambiguidade e lanca um erro de tempo de execução que diz "Não existe tal método" erro. Quando você declara uma função principal, não esqueça de especificar a palavra-chave estático. Kit de Desenvolvimento Java (JDK) --------------------------------- JDK é uma abreviatura para Java Development Kit, que é um pacote combinado de JRE (Java Runtime Environment) e ferramentas de desenvolvimento utilizadas para projetar aplicações Java e applets. Oracle dispensa as seguintes variantes para Java Development Kit: 1. Java Development Kit padrão: normalmente usado por aprendizes e desenvolvedores intermediários. 2. Java Development Kit para Empresa: essa variante Starter Edition é usada por programadores Java profissionais para desenvolver aplicações e frameworks Java-based. 3. Java Development Kit Lightweight Edition. Especificadores de Acesso em Java ---------------------------------- Os especificadores de acesso são palavras-chave pré-definidas utilizadas para ajudar a Java Virtual Machine a entender o escopo de um determinado membro de dados ou método manipulando de dados em uma classe ou fora da classe. Em Java, temos quatro tipos de especificadores de acesso: 1. Especificador de Acesso Público: Quando você declara um membro de dados ou um método manipulando de dados como público, então esse membro de dados ou métodos poderá ser acessível por qualquer classe ou objeto durante o pacote. 2. Especificador de Acesso Privado: Diferentemente do especificador de acesso público, quando você fornece a palavra-chave privada, a visibilidade do membro particular de dados ou manipulador de dados específico será fornecida apenas para classes específicas e objetos específicos. 3. Especificador de Acesso Protegido: O especificador de acesso protegido é mais seguro do que o especificador de acesso privado. O acesso ao membro particular de dados ou manipulador de dados específico poderá ser mais difícil de acessar quando você implementar tudo que está presente em esse pacote. 4. Especificador de Acesso Comum: O especificador de acesso comum será fornecido pela Java Virtual Machine. Caso você declare uma variável ou um manipulador de dados sem utilizar algum especificador de acesso (público, privado e protegido), então a JVM considerará o especificador de acesso comum. Existem poucas diferenças entre o especificador de acesso público e o especificador de acesso comum. Ambos apresentam a mesma função e acessibilidade. É possível uma função Construtora Retornar um Valor? ---------------------------------------------------- Sim, uma construtora pode retornar um valor. No entanto, ele é implícito ao retornar a instância atual da classe. Você não pode fazer uma construtora retornar um valor explicitamente. Esta Palavra-chave em Java --------------------------- A palavra-chave this é uma palavra-chave especial designada como uma variável de referência. O termo this keyword é utilizado para se referir aos propriedades da classe atual, como membros de dados, métodos manipuladores de dados, e construtores. Palavra-chave Super em Java ---------------------------- A palavra-chave super é uma palavra-chave especial designada como uma variável de referência, similar à palavra-chave this. No entanto, a diferença é a palavra chave super é usada para se referir ao objeto da classe pai imediatamente. Multicarga de Métodos em Java ----------------------------- A criação de muitos signaturas de método utilizando o mesmo nome de método é chamado de sobrecarga de métodos. Por exemplo, consderando que você quer incluir uma operação de soma em seu programa que realiza operações de soma. A primeira função será nomeada add e dentro da função, parâmetros você terá parâmetros de dois tipos de inteiros. De forma semelhante, você quer realizar outra operação de soma com o mesmo nome. Aqui você fornecerá o nome do método completamente o mesmo do primeiro método, mas dentro dos parâmetros, haverá uma diferença: você terá três parâmetros aqui. Quando você passar os valores para o método add, qual método será sobrecarregado: que é a confusão. Você deve sobrecarregar ou você executará a primeira função add ou a segunda função? A decisão completamente depende do número de parâmetros que você fornece. Se você fornecer dois parâmetros, então a primeira função será executada. Se você fornecer três parâmetros, então a segunda função será executada. Sobrecarga de Métodos estáticos ------------------------------- A visibilidade das variáveis ou manipuladores de métodos não serão alteradas quando utilizamos a palavra-chave estática à frente dele. ```markdown # Curso de Desenvolvimento de Software - Dia 4 | Programação em Java Core | Desenvolvedor de Software | Simplilearn ## 🔥Tópico: Programação em Java Core Esta seção aborda conceitos de Programação Orientada a Objetos em Java, Tratamento de Exceções e mais. Por concluir este tópico, você terá uma boa compreensão dos conceitos básicos de Java. Segue o texto corrigido e formatado: --- ```markdown Classes e métodos ajudam os programadores a especificar uma declaração de um único método ou um conjunto de métodos relacionados com uma declaração de classe única. Após isso, temos nossa próxima pergunta: "Explique a interface `Externalizable`. " A resposta para esta pergunta é: A interface `Externalizable` ajuda no controle do processo de serialização. A interface de `Externalização` inclui os métodos `readExternal` e `writeExternal`. Aqui encontramos um novo termo: serialização. A serialização é um processo de envio do seu código Java ou do projeto Java de um sistema de computador para um sistema de computador diferente. Se você quisesse executar algum tipo de programa Java de um local diferente, poderá serializar este código específico para outro local em que você realmente quer executá-lo. Este processo específico de transferência do seu código é chamado de serialização. Próxima pergunta: "Explique uma thread demônio. " A resposta para esta pergunta é: Uma thread demônio pode ser definida como uma thread com menos responsabilidades. A thread demônio é projetada para executar no fundo durante o processo de coleta de lixo em Java. O método `setDaemon` é usado para criar a thread demônio na linguagem de programação Java. Próxima pergunta: "Explique o termo enumeração em Java. " A resposta para esta pergunta é: Um enumerador, ou `enum`, é uma interface em Java. `enum` permite o acesso sequencial dos elementos armazenados em uma coleção em Java. Próxima pergunta: "Por que Java é considerado uma linguagem de programação dinâmica? " A resposta para esta pergunta é: Java foi projetado para se adaptar a um ambiente em evolução. Os programas Java incluem uma grande quantidade de informação de tempo de execução que é realmente usada para resolver o acesso aos objetos em tempo real, portanto, isso é um dos motivos pelos quais Java é considerado uma linguagem de programação dinâmica. Seguindo este, temos nossa próxima pergunta: "É possível executar código antes de executar o método main? " A resposta para esta pergunta é: Sim, é possível executar qualquer código antes do método main. Usaremos o bloco de código estático na classe. Quando criamos os objetos durante o tempo de carregamento da classe, qualquer instrução no bloco de código estático da classe será executada uma vez durante a criação da classe, mesmo antes da criação dos objetos no método main. Última pergunta no segmento intermediário: "Quantas vezes é chamado o método `finalized`? " A resposta para esta pergunta é: O método `finalized` é chamado pelo coletor de lixo. Para cada objeto, o coletor de lixo chama o método `finalized` apenas uma vez. Com isso, entramos no segmento avançado das perguntas baseadas em Java. Primeira pergunta no segmento avançado: "Os keywords `this` e `super` podem ser usados juntos? " A resposta para esta pergunta é: Os keywords `this` e ` # Executção e Anatomia do Programa Java em Português de Portugal Iniciemos com a compreensão do processo de execução dos programas Java e como a independência de plataforma é alcançada. ## Executando um Programa Java 1. Escreva seu programa Java e guarde-o como um arquivo com a extensão `. java`. 2. Compile o seu arquivo `. java` usando o Compilador Java (fornecido pelo JDK). O arquivo compilado será um arquivo `. class`, também conhecido como o arquivo do byte code. ```bash javac SeuPrograma. java ``` 3. Execute o arquivo `. class` usando o Ambiente de Execução Java (JRE) ou a Máquina Virtual Java (JVM). ```bash java SeuPrograma ``` Interessantemente, os dois primeiros passos (escrever e compilar o programa Java) podem ser realizados em qualquer máquina. O arquivo do byte code, `. class`, pode ser executado em qualquer plataforma (Linux, Windows, Mac OS, etc. ). Este conceito é conhecido como **independência de plataforma** java. ## Anatomia do Java 1. **Kit de Desenvolvimento Java (JDK)** - O JDK inclui o Ambiente de Execução Java (JRE), Máquina Virtual Java (JVM), e várias bibliotecas de classe e bibliotecas de suporte. O JDK é o módulo de instalação necessário na máquina local para executar programas Java. 2. **Ambiente de Execução Java (JRE)** - O JRE executa o arquivo `. class` gerado a partir do código fonte Java compilado. Ele também fornece as bibliotecas de runtime e de suporte necessárias. 3. **Máquina Virtual Java (JVM)** - A JVM é o ambiente virtual dentro do qual seu programa roda. Ele requer bibliotecas de runtime, fornecidas pelas bibliotecas de classe incluídas no JDK. ### Instalação do JDK em Windows Para instalar o JDK em uma máquina Windows, siga estes passos: 1. Baixe o JDK do site da Oracle oficial: [Downloads do Java SE da Oracle](https://www.oracle.com/java/technologies/javase-jdk14-downloads.html) 2. Escolha a versão certa para Windows (x64) e baixe o instalador. 3. execute o instalador baixado para instalar o JDK. 4. Depois de instalado, verifique a instalação executando `java -version` no prompt de comando. Agora que entendemos os fundamentos da execução dos programas Java, as aulas futuras trarão mais detalhes sobre várias características e aspectos de Java. Continue a aprender e boa sorte ao codar! 🤘✨ # Instalando Eclipse em uma máquina Windows ## Introdução Nesta sessão de tutorial, vamos lhe guiar pelo processo de instalação do Eclipse em uma máquina Windows. O Eclipse é uma plataforma de desenvolvimento de software aberta que é um passo natural para qualquer desenvolvedor Java. ## Passos para Instalar o Eclipse 1. **Faça o Download do Eclipse**: - Abra seu navegador da web. - Digite "Download do Eclipse" no campo de busca e pressione a tecla Enter. - Você encontrará o link "eclipse. org downloads" que é o primeiro link nas suas resultados de busca. O link o leva à página de downloads do Eclipse. - Na página de downloads do Eclipse, verá uma lista de opções. A opção default deve ser a "Instalador do Eclipse para GRE (Java) para Mac OS, Windows, e Linux". - Dependendo de sua máquina, o Eclipse identificará automaticamente se precisará do instalador de 64 bits ou de 32 bits. 2. **Escolha a Localização do Download**: - Após escolher o instalador do Eclipse, você será redirecionado para outra página onde podrá escolher a localização do download. - Baseado na sua localização do ISP, será sugerido um servidor para minimizar o tempo de download. Você pode alterar a localização, se necessário. 3. **Instale o Eclipse**: - Após baixar o instalador do Eclipse, duplique-o para iniciar o processo de instalação. - O instalador descompactará e criará arquivos de instalação de acordo com a capacidade e a velocidade da computadora. - Quando os arquivos de instalação estão prontos, será apresentada uma tela mostrando várias opções de IDE. Escolhemos "Eclipse IDE para Desenvolvedores de Java para Empresas" nesta sessão de tutorial. - Escolha a VM Java (Java Virtual Machine) e a localização da instalação. A localização padrão é "C: \Utilizadores\<Seu Nome de Usuário>\Eclipse\Jee<Número de Versão>". - Aceda ao acordo de utilização e apareça a tela "Instalar". - Durante a instalação, o Eclipse criará um ícone no ecrã de início e um atalho no menu começar. 4. **Inicie o Eclipse**: - Após a instalação estar concluída, você pode iniciar o Eclipse do ícone no menu começar ou do atalho no ecrã de início. - Se escolher uma pasta de trabalho, será solicitado que escolha a localização da pasta de trabalho. - Será apresentada uma tela de boas-vindas, fornecendo várias opções para trabalhar, como criar um novo projeto Java, importar um projeto existente, e actualizar o software. . . ## Conclusão Parabéns! Você instalou com sucesso o Eclipse em sua máquina Windows. Na próxima sessão, falaremos sobre os tipos de dados em Java. Comencemos! ```bash - Instalar Eclipse - Fazer o Download do Eclipse - Escolher Localização de Download - Instalar Eclipse * Escolher IDE * Selecionar VM Java * Definir a Localização de Instalação - Iniciar Eclipse - Conclusão ``` # Aula de tipos básicos de dados em Java ## Introdução Bem-vindo a uma visão geral dos tipos básicos de dados em Java! Ensambalharemos sobre os tipos básicos de dados em Java, realizarámos uma demonstração curta e compreenderemos seus principais recursos. Fiquem à vontade! Comecemos a olhar para os tipos de dados que Java fornece. Podem ser categorizados da seguinte maneira: - Números: `byte`, `short`, `int`, `long`, `float`, `double` - Boolean: `boolean` - Caracter: `char` ## Números Os tipos de dados baseados em números em Java são projetados para armazenar diversos valores numéricos. Os seis tipos datos abaixo podem armazenar qualquer tipo de valor numérico: - `byte`: O menor tipo datos utilizado para armazenar números, com um limite de -128 a 127. - `short`: Maior que `byte`, com um limite de -32768 a 32767. - `int`: Útil para armazenar valores maior com um limite de -2³¹ a 2³¹ - 1. - `long`: Maior que `int`, possibilidade de armazenar valores entre -2⁶³ ao 2⁶³ - 1. - `float`: Projeto para valores numéricos com representação decimal. No entanto, note-se que ele pode apenas armazenar valores de menor precisão, e talvez deverá usar `double` para valores que exigam maior precisão. - `double`: Tipo datos com maior precisão para lidar com valores maiores com representação decimal. ## Boolean O type datos Boolean é utilizado para representar valores verdadeiros ou falsos, com apenas dois valores possíveis. ## Character Um `char` é utilizado para armazenar caracteres e depende da representação Unicode para compatibilidade entre plataformas. ## Demonstração Aqui está uma demonstração rápida utilizando Eclipse: ``` // Criar variáveis para cada tipo datos e imprimi-las String cat = "a"; byte byteValue = 2; short shortValue = 22; int intValue = 45; float floatValue = 4. 5f; double doubleValue = 4. 5; boolean booleanValue = true; char charValue = 'G'; System. out. println(cat); System. out. println("Byte Value: " + byteValue); System. out. println("Short Value: " + shortValue); System. out. println("Int Value: " + intValue); System. out. println("Float Value: " + floatValue); System. out. println("Double Value: " + doubleValue); System. out. println("Boolean Value: " + booleanValue); System. out. println("Char Value: " + charValue); // Como executar a aplicação 1. Clique duas vezes no arquivo Java para executá-lo 2. Execute opção Run 3. Selecione a opção Run As > Aplicação Java para executar a aplicação Java ``` ## Non-Primitive Data Types (Seguindo em breve. . . ) No próximo vídeo, iremos delvear em alguns tipos de dados não-básicos, como classes, arrays, e strings. Acompanhe! # Criando e Entendendo Variáveis de Cadeia de Caracteres em Java (Português do Portugal) Existem várias formas de criar uma variável de cadeia de caracteres em Java. Aqui está uma das formas: ``` Variável pode ser criada como string usando o seguinte método: existe outra maneira de criar uma variável de cadeia de caracteres, que é: ``` A palavra-chave `new` é usada em ambas as situações, mas a sua importância será explicada quando discutiremos a execução do nosso primeiro programa em Java. A diferença entre as duas maneiras é que a primeira se reutiliza a mesma instância de objeto várias vezes, enquanto que a segunda cria um novo objeto `String` a cada vez que é chamado. Aqui está um exemplo da primeira maneira: ``` String test = "test"; String str1 = test; System. out. println(test); System. out. println(str1); ``` No exemplo acima, primeiremos criar um objeto `String` chamado `test` e colocamos o valor "test" neste objeto. Em seguida, criar um novo objeto `String` chamado `str1` e atribuir o valor de `test` a este. Como o `test` é reutilizado, ambos o `test` e `str1` têm a mesma localização de memória e consequentemente o mesmo valor. Arrays em Java são outro tipo não primitivo que podem armazenar uma sequência de valores. Um array é um bloco de memória contínuo que armazena uma coleção de valores de tipos semelhantes. Aqui está um exemplo que ilustra como criar um array inteiro: ``` int[] ARR = new int[2]; ARR[0] = 0; ARR[1] = 1; System. out. println(ARR[0]); System. out. println(ARR[1]); ``` No exemplo acima, criaremos um array chamado `ARR` com um tamanho de 2. A cada vez que atribuimos valores ao array, ele ocupa uma localização de memória continua que se estenda de 0 a 1. O Índice é utilizado para identificar a localização da memória onde o valor está armazenado. Neste caso, a primeira localização (índice 0) armazena 0 e a segunda localização (índice 1) armazena 1. Lembre-se de que os arrays são bases em zero-index, assim, a primeira localização sempre é 0 e não 1. ## Execução da Aplicação Para executar a aplicação, podemos ir para `Executar como` e clicar em `Executar como Aplicação Java`. Isso fará com que a aplicação seja executada e exibe a saída no console. Neste caso, a saída será: ``` test test 0 1 ``` A primeira saída é a variável `String` `test`, seguida da saída da variável `String` `str1`. A próxima saída é toda a array e a última saída é o valor inicial da array (armazenado no índice 0). ## Token em Java Em Java, os tokens são some expressões reservadas, palavras ou símbolos que possuem um significado predefinido e que não pode ser rebatizado seu significado. Estes tokens estão divididos em cinco categorias: 1. **Palavras-chave**: Estas são palavras que têm um significado predefinido em Java. Exemplos incluem `int`, `boolean`, `byte`, `char`, `double`, `float`, `short`, `long`, `if`, `else`, e `while`. 2. **Identificadores**: Estas são as variáveis que declarares no seu programa. Java posui alguns restrições sobre estas, como impedir iniciar uma variável por um número, não permitir espaços nos nomes de variáveis e não permitir caracteres especiais como `+`, `-`, e `&` nos nomes de variáveis. 3. **Constantes**: Estas são os identificadores cujo valor não pode ser alterado depois de definido. Por exemplo, você pode declarar uma constante como `final int I = 5; ` que garantirá que o valor de `I` não mudará ao longo da execução do programa. 4. **Símbolos especiais**: Estes símbolos têm um significado predefinido em Java. Por exemplo, `[]` é usado para indicar um array, `{}` é usado para definir o corpo de uma função ou um bloco, e `()` é usado para chamar uma função ou um construtor. 5. **Operadores**: Operadores são símbolos que são usados para realizar operações em variáveis ou símbolos. Exemplos incluem `+` (adição), `-` (subtração), `*` (multiplicação), e `/` (divisão). Vejamos estes tokens em detalhes em aulas futuras. # Tokenes e Conversões de Tipos em Java O Java utiliza vários token para estruturar seu código. Aqui está uma visão geral rápida dos diferentes tipos de token em Java: 1. **Palavras-chave**: São palavras reservadas com significados específicos em Java. Exemplos incluem `public`, `static`, `void`, `class`, `if`, `else`, `while`, `for`, `switch`, `case`, `default`, `try`, `catch`, `finally`, `throw`, `throws`, `synchronized`, `transient`, `volatile`, `interface`, `extends`, `implements`, `package`, `import`, `this`, `super`, `new`, `true`, `false`, `null`, `void`. 2. **Identificadores**: São nomes dados a variáveis, métodos, classes e outros construtos de programação. Devem seguir determinadas convenções de nomenclatura (por exemplo, sem espaços, sem palavras reservadas, etc. ). 3. **Valores Constantes**: São valores que não podem ser alterados durante a execução do programa. O Java possui valores constantes pré-definidos (por exemplo, `Math. PI`, `System. out`) e também é possível criar seus próprios valores constantes usando a palavra-chave `final`. 4. **Símbolos Especiais**: Incluem operadores, símbolos de pontuação e outras símbolos com significados específicos em Java. Exemplos incluem `(`, `)`, `{`, `}`, `; `, `, `, `=`, `+`, `-`, `*`, `/`, `<`, `>`, `==`, `! =`, `&&`, `||`, `! `, `|`, `&`, `^`, `~`, `? `, `: `, `, `, e `. `. 5. **Operadores**: São símbolos que realizam operações específicas em valores ou expressões. Exemplos incluem operadores aritméticos (`+`, `-`, `*`, `/`), operadores de comparação (`==`, `! =`, `<`, `>`, `<=`, `>=`), operadores lógicos (`&&`, `||`, `! `), e operadores bit a bit (`&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`). No Java, você utiliza chaves `{}` para definir um bloco de código. Essas chaves são usadas para agrupar instruções e criar um escopo para variáveis. Em parâmetros de método, você utiliza parênteses `()` para definir os argumentos que o método recebe. Uma vírgula `; ` é usada para finalizar uma instrução em Java. No texto seguinte, corrigi a formatação e a gramática, organizando o conteúdo em seções e parágrafo. Preservei também todos os URLs e comandos como estavam. --- ## Tokenes em Java O Java utiliza vários token para estruturar seu código. Aqui está uma visão geral rápida dos diferentes tipos de token em Java: - **Palavras-chave**: São palavras reservadas com significados específicos em Java. Exemplos incluem `public`, `static`, `void`, `class`, `if`, `else`, `while`, `for`, `switch`, `case`, `default`, `try`, `catch`, `finally`, `throw`, `throws`, `synchronized`, `transient`, `volatile`, `interface`, `extends`, `implements`, `package`, `import`, `this`, `super`, `new`, `true`, `false`, `null`, `void`. - **Identificadores**: São nomes dados a variáveis, métodos, classes e outros construtos de programação. Devem seguir determinadas convenções de nomenclatura (por exemplo, sem espaços, sem palavras reservadas, etc. ). - **Valores Constantes**: São valores que não podem ser alterados durante a execução do programa. O Java possui valores constantes pré-definidos (por exemplo, `Math. PI`, `System. out`) e também é possível criar seus próprios valores constantes usando a palavra-chave `final`. - **Símbolos Especiais**: Incluem operadores, símbolos de pontuação e outras símbolos com significados específicos em Java. Exemplos incluem `(`, `)`, `{`, `}`, `; `, `, `, `=`, `+`, `-`, `*`, `/`, `<`, `>`, `==`, `! =`, `&&`, `||`, `! `, `|`, `&`, `^`, `~`, `? `, `: `, `, `, e `. `. - **Operadores**: São símbolos que realizam operações específicas em valores ou expressões. Exemplos incluem operadores aritméticos (`+`, `-`, `*`, `/`), operadores de comparação (`==`, `! =`, `<`, `>`, `<=`, `>=`), operadores lógicos (`&&`, `||`, `! `), e operadores bit a bit (`&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`). No Java, você utiliza chaves `{}` para definir um bloco de código. Essas chaves são usadas para agrupar instruções e criar um escopo para variáveis. Em parâmetros de método, você utiliza parênteses `()` para definir os argumentos que o método recebe. Uma vírgula `; ` é usada para finalizar uma instrução em Java. `TestHelloWorld`. - `public static void main(String[] args)` is the main method that serves as the entry point of the program. - `System. out. println("Hello, World! "); ` uses the `println` method of the `System` class to print "Hello, World! " to the console. ## Running a Java Program To run a Java program, follow these steps: 1. Right-click on the class file. 2. Select `Run as` > `Java Application`. With these steps, you will learn how to create a Java project, create packages, and write a simple Java class. --- # Executando Seu Primeiro Programa Java e Introdução aos Arrays em Java Este guia demonstra como executar um programa Java e fornece uma introdução aos arrays em Java. ## Saída do Console Usando os Métodos `print` e `println` Existem dois métodos para impressão de saída no console: `print` e `println`. A diferença entre eles consiste em se um novo linha for fornecido para a saída. ### Método `print` Quando usar `print`, a saída não será impressa em uma nova linha. Este método é útil nos casos em que deseja impressão de múltiplas saídas na mesma linha. ```java System. out. print("Olá Mundo 1"); ``` ### Método `println` No contrário, ao usar `println`, um novo pulará de linha e a saída será impressa em uma nova linha. Este método é útil quando deseja que cada saída seja impressa em uma linha adicional. ```java System. out. println("Olá Mundo"); ``` ## Executando um Programa Java Para executar um programa Java, siga estas etapas: 1. Clique com o botão direito no programa em seu IDE. 2. Selecione "Executar Como" e então "Aplicação Java". 3. Salve quaisquer recursos antes de lançar caso necessário. 4. Observe a saída. ## Exemplo usando `print` e `println` ```java System. out. println("Olá Mundo"); System. out. print("Olá Mundo 1 "); System. out. println(); // uma linha em branco para separação ``` ## Introdução aosArrays Os arrays são uma série de valores ou números que são armazenados de forma contínua na memória. ### Criando um Array Para criar um array, declare uma variável com o tipo de dado desejado seguido de colchetes. Alocar um tamanho usando a palavra-chave `new` como mostrado abaixo. ```java int[] meuArray = new int[10]; ``` ### Acessando Elementos do Array Acessar elementos do array é feito utilizando o índice. Lembra-se que o índice começa em 0 e termina em `arrayLength - 1`. ```java meuArray[0] = 100; int valor = meuArray[0]; ``` ### Imprimindo Elementos do Array Para impressão de elementos do array, utilize um loop `for` ou `for-each`. ```java for (int i = 0; i < meuArray. length; i++) { System. out. println("Elemento " + i + ": " + meuArray[i]); } ``` ## Em seguida Em seguida, discutiremos operadores em Java. Vamos começar com operadores aritméticos e de atribuição. 🇵🇹 # Demonstração de Operadores Aritméticos em Java Nesta apresentação, demonstraremos o uso de operadores aritméticos em Java. Aqui criamos uma classe chamada `ArithmeticDemo`. ```java public class ArithmeticDemo { public static void main(String[] args) { int result; // Operações de adição result = 1 + 2; // armazena o valor de 1 + 2 System. out. println("1 mais 2 é igual a " + result); int originalResult = result; // armazenando o resultado em uma nova variável result -= 1; // subtraindo 1 do resultado System. out. println("O resultado original era: " + originalResult); System. out. println("O resultado atual é: " + result); result *= 2; // multiplicando o resultado por 2 System. out. println("O resultado original: " + originalResult); System. out. println("O resultado atual: " + result); result /= 2; // dividindo o resultado por 2 System. out. println("O resultado atual: " + result); result += 8; // adicionando 8 ao resultado System. out. println("O resultado atual: " + result); System. out. println("O resultado original: " + originalResult); originalResult = result; // atribuindo o novo resultado ao resultado original System. out. println("O resto de " + result + " mod 7: " + (result % 7)); // Operações restantes são adicionadas no final do programa System. out. println("Vamos executar o programa e ver os resultados: "); // . . . (Repete o código acima e insira as operações restantes aqui) } } ``` Na sessão seguinte discutiremos operadores de joalharia e outros operadores interessantes utilizados em Java. ## Operadores Unários ```java public class UnaryDemo { public static void main(String[] args) { int result = 1; // Operador Unário Plus System. out. println("1 + (unário +) é: " + (1 + +result)); // Operador Decremento System. out. println("1 -- é: " + (1 --)); // Operador Incremento System. out. println("1 ++ é: " + (1 ++)); // Operador Unário Minus System. out. println("1 - (unário minus) é: " + (1 - -result)); boolean success = false; System. out. println("O valor de success é: " + success); System. out. println! ("O valor invertido de success é: " + ! success); // Operadores de Incremento Pre-incremento e Post-incremento int i = 3; System. out. println("i++ (post-incremento) é: " + (i++)); System. out. println("i ++ (pre-incremento) é: " + ++i); } } ``` # Utilização dos Operadores de Incremento Pós e Pré-Incremento Este exemplo ilustra a diferença entre a utilização do operador de incremento prê-incremento e pós-incremento em Java. ``` ## Exemplo Explicando o Operador de Incremento Pós Depois da linha 15, o valor de `I` virá a ser `7`, mas na linha 15 o valor de `I` ainda é `6`, pois estamos a utilizar um operador de incremento pós, pelo que o valor ainda é **atribuído** a `I`, sem modificação, e só depois é incrementado. Quando faremos `System. out. println`, o valor atribuído é impresso, não o valor incrementado, assim, tal como disse após a linha 15, o valor de `I` virá a ser **incrementado** por 1 e vai se tornar 7. Então, **esperei** que **entende** este exemplo, ou pelo menos a **diferença** entre o **pré-**incremento e **pós-**incremento, lembrando que a regra básica é que se colocarmos `++` antes de uma variável, como no linha `9`, o **valor** vai ser incrementado **primeiro** e **depois** atribuído, assim, **na linha 13**, o valor atualizado vai ser impresso porque primeiramente faremos o incremento e depois a impressão do valor. Para atribuição, um processo similar aplicável na linha 15 - **primeiro**, imprimiremos o valor **e depois** incremento o valor. Assim, quando o valor for impresso na linha 15, o **antigo** valor `5` vai ser impresso, mas após a linha 15, o novo valor de `I` será **acessível ao programa. ** > Clique com o botão direito neste e execute o programa. **Agora**, **se vê os valores**, encontraremos que `I` foi atribuído como `3`. Aplicamos um incremento pós aqui, assim `I` tornou-se `4` (o valor atribuído para `I` permanece inalterado enquanto aplicamos o código `++I`). > Imprimimos `4`, porque é o valor atribuído e não o obtido após aplicar o operador de incremento pós (o qual não altera até ser atribuído). Na linha `9`, colocámo-nos `++I`, de modo que `4 + 1` se transforma em `5` (apesar de ser a pre-incremento na linha `9` - devido a não antecipar a publicação de `5` como é, não há qualquer alteração real neste cenário específico). `5` é impresso na linha `11`. A seguir, na linha 13, `++I`, isto é, incrementamos, atribuímos e depois impresso o valor incrementado, pelo que é exibida a `6` neste ponto. E o mesmo comportamento exemplificado pode ser observado **na linha 15**, primeiro, o **valor** de `I` é **impresso** como o `6` que ves aqui (nosso comportamento específico do uso de operador de incremento pós), mas depois `I` torna-se `7` devido ao incremento. --- ## Utilização dos Operadores Relaționais/Comparação Java Entender os operadores relacionais ou de comparação em Java oferece um abordagem mais aproximada para a comparação de valores de objetivos ou de variáveis. Nas Official JavaDocs, podem ser observados intercambiavelmente referidos como **Operadores Comparação ou Relações Alberto Doc**s. Acompanhém-nos em seguida! ### Sintaxe Operadores de comparação: | Operação | Carácter | Descritivo em português | |------------|------|---| | Igualdade | `==` | é igual | | Não igual | `! =` | é diferente | | Menor que | `<` | é menor que | | Maior que | `>` | é maior que | | Menor ou igual| `<=` | é menor ou igual a | | Maior ou igual|` >=` | é maior ou igual a | --- ### Demonstrações A seguir são demonstradas demonstrações mostrando a utilização dos **operadores de comparação Java relacional/comparação** seguidas por uma discussão das diferentes resultados: ``` public static void main(String[] args) { // Demonstração da comparação entre `valor 1` (3) e `valor 2` (2) numa classe Java. . . } ``` . . . O texto original em inglês foi traduzido para português e mantidas todos os elementos de formatação Markdown. Os comandos e códigos inalterados foram preservados. # Aula: Operadores de Comparação e Bitwise em Java Esta aula abordará os operadores de comparação e bitwise em Java. O entendimento destes operadores ajuda na criação de programas complexos e eficientes. ## Operadores de Comparação ``` Por exemplo, nesta expressão exigem-se ambas as condições para serem verdadeiras. Se qualquer uma delas se torna falsa, a expressão inteira torna-se falsa. No estado atual, a linha 10 será executada. No entanto, se eu alterar isso para: ``` ```javascript let a = 5; let b = 7; if (a === 5 && b === 7) { console. log("Linha 10: a e b são ambos 5 e 7"); console. log("Linha 13: Ambas as condições são avaliadas a verdade"); } else { console. log("Linha 10: a e b não são ambos 5 e 7"); console. log("Linha 13: Uma ou mais condições são avaliadas a falsa"); } // Alterando o valor de 'a' para 4 a = 4; if (a === 5 && b === 7) { console. log("Linha 10: a e b são ambos 5 e 7"); // Não impresso porque esta expressão avalia a false console. log("Linha 13: Ambas as condições são avaliadas a verdade"); // Não impresso porque a expressão inteira avalia a false } else { console. log("Linha 10: a e b não são ambos 5 e 7"); console. log("Linha 13: Uma ou mais condições são avaliadas a falsa"); } // Na situação OR, é preciso que cada uma das condições seja verdadeira. ``` Veja no exemplo acima que o valor 2 igual a 5 resultará em uma expressão falsa porque 2 é realmente 2, não 5. Mesmo que visto este expressão em particular, ainda é impressa pois cada um dos lados precisa de ser verdadeiro. Caso façamos ambas as condições falsas, nada será impresso. Na situação OR (usando o operador |), uma das condições deve ser verdadeira para a expressão global se tornar verdadeira. Se as condições das duas faces do pipe `|` e na face direita do pipe `|` se tornarem falsas, nada será impresso, conforme mostrado no exemplo abaixo: ``` if (a === 5 || b === 7) { console. log("Linha 10: Um de a e b é 5 ou 7"); console. log("Linha 13: Uma ou mais condições são avaliadas a verdade"); } // Alterando os valores para falsos ambos a = 4; b = 2; if (a === 5 || b === 7) { console. log("Linha 10: Um de a e b é 5 ou 7"); // Não impresso porque nenhum valor da condição é verdadeira console. log("Linha 13: Uma ou mais condições são avaliadas a verdade"); // Não impresso porque a expressão inteira avalia a false } ``` ## Operadores Bitwise Operadores bitwise são menos frequentemente utilizados no mundo de programação em Java. Normalmente, eles são usados para cálculos bitwise complexos em que é necessário manipular bits. ``` Se lembrar do quando falamos sobre variáveis de tipos inteiro, aprendemos que cada um dos tipos de variáveis ou tipos de dados tem um tamanho predefinido, e tipos inteiro ocupam os seguintes espaços de mem # Logica Condicional IF Else em Java (Acompanhado de Exemplo) Este exemplo mostra como utilizar a lógica de condição `if` e `else` em Java para determinar a classificação do aluno baseado na sua pontuação final. ## Sintaxe de condições em Java ```java if (condição) { // código a ser executado se a condição for verdadeira } else if (outraCondição) { // código a ser executado se a primeira condição for falsa e a nova condição for verdadeira } else { // código a ser executado se todas as outras condições forem falsas } ``` Neste exemplo, a variável `testScore` é inteiro que refere-se à pontuação do aluno no exame, definida com o valor 76. A classificação do aluno é determinada conforme as seguintes regras: - se a pontuação é maior ou igual a 90, o aluno recebe uma A - se a pontuação não é maior ou igual a 90, mas é maior ou igual a 80, o aluno recebe uma B - se a pontuação não é maior ou igual a 80, mas é maior ou igual a 70, o aluno recebe uma C - se a pontuação não é maior ou igual a 70, mas é maior ou igual a 60, o aluno recebe uma D - caso contrário, o aluno recebe um F Vamos analisar este trecho de código em particular: ```java if (testScore >= 90) { grade = "A"; } else if (testScore >= 80) { grade = "B"; } else if (testScore >= 70) { grade = "C"; } else if (testScore >= 60) { grade = "D"; } else { grade = "F"; } ``` Neste caso, o primeiro bloco de condições `if` testa se o valor de `testScore` é maior ou igual a 90 e atribui a variável `grade` o valor `"A"` se for verdadeiro. Se o valor de `testScore` for maior ou igual a 80 mas não for maior ou igual a 90, então um bloco de `else if` é executado para verificar se o valor de `testScore` é maior ou igual a 80 e atribui a variável `grade` o valor `"B"` se for verdadeiro. Se o valor de `testScore` não for maior ou igual a 80 mas for maior ou igual a 70, então um bloco de `else if` é executado para verificar se o valor de `testScore` é maior ou igual a 70 e atribui a variável `grade` o valor `"C"` se for verdadeiro. Se o valor de `testScore` não for maior ou igual a 70 mas for maior ou igual a 60, então um bloco de `else if` é executado para verificar se o valor de `testScore` é maior ou igual a 60 e atribui a variável `grade` o valor `"D"` se for verdadeiro. Se todos os blocos de `if` e `else if` forem falsos, então um bloco de `else` é executado, atribuindo a variável `grade` o valor `"F"`. ```java if (testScore >= 90) { grade = "A"; } else if (testScore >= 80) { grade = "B"; } else if (testScore >= 70) { grade = "C"; } else if (testScore >= 60) { grade = "D"; } else { grade = "F"; } System. out. println("grade: " + grade); ``` No exemplo acima, se o valor do testScore for maior ou igual a 76, o resultado será `grade: C`. ## Else e blocos de condições `else if` Os blocos de `else if` são utilizados quando se deseja verificar várias condições até uma condição específica ser verdadeira. Uma vez que uma condição seja verdadeira, o controle de fluxo pula para o bloco `else` anônimo que aparece depois da última condição. No exemplo acima, deixamos a variável `grade` em branco, caso nenhuma das condições sejam verdadeiras. À medida que a classificação do aluno abaixar, o bloco `else if` atribui a variável com uma classificação não egípcia. ```java if (testScore >= 90) { grade = "A"; } else if (testScore >= 80) { grade = "B"; } else if (testScore >= 70) { grade = "C"; } else if (testScore >= 60) { grade = "D"; } else { // condição não especificada // condição falha dentro do bloco } ``` Neste caso, se a condição do `while` for false, o bloco `else` é executado, mas a condição não especificada não é possível ser avaliada, gerando um erro de compilação. Além disso, adicionar um comando `else` pode ser redundante neste exemplo, uma vez que um bloco `else` só é necessário quando se deseja fornecer uma alternativa para todas as condições `if`. ## Enumerando 1. FORMATAÇÃO MARKDOWN: - Use `#` para títulos e subtítulos - Use `**` para negrito em termos importantes - Use `` para código inline - Use `` para blocos de código - Use > para citações - Use - ou `*` para listas - Use --- para separadores - Preserve todas as URLs existentes 2. ESTRUTURA: - Organize em seções com títulos claros - Use parágrafos para separar ideias - Mantenha listas e enumerações - Preserve a hierarquia de títulos 3. CONTEÚDO: - Corrija erros de pontuação e gramática - Mantenha todos os termos técnicos inalterados - Preserve comandos e códigos exatamente como estão - Preserve URLs e referências intactas Title: Operadores Ternários e Declarações Switch em Java ---------------------------------------------------------------- O operador ternário é um encurtamento do `if-else` e é utilizado para escrever código conciso quando for necessário atribuir um valor baseado em uma condição. ### Sintaxe do Operador Ternário ```java condition ? expression_if_true : expression_if_false; ``` Exemplo: ```java int a = 1; int b = 2; int result = (a < b) ? a : b; // result será 1 ``` ### Operador Ternário vs. `if-else` O operador ternário pode ser usado como encurtamento para um `if-else` statement, mas ele tem limitações: 1. Pode ter apenas uma instrução nos blocos `if` e `else`. 2. É menos legível e mais difícil de depurar para condições complexas. ### Usando o Operador Ternário em Condições Aninhadas Você pode usar o operador ternário em condições aninhadas, mas é geralmente melhor usar vários `if-else` para alegibilidade. Exemplo: ```java int a = 1; int b = 2; int c = 3; int result = (a < b) ? (b < c ? b : c) : a; // result será 2 ``` ### Declaração Switch A declaração `switch` é utilizada quando várias condições constantes precisam ser avaliadas em relação a uma expressão constante. Exemplo: ```java int month = 6; String monthName; switch (month) { case 1: monthName = "Janeiro"; break; case 2: monthName = "Fevereiro"; break; // . . . case 12: monthName = "Dezembro"; break; default: monthName = "Mês inválido"; } ``` ### Declaração Break A declaração `break` é utilizada para sair da declaração `switch` quando uma correspondência é encontrada. Se não utilizarmos `break`, o código continuará a ser executado todas as seguintes declararções. ### Usando a Declaração Switch com Strings Você pode usar a declaração `switch` com strings comparando-as com o método `String. equals()`. Exemplo: ```java String day = "Tuesday"; String dayName; switch (day) { case "Monday": dayName = "Segunda-feira"; break; case "Tuesday": dayName = "Terça-feira"; break; // . . . default: dayName = "Dia inválido"; } ``` ### Arrays bidimensionais (2D Arrays) Um array bidimensional é um array de arrays. É usado para armazenar uma tabela de dados com linhas e colunas. Exemplo: ```java int[][] array = new int[3][4]; // Preencher oarray bidimensional array[0][0] = 1; array[0][1] = 2; array[0][2] = 3; array[0][3] = 4; array[1][0] = 5; array[1][1] = 6; array[1][2] = 7; array[1][3] = 8; array[2][0] = 9; array[2][1] = 10; array[2][2] = 11; array[2][3] = 12; // Imprimir oarray bidimensional for (int i = 0; i < array. length; i++) { for (int j = 0; j < array[i]. length; j++) { System. out. print(array[i][j] + " "); } System. out. println(); } ``` Saída: ``` 1 2 3 4 5 6 7 8 9 10 11 12 ``` ### Arrays tridimensionais (3D Arrays) Um array tridimensional é um array de arrays bidimensionais. É utilizado para armazenar uma tabela de dados tridimensionais. Exemplo: ```java int[][][] array = [. . . ] ``` Utilize `\` para continuar uma linha em Markdown em Java. Por exemplo: ```java int[][][] array = new int[2][3][4]; // preencher o array tridimensional aqui. . . ``` # Arrays em Java: um rápido review de arrays uma e multi-dimensionais Neste exemplo, iremos revisar como criar e utilizar arrays uma e multi-dimensionais em Java. Começaremos com arrays uma e depois passaremos a tratar arrays multi-dimensionais. ## Arrays uma Empurre as mensagens de erro e inclui muito comentário no código para melhorar a compreensão do funcionamento de arrays em Java. ```markdown ``` Java int [] a; // Declaração de uma variável de referência para um array // Alocação de memória para o array a = new int[4]; // Inicialização de um array uma (allow more than one assignment if needed) a[0] = 10; a[1] = 20; a[2] = 30; a[3] = 40; // Mostra os valores dos elementos do array for (int i = 0; i < 4; i++) { System. out. println("Elemento na posição " + i + " é " + a[i]); } ``` Neste código, podemos ver como declarar uma variável de referência para um array, alocar memória para o array e inicializá-lo, além de iterar pela posição dos elementos e mostrar cada valor individual. Lembrando que, como todos os arrays de dados em Java são baseados em zero, começamos nos primeiros índices com zero. ## Arrays multi-dimensionais Array uma são frequentemente bastante úteis em diversas situações, mas quando lidamos com matrizes de dados como as matrizes comuns utilizadas em álgebra linear, precisaremos de arrays multi-dimensionais. Um array uma consiste em uma simples linha de dados, enquanto um array multi-dimensional é uma matriz de valores. Iremos criar um array uma e usar para representar uma matriz. ```markdown ``` Java ``` #include <iostream> int main() { // Declaração de uma variável de referência para um array 2D int arr2D[][]; // Inicialização do tamanho do array arr2D = new int[2][3]; // Inicialização dos elementos do array 2D arr2D[0][0] = 237; // zero (0) linha, primo (1) coluna arr2D[0][1] = 2; // zero linha, segundo coluna arr2D[0][2] = 3; // zero linha, terceira coluna arr2D[1][0] = 4; // primeira linha, primo coluna arr2D[1][1] = 5; // primeira linha, segundo coluna arr2D[1][2] = 6; // primeira linha, terceira coluna // Mostra os valores dos elementos do array 2D for (int i = 0; i < 2; i++) { for (int j = 0; j < 3; j++) { std: : cout << "Elemento (" << i << ", " << j << ") é " << arr2D[i][j] << "\n"; } } return 0; } ``` C++ Aqui, podemos ver como declarar uma variável de referência para um array 2D, alocar memória para ele e inicializá-lo elemento a elemento. Em seguida, utilizaremos um nested for-loop para iterar pela matriz. Podemos utilizar este mesmo exemplo para adaptar a outros tipos de arrays multi-dimensionais, como arrays 3D, 4D, etc. , simplesmente aumentando o número de dimensões. Isso permitirá experimentar matrizes mais complexas, como cúbicas, ou o uso de arrays mais compactos para diversas necessidades específicas. # Arrays Tridimensionais e laços `do-while` em Java (Português de Portugal) Este guia explica o uso de um array tridimensional e o `do-while` loop em Java. ## Arrays Tridimensionais Um array tridimensional pode ser visto como uma série de 1D arrays ordenados em uma grade tridimensional, com dimensões que abrangem os eixos X, Y e Z. ``` - Eixo X: este, o outro eixo X - Eixo Y: o eixo Y - Eixo Z: os elementos dentro deste são o eixo Z (exemplos fornecidos a seguir) ``` ### Exemplo Aqui está um exemplo de um array tridimensional e como interpretá-lo: ``` Resumidamente, isto define o eixo X para que tenmos dois elementos no eixo X: - este: 0 - este: 2 Em seguida, temos dois elementos no eixo Y: - no primeiro eixo X: - este é um: 2 - este é 2: 1 - no segundo eixo X: - este é um: 11 - este é 2: 13 Então no eixo Z, tenho três elementos cada: - portanto, 0 com o eixo X neste bloco: primeiro no eixo Y (em vez do segundo elemento, como conta a partir de 0) - segundo elemento ou o elemento do eixo Z ou segundo posicionamento deste bloco que é 11 (ajustando o eixo Y de acordo) ``` ## Laços `do-while` O `do-while` loop é útil quando deseja executar uma declaração mesmo antes de verificar a condição. Aqui está uma explicação de sua sintaxe e utilização em Java: ``` - Sintaxe: ``` do { // Declarações Executáveis } while (Expressão); ``` ### Exemplo Para um melhor entendimento, vamos usar um programa exemplo que demonstre a utilização de um laço `do-while`: ```java public class DoWhileDemo { public static void main(String[] args) { int count = 1; do { System. out. println(count); count++; } while (count < 10); } } ``` Neste exemplo, o laço `do-while` executa a declaração de impressão, independentemente da condição se verdadeira ou falsa durante a primeira iteração. A condição será verificada após a execução, antes da loop continuar a iterar. Isso pode ser útil para executar código de inicialização antes de verificar a condição. ``` saída: 1 2 3 4 5 6 7 8 9 ``` # Laços `while` em Java Este tutorial tem por objetivo explicar o conceito de laços `while` em Java, incluindo uma demonstração de sua utilização. ## Visão Geral Os laços `while` permitem executar uma série de instruções repetidamente enquanto uma condição especificada for verdadeira. Este bloco de código iterará até que a condição seja falsa, permitindo que seja realizada uma tarefa de forma indiscriminada ou um número especificado de vezes. ## Exemplo de Um Laço `while` Aqui está um exemplo de um laço `while` simples em Java: ```java public class WhileDemo { public static void main(String[] args) { int count = 1; while (count < 10) { System. out. println("Contador é: " + count); count++; } } } ``` Neste exemplo, inicializamos uma variável `count` com um valor inicial de 1. O laço `while` verifica se o valor de `count` é menor que 10. Se a condição é verdadeira, ele imprime o valor atual de `count` e incrementa-o utilizando a operação `count++`. O laço continua até que o valor de `count` seja 10, causando a condição a se tornar falsa e encerrando o laço. ## Aviso sobre laços infinitos Os laços `while` podem resultar em um laço infinito se esquecer de atualizar a condição ou o valor que afeta a condição dentro do laço. Um laço infinito é um laço que corre indefinidamente sem nenhum critério de paragem, potencialmente causando o programa a congelar ou consumir recursos de sistema excessivos. ## Laços `for` Os laços `for` são outro tipo de laço em Java, frequentemente utilizados para iterar sobre coleções. Seremos abordados for mais detalhadamente em seções posteriores. No próximo módulo, vamos explorar laços `do-while` e comparar sua utilização com laços `while`. Também vamos olhar para exemplos de utilização de arrays e outras estruturas de dados com laços `for`. # Laços de repetição em Java: Laços de repetição melhorados (ForEach) Este tutorial abordará os laços de repetição melhorados (ForEach) em Java, uma maneira mais inteligente de escrever laços de repetição em comparação às tradicionais. ## Laços de repetição tradicionais No módulo anterior, abordamos a estrutura e o fluxo de controle dos laços de repetição tradicionais. Aqui, iremos focar nos laços de repetição melhorados, uma opção mais otimizada para cenários que envolvem coleções ou arrays de itens. ### Sintaxe Os laços de repetição melhorados são mais simples e utilizam a seguinte sintaxe: ``` for (tipo_dados variável : coleção) { // código a ser executado } ``` Você pode usar esta sintaxe para várias coleções como arrays, listas e maps. A coleção fica ao lado direito do colchete, e você pode representar o membro da coleção como desejado, por exemplo: ``` int[] números = {1, 2, 3}; for (int número : números) { System. out. println(número); } ``` Este código executará e irá iterar sobre o array de elemento a elemento, de primeiro para o último. Você não precisa escrever nenhuma inicialização, terminação ou código de incremento/decremento, pois a iteração é gerenciada automaticamente. ## Entendendo o laço de repetição melhorado O laço de repetição melhorado utiliza o laço de repetição tradicional de forma implícita, simplesmente porque ele sabe que, ao iterar sobre uma coleção, iniciará com o Primeiro elemento, iterará até o último elemento, e gerencia as condições de inicialização, término e incremento/decremento através de uma lógica interna. ### Impressão de elementos de arrays Utilizando o laço de repetição melhorado, é fácil imprimir todos os elementos de um array ou uma coleção de elemento a elemento: ``` int[] números = {1, 2, 3}; for (int número : números) { System. out. println(número); } ``` No próximo módulo, discutiremos o conceito OOP e forneceremos um exemplo de como implementar laços de repetição aninhados e quando usá-los. ### Laços de repetição aninhados Nos laços de repetição aninhados, utilizamos mais de um laço de repetição em uma situação em que precisamos iterar sobre coleções baseadas em outra coleção. No exemplo a seguir, usamos um array binomial, onde o laço externo itera sobre linhas, e o laço interno itera sobre colunas: ``` int[][] a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; for (int i = 0; i < a. length; i++) { for (int j = 0; j < a[i]. length; j++) { System. out. print(a[i][j] + " "); } System. out. println(); } ``` Este programa impressos a seguinte saída: ``` 1 2 3 4 5 6 7 8 9 ``` No exemplo, o primeiro laço inicializa `i` com zero, executa enquanto `i` é menor do que o número de linhas, e incrementa i em cada passo. O laço interno inicializa `j` com zero, executa enquanto `j` é menor do que o número de colunas, e incrementa `j` em cada passo. A impressão é feita através dos elementos do array nas posições correntes de `i` e `j`. # Tópico da Sessão: Laços aninhados e o Framework de Coleções Java Nesta sessão, discutiremos o conceito de laços aninhados e exploraremos o Framework de Coleções Java. Este assunto é importante, pois é frequentemente usado em aplicações de produção e a compreensão das coleções é essencial para qualquer programador Java. ## Laços Aninhados Iteraremos sobre uma matriz multidimensional (ou coleção) usando laços aninhados. Aqui está um exemplo básico: ```markdown para (int i = 0; i < array. length; i++) { para (int j = 0; j < array[i]. length; j++) { // Processar elemento (i, j) aqui } } ``` Esse padrão pode ser aplicado a qualquer matriz n-dimensional ou coleção. ## Framework de Coleções Java ### Visão Geral O Framework de Coleções Java fornece uma maneira de gerir as coleções de objetos, como lists, sets e filas. Ele consiste em várias interfaces abstractas, classes abstractas e classes de implementação concreta. ### Interfaces-chave 1. `Collection` - Um`AbstractCollection (coleção)`interface abstracto define uma coleção, que é um objeto que pode conter vários elementos. 2. `Set` - Um`Set` é uma coleção que não pode conter elementos duplicados. 3. `List` - Um`List` é uma coleção que mantém a ordem de seus elementos. Pode conter elementos duplicados. 4. `Queue` - É uma coleção que segue o princípio de `FIFO` (primeiro em, primeiro sai), ou seja, o elemento que foi inserido primeiro será o primeiro a ser removido. ### Classes Abstractas-chave 1. `AbstractCollection` - Uma classe abstracta para a implementação de coleções, como sets, lists, etc. 2. `AbstractSet` - Uma classe abstracta para a implementação de sets. 3. `AbstractList` - Uma classe abstracta para a implementação de lists. 4. `AbstractQueue` - Uma classe abstracta para a implementação de filas. ### Classes Concretas-chave 1. `ArrayList` - Uma implementação concreta da interface de `List`, com base em um array. 2. `LinkedList` - Uma implementação concreta da interface de `List`, baseada em nós conectados. 3. `HashSet` - Uma implementação concreta da interface de `Set`, com base em uma tabela de hash. 4. `TreeSet` - Uma implementação concreta da interface de `Set`, com base em um árvore para armazenar elementos. 5. `Stack` - Uma implementação concreta da interface de `Queue`, representando uma estrutura de dados LIFO (Ultimo em, Primeiro sai). 6. `PriorityQueue` - Uma implementação concreta da interface de `Queue`, com base em uma prioridade para ordenar os elementos. Não vámos entrar nas exerciços de mãos-nos por todos os tipos de coleção-classe pois isso levaria muito tempo para se completar. Em vez disso, focaremosCertificate Enterprise Associate NODEJS SESSION 11 em entender a relação entre classes, seus propósitos no framework e a hierarquia em sessões futuras. Na próxima sessão, iremos explorar os exercícios de mãos-nos para algumas coleções populares. Acompanhe-nos! Translzeitem o texto com base nas regras especificadas: # Coleções Java: Listas Utilize o ArrayList quando precisar de uma estrutura de dados para armazenar e acessar elementos em ordem. ## ArrayList Um ArrayList é uma implementação comum da interface List que usa matrizes internas para armazenar os elementos. Os elementos podem ser acessados diretamente usando seu índice e ela aceita duplicados por padrão. ### Utilizando o ArrayList ```java ArrayList<Integer> minhaLista = new ArrayList<>(); // Adicionar um elemento minhaLista. add(1); // Adicionar vários elementos minhaLista. addAll(Arrays. asList(2, 3, 4, 5)); // Remover um elemento minhaLista. remove(0); // Recuperar um elemento Integer elemento = minhaLista. get(0); ``` ### Dicas e Sugestões - Inicializar com um tamanho conhecido para evitar desperdício de memória. - Utilize listas genéricas para evitar erros de compilação. ## LinkedList Uma LinkedList não é usada no Java através de uma classe diretamente, mas é implementada através da interface List. Ela pode ser usada para armazenar elementos em uma estrutura sequencial onde cada nó referencia o próximo na lista. ### Utilizando o LinkedList ```java LinkedList<Integer> minhaLista = new LinkedList<>(); // Adicionar um elemento minhaLista. addFirst(1); // Adicionar vários elementos minhaLista. addAll(Arrays. asList(2, 3, 4, 5)); // Recuperar o primeiro elemento Integer primeiroElemento = minhaLista. getFirst(); // Recuperar o último elemento Integer ultimoElemento = minhaLista. getLast(); ``` ### Principais Diferenças entre Lista e LinkedList - Os acessores de elementos em um ArrayList são mais rápidos em contextos de leitura, enquanto processos de inserção e remoção efetuados por ordem são mais lentos do que em uma LinkedList. - Um ArrayList tem tempo de acesso constante para o n-ésimo elemento, enquanto nesse caso o tempo de acesso de uma LinkedList é linear. - As operações de inserção e remoção na posição inicial e final de um ArrayList são mais eficientes do que nesse caso em uma LinkedList. ## Stack A classe Stack em Java é uma implementação emFIFO (Primeiro em Chegar, Primeiro Sair) de uma lista, por padrão com capacidade limitada. ### Utilizando Stack ```java Stack<Integer> minhaPilha = new Stack<>(); // Empilhar um elemento minhaPilha. push(1); // Desempilhar um elemento Integer elementoDesempilhado = minhaPilha. pop(); ``` ## Queue A classe Queue em Java é uma implementação emFIFO (Primeiro em Chegar, Primeiro Sair) de uma lista. Todos os elementos na fila são armazenados em ordem de inserção e o próximo elemento a ser processado (ou removido) é sempre o primeiro da fila. ### Utilizando Queue ```java Queue<Integer> minhaFila = new LinkedList<>(); // Adicionar um elemento minhaFila. offer(1); // Remover o primeiro elemento da fila Integer elementoRemovido = minhaFila. poll(); ``` ### Prioridade na Queue A classe PriorityQueue funciona como um heap max para prioridades de elementos em uma fila. Por padrão, o objeto de maior prioridade é o primeiro no bundle. ### Utilizando PriorityQueue ```java PriorityQueue<Integer> minhaPrioridade = new PriorityQueue<>(); // Adicionar um elemento com prioridade minhaPrioridade. add(1); // Remover o elemento de prioridade mais alta Integer elementoRemovido = minhaPrioridade. poll(); ``` ## Set A interface Set em Java é uma coleção não ordenada. É garantido que, independentemente do ordem de inserção, nenhum elemento pairará com outro já presente na coleção em Java Collections. Há duas classes implementando a interface Set: TreeSet e HashSet. ### TreeSet A classe TreeSet em Java implementa um conjunto incialmente ordenado pelos métodos compareTo() e compare() dos próprios elementos, conforme eles implementarem a interface Comparable. Você também pode definir um Comparador Customizado para uma TreeSet. ### HashSet A classe HashSet em Java implementa um conjunto não ordenado com uma tabela de hash na qual cada elemento é colocado com uma chave de hash única da transformação da chave origem. # Operações de Lista de Erros e Listas Encadeadas em Java Este documento explica como remover um elemento de uma lista de erros usando o `remove()` método e apresenta uma breve introdução às Listas Encadeadas em Java. ## Operações da Lista de Erros Neste exemplo, foi removido um elemento de uma lista de erros usando o método `remove()`. Esta operação faz parte de uma implementação baseada em arrays e começará a partir do índice 0. ```markdown Outra operação desta lista de erros é removê-la. Para remover um elemento da lista de erros, basta chamar `errorList. remove(index)` e especificar o índice a partir do qual você deseja remover o elemento. Lembre-se, você precisa especificar o índice e, como mencionado no início, trata-se de uma implementação baseada em arrays, portanto este começa a partir de 0. Assim, quando dizemos remover o elemento no índice 3, em termos técnicos, se refere ao quarto elemento da lista de erros. Após isso, uma vez que ele foi removido, estou novamente mostrando a lista de erros modificada e depois impresso todos os elementos da lista de erros um por um. Para recuperar um elemento, observe o laço `for` abaixo. Aqui, uso o método `get(index)` do `ArrayList`. Este método pode ser usado para recuperar elementos a partir do índice 0 (`get(0)`, `get(1)`, `get(2)`, e `get(3)`). Se você deseja imprimir a lista inteira de erros, basta usar `System. out. print(errorList)`. ``` ## Saída ``` // Lista de Erros Originais (antes da remoção) Se você deseja apenas imprimir toda a lista inteira de erros, basta colocar `System. out. print(errorList)` na linha 20 // Removendo um elemento (removendo o elemento no índice 3) // Imprimindo novamente a lista de erros modificada ``` ## Lista Encadeada A Lista Encadeada é outra implementação da interface `List`. Quando a ordem dos elementos é mantida de forma estrita e o primeiro elemento pode referir-se ao segundo elemento, o segundo elemento ao terceiro elemento e assim por diante, você utilizará Lista Encadeada. Outra propriedade da Lista Encadeada é que você não pode acessar um elemento aleatório de forma direta, como foi feito com um `ArrayList`. Para acessar qualquer elemento aleatório, precisará começar pelo cabeçalho (o primeiro elemento) e continuar percorrendo até o elemento desejado. A Lista Encadeada não é sincronizada, então se vá threads estiverem tentando acessar uma Lista Encadeada simultaneamente, pelo menos uma das threads deve modificar o conjunto externamente ou você obterá resultados inesperados. ```markdown A Lista Encadeada fornece uma variedade de métodos utilitários, como `add()`, `addAll()`, `addFirst()`, `contains()`, `getFirst()`, `getLast()`, etc. Vamos abordar alguns desses métodos na demonstração abaixo. ``` ## Demonstração da Lista Encadeada Agora, vamos avançar nos exemplos de Lista Encadeada. ```markdown Aqui, criamos uma classe `LinkedListDemo` com um método público estático `main`. Na linha 10, declaramos a Lista Encadeada, `linkedList`, que se parece com a maneira como declarávamos um `ArrayList`. Agora, vamos adicionar alguns elementos à lista encadeada. Para isso, possuímos o método `add()`, que disponível na classe `LinkedList` e que nos dá a capacidade de adicionar elementos. A linha 12 e 13, posso adicionar dois elementos. A linha 14, usamos outro método interessante desta classe de lista encadeada, que diz `addLast()`. Este método especificamente adiciona o elemento no final da lista encadeada. Então, na linha 15, usamos outro método interessante da classe de lista encadeada chamado `addFirst()`. Este método insere o elemento no começo da lista encadeada, semelhante ao antes do primeiro elemento. ``` ## Saída ``` // Lista Encadeada Original (antes de serem realizadas as operações) // Adicionando dois elementos // Adicionando um elemento no final // Adicionando um elemento no início // Imprimindo a Lista Encadeada ``` Com isso, concluímos a discussão sobre operações de lista de erros e uma introdução à lista encadeada em Java. Na próxima sessão, abordaremos mais fundamente a lista encadeada, incluindo vários exemplos e demonstrações práticas. Continue a se inscrever para conteúdo informativo adicional. # Removendo Elementos de uma Lista Encadeada usando Métodos em Java Esse programa demonstra diferentes operação que podem ser executadas usando vários métodos em uma Lista Encadeada em Java. Nessa sessão, vamos focar em uma Lista Encadeada e em sessão seguinte, vamos abordar a classe da framework chamada Set em Java. ## Operações em uma Lista Encadeada usando a classe `LinkedList` No Java, a LinkedList faz parte da hierarquia de interfaces de coleções chamadas list. É uma coleção de elementos que permite elementos duplicados e os elementos são armazenados em ordem sequencial. ### Adicionando Elementos Há várias formas de adicionar elementos a uma Lista Encadeada, como: - Usando o `add(E e)` método, que adiciona um novo elemento no fim da lista. - Usando o `addFirst(E e)` método, que adiciona um novo elemento no começo da lista. - Usando o `addLast(E e)` método, que adiciona um novo elemento no fim da lista. ### Removendo Elementos Há três métodos disponíveis para remover elementos da Lista Encadeada: - Usando o `remove(int index)` método, que remove o elemento no índice especificado. - Usando o `remove(Object o)` método, que remove a primeira ocorrência do elemento especificado na lista. - Usando o `removeFirst()` método, que remove o primeiro elemento da lista. - Usando o `removeLast()` método, que remove o último elemento da lista. ### Exemplo Aqui está um exemplo de adicionar e remover elementos usando a classe LinkedList em Java: ```java public class LinkedListDemo { public static void main(String[] args) { LinkedList<String> lista = new LinkedList<>(); // Adiciona elementos lista. add("B"); lista. add("A"); lista. add("C"); lista. add("C"); // elemento duplicado // Imprime a lista inicial System. out. println(lista); // [B, A, C, C] // Remove elemento no índice 2 lista. remove(2); System. out. println(lista); // [B, A, C] // Remove elemento duplicado "C" lista. remove("C"); System. out. println(lista); // [B, A] // Remove elemento "B" em primeira posição lista. removeFirst(); System. out. println(lista); // [A] } } ``` Com o entendimento da classe LinkedList, você pode realizar várias operações como adicionar, remover, pesquisar elementos e mais na lista para implementar estruturas de dados complexas de forma efetiva em suas aplicações. Para mais métodos disponíveis na hierarquia de interfaces da LinkedList, confira a documentação da API. Na próxima sessão, vamos discutir a classe importante chamada Set em Java. Fique atento! # Sorted Set em Java: Entendendo o Set com Ordem Natural O Sorted Set, também conhecido como TreeSet, é uma estrutura de dados versátil fornecida pelo framework Collections de Java. Se você estiver trabalhando com uma coleção de elementos em que a manutenção da ordem natural (ascendente) é importante, o Sorted Set pode ser a escolha certa para você. Este guia ajudará você a entender o conceito básico, propriedades e diferentes implementações do Sorted Set em Java. **Tabela de Conteúdos** 1. Pré-requisitos 2. Propriedades e Vantagens do Sorted Set 3. Implementações do Sorted Set 4. Criando e Manipulando um Sorted Set 5. Interfaces Comparable e Comparator 6. Uso de Exemplo 7. Comparação com HashSet ## Pré-requisitos - Uma compreensão básica de conceitos de programação em Java - Familiariidade com interfaces de coleção (e. g. , Collection, List, Map) - Uma compreensão sobre a diferença entre Comparable e Comparator ## Propriedades e Vantagens do Sorted Set - Os elementos são automaticamente ordenados e armazenados de forma única em ordem crescente de acordo com sua sequência de ordem natural, i. e. , `a < b < c` - Por padrão, objetos `String`, `Integer`, `Float`, `Double` são ordenados usando sua ordem natural - Se você utilizar uma classe personalizada como o tipo da coleção de entrada, você deve fornecer implementações de Comparable e Comparator para informar a Java sobre a lógica de ordenação, o que abordaremos em detalhes mais tarde ## Implementações do Sorted Set Existem principalmente três implementações do Sorted Set em Java: - `TreeSet`: implementa a interface NavigableSet e oferece mais métodos para consultas de intervalo - `LinkedHashSet`: uma combinação das propriedades de Set e LinkedList, mantém a ordem de inserção - `HashSet`: desordenado e não mantém a ordem de inserção, útil quando a performance é prioridade ## Criando e Manipulando um Sorted Set Aqui está um exemplo simples demonstrando a criação e manipulação de um Sorted Set: ```java import java. util. SortedSet; import java. util. TreeSet; public class SortedSetDemo { public static void main(String[] args) { SortedSet<String> ss = new TreeSet<>(); ss. add("C"); ss. add("B"); ss. add("A"); for (String s : ss) { System. out. print(s + " "); } } } ``` Saída: `ABC` A ordem natural dos elementos (`a < b < c`) é automaticamente mantida pelo Sorted Set. ## Comparable e Comparator Interfaces - Quando usar uma classe personalizada como o tipo da coleção de entrada, você deve implementar a interface Comparable ou Comparator para notificar a Java como comparar e ordenar os elementos - Por padrão, as classes String e númericas (String, Integer, Float, Double) implementam a interface Comparable ## Uso de Exemplo com Classe Personalizada Nos próximos tópicos, exploraremos exemplos de uso com classes personalizadas e abordaremos mais detalhadamente as interfaces Comparable e Comparator. ## Comparação com HashSet Em contraste com um HashSet, onde a ordem dos elementos pode variar ao iterar pela coleção, os elementos em um TreeSet são sempre ordenados e mantêm a ordem de inserção ao usar LinkedHashSet. Além disso, se você precisar de um HashSet seguro para threads, considere usar o Hashtable em vez disso. # Demonstração de Hash Map em Java Este exemplo mostra uma implementação simples de um Hash Map em Java. ```java # Método principal No método principal, inicializamos o hash map, criamos seu par de chave-valor e demonstramos seu uso. ``` ```java // Importando pacotes necessários import java. util. HashMap; // Método principal public class HashMapDemo { public static void main(String[] args) { // Inicializando o HashMap HashMap<String, Integer> map = new HashMap<>(); // Aqui, os généricos <String, Integer> já estão definidos, então não precisamos especificá-los novamente. // Nomeie o map ("map" para simplicidade) // Especifique o tamanho ou omita isso conforme necessário com base em requisitos de memória e do programa. // Adicionando elementos/entradas ao mapa // O método para adicionar entradas é `put` // Sintaxe: map. put(chave, valor) // Aqui, adicionamos três entradas/elementos map. put("A", 10); map. put("B", 20); map. put("C", 30); // Demonstra o tamanho do mapa System. out. println("Tamanho do mapa: " + map. size()); // Imprime o mapa System. out. println("Mapa: " + map); // Métodos e exemplos adicionais não mostrados aqui para evitar confusão. } } ``` Pode observar como o mapa é ordenado quando é impresso. Isso ocorre porque as chaves são inteiros, e o Java ordena as entradas em ordem crescente de forma natural. --- Para o exemplo do TreeMap: ```java # Título: Tree Map em Java Este exemplo mostra uma implementação simples de um Tree Map em Java. ``` ```java // Importando pacotes necessários import java. util. TreeMap; // Método principal public class TreeMapDemo { public static void main(String[] args) { // Inicializando o TreeMap TreeMap<Integer, String> treeMap = new TreeMap<>(); // Adicionando elementos/entradas ao mapa // O método para adicionar entradas é `put` // Sintaxe: treeMap. put(chave, valor) // Aqui, adicionamos três entradas/elementos treeMap. put(3, "A"); treeMap. put(2, "B"); treeMap. put(1, "C"); // Imprime o mapa ordenado System. out. println("Tree Map: " + treeMap); // Métodos e exemplos adicionais não mostrados aqui para evitar confusão. } } ``` Pode verificar neste exemplo que, desde as chaves são inteiros, o TreeMap ordena as entradas de forma natural em ordem crescente. --- Nos exemplos de HashMap e TreeMap, as chaves e valores são definidas como Strings e Inteiros para demonstrar o comportamento de ordenação e compatibilidade. No entanto, você pode substituí-los por seus tipos preferidos de acordo com os requisitos do seu programa. # Árvores de Recursão e Pilhas em Java ## Árvores de Recursão Uma árvore de recursão, ou tree map, é uma estrutura de dados semelhante ao mapa que mantém os elementos ordenados de acordo com o seu valor. A sequência de representação dos elementos não mudará, independentemente de quanto você execute o programa. Você pode realizar comportamentos semelhantes aos mapas, como por exemplo trocar a chave de `String` para `Integer` e vice-versa. A hierarquia dos nomes dos atributos é mostrada abaixo: ``` TreeMap<String, Integer> treeMap = new TreeMap<>(); ``` Inserir valores de exemplo para demonstrar o comportamento do tree map: ``` treeMap. put("B", 2); treeMap. put("C", 1); treeMap. put("A", 3); ``` Salve o arquivo e execute para ver a estrutura da árvore: ``` B C A ``` Dado a ordem natural de ordenação dos strings no Java, os elementos serão ordenados automaticamente na ordem: `a até z`. Para saber mais sobre os métodos disponíveis para remover elementos e outras funcionalidades, entre em contato com a documentação da API `TreeMap`. ## Pilhas em Java Uma pilha é uma estrutura de dados baseada em lista, com uma representação LIFO (push later pop first). Você usará uma pilha em cenários em que precise manter uma representação de objetos LIFO. ```java import java. util. Stack; public class StackDemo { public static void main(String[] args) { // Inicializando uma pilha com string Stack<String> stack = new Stack<String>(); // Adicionando elementos stack. push("América"); stack. push("Alemanha"); stack. push("Índia"); // Imprimindo a pilha System. out. println(stack); // Retirando os elementos da pilha String poppedElement = stack. pop(); System. out. println("Elemento removido: " + poppedElement); System. out. println(stack); } } ``` Como resultado, você obterá o seguinte: ``` [América, Alemanha, Índia] Elemento removido: Índia [América, Alemanha] ``` Também existe uma função `peek()` para exibir o elemento mais recente da pilha, sem removê-lo. # Recursos e Filas em Java Nesta sessão, discutiremos os recursos das pilhas e filas em Java, com ênfase em uma demonstração prática de filas. Vamos começar discutindo sobre pilhas. Uma pilha segue a filosofia Last In First Out (LIFO), o que significa que o elemento mais recentemente inserido é o primeiro a ser removido. Em contraste, uma fila segue a filosofia First In First Out (FIFO), onde o primeiro elemento inserido é o primeiro a ser removido. ## Pilhas Aqui, tinha uma pilha com a India como o elemento mais alto, Alemanha no meio e América no fundo. Depois de remover o elemento mais alto (India), a pilha foi modificada, ficando com apenas dois elementos (Alemanha e América) restantes. A linha 22, chamamos o método `Peak` para obter o elemento mais alto, e a linha 23, imprimimos a pilha para ver se o método `Peak` removeu o elemento mais alto ou simplesmente o retornou sem removê-lo, como faria o método `pop`. Se chamarmos o método `Peak` nesta pilha, obtemos Alemanha, mas se imprimirmos a pilha novamente, podemos ver que a Alemanha permanece porque o método `Peak` apenas retorna o elemento mais alto, não removendo-o, como faria o método `pop`. Agora, vamos avançar para as filas. As filas foram inspiradas em filas reais, nas quais as pessoas se agrupam em linha para concluir tarefas. Em uma fila, os elementos são organizados de acordo com o princípio FIFO. Voltando atrás ao capitulo anterior no qual discutimos pilhas, as pilhas são uma estrutura de Árvore, enquanto as filas são uma estrutura de Ramificação. ## Filas Em uma fila, a estrutura de Ramificação, o primeiro elemento que entra é o primeiro que sai, o que contrasta com uma estrutura de Árvore, onde o último elemento inserido é o primeiro a sair. Lembre-se que se você tem uma situação em seu projeto em que o elemento que entra na coleção deve ser o primeiro a sair, você deve usar uma fila. No entanto, se tiver uma estrutura em que o elemento mais recente inserido deve ser o primeiro a sair, use uma pilha. A interface de fila é uma interface, similar às pilhas, e existem diversas implementações dela, uma das mais populares sendo a classe PriorityQueue. A classe PriorityQueue é uma fila que funciona de acordo com o conceito de FIFO, mas também considerando a prioridade dos elementos. Você pode atribuir uma prioridade aos elementos, e o elemento com maior prioridade sairá da coleção mais rapidamente. Agora, vamos olhar um exemplo prático de uma fila prioritária em Java: ```java public class QueueDemo { public static void main(String[] args) { PriorityQueue<String> q = new PriorityQueue<>(); // Criando uma fila prioritária que pode apenas manter objetos de cadeiastring q. add("India"); q. add("Germany"); q. add("America"); System. out. println("Fila original: " + q); // Imprimindo a fila para verificar se os elementos foram acrescentados na ordem correta esperada // . . . (Mais código omitido para brevidade) } } ``` Neste exemplo, criamos uma fila prioritária de cadeias de caracteres, acrescentamos alguns elementos e imprimimos a fila. Ao imprimir a fila, você observará que fica desorganizada devido ao método toString() padrão chamado quando se imprime a fila. No entanto, uma vez que usamos métodos como `add`, `remove`, ou `Peak`, os elementos serão retornados na ordem natural. # Caso Especial de Filas Este tutorial abordará um caso especial para filas, especificamente quando a fila possui apenas um elemento restante. Além disso, discutiremos classes e objetos em Java, utilizando o exemplo de um sistema de gerenciamento de alunos para entender a ideia de classes e objetos e seus atributos (propriedades) e comportamentos (métodos) em Java. ## Filas No caso especial, se a fila possui apenas um elemento restante, esse elemento servinge como tanto a cabeça quanto a cola da fila. ``` Se a fila possui apenas um elemento restante, esse elemento será tanto a cabeça quanto a cola. Isso é um caso especial a ser considerado ao utilizar filas. ``` Para obter mais informações sobre filas e filas prioritárias, consulte as docs API do Java ou a interface de fila e as classes de fila prioritárias. Aproveite-se com todos os diferentes métodos disponíveis nas classes para melhor utilizar o quando trabalhando com estes tipos de coleção. ### Métodos Automáticos de Exibição Muitos IDEs mostram todos os métodos disponíveis em uma classe ao usar a notação de ponto (. ); isso pode ajudá-lo a encontrar e entender o que cada método faz. ## Classes e Objetos em Java Uma classe é um molde para um objeto, atuando como uma entidade lógica que pode ser pensada como qualquer entidade no mundo real. Entidades têm duas especificações chave: atributos e comportamentos. 1. Atributos: Exemplos de atributos em seres humanos são mãos, olhos, orelhas e pernas; esses são os atributos que constituem a entidade humana. 2. Comportamentos: As ações ou comportamentos podem ser pensadas como a habilidade de um ser humano falar, ouvir ou andar. Essas ações são comportamentos que podem ser representados em um programa Java. Identificando essas entidades, os atores da vida real podem ser mapeados para classes Java, permitindo a criação de um programa Java que represente essas entidades. Java impõe essa forma de pensar exigindo que se encontrem entidades que possuem atributos e comportamentos. ### Exemplo: Classe de Aluno Para um sistema de gerenciamento de alunos, o aluno é uma das entidades principais que serão importantes ao momento de se tomar os requisitos. A entidade do aluno tem vários atributos, como o nome, idade e endereço, bem como comportamentos como matricular-se em cursos, frequentar aulas, tomar férias e provar exames. Aqui está um exemplo de classe de aluno: ```java public class Student { private String name; private int age; private String address; // Setters and Getters methods for each property // . . . public Student(String name, int age, String address) { this. name = name; this. age = age; this. address = address; } // . . . } ``` A classe de aluno inclui propriedades para nome, idade e endereço, bem como um construtor para inicializar o objeto da classe com os valores especificados. Este construtor é chamado sempre que é criado um objeto Novo Student. # Criando um Objeto de Aluno em Java Este tutorial aborda os aspectos básicos da criação de um objeto de aluno em Java, incluindo o uso de construtores e getters e setters. ## Inicialização de um Objeto de Aluno Para criar um objeto de aluno, você deve seguir estes passos: 1. Identificar as propriedades e comportamentos (getters e setters) para a classe de aluno. 2. Escreva um construtor que inicialize as propriedades obrigatórias com base nos argumentos fornecidos. 3. Instancie a classe para criar o objeto de aluno. 4. Use os getters para acessar as propriedades do objeto. ### Uso do Construtor Na classe de aluno, temos um construtor que recebe três parâmetros: name, age e address. Esses parâmetros devem corresponder aos parâmetros disponíveis na classe. ```java // Criando um objeto de Aluno Student john = new Student("John", 25, "123 Main Street"); ``` Se os argumentos fornecidos não corresponderem a nenhum construtor, o Java enviará uma mensagem de erro e o código não será compilado. Por exemplo, fornecer quatro argumentos para a classe de aluno sem nenhum construtor que correspondente a quatro argumentos causará um erro. ```java // Isto causará um erro pois não há nenhum construtor com quatro argumentos Student jane = new Student("John", 25, "123 Main Street", "456 Oak Street"); ``` ### Uso de Getters e Setters Depois de criar o objeto de aluno, você pode usar os getters para acessar as propriedades do objeto. Por exemplo: ```java // Acessando as propriedades do objeto de aluno System. out. println(john. getName()); // John System. out. println(john. getAge()); // 25 System. out. println(john. getAddress()); // 123 Main Street ``` Você também pode usar os setters para modificar os valores das propriedades. ## Mais Sobre Construtores No próximo módulo, vamos abordar mais profundamente o conceito de construtores e como escrever diferentes tipos de construtores em Java. as expectativas! ### Múltiplos Construtores Em certas circunstâncias, você poderá ter um caso em que algumas propriedades são obrigatórias, enquanto outras são opcionais. Nessas circunstâncias, pode escribir vários construtores para responder a diferentes necessidades. Suponha que temos uma classe de Cubo com as propriedades width, height e depth. Poderíamos criar diferentes construtores para cenários em que algumas propriedades são obrigatória enquanto outras são opcionais. Aqui está um exemplo de uma classe simples de Cubo com vários construtores. ```java public class Cubo { private int width; private int height; private int depth; // Construtor com todos os parâmetros public Cubo(int width, int height, int depth) { this. width = width; this. height = height; this. depth = depth; } // Construtor com width e height, mantendo o depth constante public Cubo(int width, int height, int defaultDepth) { this. width = width; this. height = height; this. depth = defaultDepth; } // Construtor com um parâmetro, estabelecendo width, height e depth como o valor fornecido public Cubo(int value) { this. width = value; this. height = value; this. depth = value; } // Construtor sem parâmetros, estabelecendo valores default public Cubo() { this. width = 10; this. height = 10; this. depth = 10; } // Calcule o volume do cubo public double calculateVolume() { return width * height * depth; } // Getters e Setters para cada propriedade // . . . } ``` Agora, você pode criar objetos diferentes de cubo com base nos construtores disponíveis. ```java // Criando objetos de cubo com diferentes construtores Cubo cuboPadrão = new Cubo(5, 5, 5); Cubo cuboComDefaultDepth = new Cubo(3, 4, 10); Cubo cuboComUMValor = new Cubo(7); Cubo cuboSemValores = new Cubo(); ``` # Calculando o Volume de Cubos Padrão Usando Construtores e Métodos Essa classe demonstra quatro tipos diferentes de chamadas de construtor para uma classe `Cuboid`, mostrando cenários de uso diferentes dos construtores. Vamos tomar um olhar mais aprofundado no código abaixo: ```markdown ## Cubo Padrão de Invocação do Construtor Neste primeiro caso de uso, o construtor é chamado com três argumentos (amplitude, altura e profundidade) e o volume é calculado e impresso. uso case 1: Três argumentos fornecidos ================ CuboPadrao cubo1 = new CuboPadrao(10, 20, 15); int volume = cubo1. calcularVolume(); System. out. println("O valor do cubo com dimensões 10 x 20 x 15 é: " + volume + " unidades cúbicas. "); ## Cubo com Profundidade Padrão Neste segundo caso de uso, o construtor é chamado com dois argumentos (amplitude e altura), e a profundidade é automaticamente definida como 10. O volume é então calculado e impresso. uso case 2: Dois argumentos fornecidos com profundidade padrão ======================================= CuboPadrao cubo2 = new CuboPadrao(10, 20); int volume = cubo2. calcularVolume(); System. out. println("O valor do cubo com dimensões 10 x 20 x 10 é: " + volume + " unidades cúbicas. "); ## Cubo com Profundidade Padrão - O Cubo Neste terceiro caso de uso, o construtor é chamado com um único argumento (todas as dimensões são definidas como o valor fornecido, criando um cubo). O volume é então calculado e impresso. uso case 3: Um argumento fornecido - cria um cubo ===================================== CuboPadrao cubo = new CuboPadrao(10); int volume = cubo. calcularVolume(); System. out. println("O valor do cubo com uma dimensão de 10 unidades em todos os lados é: " + volume + " unidades cúbicas. "); ## Cubo Padrão Neste quarto e final caso de uso, o construtor é chamado sem nenhum argumento, criando um cubo vazio. Os valores padrão para amplitude, altura e profundidade são definidos, e o volume é então calculado e impresso. uso case 4: Sem argumentos fornecidos – cubo padrão ======================================= CuboPadrao cuboPadrao = new CuboPadrao(); int volume = cuboPadrao. calcularVolume(); System. out. println("O valor do cubo padrão, com dimensões de 0 x 0 x 0, é: " + volume + " unidades cúbicas. "); ``` As anotações sobre construtores padrão e comportamento do Java são adicionadas ao código: ```markdown ## Construtor Padrão em Java Se nenhum construtor for fornecido para uma classe em Java, o Java providenciará automaticamente um sem parâmetros. Esse comportamento é demonstrado abaixo. Construtor Padrão em Java ========================= CuboPadrao cuboSemArgs = new CuboPadrao(); // Java providenciará automaticamente um construtor sem parâmetros ``` A seguir é apresentado o código para entender o conceito de fluxos em Java: ```markdown # Fluxos de Java Esta seção discute o conceito de fluxos em Java, introduzido em Java 8, que lhe leva a melhores e otimizadas maneiras de manusear coleções. A principal foco é o uso da API de fluxos para calcular as potências de cada elemento na lista. ## Aproximação Tradicional Usando uma aproximação tradicional, você escreveria o código para criar uma lista, calcular potências de seus elementos e gravá-las em outra lista. A seguir estão exemplos antes dos fluxos: Aproximação Tradicional ==================== List<Integer> numeros = Arrays. asList(10, 20, 30, 40); List<Integer> potencias = new ArrayList<>(); for (Integer numero : numeros) { potencias. add(numero * numero); } ## Usando Java Streams O mesmo trabalho pode ser realizado usando Java Streams, demonstrando um padrão de uso e óptimo desempenho: Usando Java Streams ================== List<Integer> numeros = Arrays. asList(10, 20, 30, 40); List<Integer> potencias = numeros. stream(). map(n -> n * n). collect(Collectors. toList()); ``` Esse exemplo mostra uma maneira mais eficiente e fácil de ler de se trabalhar com coleções usando Java Streams, em conformidade com o paradigma de programação funcional. # Stream API em Java Este tutorial aborda o uso da API Stream em Java, com ênfase nos métodos map e collect, assim como a diferença entre operações intermediárias e terminais. ## Visão Geral da API Stream A API Stream fornece uma série de métodos inspirados na programação funcional que operam em uma sequência de elementos. Essa API veio com Java 8. ### Método Map O método `map` é utilizado para transformar cada elemento em uma sequência de entrada em um elemento correspondente em uma sequência de saída do mesmo tipo. Neste caso, utilizaremos o método `map` para transformar os elementos de entrada em suas potências quadradas. ``` stream. map( x -> x * x ); ``` ### Funções Lambda A sintaxe utilizada para o método `map` é baseada em Funções Lambda, que são funções anônimas que podem ser utilizadas para encapsular a lógica necessária para transformar os elementos na sequência. As Funções Lambda foram introduzidas em Java 8 e fornecem uma forma simples de definir construtos funcionais. ``` stream. map( x -> x * x ); ``` No exemplo acima, `x -> x * x` representa a Função Lambda que recebe um argumento (`x`) e retorna a sua potência quadrada. ### Método Collect O método `collect` é uma operação terminal que coleta todos os elementos na sequência em uma estrutura contendo dados, como uma lista, conjunto ou um `Collector` personalizado. Aqui, utilizaremos o método `Collectors. toList()` para converter o resultado do fluxo em uma lista. ``` List<Integer> listaQuadrada = stream. map( x -> x * x ). collect(Collectors. toList()); ``` ## Exemplo: Transformar uma Lista em uma Lista Quadrada Antes de utilizar a API Stream, você transformaria os elementos na lista iteração por ela e calculando as potências quadradas manualmente. Neste exemplo, convertemos uma lista de números em uma lista de seus quadrados utilizando a API Stream. ```java List<Integer> números = Arrays. asList(10, 20, 30, 40); List<Integer> listaQuadrada = números. stream() . map( x -> x * x ) . collect(Collectors. toList()); System. out. println(listaQuadrada); // Saída: [100, 400, 900, 1600] ``` ## Operações Intermediárias e Terminais A API Stream distingue entre operações **intermediárias** e **terminais**: - Operações intermediárias produzem uma nova stream e podem ser encadeadas. - Operações terminais não produzem uma nova stream e indicam o fim da pipeline. Um erro comum é utilizar uma operação terminal depois de uma operação intermediária. Nesses casos, você encotrará exceções estranhas. Por exemplo, o método `map` é uma operação intermediária, enquanto o método `collect` é uma operação terminal. Você pode encadear várias operações intermediárias (como `map` e `filter`) antes de chamar o método `collect`. Ao chamar o método `collect`, o fluxo é finalizado (terminal), e nenhum outro operação pode ser realizada nele. ## Referências - [Tutorial de APIs Stream Java 8](https://www.baeldung.com/java-8-streams) - [Tutorial de Expressões Lambda](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html) - [Classe Collectors](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/stream/Collectors.html) Formatação: Sera mantida a formatação Markdown, preservando todos os elementos (# ** ` [] () etc. ) e a estrutura de títulos e seções. Blocos de código serão preservados sem tradução. Tradução: Sera utilizado português europeu (não brasileiro) e mantidos termos técnicos em inglês. Comandos e códigos serão mantidos inalterados e URLs serão preservadas intactas. O texto traduzido com a formatação original (incluindo Markdown) é o seguinte: ```markdown # Usando a API de fluxos para filtrar e ordenar coleções ## Filtrando Coleções Neste exemplo mostraremos como utilizar o método `filter` da API de fluxos para aplicar lógica de filtro em uma coleção. O código demonstra como filtrar uma lista com base em uma condição (neste caso, elementos que começam com a letra "P"). ``` ```java // Define a coleção original List<String> idiomas = Arrays. asList("Java", "Python", "Scala", "Basic"); // Utilize o método de fluxos `filter` para filtrar elementos com base em uma condição List<String> listaFiltrada = idiomas. stream() . filter(s -> s. startsWith("P")) . collect(Collectors. toList()); // Imprima o resultado filtrado System. out. println(listaFiltrada); ``` **Saída: ** ``` [Python, Programa] ``` ### Vantagens da utilização da API de fluxos - Integração suave da lógica de filtro em uma linha de código - Utilização eficiente de processadores multicore ## Ordenando Coleções Nesta seção mostraremos que é possível utilizar o método `sorted` da API de fluxos para ordenar uma coleção em ordem natural. ```java // Define a coleção original List<String> idiomas = Arrays. asList("Java", "Python", "Scala", "Basic", "Basic1", "Basic2", "Basic3"); // Ordene os elementos da lista utilizando o método `sorted` List<String> listaOrdenada = idiomas. stream() . sorted() . collect(Collectors. toList()); // Imprima o resultado ordenado System. out. println(listaOrdenada); ``` **Saída: ** ``` [Basic, Basic1, Basic2, Basic3, Java, Python, Scala] ``` ## Iterando sobre Coleções A API de fluxos fornece um mecanismo de iteração através do método `forEach`, permitindo uma iteração sobre coleções em uma única linha de código. ```java // Itere sobre a coleção utilizando o método `forEach` idiomas. stream(). forEach(System. out: : println); ``` **Saída: ** ``` Java Python Scala Basic Basic1 Basic2 Basic3 ``` ## Reduzindo Coleções Nesta sessão discutiremos a funcionalidade `reduce` da API de fluxos, que permite reduzir uma coleção a um único resultado. ```markdown # Futuros Tópicos - Reduzindo Coleções - Mais funcionalidades da API de fluxos ``` # Reduce Método na API de Streams O **reduce** método é usado para acumular o conteúdo de um fluxo em um único resultado em casos em que deseja um único resultado. Aqui está uma explicação correta e formatada do método reduce e de sua utilização. ```markdown Para a representação completa de uma coleção em um único resultado, utilizará-se o método `reduce` da API Streams. Se aplicar esta definição ao exemplo que lhe dei, tenho uma coleção de números, e eu quero calcular a soma de todos os elementos desta coleção, que é um único resultado, um único número. Portanto, sim, meu exemplo se aplica corretamente à definição geral do método `reduce`. Lembrar-se desta definição geral; ajudará-o a entender quando usar o método reduce no seu programa. ## Como funciona o método reduce? Você pode ver que viu um exemplo de sintaxe do método `reduce`, e parece não muito simples, então vamos tentar entender o que está acontecendo aqui para entender a funcionalidade do método `reduce`. Tem que entender três termos: identidade, acumulador e combinador (opcional). ### Identity A identidade é o valor default ou inicial da operação de redução. Este valor será usado se o fluxo próprio estiver vazio ou será usado como o primeiro valor do resultado que você quer obter eventualmente. Por isso, se tiver de enviar todos os elementos de uma coleção, o valor inicial pode ser definido como `0`, e é o primeiro coisa que você tem de passar dentro do método `reduce`, então pode ver aqui `0`. ### Acumulador O acumulador é uma função que vai receber dois parâmetros. O primeiro parâmetro iria ser o resultado atual parcial (digamos que você tem que calcular a soma de todos os elementos e digamos que já iterou dois elementos porém, então o resultado temporário ou parcial irá ser a sua variável atual, e esta será a primeira argumento do método Accumulator. Neste caso, é esta variável que é abreviada como `A` e `S` (resposta). Portanto, o primeiro argumento é o resultado parcial, e o segundo argumento do método acumulador é o próximo elemento do fluxo. Qualquer o próximo elemento que é suposto ser adicionado ao resultado existente será a próxima argumento do método acumulador, que neste caso seria `I`. ### Combinador (opcional) O combinador é uma função opcional que requer que use se quiser somar dois elementos que não têm o mesmo tipo de dados. Por exemplo, neste caso, `ANS` ou resposta e `I` ambos são inteiros. Se ambos os argumentos do seu método acumulador tiverem o mesmo tipo de dados, não precisará-se de um combinador, e é por isso que não tem combinador aqui. Mas se tiver uma situação em que você está, por exemplo, a adicionar um objeto estudante a uma soma, não é possível, porque um objeto estudante é um objeto personalizado, e o resultante atual é um objeto de número. Por caso, `Student` não pode ser adicionado a um `number` objeto. Pode funcionar se realizar o `student. getAge()`, que é um objeto de número, então `currentAnswer + student. getAge()` pode funcionar, mas `currentAnswer + student` não funcionará nas situações em que houve incompatibilidade de tipos de dados, nessas situações será necessária uma função combinador. Neste caso, não terá que escrever uma função combinador because both of the elements or the arguments of the accumulator function are of the same data type, então escreve-se assim: ```markdown accumulator. accept(acumulatorArgument1, accumulatorArgument2) ``` Esta é a implementação e, novamente, usando um construtor lambda. Portanto, dará a implementação desta função particular do acumulador e então há nenhum combinador aqui. Porque ambas as funções lá fora são de um tipo de dados diferente, será necessário um comparador que fará essa conversão. Se tiver combinador, há um primeiro argumento e então escreverá a função combinador lá fora onde irá fazer essa conversão. ## Exemplo ```java List<Integer> numbers = Arrays. asList(10, 20, 30, 40); Optional<Integer> sum = numbers. stream(). reduce(0, (partialResult, number) -> partialResult + number); // Saída: 100 ``` Neste exemplo, estamos calculando a soma de uma lista de inteiros. O valor inicial é `0`, e a função acumulador function simplesmente adiciona o elemento atual ao resultado parcial. Todos os elementos são inteiros, não precisando de uma função combinador. O resultado é armazenado no `sum` optional. Se você rodar este exemplo, terá a saída esperada de `100`, que é a soma de todos os números na lista. # Acessos em Java: Entendendo Público, Padrão, Protegido e Modificadores Privados Saiba sobre os acessos em Java e como eles afetam a visibilidade de uma classe ou método. Este tutorial aborda as diferenças entre modificadores públicos, padrão, protegidos e privados. ## Modificador Privado Um membro (método ou variável) privado pode ser acessado apenas dentro da classe na qual foi definido. Como você se move um pouco acima dos acessos, você verá que há apenas um "y" e três "n" na diagramas abaixo. Ao mover um leve um pouco acima para o modificador padrão, você obtém dois "y's", indicando que todos dentro da classe e pacote irão ser capazes de acessar o componente. ```java class Test { private void display() { // Seu código aqui } // Resto do código } ``` No exemplo acima, o método `display` é privado, significando que ele pode ser acessado apenas dentro da classe `Test`. ### Modificador Padrão Por padrão, se nenhum modificador for especificado, a classe ou membro terá o nível de acesso do pacote, significando que apenas classes dentro do mesmo pacote podem acessá-lo. Se você tentar acessar a classe em um pacote diferente, obterá um erro de compilação. ```java // Test. java arquivo é no pacote myPackage1 public class Test { // Outro código } // testDemo. java arquivo é em um pacote diferente myPackage2 import myPackage1. Test; public class TestDemo { public static void main(String[] args) { Test t = new Test(); // Erro de compilação } } ``` No exemplo acima, a classe de teste não é acessível na classe `TestDemo` do pacote diferente `myPackage2`. Para resolver isso, faça a classe Test pública: ```java // Test. java arquivo public class Test { // Outro código } ``` ### Modificador Público Quando você faz uma classe ou um método público, você pode acessá-los de qualquer lugar no programa. ```java // Test. java arquivo é público public class Test { // Outro código } public class TestDemo { public static void main(String[] args) { Test t = new Test(); } } ``` No exemplo acima, a classe `Test` agora é acessível na classe `TestDemo` de um pacote diferente. ### Modificador Protegido *O acesso protegido é semelhante ao privado e público, mas ele possui algumas restrições adicionais. Permite acesso dentro da classe, no seu pacote e nas classes filhas. * ```java // Test. java arquivo class Test { protected void display() { // Seu código aqui } // Resto do código } ``` No exemplo acima, o método `display` é protegido, significando que ele pode ser acessado dentro da classe `Test`, no seu pacote e nas classes filhas. ## Explorando Modificadores de Acesso com um Exemplo Vamos tomar um exemplo simples para entender a diferença entre os modificadores de acesso: ```java // Test. java arquivo public class Test { public void publicMethod() { // Seu código aqui } void defaultMethod() { // Seu código aqui } protected void protectedMethod() { // Seu código aqui } private void privateMethod() { // Seu código aqui } } ``` Agora, vamos criar uma classe `TestDemo` em um pacote diferente e tentar acessar cada método com seu respectivo nível de acesso. ```java // TestDemo. java arquivo public class TestDemo { public static void main(String[] args) { Test t = new Test(); // Você pode chamar os métodos públicos, padrão e protegidos t. publicMethod(); t. defaultMethod(); t. protectedMethod(); // Mas não os métodos privados, pois eles só são acessíveis dentro da classe Test } } ``` Este tutorial aborda apenas os modificadores de acesso em Java. Para obter informações adicionais, leia o [Documento Oficial da Oracle Java](https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html). Experimente-se com essas ideias para se sentir mais confortável com elas. # Bicicleta e Bicicleta de Montanha: Análise Conceitual Criei uma classe chamada `Bicycle`, que serve como uma classe base. Lá, defini aquilo que chamarei de propriedades `gear` e `speed`. Por enquanto, mantenhamos o uso do keyword `protected`, mas vamos voltar a este tópico mais tarde. Também incluí um construtor para inicializar a velocidade inicial e a empresa, bem como três métodos: `setGear`, `applyBrakes` e `speedUp`. Quando você aplica frenos, a velocidade será reduzida devido ao operador de unidade `-=`. Quando tenta acelerar, o operador de seu único operador `+=` incrementará a velocidade pelo valor fornecido no método. Agora, vamos entregar ao nosso relacionamento de herança na Java com a utilização da palavra-chave `extends`. Você cria uma propriedade adicional para a classe `MountainBike` pois pode ter uma propriedade adicional para ajustar a altura da cadeia. A classe `MountainBike`, ao herdar da classe `Bicycle`, também herda a responsabilidade de inicializar a classe base. Isso é feito chamando o construtor da classe base no seu construtor da classe, e em seguida invocando o construtor da superclasse usando a palavra-chave `super` e fornecendo os argumentos necessários. Aqui está o construtor da classe `MountainBike`: ```java class MountainBike extends Bicycle { private int startHeight; // propriedade local "altura inicial" para esta classe (a altura da cadeia) public MountainBike(int startHeight, int startSpeed, int startGear) { super(startSpeed, startGear); // invocar o construtor da superclasse chamando super() e fornecendo os argumentos this. startHeight = startHeight; } } ``` Agora, vamos testar esta classe criando uma classe `InheritanceDemo` com um método principal estático público. Inicialize a classe `MountainBike` com os parâmetros necessários e, em seguida, acesse suas propriedades e métodos: ```java public class InheritanceDemo { public static void main(String[] args) { MountainBike mountainBike = new MountainBike(20, 10, 1); // inicialize com os parâmetros necessários System. out. println("engrenagem: " + mountainBike. gear); System. out. println("altura da cadeia: " + mountainBike. startHeight); System. out. println("velocidade: " + mountainBike. speed); mountainBike. applyBrakes(1); System. out. println("velocidade da bicicleta após aplicar frenos: " + mountainBike. speed); } } ``` Agora, let's discuss the `protected` keyword no contexto do modificadores de acesso. Quando definimos algo como protegido, torna-se acessível nas classes filhas da classe base, como no exemplo acima onde deliberadamente fiz a propriedade `startHeight` privada, mas tornou-se acessível à classe `MountainBike` pois ela herda da classe `Bicycle`. Isso permite que a classe `MountainBike` acesse as propriedades e métodos da classe base sem dificuldades, sem qualquer diferenciação. # Getters e Setters em Java Esse artigo apresenta os Getters e Setters em Java. Um Getter é um método que permite que outras partes do código acessem propriedades de uma classe privadas. Os Getters começam com a palavra reservada `get` seguida do nome da propriedade sem formatação específica. Por exemplo: ``` public String getName() { return name; } ``` Este método retorna o valor da propriedade `name`. Um Setter é um método que permite que outras partes do código atuem sobre propriedades de uma classe privadas. Os Setters começam com a palavra reservada `set` seguida do nome da propriedade. Por exemplo: ``` public void setName(String name) { this. name = name; } ``` Por padrão em Java, todas as propriedades de uma classe são públicas. Entretanto, você pode privatizar propriedades para apenas fornecer acesso por meio de Getters e Setters. Por exemplo: ``` private String name; public String getName() { return name; } public void setName(String name) { this. name = name; } ``` ## Exibição e Ocultamento de Propriedades Tanto os Getters quanto os Setters permitem o exibição e o ocultamento de propriedades de uma classe. Por exemplo, se a classe `Student` possui uma propriedade privada `name`, você pode criar um Getter para retornar o nome do aluno. ``` private String name; public String getName() { return name; } ``` Em seguida, outras partes do código podem usar o Getter para acessar o nome do aluno: ``` Student student = new Student(); student. setName("John Doe"); String name = student. getName(); ``` Você também pode privatizar uma propriedade e fornecer um Setter que limita o compartilhamento do valor. Por exemplo, se você não quer que o nome do aluno seja alterado após a criação do objeto `Student`, você pode privatizar a propriedade e apenas fornecer um Getter. ``` private String name; public String getName() { return name; } // Não é possível criar um melhor Setter neste caso ``` Outras partes do código não conseguem alterar o valor da propriedade `name` por meio da chamada ao método `setName` pois este não existe. Neste caso, o nome do aluno é mantido privado e é apenas possível acessar através do Getter. ## Gerando Getters e Setters com um Ambiente de Desenvolvimento Integrado (IDE) Criar Getters e Setters pode ser uma tarefa demorada, especialmente se o seu código possuir muitas propriedades. Entretanto, algumas IDEs (ambientes de desenvolvimento integrado) permitem a automação da geração de Getters e Setters. No Eclipse, Por exemplo, é possível gerar Getters e Setters clicando com o botão direito do mouse no nome de uma propriedade e selecionando a opção `Source > Generate Getters and Setters`. A IDE irá gerar automaticamente os métodos conforme suas configurações e as propriedades selecionadas. ## Referências - [Java Docs - Getters e Setters](https://docs.oracle.com/javase/tutorial/java/javaOO/getset.html) Documentação: Heredança e Abstração em Java - Parte 2 -------------------------------------------------------- Uma das coisas que também faço é fornecer outra classe filha porque poderá haver vários filhos de um determinado pai. O retângulo também estende de um objeto gráfico e fornece sua própria implementação de desenhar e resize, porque, geralmente, como você desenhara um retângulo e você redimensionará um retângulo são diferentes que desenharam ou redimensionar uma circunferência. Abaixo, eu não estou fazendo nenhuma coisa nos métodos, porque isso é apenas para demonstrar o conceito; eu apenas estou printando "Executando" indo "Executando o círculo" e redimensionando "Redimensionando um círculo" na classe de círculo, e em "Executando o retângulo" e redimensionando "Redimensionando um retângulo" na classe de retângulo. **Uma Classe-pai abstrata é o `ObjectoGráfico`**. Duas subclasses são **`Circulo`** e **`Retangulo`**; ambas fornecendo a implementação das métodos abstratos declarados na classe-base. Agora vamos para o método main, onde definei o `public static void main(String[] args)` e mostra-você, neste, eu criei dois blocos de código diferentes. O primeiro bloco é onde digo `ObjectoGráfico referência = ObjectoGráfico; ` e "inicializa" a classe de referência do objeto gráfico chamando-o "Circulo"; inicializa-se uma instância do objeto de círculo abaixo. Você pode perceber aqui a diferença entre a classe abstrata e a classe concreta: o que está à direita da associação é o tipo de objeto que será capturado. Se criar uma instância do objeto do círculo e depois se chamar a função "draw" e "resize" estas funções serão chamadas da classe "Circulo", se inicializar um novo retângulo com a referência do objeto gráfico e chamá-los "draw" e "resize", as funções serão chamadas da classe "Retangulo" - isso é o como você definirá a inicialização de uma classe que se baseia na classe abstrata. Por isso você chamou um "ObjectoGráfico" como **`Circulo`** instanciada e chamei "circulo. draw()" e "circulo. resize()". Dê um outro exemplo chamando um "retângulo" como uma referência gráfica que é uma **`Retangulo`** inicializada abaixo e chamando "retangulo. draw()" e "retangulo. resize()". Executá-lo esta aplicação e observar a saída - quando eu inicializo esse bloco de código de classe de objeto de círculo então "executando o círculo" é exibido junto com "Redimensionando um círculo"; quando eu criar a instância da classe de objeto de retângulo e chamá-las "retangulo. draw()" e "retangulo. resize()", é impresso "desenhando o retângulo" seguido de "Redimensionando um retângulo" - neste exemplo, estamos usando a abstração. Outra coisa interessante que você deveria observar aqui é que removi o `System. out` no construtor da classe-mãe abstracta, lembrando que as classes abstratas não podem ser instantaneas por si só e, se houver um construtor implícito, você não poderá chamá-lo - se tentar, o sistema lhe fará uma notificação; no entanto, quando usamos o exemplo de referência do gráfico a partir de cada classe filha, a própria função construtora da classe-mãe é implicitamente chamada, para que acessemos os métodos de inicialização dos objetos. # Entendendo Interfaces e Classes Abstratas em Java As interfaces e classes abstratas são dois conceitos importantes em Java que ajudam a criar código flexível e reutilizável. ## Interfaces As interfaces são usadas para contratos ou especificações. Eles não contêm implementações concretas, mas sim fornecem um modelo para que as classes possam seguir. Aqui está um exemplo de uma interface simples semelhante ao fornecido: ```markdown interface Bicicleta { void frear(); void acelerar(); } ``` Uma classe pode implementar esta interface e fornecer a implementação para os métodos: ```markdown class BicicletaMontanhista implements Bicicleta { private int alturaAssento, marcha, velocidade; // Construtor, getters, e setters omitidos para brevidade @Override public void frear() { // Implementação de frear() aqui } @Override public void acelerar() { // Implementação de acelerar() aqui } } ``` Se uma classe implementar uma interface e os métodos da classe base não forem implementados, o Java irá lançar um erro, pedindo para adicionar as implementações não implementadas ou para tornar a classe abstrata. ## Classes Abstratas As classes abstratas, por outro lado, podem ter comportamento concreto além de métodos abstratos. Eles servem como classes incompletas que não podem ser instanciadas e são destinadas a serem subclassadas: ```markdown abstract class BicicletaBase { public void frear() { // Implementação concreta de frear() aqui } public void acelerar() { // Implementação concreta de acelerar() aqui } // Outros métodos omitidos para brevidade } ``` Uma subclasse pode herdar os métodos de uma classe abstrata e fornecer sua própria implementação: ```markdown class BicicletaMontanhista extends BicicletaBase implements Bicicleta { // Construtor, getters, e setters omitidos para brevidade @Override public void frear() { // Sobrescrevendo frear() da classe base e da interface } @Override public void acelerar() { // Sobrescrevendo acelerar() da classe base e da interface } } ``` Em resumo, as principais diferenças entre interfaces e classes abstratas são: 1. As classes abstratas podem ter comportamento concreto, enquanto as interfaces não. 2. Uma classe pode apenas estender uma classe abstrata, mas pode implementar múltiplas interfaces. 3. As classes abstratas podem ser instanciadas, enquanto as interfaces não podem. ## Programa de Exemplo Aqui está um exemplo de um programa completo que demonstra o uso de interfaces e classes abstratas com herança: ```markdown interface Bicicleta { void frear(); void acelerar(); } abstract class BicicletaBase { // Construtor e propriedades omitidos public void frear() { // Implementação de frear() } public void acelerar() { // Implementação de acelerar() } } class BicicletaMontanhista extends BicicletaBase implements Bicicleta { private int alturaAssento, marcha, velocidade; public BicicletaMontanhista() { // Construtor vazio } // Getters e setters omitidos @Override public void fre # Acessar e dirigir uma Interface de Veículo em Java (Português de Portugal) Agora posso aceder e dirigir um veículo, com a implementação/declaração do método `canDrive` na interface `Vehicle`. Se eu procurar o método de dois rodas, posso ver o mesmo? Vamos ver se posso. Sim, e este é o método do dois rodas da classe: ```java // Esta é a classe do dois rodas public class TwoWheeler { // O método diz "pode girar dois rodas" public void canRotateTwoWheels() { System. out. println("Dois rodas podem girar. "); } } ``` Posso chamar este método específico, que vem da `classe TwoWheeler`. Posso também chamar o método declarado na classe `Vehicle`, o qual foi `canDrive`. Isso é possível porque uma bicicleta de montanha ciza a interface `Vehicle`: ```java // Esta é a classe da bicicleta de montanha public class MountainBike extends Vehicle { // Inicialização da bicicleta de montanha e impressão de valores public void initialize() { System. out. println("Engrenagem: " + getGear()); System. out. println("Altura da Sela: " + getSeatHeight()); System. out. println("Velocidade do Bike: " + getSpeed()); } // Aplicando o freno e acelerando public void applyBrakeAndSpeedUp() { setSpeed(getSpeed() - 1); System. out. println("Velocidade após aplicar freno: " + getSpeed()); setSpeed(getSpeed() + 10); System. out. println("Nova Velocidade: " + getSpeed()); } // Girando dois rodas public void canRotateTwoWheelers() { TwoWheeler twoWheelerObject = new TwoWheeler(); twoWheelerObject. canRotateTwoWheels(); } // Sobrecarregando o método canDrive da interface Vehicle public void canDrive() { System. out. println("Bicicleta de montanha pode andar. "); } } ``` Neste exemplo, vamos demonstrar como fazer a herança múltipla em Java usando interfaces e combinar classes e interfaces, seguindo estas regras: 1. Somente uma classe pode ser a classe-pai. 2. É possível ter qualquer número de interfaces como entidade-pai. Na sessão atual, vamos discutir conceitos de encadeamento de métodos em Java. Vamos começar com a polimorfismo: 1. **Polimorfismo**: Uma entidade específica (objeto, classe ou método) pode manifestar várias formas. Nesta sessão, vamos falar sobre o polimorfismo exposto pelos métodos. 2. **Encadeamento de Métodos**: Um único método em Java pode aceitar várias formas diferentes com lógicas diferentes mas com o mesmo nome. Esta ideia se chama **encadeamento de métodos**. Vamos ver como um único método em Java pode aceitar várias formas diferentes com lógicas diferentes mas com o mesmo nome e esta ideia se chama encadeamento de métodos. Neste caso, neste exemplo específico, o método `multiply` está sendo encadeado. As assinaturas dos métodos são as seguintes: - O primeiro método `multiply` aceita dois argumentos inteiros e retorna o resultado de sua multiplicação. - O segundo método `multiply`, com a mesma visibilidade, tipo de retorno e nome de método, aceita três argumentos inteiros e também retorna o produto desses três números inteiros. - O terceiro `multiply` método usa o mesmo nome de método, mas com o tipo de retorno agora que se torna `double`, aceita dois argumentos double e retorna o resultado de sua multiplicação. Manter o nome do método quando varia a quantidade ou o tipo de argumentos é a ideia de base para como implementar o encadeamento de métodos. Para implementar o encadeamento de métodos corretamente: 1. Faça garantir que o nome de método se mantenha o mesmo. 2. O tipo de retorno de um método encadeado pode mudar. 3. outra coisa que pode variar entre o mesmo método a ser definido às vezes é a quantidade e o tipo dos argumentos. ```java class Demo { // O método a ser encadeado, o primeiro caso aceita dois argumentos integer e retorna o resultado. public int multiply(int a, int b) { return a * b; } // O segundo caso do método encadeado aceita três argumentos integer e também retorna um inteiro. public int multiply(int a, int b, int c) { return a * b * c; } // O terceiro caso aceita dois argumentos double e retorna um valor dopoelulo. public double multiply(double a, double b) { return a * b; } public static void main(String[] args) { Demo demo = new Demo(); System. out. println(demo. multiply(10, 20)); // Saída: 200 System. out. println(demo. multiply(10, 20, 30)); // Saída: 6000 System. out. println(demo. multiply(10. 5, 20. 5)); // Saída: 215. 25 } } ``` Isso é tudo para hoje! Na próxima sessão, vamos discutir o encadeamento de métodos em Java. Vamos começar com o encadeamento de métodos em Java. # Métodos Estáticos em Java Este documento fornece uma breve explicação de métodos estáticos e apenas-a-classe em Java. ## Visão geral de Métodos Estáticos Os métodos estáticos são métodos de classe, o que significa que eles pertencem à classe, não a uma instância específica do objeto. Aqui estão alguns pontos-chave sobre métodos estáticos: - Um método estático pode ser chamado sem criar uma instância da classe. - Um método estático não tem acesso aos membros não-estáticos (variáveis ou métodos) da classe. - Um método estático pode ser sobrescrito dentro da mesma classe. ### Erro de Compilação ao sobrescrever um método estático Em Java, não se permite sobrescrever um método estático da superclasse. Tentar definir um método de instância com a mesma assinatura de um método estático na subclasse resultará em um erro de compilação. ### Apenas-a-classe Quando uma subclasse define um método estático com a mesma assinatura de um método estático na superclasse, o método da superclasse se torna invisível. Em outras palavras, o método da subclasse esconde o método da superclasse. ### Exemplo de Apenas-a-classe Considera-se uma classe-mãe `Bicycle` com três métodos de instância (`setGear`, `applyBrake` e `speedUp`) e duas propriedades (`gear` e `speed`). Uma classe filha `MountainBike` estende `Bicycle` e sobrescreve os três métodos com sua própria implementação: ```java class Bicycle { int gear; int speed; Bicycle(int gear, int speed) { this. gear = gear; this. speed = speed; } void setGear(int gear) { this. gear = gear; } void applyBrake(int decrement) { speed -= decrement; } void speedUp(int increment) { speed += increment; } } ``` ```java class MountainBike extends Bicycle { int seatHeight; MountainBike(int gear, int speed, int seatHeight) { super(gear, speed); this. seatHeight = seatHeight; } void setGear(int gear) { super. setGear(gear + 2); // Sobrescribindo o método basado na classe-mãe ao somar 2 ao valor de transmissão } void applyBrake(int decrement) { super. applyBrake(decrement + 10); // Sobrescribindo o método basado na classe-mãe ao subtrair um adicional em cima do valor de decréscimo } void speedUp(int increment) { super. speedUp(increment + 10); // Sobrescribindo o método basado na classe-mãe acrescentando um adicional em cima do valor de aumento } } ``` ## Classe Principal de Exemplo ```java public class Main { public static void main(String[] args) { Bicycle bicycle = new Bicycle(1, 10); MountainBike mountainBike = new MountainBike(3, 50, 50); bicycle. setGear(1); System. out. println("Bicicleta: transmissão " + bicycle. gear); mountainBike. applyBrake(1); System. out. println("Bicicleta de montanha: velocidade " + mountainBike. speed); mountainBike. speedUp(10); System. out. println("Bicicleta de montanha depois de acelerar: velocidade " + mountainBike. speed); } } ``` ## Por que a palavra-chave `static` em Java O palavrus `static` é usado para aqueles membros que pertencem à classe. Nos casos em que é útil ter propriedades ou métodos que são compartilhados para todas as instâncias de uma classe, o `static` serve para isso. Por exemplo, imagine um sistema de gerenciamento de empregados que armazena o nome da empresa. Neste caso, o nome da empresa será o mesmo para todos os empregados, portanto, é apropriado tornar o `college` propriedade estática. O mesmo se aplica à propriedade `employeeNumber` no sistema de gerenciamento de empregados, onde cada objeto empregado deverá ter um número de funcionário único baseado no contador anterior. Em resumo, o `static` permite criar variáveis e métodos de classe que são vinculados à classe e não associados às instâncias, garantindo o mesmo valor para todas as instâncias da classe. # Métodos Estáticos, Variáveis Estáticas e Blocos Estáticos em Java Os métodos estáticos, variáveis e blocos estáticos são conceitos importantes em Java que permitem compartilhar funcionalidade e estado entre objetos. Neste exemplo, discutiremos os casos de uso, restrições e exemplos de métodos estáticos, variáveis estáticas e blocos estáticos. ## Métodos Estáticos Os métodos estáticos pertencem à classe, não aos objetos. Eles são usados para compartilhar funcionalidade comum entre objetos, e podem ser chamados sem criar uma instância da classe. Um método estático não pode acessar variáveis não estáticas, mas um método não estático pode acessar variáveis estáticas. ```java public class Aluno { private static final String NOME_DA_ESCOLA = "XYZ"; private String nome; private int idade; private String endereco; private int qtde; // Construtores, Getters, Setters, e outros métodos não estáticos // Método estático public static void incrementarQtde() { qtde++; } // Método estático para obter a quantidade public static int getQtde() { return qtde; } } ``` ## Variáveis Estáticas As variáveis estáticas são associadas à classe, não aos objetos. São inicializadas apenas uma vez durante o processo de carregamento da classe e podem ser acessadas por qualquer objeto da classe. Elas também podem ser marcadas como constantes usando o modificador final. ```java public class Aluno { // . . . // Variável estática final public static final int QUANTIDADE_MAXIMA_DE_BIÇICLETAS = 10; } ``` ## Blocos Estáticos Os blocos estáticos são blocos de código executados quando a classe é carregada no tempo de execução. Eles são usados para inicializar variáveis estáticas ou realizar qualquer inicialização que deve ocorrer apenas uma vez durante a execução total do programa. ```java public class Aluno { // . . . static { // Código de inicialização } } ``` Agora, vejamos como podemos utilizar o modificador estático em Java. Usaremos a classe `Aluno. java` novamente, como em outros exemplos. ```java Aluno aluno1 = new Aluno("Aluno1", 20, "Endereço1"); Aluno. incrementarQtde(); // Incrementa a quantidade para todos os alunos int quantidade = Aluno. getQtde(); // Obtém a quantidade de alunos ``` # Classes Aninhadas em Java Este texto discute o conceito de classes aninhadas, focando tanto em classes estáticas aninhadas quanto em classes não-estáticas (interiores). ## Classes Estáticas Aninhadas As classes estáticas aninhadas podem apenas acessar variáveis estáticas e não podem acessar variáveis não-estáticas. ```markdown classe exterior { # Títulos e subtítulos private static int variável = 10; private static staticVariável2 = 20; private instanciaVariável = 30; # Método estático normal private void métodoNormal() {} # Define uma classe aninhada estática static class ClasseAninhadaEstática { # Método dentro da classe aninhada void mostrar() { System. out. println(variável); # Acessando variável da classe exterior estática System. out. println(staticVariável2); # Acessando variável estática da classe exterior // System. out. println(instanciaVariável); # Compilação com erro, não é possível acessar variáveis não estáticas de um bloco ou método estático } } } # Criar objetos de classes aninhadas estáticas classe exterior. ClasseAninhadaEstática objetoAninhado = new classe exterior(). new ClasseAninhadaEstática(); objetoAninhado. mostrar(); ``` ## Classes não-estáticas (interiores) As classes não-estáticas (interiores) podem acessar váriaveis tanto estáticas quanto não-estáticas. ```markdown classe exterior { # Títulos e subtítulos private static int variável = 10; private static staticVariável2 = 20; private instanciaVariável = 30; # Método estático normal private void métodoNormal() {} # Define uma classe não estática (interior) class ClasseInterior { # Método dentro da classe não estática void mostrar() { System. out. println(variável); # Acessando variável da classe exterior estática System. out. println(staticVariável2); # Acessando variável estática da classe exterior System. out. println(instanciaVariável); # Acessando variável não estática da classe exterior } } } # Criar objetos de classes não estáticas classe exterior exteriorObject = new classe exterior(); classe exterior. ClasseInterior interiorObject = exteriorObject. new ClasseInterior(); interiorObject. mostrar(); ``` ### Classe Local de Método Uma classe local de método pode ser criada dentro de um método da classe exterior. ```markdown classe exterior { # Método que contém uma classe local void métodoExterior() { # Define uma classe local class ClasseLocal { # Método dentro da classe local void métodoLocal() { System. out. println("Eu sou uma classe local de método! "); } } # Instanciar e chamar o método local ClasseLocal classeLocalObject = new ClasseLocal(); classeLocalObject. métodoLocal(); } } classe exterior exterior = new classe exterior(); exterior. métodoExterior(); ``` Com estes exemplos, deve ter uma melhor compreensão sobre classes aninhadas em Java, incluindo classes estáticas aninhadas e classes não-estáticas (interiores), além de classes locais de método. Pratique estes conceitos para melhorar sua compreensão e se tornar mais confiante ao trabalhar com classes aninhadas. # Classe Locais e Classes Anônimas Internas Nesta seção, abordaremos as classe locais e as classes anônimas internas. Comecemos com a explicação. ## ClasseLocal As classe locais são classes que existem apenas dentro de um método. Aqui está um exemplo básico: ``` interface Bicicleta { void canSpeedUp(); void canApplyBreak(); } class MountainBike implements Bicicleta { public void canSpeedUp() { // implementation } public void canApplyBreak() { // implementation } } // Exemplo de Classe Local void someMethod() { class MyBicicleta implements Bicicleta { public void canSpeedUp() { // implementation } public void canApplyBreak() { // implementation } } Bicicleta bicicleta = new MyBicicleta(); // Use a classe local } ``` ## Classes Anônimas As classes anônimas são instâncias de classes criadas quando o controle atinge a palavra-chave `new`, mesmo que a classe não tenha nome. Aqui está um exemplo de criação de uma classe anônima: ``` Bicicleta bicicleta = new Bicicleta() { public void canSpeedUp() { // implementation } public void canApplyBreak() { // implementation } }; ``` ### Porque Usar Classes Anônimas? As classes anônimas podem ser úteis quando queremos evitar a criação de uma classe separada para uma operação única ou quando precisamos implementar uma classe de ajuda de uma vez. No entanto, elas são menos legíveis e podem fazer o código mais difícil de manter. ## Funções Lambda para Interfaces Funcionais As funções Lambda podem ser utilizadas como alternativa às classes anônimas para interfaces funcionais. Eles fornecem uma sintaxe mais enxuta para organizar o nosso código, mas não aprimoram a legibilidade. ``` Bicicleta bicicleta = (Bicicleta actions) -> { actions. canSpeedUp(); actions. canApplyBreak(); }; ``` ### Usando Classes Anônimas com Interfaces Aqui está um exemplo demonstrando o uso de interfaces e classes anônimas: ``` interface Bicicleta { void canSpeedUp(); void canApplyBreak(); } void someMethod() { Bicicleta bicicleta = new Bicicleta() { public void canSpeedUp() { System. out. println("Can Speed Up"); } public void canApplyBreak() { System. out. println("Can Apply Break"); } }; // Usando a classe anônima bicicleta. canSpeedUp(); bicicleta. canApplyBreak(); } ``` ## Pacotes em Java Agora que tivemos coberto as classe locais e as classes anônimas, vamos falar sobre os pacotes em Java. Os pacotes fornecem uma maneira de agrupar tipos relacionados juntos, como classes, interfaces e classes anônimas internas. Os nomes de convencionais para pacotes variam, mas é comum usar o nome do domínio invertido da aplicação como o nome de base do pacote. ### Criando Pacotes Para criar um pacote, siga estas etapas num IDE como o Eclipse: 1. Navegue para o `src` pasta. 2. Abra o menu com direito clicando e escolha `Novo > Pacote`. 3. Insira o nome do pacote e clique `Concluir`. Os pacotes seguem a notação ponto para se aninhar pacotes dentro de outros. O nome do pacote não pode conter palavras-chave reservadas como `else`. Aqui está um exemplo de hierarquia de pacote para uma aplicação web: ``` com. minhapp. web - frontend - auth - LoginController. java - backend - services - UserService. java ``` Bem nomeados os pacotes e mantê-los relacionados pode melhorar a legibilidade e manutenibilidade do código. 😉 # Pacotes e Classes Privadas em Java Este guia explicará o conceito de pacotes e classes privadas em Java, utilizando exemplos para ilustrar seu uso e vantagens. ## Classes Privadas dentro de um Pacote Comece a escrever uma classe particular dentro de um pacote, e se você converter essa classe particular para visualização privada do pacote, essa classe será visível apenas dentro do pacote. Você pode recriar a mesma classe com a mesma definição exata em outro pacote. ``` package dot. inheritance; // Essa é uma classe privada chamada Bicicleta, visível apenas dentro deste pacote class Bicycle { // Detalhes da classe aqui } ``` Em outro pacote, digamos `dot. methodOverriding`, você poderá ter outra `Bicycle. java` com a mesma definição de classe. Como ambas as classes são privadas do pacote e moram em pacotes diferentes, não entrarão em conflito com uma a outra. ``` package dot. methodOverriding; // Essa é outra classe privada de bicicleta, visível apenas dentro deste pacote class Bicycle { // Detalhes da classe aqui } ``` ## Visibilidade de Classes Privadas Quando você tentar acessar uma classe privada de um pacote de outro pacote, pode confrontar diferentes níveis de visibilidade. Por exemplo, se você tiver uma classe privada `Bicicleta` no pacote `dot. methodOverriding` e quer usá-la no pacote `dot. main`, você pode mudar a visibilidade da `Bicicleta` classe no pacote `dot. inheritance` para público. ``` // Faze a classe Bicicleta pública no pacote dot. inheritance package dot. inheritance; public class Bicycle { // Detalhes da classe aqui } ``` Agora, se você voltar para o pacote `dot. methodOverriding` e tentar importar a `Bicycle` classe, verá ela como uma opção disponível. ``` // Importe a classe de bicicleta pública do pacote dot. inheritance import dot. inheritance. Bicycle; // Use a classe de bicicleta importada aqui ``` ## Práticas Recomendadas É sempre uma boa prática trabalhar com modificadores de acesso e tentar restringir a visibilidade das classes àquela que devem ser acessíveis. Manter classes privadas dentro da visibilidade do pacote garante-as visíveis apenas dentro do pacote, o que ajuda a evitar a ambiguidade e problemas potenciais ao trabalhar em projetos grandes que contêm nomes de classes semelhantes. ## Recursão em Java Esta seção abordará a recursão em Java, começando com uma explicação sobre o que é recursão e continuando com exemplos e detalhes da classe usada para ilustração. ### Entendendo a Recursão A recursão é o fenômeno de um método chamando a si mesmo. Enquanto isso pode parecer confuso, é útil em cenários em que uma classe precisa chamar a si mesma. No entanto, é importante observar que um laço infinito pode ocorrer se o método se chamar a si mesmo sem condição de parada. No exemplo abaixo, demonstraremos a recursão com a função fatorial. ``` // Classe para calcular fatoriais usando recursão public class ComplexFunction { // Calcule o fatorial de um número dado usando recursão public static int calculateFactorial(int n) { // Caso base: fatorial de 1 é 1 if (n == 1) { return 1; } // Caso recursivo: fatorial(n) = n * fatorial(n - 1) return n * calculateFactorial(n - 1); } public static void main(String[] args) { int number = 5; // Mude este valor para calcular o fatorial de um número diferente System. out. println("Fatorial de " + number + " é: " + calculateFactorial(number)); } } ``` Neste exemplo, o `calculateFactorial` método chama a si mesmo com uma diminuição de valor na `n` até que atinge o caso base de `n = 1`, no qual ele retorna o cálculo do fatorial. # Recursão e Chamada de Métodos em Java A recursão é um conceito essencial no programação, e frequentemente surge quando se tenta resolver problemas como série de Fibonacci, três em três, e traverse de árvores. Nesta sessão, discutiremos a importância da condição base, entenderemos como funciona a recursão e praticaremos seu uso. Em seguida, moveremos para a chamada de métodos em Java. ## Recursão ### Entendendo a Recursão A recursão é um método (função) que chama a si mesmo directamente ou indiretamente. Uma função recursiva resolve um problema complexo dividindo-o em subproblemas menores do mesmo tipo, que são mais fáceis de lidar. Lembre-se de que a saída da primeira execução é passada para as próximas iterações e a pilha vazia a si mesma durante a desempilhagem da função. A condição de base é essencial para prevenir recursão infinita. ### Importância da Condição de Base Na função recursiva, a condição de base é o ponto mais baixo que habilita a função para parar de repetir chamadas e devolver um resultado. Se não houver condição de base, a função nunca devolverá e procederá a chamarla indiscriminadamente, resultando em um erro de stack overflow. ### Calculando fatorial usando recursão Veja como implementar um método recursivo para calcular o fatorial de um número, como um exemplo. ```java public void calcularFactorial(int n) { // Condição de base if (n == 1) { System. out. println("Fatorial de " + n + " é " + n); return; } // Chamada recursiva System. out. println("Calculando fatorial de " + n); calcularFactorial(n - 1); System. out. println("Obtivemos o fatorial de " + (n - 1)); System. out. println("Fatorial total de " + n + " é " + (n * (n - 1))); // Combinar resultados da chamada recursiva } ``` --- ## Chamada de Métodos em Java ### Anatomia de Métodos Definição de um método em Java vem a três partes principais: 1. Modificador de acesso (public, private, protected, ou sem modificador) 2. Tipo de retorno (tipo de dados do valor que o método vai produzir) 3. Nome do método (qualquer nome escolhido, seguindo a convenção camelCase) 4. Argumentos (zero ou mais, com seus tipos e nomes) 5. Corpo do método (onde a lógica é colocada) 6. Declaração de retorno (se o método tem um tipo de retorno) 7. Cláusula throws (Utilizada para declarar quaisquer erros que o método possa lançar) ### Passagem de Argumentos para Métodos Os argumentos passados à um método em Java são passados por valor, não de referência. Isto significa que quando um método modifica um argumento, não afeta a variável original. Para demonstrar isto, vamos criar um método que incrementa um inteiro: ```java public static void mudarValor(int i) { i++; } public static void main(String[] args) { int i = 1; System. out. println("Valor inicial: " + i); // Valor inicial: 1 mudarValor(i); System. out. println("Valor após mudarValor(i): " + i); // Valor após mudarValor(i): 1 } ``` Aqui, pois o argumento é passado por valor, a variável original `i` no método `main` permanecerá inalterada. Para obter o valor modificado do método, é possível retorná-lo: ```java public static int mudarValor(int i) { i++; return i; } public static void main(String[] args) { int i = 1; System. out. println("Valor inicial: " + i); // Valor inicial: 1 i = mudarValor(i); // Atribui o valor retornado por mudarValor(i) à variável i System. out. println("Valor após mudarValor(i): " + i); // Valor após mudarValor(i): 2 } ``` # Passagem de Argumentos por Valor em Comparecimento à Passagem por Referência em Java Enviaremos e passaremos o objeto John dentro dele, e depois tentaremos imprimir o nome do objeto referenciado por John. Se dizer `get name`, estou chamando este método em particular, passando o objeto John aqui. Estou substituindo o nome John por Jane e em seguida imprimindo o novo nome do objeto John. Vamos ver o que acontece agora. ``` Se eu executar esse programa em particular, sim, posso ver que o nome foi substituído de John para Jane. Este aconteceu porque você passou a referência do objeto dentro do método, e então substituiu o nome no objeto que foi apontado por essa referência. Apenas parece que isso é passado por referência, mas ainda é passado por valor, pois essa referência não é a mesma referência aqui; esta é uma referência diferente. Todas as referências, no entanto, apontam para o mesmo objeto—a única coisa em comum aqui. Portanto, é possível mutar um determinado objeto dentro de um método, mas tenha muito cuidado. Nunca tente fazer isso, pois resultará em muitos resultados inesperados para você. Potencialmente você está chamando um determinado método de alguma outra aplicação, que está fazendo uma grande quantidade de alterações no mesmo objeto argumento que é fornecido, e então não sabemos o estado atual dele. É um padrão muito perigoso e uma maneira muito perigosa de mutar objetos. Não faça isso. Encontre outra maneira de lidar com este problema. ## Passagem por Valor vs. Passagem por Referência em Java - Se não deseja mutar o mesmo objeto, como soluciona este problema? - Pode solucionar este problema simplesmente criando um novo objeto e alterando o o que quiser alterar. - Tenho outro método aqui, que diz `alterar o nome de um objeto diferente`. Ele está também aceitando o objeto de aluno e depois, aqui, está criando um novo objeto de aluno, e por aqui está substituindo o nome, mas recebendo a idade e a endereço como os mesmos valores do argumento. - Assim, a idade e o endereço permanecem os mesmos, mas criamos um novo nome, mas não substituimossmos o mesmo objeto. Em vez disso, criamos um novo objeto, e então podemos retornar este objeto novo, se quiseremos. ``` - Posso fazer isso e dizer `return new student`, então posso armazenar o valor deste método lá. Posso chamá-lo aqui com o mesmo argumento `John`. Vou comentar este um, e posso armazenar o valor do resultado `objeto student result`. - Posso obter o valor aqui, então posso dizer `objeto result dot get name`. Se eu executar esse programa agora, lembre-se que estou chamando um determinado método agora, que vai criar um novo objeto, e então vai alterar o valor. Eu consigo obter o mesmo efeito, mas agora meu objeto John anterior não foi obviamente afetado de todo. Está seguro e sólido; posso reutilizá-lo, e posso espora certo que nada está sendo alterado em termos do estado do objeto. ## Exceções em Java - A seguir sempre seja seguido deste padrão, sempre que você estiver chamando métodos e enviando argumentos aos métodos, e se esses argumentos forem suas classes personalizadas e mesmo as classes Java, de fato, então sempre tente criar uma cópia nova do objeto ao seu interior se pretendermos mutar ou alterar o estado do objeto. # Exceções em Java ## Compreendendo as Exceções em Java - Em Java, exceções e erros são duas coisas tratadas de formas diferentes. - A razão para a existência de exceções é que os desenvolvedores fazem erros e criam bugs ao escrever código. - Aquando que escreve código, é natural que posso cometer esse tipo de erro ou outro, que cria uma falha na aplicação, que cria um defeito na aplicação, e então o time de testes acha esse defeito, e então a gente o corrige. - Assim, um ciclo normal de vida de software se develop. - Para disparar os tipos de exceções e erros, todos os sharementos de código provêm seus próprios quadros de exceção e de erro para ajudar o desenvolvedor em localizar esses erros e fixar esses erros e lidar com os erros em vez disso. - O Java também fornece seu próprio quadro de exceção. ! [Java Exception Hierarchy](https://www.javatpoint.com/images/exception-example/java-exception-hierarchy.jpg) - Este é uma imagem de uma visão geral da hiearquia de exceção em Java, a qual há uma longa hierarquia de classes diferentes aqui. - Esta é igualmente uma hiearquia de herança para dar-lhe contexto, e a hiearquia completa da hiearquia de exceção é herança em Java começa com uma classe chamada `Throwable`. - `Throwable` é a classe raiz ou a classe pai de manusear todas as exceções e erros. - A `Throwable` classe possui dois subclasses imediatas: `Error` e `Exception`. - Sob a hierarquia de `Exception`, você vê algumas exceções como as exceções IO, as quais é uma exceção que surge sempre que alguma coisa vá errado ao escrever em um arquivo, ao ler um arquivo ou ao lidar com um arquivo. - Você também tem exceções SQL, que surgem sempre que se fala com o banco de dados e escrever SQL queries, e alguma coisa fica errada. - Você também tem `ClassNotFoundException`, que surge quando uma classe não é encontrada no tempo de execução, ou quando a classe encontra-se sendo carregada na JVM. - Em seguida, você tem exceções de tempo de execução como `ArithmeticException`, `NumberFormatException`, e muitas outras como essas tipos de exceções. - Na parte direita, você vê o tipo de `Error`, e você tem alguns erros como os erros JVM, quando há erros de memória, e `Framework Error`. ## Diferenças entre Exception e Error em Java - Uma exceção é um tipo de problema que pode ser recuperado em um programa dele do qual o programa pode ser recuperado. - O desenvolvedor deverá ter a responsabilidade de garantir que nenhum dos estes erros ocorram em slaponfo program, e se os estes erros ocorrerem em seu programa, então o desenvolvedor tem a responsabilidade de lidar com esses erros de forma correta. - Vamos ver alguns exemplos de como o desenvolvedor pode lidar com essas exceções no próximo módulo. - Na parte direita, você tem o tipo de `Error`, onde o desenvolvedor não tem controle. - Se o JVM tiver um erro ou se o mémoria inferior do computador ou a memória do JVM seja erro ou se a biblioteca ela própria java seja erro, você pode não fazer nada disso, e esses são os tipos de problemas que entram na categoria de erros. ``` Tive em conta a estrutura original, corrigi alguns erros de gramática e ortografia, dividi em parágrafos para melhor leitura, e formeiei o código e as listas de forma Markdown. Além disso, adicionei links para imagens relevantes. Reveja as alterações e deixe-me saber se algumas emendas forem necessárias. # Gestão de Exceções em Java: Uma Pequena Guia Rápida Este tópico abordará como gerenciar vários Tipos de Exceções em Java usando blocos try-catch. Colemos informações sobre os diferentes Tipos de Exceções, включаindo exceções de tempo de execução, checadas e personalizadas. ## Entendendo Exceções A Java oferece três tipos de exceções: 1. **Exceções de tempo de execução** (exceções não checadas) ocorrem devido a erros de programação do desenvolvedor no programa. Também conhecidas como exceções não checadas porque o Java não nos força a lidar com elas ao compilar. 2. **Exceções checadas** não são necessariamente criadas pelo desenvolvedor mas deveriam ser lidadas pelo mesmo. Exemplos incluem `FileNotFoundException` e `IOException` ao lidar com operações de manipulação de arquivos. 3. **Exceções personalizadas** são exceções criadas pelo desenvolvedor com base em necessidades específicas. São explicitamente exceções checadas, e você deve lidar ou lançar elas ao compilar para evitar problemas ao executar o programa. ### Criando Exceções Personalizadas Para criar uma exceção personalizada, você pode estender a classe de `Exception`: ```java public class MyException extends Exception { // Construtores } ``` ## Gestão de Exceções com blocos try-catch Para lidar com exceções em Java, utilize blocos try-catch: ```java try { // Código suspeito ou não suspeito que pode lançar uma exceção } catch (ExcecaoTipo1 e1) { // Código para lidar com ExcecaoTipo1 } catch (ExcecaoTipo2 e2) { // Código para lidar com ExcecaoTipo2 } finally { // Código de limpeza para ser executado independentemente de se exibir uma exceção } ``` Lembre-se de que você pode: - Escrever blocos catch para diferentes exceções. - Agrupar vários tipos de exceções em um único bloco catch se seu processamento lógico for o mesmo. - Omitir o `finally` bloco se não há código de limpeza ou recursos para desalocar. Como exemplo, veja o uso de bloco de tentativa e captura em o método `writeList()`: ```java public void writeList() { ArrayList<Integer> list = new ArrayList<>(); list. add(10); try { int index = 1; int value = list. get(index); // Lança IndexOutOfBoundsException } catch (IndexOutOfBoundsException e) { System. out. println("IndexOutOfBoundsException: " + e. getMessage()); } finally { System. out. println("Bloqueio final"); } } ``` Nesta classe principal, você pode criar um objeto do `WriteListDemo` classe e chamar o método `writeList()`: ```java public class Main { public static void main(String[] args) { WriteListDemo writeListDemo = new WriteListDemo(); writeListDemo. writeList(); // Saída: IndexOutOfBoundsException: Index: 1, The array index is out of range: 1 } } ``` Com a exceção corretamente gerenciada, você pode garantir que o seu programa seja resistente a problemas inesperados e os possa lidar de forma amigável. Sorte a programação! 😊 ## Gestão de Exceções com Bloques Try, Catch e Finally Este exemplo destaca o uso e exemplos dos bloques Try, Catch e Finally em Java. Aqui está como funcionam: - **Bloqueio Try-Catch** captura uma exceção e executa ações de recuperação. - **Bloqueio Finally** garante que os recursos sejam limpos, independente de uma exceção ter ocorrido ou não. ### Aninhamento de Bloques Try Você pode aninhar bloques Try para o tratamento de casos excepcionais dentro de outros casos excepcionais: ```java try { try { // código a ser executado } catch (Exception1 e) { // tratar exception1 } try { // código a ser executado } catch (Exception2 e) { // tratar exception2 } } finally { // código de limpeza } ``` ### Exemplo com Exceção ArrayIndexOutOfBounds Aqui está um exemplo demonstrando o tratamento de uma `ArrayIndexOutOfBoundsException`: ```java public class IndexOutOfBoundsExample { public static void main(String[] args) { int[] meuArray = {1, 2, 3, 4}; try { System. out. println("Acessando elemento 10: " + meuArray[10]); // array fora dos limites } catch (ArrayIndexOutOfBoundsException e) { System. err. println("Exceção IndexArray fora dos limites: " + e. getMessage()); // rethrowing a exceção throw e; } finally { System. out. println("Bloqueio Final, sempre executado. "); } try { System. out. println("Acessando array não existente: " + meuArrayNaoExistente[0]); // este array não existe } catch (ArrayIndexOutOfBoundsException e) { System. err. println("Exceção IndexArray fora dos limites: " + e. getMessage()); } finally { System. out. println("Bloqueio 2 Final. "); } } } ``` > Quando você executar este programa, verá a exceção IndexArray fora dos limites no bloqueio Try-Catch inicial, uma vez que o programa tenta acessar um elemento além dos limites do array. A exceção é capturada, e uma mensagem é impressa. Em seguida, o programa continua com o Bloqueio Final, que sempre será executado independente da presença da exceção. > > Neste exemplo, o comando `throw` é utilizado para rethrow uma exceção de um bloqueio catch para que possa ser capturada por um bloqueio catch exterior. ### Igualdade e HashedCode em Java Uma análise detalhada da importância da Igualdade e HashedCode em Java, especialmente para questões de entrevista: - A classe `Object` já define os métodos `equals` e `hashCode`. - O propósito desses métodos é testar a igualdade e fornecer um hash code para um objeto. - Se você criar objetos personalizados e precisar de comparações de igualdade, sobrepasse o método `equals` em sua classe. - Quando você sobrepassar o `equals`, também sobrepasse o método `hashCode` porque ele é utilizado em certas Collection. Vejamos como isso se aplica a uma classe `Student`: ```java public class Student { private int matricula; private String nome; private String endereço; // construtor, setters, e getters // Tente aplicar estes métodos de exemplo: // Sobrescreva o método equals de acordo com o contrato @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null || getClass() ! = obj. getClass()) return false; Student student = (Student) obj; // explicitamente castar o objeto para o tipo de estudante return matricula == student. matricula && Objects. equals(nome, student. nome); } // Sobrescreva o método hashCode de acordo com o contrato @Override public int hashCode() { return Objects. hash(matricula); } } ``` > O método `equals` agora compara a igualdade com base na matricula (e possivelmente outros campos, dependendo de como você deseja definir a unicidade para um objeto estudante). O método `hashCode` garante que a hash code seja calculada considerando a matricula. > > Este impementação atualiza garante que objetos iguais estudantes compararam-se como iguais e conservar a unicidade em coleções como HashSet. # Duplicados e Igualdade em Java (Português Europeu) Esta seção aborda o conceito de objetos duplicados e igualdade em Java, enfocando o uso do método `equals` e do método `hashCode`. ## Objetos Duplicados Neste exemplo, temos dois objetos com o mesmo número de aluno, e definimos sua unicidade baseado no número de aluno. Se os números de aluno são iguais, os objetos são considerados iguais (ou duplicados). Se os números de aluno são diferentes, os objetos são considerados diferentes. ```markdown Defino a unicidade e a duplicidade de objetos baseado no número de aluno. Se os números de aluno são iguais, os objetos são iguais (ou duplicados), e se os números de aluno são diferentes, os objetos são diferentes. Nesta classe principal, tenho o mesmo número de aluno para ambos John e John 2. Troco o nome e endereço apenas para diversão, mas o número de aluno permanece o mesmo. Quando executo o programa, obtendo `true` pois utiliza-se o método `equals` para comparar os objetos. Isso estabelece como podemos utilizar o contrato do `equals` para manter a unicidade. Também mencionei que, ao definir o método `equals`, devemos também sobrescrever o método `hashCode`. Para entender por que precisamos do método `hashCode`, voltemos a ver como hash maps funcionam. Em Java, hash maps mantêm a unicidade utilizando tanto o método `equals` como o método `hashCode`. O método `hashCode` é uma caixa de memória na memória de Java onde o objeto é armazenado. É uma localização de memória para cada objeto. Quando lidamos com conjuntos de hash ou hash maps, somos obrigados a sobrescrever tanto estes métodos. Vamos entender isso funcionando: 1. Quando tentamos inserir um elemento em um conjunto de hash, Java utiliza sua definição do `equals` método para verificar se um objeto semelhante ao que está sendo inserido já está presente no conjunto de hash. Se encontra um objeto, o marca como duplicado e não o insere. 2. Quando extraemos um elemento de um conjunto de hash, Java calcula o hash code do objeto. O hash code é a impressão ou assinatura de memória onde o objeto está armazenado. A maneira que calcula o hash code é baseada na definição que fornecemos. O hash code calculado é utilizado para achar a localização da memória onde o objeto está armazenado. 3. Se tiverem vários objetos presentes na mesma localização de memória calculada com base na implementação da sua hash code, Java utiliza o contrato do `equals` para comparar os objetos e encontrar o objeto exato. 4. É uma boa prática sempre sobrescrever os métodos `equals` e `hashCode` em sua aplicação quando você está criando classes. Isso é porque você não sabe em qual momento e onde estas classes serão armazenadas numa coleção ou numa mapa de coleção. 5. Quando implementamos o método `hashCode`, a regras de dito é utilizar os mesmos parâmetros que foram utilizados no contrato do `equals`. Isso é para garantir que a lógica da localização da memória e do manuseio da unicidade é consistente. ``` ## Interface Comparable em Java O problema de se utilizar a interface `Comparable` aparece quando queremos ordenar nossas coleções. Para entender isso, movemos-nos para a documentação oficial de Java. A ideia básica é que você quer ordenar a sua coleção e Java fornece-lhe um método chamado `Collections. sort`. Voce só fornece a sua lista ou coleção dentro do método `sort` e todos os elementos ou objetos dentro da coleção serão ordenados de acordo com a ordem natural. Isso se mantém verdadeiro para tipos primitivos, mas o que acontece se a sua lista for de tipos `Student`? Neste caso, Java não sabe como ordenar os `Student` objects. Para resolver este problema, java fornece uma interface chamada `Comparable`. Esta interface precisa ser implementada para a classe sempre que você precisar ordenar os objetos ou do tipo da classe. Esta interface fornece um único método chamado `compareTo`, que fornece o objeto estrangeiro e depois é necessário comparar este objeto com seu objeto atual. Voltemos agora a nossa classe Java e compreendemos como funciona esta interface `Comparable`. Novamente, utilizei a classe `Student` para fins de coesão e tenho as mesmas propriedades como número de aluno, nome e idade. Porém, neste caso, uso o `implements Comparable<Student>` para definir que esta interface do `Comparable` trabalhará somente com tipos do tipo `Student`. Caso faça isso, Java te obriga a fornecer a implementação do método `compareTo`. Utilizando um IDE como Eclipse, se sobreescreve este, você obterá esta assinatura automaticamente. Vamos ver como isso funciona. Se assim é que feitas, você obterá o seguinte: ``` # Ordenação e Comparadores em Java Nesta sessão, vou discutir como implementar a ordenação personalizada e lógicas de ordenação múltiplas usando comparadores em Java. Primeiro, vamos revisar a interface `Comparable` e seus limites. ## Interface Comparable A interface `Comparable` fornece uma ordenação natural para os objetos, permitindo que eles sejam ordenados de acordo com as propriedades intrínsecas que eles possuem. Para implementar isso, é necessário fornecer um método `compareTo` dentro da classe do objeto. ```java public class Aluno implements Comparable<Aluno> { // Propriedades. . . public int compareTo(Aluno outro) { // Sua implementação personalizada do compareTo. . . } } ``` No entanto, existem situações em que a ordenação natural não é adequada e é necessário definir nossa própria lógica de ordenação personalizada. Nessas circunstâncias, a interface `Comparator` pode ser usada. ## Interface Comparator A interface `Comparator` permite definir a lógica de ordenamento personalizada para os objetos que não implementam a interface `Comparable` ou para implementar lógicas de ordenamento multiplas na mesma coleção. ```java public class ComparadorIdade implements Comparator<Aluno> { public int compare(Aluno aluno1, Aluno aluno2) { // Sua implementação personalizada do compare. . . } } ``` ### Usando Comparadores Para ordenar uma coleção usando um comparador, precisamos fornecer o objeto comparador quando chamar o método `sort()`. ```java List<Aluno> alunos = Arrays. asList( new Aluno(1, "Jane", 21), new Aluno(2, "Tom", 20), new Aluno(3, "John", 18) ); // Por padrão, a lista é ordenada pelo número de matrícula. Collections. sort(alunos); // Para ordenar a lista pela idade, forneça o comparador desejado. Collections. sort(alunos, new ComparadorIdade()); ``` Você pode criar tantas comparadores quanto foremos necessários, dependendo das suas necessidades. ### Projeto: Aplicação de ÁTMs Na próxima sessão, construiremos uma aplicação de ÁTMs utilizando várias ideias de Java e de POO que já aprendemos até agora. Essa aplicação irá te ajudar a entender como desenhar e implementar aplicativos simples ou complexos em Java utilizando conceitos desta série. Ate logo! 🚀✨ # Aplicação de Átomometragem ## Obter Login Inicie-se com esta método, o qual pedirá ao utilizador uma referência de cliente válida. Após ter introduzido um número de referência de cliente válido, este método pedirá ao utilizador que introduza um número de identificação de PIN. Remista que o número de referência de cliente está mapeado para o número de PIN, então aquilo que escolher do seguinte período irá fornecer correspondentemente o número de PIN. Se o utilizador fornecer um número de identificação de PIN inválido, obterá um erro. Isso acontecerá todo dentro do bloco `try`. Se fornecer quaisquer caracteres inválidos no número de PIN ou número de referência de cliente do Átomometragem, obterá uma exceção que estou definida no bloco `catch`. ## Obter Tipo de Conta Depois que o cliente fornecer o número de referência de cliente e de PIN, perguntaremos ao cliente que forneça o tipo de conta. Esta aplicação apoia duas opções diferentes de tipos de conta: conta corrente ou conta poupança. Então o cliente terá de escolher uma delas. Tiremos o input do comando de linha usando a classe `Scanner`, e depois uso um `switch`/`case` para fornecer opções diferentes ao cliente. Também especifiquei uma opção `default` aqui que diz "escolha inválida". ## Obter Conta Corrente Se o cliente escolher uma conta corrente, oferecemos as seguintes funções ao cliente: 1. Ver saldo 2. Retirar fundos 3. Depositar fundos 4. Sair da aplicação Utilizo um `switch`/`case` aqui com base nas escolhas do cliente. Por exemplo, se o cliente quer ver o saldo, este bloco será executado. ## Obter Retirada de Conta Corrente Se a cliente escolher a opção para retirar fundos, é chamado o método `getCheckingWithdrawInput`. Em seguida, chamo o método `getAccountType`. Similarmente, se for 3, retiraremos o fundo e para isso tenho definido o método `getCheckingDepositInput`. ## Obter Poupança Se a cliente escolher a conta poupança, chamaremos o método `getSaving`, onde novamente abordo exatamente o mesmo formato que vimos na obtenção de conta corrente, onde apresentamos as seguintes opções: 1. Ver o saldo 2. Retirar fundos 3. Depositar fundos Tenho alguns métodos definidos aqui, por exemplo: 1. `getSavingWithdrawInput` 2. `getSavingDepositInput` Definei o `switch`/`case` aqui com base nas escolhas dos clientes aqui, e isso é o que está acontecendo no método `getSaving`. ### Exemplo de Métodos Definidos ```java public double getCheckingWithdrawInput(Scanner scanner) { System. out. println("Entrar com a quantia que pretende retirar: "); double amount = scanner. nextDouble(); // valide a quantia aqui return amount; } public double getCheckingDepositInput(Scanner scanner) { System. out. println("Entrar com a quantia que pretende depositar: "); double amount = scanner. nextDouble(); // valide a quantia aqui return amount; } public double getSavingWithdrawInput(Scanner scanner) { System. out. println("Entrar com a quantia que pretende retirar: "); double amount = scanner. nextDouble(); // valide a quantia aqui return amount; } public double getSavingDepositInput(Scanner scanner) { System. out. println("Entrar com a quantia que pretende depositar: "); double amount = scanner. nextDouble(); // valide a quantia aqui return amount; } ``` ## Menu de Opções Este é o ponto principal onde pedimos ao cliente que entre com o número de referência de cliente e o PIN numérico a partir da `getLogin` method, depois com base nisso fornecemos ao utilizador as opções de escolher o tipo de conta (poupança ou conta corrente), e com base no tipo de conta que utilizador escolher, chamaremos o `getChecking` ou o método `getSaving`. Nesta função, fornecemos ao utilizador as outras opções para retirar dinheiro, depositar dinheiro, ou ver o saldo. Isso está acontecendo dentro desta classe `OptionMenu`. Agora, vamos para a classe `Conta` e todos os métodos que abordamos anteriormente terão sua definição na classe de conta. Também ves este `OptionMenu` está herdando a classe Conta, pelo que um conceito de herança é utilizado aqui. ## Conta Esta é a classe Conta onde tenho definido algumas variáveis privadas membro, como: 1. número de referência de cliente 2. PIN número 3. saldo da conta corrente 4. saldo da conta poupança Também posso partilhar a classe de conta em três classes filha onde tenho uma classe de conta poupança e uma conta corrente, mas para simplicidade, mantive atualmente na mesma classe. Iniciei a classe scanner input que será utilizada em múltiplas localizações e então tenho as Setters e Getters para estas quatro variáveis de membro. Podes ver que `setCustomerNumber` foi chamado nesta classe OptionMenu na `getLogin` método caso volte para atrás, e se fornecer a conta poupança, será chamado o método `getSaving` método, então aqui é onde o método `getSaving` está definido, e novamente abordo o mesmo formato como vimos no `getChecking` método, onde oferecemos as seguintes opções de ver o saldo, retirar dinheiro e depositar dinheiro. Tenho algumas definições de métodos nesta classe por exemplo, `getSavingWithdrawInput`, `getSavingDepositInput`, `calcSavingWithdraw`, e `calcSavingDeposit`. Utilizo o `switch`/`case` com base cada vez mais nos escolhas do utilizador e aquilo que está acontecendo no método `getSaving`. Também defini o método `calcCheckingWithdraw` e `calcCheckingDeposit` que serão usados no cálculo para as contas corrente e poupança. O que está definido nesta classe OptionMenu. Por isso, pedimos ao utilizador para introduzir o número de referência de cliente e o PIN numérico num método `getLogin`, depois com base nisso fornecemos ao utilizador as opções de escolher o tipo de conta (poupança ou conta corrente) e com base no tipo de conta que o utilizador escolher, chamaremos o método `getChecking` ou o método `getSaving`, e dentro deste método, oferecemos ao utilizador opções adicionais para retirar dinheiro, depositar dinheiro ou ver o saldo. O que está acontecendo nesta classe OptionMenu. Agora vamos para a classe `ATM` que é o ponto de inicialização, que basicamente inicializa a classe `OptionMenu` e chama o método `getLogin`. # Aplicação de Conta Bancária Este exemplo demonstra o uso de conceitos orientados a objetos em uma aplicação Java simples, especificamente em uma aplicação bancária de conta com dois tipos de contas: conta corrente e conta de poupança. A aplicação permite aos usuários depósitar, retirar e verificar o saldo da conta. Ela também inclui a possibilidade de tratamento de erros para saldo negativo. ## Conta Corrente Aqui está uma descrição passo a passo da funcionalidade da conta corrente: 1. O usuário é apresentado com um menu para selecionar o tipo de conta: conta corrente ou conta de poupança. 2. Se o usuário escolher conta corrente, serão executados os seguintes passos: - O saldo atual é exibido, que inicialmente é zero. - O usuário é solicitado a digitar a quantia que deseja depositar. - Após digitar a quantia de depósito, a mensagem "Você depositou com sucesso o dinheiro. O saldo atual da conta corrente é [quantia depositada]" é exibida. 3. Para retirar dinheiro da conta corrente, siga estas etapas: - Após escolher conta corrente, a aplicação retorna ao menu principal, chamando o método `accountType` para exibir as opções novamente. - O usuário escolhe retirar dinheiro. - O saldo atual é exibido. - O usuário digita a quantia que deseja retirar. - Após digitar a quantia da retirada, o novo saldo é calculado subtraindo a quantia da retirada do saldo anterior e exibida ao usuário. 4. Se o usuário tentar retirar uma quantia maior do que o disponível, uma mensagem "Saldo indisponível" é exibida. 5. O usuário pode sair da aplicação selecionando "3" e apertando enter, o que os redireciona de volta à tela de login para digitar o número do cliente. ## Conta de Poupança Você pode executar as mesmas operações para a conta de poupança com os mesmos passos descritos acima para a conta corrente. ## Aplicação de Calculadora (Projeto Futuro) Na próxima sessão, exploraremos outro projeto interessante de código Java Java core para melhorar nossa compreensão sobre conceitos Java código Java core. Aqui está uma previsão da aplicação de calculadora que suporta operações de adição, subtração, multiplicação e divisão. A aplicação de calculadora utiliza as seguintes classes e conceitos: 1. `ReadInput` classe para pegar entradas do usuário da linha de comando. 2. `Queue` para gerenciar números e operadores enfileirados. 3. `Operate` interface para fazer operações matemáticas. 4. Quatro subclasses concretas (`Add`, `Subtract`, `Multiply` e `Divide`) que implementam a interface `Operate`. A classe principal da aplicação processa as entradas do usuário com a ajuda da classe `ReadInput` para dividir a expressão em números e operadores, que são armazenados nas filas. Em seguida, a aplicação principal processa as filas utilizando um loop e um `switch` para chamar a classe appropriada `operate` baseado na operação (adição, subtração, multiplicação ou divisão). Por fim, o resultado calculado é exibido ao usuário. # Aplicativo de Calculadora em Java através da console ## Visão Geral Este tutorial mostrará como construir um aplicativo de calculadora simples em Java através da console. Serão demonstrados os passos para coletar entradas de usuário, dividi-las em arrays (ou filas) de números e operações e executar as operações. ``` ## Instalação de Java em Windows 10 Este tutorial vai lhe levar através do processo de instalação de Java em seu sistema operacional Windows 10. #### Passo 1: Faça o Download de Java 1. Acesse o site da Oracle e pesquise por "Download de Java". 2. Faça o Download do Java Development Kit (JDK) na versão 8. #### Passo 2: Instale o Java 1. Execute o arquivo instalador e siga as instruções durante o processo de instalação. 2. Para verificar se a instalação foi bem-sucedida, abra a Janela do Prompt de Comando e digite `java --version`. Se a instalação foi efetuada com sucesso, o número de versão será apresentado. #### Passo 3: Defina as Variáveis de Ambiente do Java 1. Acesse o Painel de Controle, então Sistema > Definições Avançadas > Variáveis de Ambiente. 2. Navegue até o caminho de instalação de Java e copie o caminho do diretório `bin`. 3. Na lista de Variáveis do Sistema, encontre a Variável `Path`, clique sobre ela e clique em Editar. 4. Cole o caminho do diretório `bin` e clique OK. ## Criando um Programa Simples de Java Este tutorial mostrará como criar um programa simples de Java para multiplicar dois números, utilizando um Integrated Development Environment (IDE). Em nosso exemplo, utilizaremos o Eclipse. 1. Faça o Download do Eclipse IDE para desenvolvedores java. 2. Execute o instalador do Eclipse baixado e faça o Follow-up das instruções de instalação. 3. Abra o Eclipse, crie um novo projeto jaova e escreva um programa simples para multiplicar dois números. 4. Execute o programa e verifique se o output é o esperado. ## Conclusão Agora que você instalou o Java com sucesso e executou um programa de java simples, pode explorar conceitos avançados de Java, melhorar a manipulação de erros e lidar com casos limites. Boa sorte! --- Fontes: [<https://www.youtube.com/watch?v=4SMj6Tf0cf0>](https://www.youtube.com/watch?v=4SMj6Tf0cf0) Linguagem: en Este é uma versão simplificada e reformatada da texto original para que segue os Modelos de Markdown fornecidos. Correções de erros e de ortografia também foram feitas ao texto. Além disso, URL original preservada. # TutoRL: Verificar Se Um Número é Par ou Ím par `Dividido por 2 fornece o resto 0 indica que é um número par. Aqui, vamos mostrar o cálculo para os números pares. Agora vejamos o **caso else: ** Se o número não for par ou, em outras palavras, o número é **impar**, abaixo tem a desintegração. Estamos termos! Agora execute este programa. **Introduzca un número ímpar**: `15` **O número é ímpar**. E, mostramos com sucesso o resultado. Isto sugerir que o programa está a funcionar corretamente. Quer com isto chegamos ao final deste tutórl. `Esperamos que este tenha sido instrutivo e útil`. Grande obrigado por assistir! Fique atento para mais de SimplyLearn 🎉 --- # Dicas Para Aprender Java (2023) Para Iniciantes - SimplyLearn [Link para aprender java](https://www.youtube.com/watch?v=G0-aOL0BacA) 🤘 ```markdown * Linguagem: en * Mensagem de boas-vindas: Olá! **Passos Importantes** para Aprender Java 1. Fundamentos Básicos - Entenda os conceitos essenciais como "tipos de dados, variáveis, operadores, funções lógicas, e declarações condicionais". * Recursos: Vea *SimplyLearn Tutorial Core Java na descrição*. 2. Algoritmos e Diagramas de Fluxo 3. Codificar a partir do zero mais tarde 4. Aprender depuragem 5. Projetos Simples e permanecer actualizado Para mais detalhes, veja o nosso tutorial ligado na descrição abaixo 😎 ``` "Uma língua de programação nova pode sentir-se abertonho, especialmente sem um caminho de aprendizado claro. Java, por exemplo, é uma língua de programação muito procurada na cumprimento de projectos IT e a sua mestria requer um curso bem planejado. Em este video, nós iremos mergulhar num método eficaz e mais rápido de aprender a língua de programação Java. Com uma curta, simples caminhada por meio de cada passo, compreenda cada dica antes de saltar para a aprendizagem de java! . " *** ## 🔥 **10 Perguntas de Interview de Java (2023) para Iniciantes - 2023 🔥** – Simplilearn [Link para Java Interview Questions](https://www.youtube.com/watch?v=bmK7cDjM_ns) 🌟 ```bash Bem-vindo ao nosso Canal Simplilearn YouTube 🎬, **hoje falamos sobre as 10 Perguntas Cruciais para Entrevistas de Java** principalmente para iniciantes 👨‍👨‍👦‍👦✨. Familiarize-se com estas, não somente seu aprendizagem para uma rodada de código próxima estará sorted, mas ainda mais, se sentirão animado(a) através! Não deve nada faltares de conteúdo ou recursos. . . Siga nosso tutorial para conselhos experientes! **Subscreva se não fez isso ainda! ! ! 🎯🌍🚀** A Baixo, Encontre #10 através de #1. * (1) **O Que é Multithreading? 🤔** <Resposta- É o procedimento que executa várias tarefas ou threads simultaneamente de uma forma mais eficiente, a utilizar menos tempo e menores recursos de memória, e também pelos seus recursos de CPU. Cada thread não precisa de uma memória própria para funcionar independentemente, fazendo assim o multithreading mais poderoso. No entanto, na nossa código, uma vez que a memória está definida para uma thread ou várias threads, todas elas ficam presas, mesmo quando demais threads terminam o processo). * 9) Java Inclui Ponteiros? Não. Pensando em vantagens da serviço de alocação automática de memória e coletor de lixo que encontramos em Java, muitos iniciantes enfrentam questões sobre "usamos realmente ponteiros"? Mas eles não são usados explicitamente, sim como uma alocação automática de objeto e limpeza de lixo em java. ``` Java Entrevista para Iniciantes: 10 Perguntas e Respostas + Informação ================================================================ --- **Idioma: ** english [Musica] **Especulando se podemos começar? ** *Sim, pode, por favor, dar-me uma pequena introdução de vocês? * > **Baba: ** Grato pela oportunidade. Sou eu, Ishwar, e fiz o meu bacharelado em ciência da computação. Obtive um GPA de 7, 8 no meu curso e 78 na minha nona série. Quanto aos meus conhecimentos técnicos, a ciência da computação está presente em todos os campos, o que é uma notícia comum para todos os países. Durante os últimos quatro anos, dediquei o meu tempo a aprimorar minhas habilidades técnicas e de software na área pesquisa da ciência da computação. Aprendi programação em Java, C++, C++, Java Script (que estou estudando agora), aprendi tecnologias de banco de dados como SQL, MySQL e MongoDB. Criei alguns projetos como gerenciamento de uma biblioteca, um aplicativo de testes, óculos de cálculo e outros projetos pequenos. Eles estão nos meus documentos de currículo, realmente. Lhe darei os links do Git Hub para esses projetos. Adicionalmente, participar de muitos "hackathons" ambos online e offline me ajudou a ser consciente sobre o que os meus colegas estão aprendendo, e manter-me atualizado com a tecnologia. > > **Sobre a minha vida pessoal, tenho algumas auspiciões. Adoro jogar futebol, adoro ler e adoro assistir a filmes de ficção científica. ** Deixe isso marcar tudo sobre mim. **Então, minha próxima pergunta é o que são as minhas metas a longo prazo? ** > **Ishwar: ** Minhas metas a longo prazo seriam ganhar o máximo de experiência possível em minha área— além disso, pretendo aproveitar o que aprendi durante esses anos iniciais, o que pode ajudá-me a me meter para uma posição mais sênior. A experiência anterior ajuda-me, assim que as oportunidades chegarem para promoção ou outras oportunidades, eu posso aproveitar se eu os utilizo à correcva tempo. A visão longo prazo para começar a sua carreira corporativa pode ser bastante útil para se aplicar e a alinhar-se com esse plano. Acho que isso é minha metas a longo prazo, pelo menos por agora. **Então, posso dizer a diferença entre o trabalho duro e inteligente? ** > **Ishwar: ** Eu realmente acho que ambos são necessários numa pessoa. Um individuo precisa entender como e quando utilizar o trabalho inteligente e quando utilizar o trabalho duro. Mas eu acho que aquilo que realmente a diferença é utilizar menos recursos e menos tempo para alcançar o mesmo resultado por colocar mais esforço nas atividades de alta rendimento em vez de passar horas às bruças sem um objetivo claro. Acho que assim está a diferenciar as diferenças entre o trabalho duro e o trabalho inteligente mais marcante. Um exemplo de citação daística por Steve Jobs ou outro homem (preciso me ainda lembrar de quem foi tal citação: "encontro num improdutivo trabalhador para fazer trabalho duro. Ele irá encontrar uma maneira fácil para fazer isso") então, acho assim que está bastante resumida as diferenças entre o trabalho duro e o trabalho inteligente. **Então, diga-me qual é a vida que vocês vivem? Outros? infelizes? ** > **Ishwar: ** Sim. Sim, Essa é a minha percepção da vida. Vida é o que é e não há grande problema. Não vale a pena ocupar-se com aquele até que não se conheça o que é um verdadeiro problema. Não sei se isso explicou seu segredo que a sua família tem. **Então qual é o curso que está interessado em estudar? ** > **Ishwar: ** Eu estou muito interessado em um MBA, principalmente porque ainda não tenho a experiência em gerenciamento. Eu acredito que conseguiria aprender comportamentos influentes, como lidar com problemas na trabalho, equilibrar as atividades e tudo mais do tipo. E depois após ter o MBA, posso tentar a empresa para encontrar trabalhos gerenciamentais. **Então, como está a sua família? ** > **Ishwar: ** Se foi sobre a minha família, eu fico em Bombaim, Indiá, e já estou resolvendo alguns problemas familiares. Entretanto, afinal eu studied neste país, então é bem fácil fazer com que todas as minhas famílias participe das minhas festas de aniversário e jogos ao redor do Natal, assim como as outras festas nacionais indianas. Então, acho que tudo vai bem nas minhas relações familiares. **Então, como é que vocês encontaram esse pedido de entrevista? ** > **Ishwar**: Acho que muitos colegas encontrei esse anúncio no LinkedIn. **Então, como vocês se sintiram numa empresa onde através da qual as famílias possam negociar? ** > **Ishwar: ** Penso que isso é muito bom para a empresa dirigir essa oferta para a família, mas neste caso, já que sou o candidato à esta ocupação, provavelmente não me aplica isso diretamente a mim, pois está sob os termos dessa empresa. **Então, se vocês ganham este emprego, quando iria começar? ** > **Ishwar: ** Sim, poderia começar assim que houver feed-back da empresa a plena satisfação do processo de seleção. Pensei que este seria o proximo passo para mim. **Então, como vocês podem trabalhar com o outro time? ** > **Ishwar: ** Sim. Bem sim. Espero aprender muito com os meus colegas e também entender o trabalho que eles estão fazendo. Acredito que isso possa ajudar a trabalhar em um ambiente mais produtivo. **Então, quantos anos de experiência em série vão vocês apresentar quando forem procurados? ** > **Ishwar: ** Eu apresento cerca de dois anos de experiência em série. Fuji apagar o email de contacto e também o nome da empresa. **Então, qual é a especialização do seu Bacharelado? ** > **Ishwar: ** A minha especialização é em Informática. **Então, como vocês vivem tecnicamente? ** > **Ishwar: ** Sou um entusiasta de computador e JAVA por aqui. Aprendi Java e C ao longo dos anos; depois de graduar-me, Learned e está aprendendo programação. Eu descobri que sabemos disso enquanto estava a estudar na minha universidade. Me facilitou aprender objetos que estavam ligados e estruturas, de modo que eu fiquei interessado em começar um Mestrado em ciência da computação. **Então, como vocês abordam estruturas de repetição em problemas de combinatório? ** > **Ishwar: ** Eu encontro os estratégias de engenharia computacional como recursão e memória dinâmica muito útil nesses casos. Também posso reduzir explicitamente muitos problemas de combinatório para problemas de gramática livre e multiplicar os estados atuais para construir estados recursivos. Ou eu poderia pesquisa um algorítmo que resoleto os problemas de estruturas de repetição de forma eficiente. **Então, como vocês abordar soluções para problemas computacionais? ** > **Ishwar: ** Em geral, primeiro eu tomo riscos e tento pesquisar um solução que já lhe é fornecida como biblioteca ou criar a solução de maneira única e auto-replicativa. Se não há nenhuma solução presumivel lhe ser fornecida, então eu caio no algoritmo que utilizo o Approach que estou familiarizado com ele. Caio normalmente às estruturas de repetições a primeira tarefa e então vou pra baixo, sempre que Eu Chego à ultima coisa, vou me anotar todas as coisas que estou utilizando. Elas podem ser reutilizadas na aplicação de interesses acima mencionados. **Então, pretendo provar que posso implementar com segurança técnica a tua inovação? ** > **Ishwar: ** Sim. Nativamente sou um dos ver suspendedidos neste assunto. Eu confirmo que realmente posso implementar com segurança técnica este software. **Então, o código Java largo a dizer que está escrito corretamente? ** > **Ishwar: ** Eu encontrei alguns problemas ao validar o código. A parte da explicação é importante para entender o valor de cada função e como ela é implementada. **Então pergunto: códigos de secretos fazem parte de sua tarefa? ** > **Ishwar: ** Eu devo aquisses códigos de segurança para proteger os meus computadores de queem quiser obter acesso aos meus dados. Todo código de segurança é something necessário a ser aberto e revisto antes de ser implementado no servidor. **Então, como vocês iriam lidar com a pressão? ** > **Ishwar: ** Eu tenho a mente organizada e posso lidar muito bem com a pressão. Qualquer coisa que eu tiver a realizar vai ficar lhe dito de forma mais simplificada, até eu me perguntar até mesmo quais são as possíveis soluções existentes. Eu pego todas as tarefas lá em cima e disseco-as um na vez. **Então, podemos para que último esforço? ** > **Ishwar: ** Sim, concluo normalmente meu trabalho nesta época mesmo. Às vezes as pressões adicionais aumentarão os níveis de estresse mas nenhum nível excessivo para interferir. **Então, vocês vão somente trabalhar em função do seu salário ou vocês sempre é intrincado ao projeto? ** > **Ishwar: ** Vou trabalhar com sincronia ao projeto. Tenho como meta, fazer o melhor ao meu capacidade. **Então, vocês podem mais tarde ter requisito para qualquer Outros job? ** > **Ishwar: ** Básicamente vou continuar na área de tecnologia. Manejo tanto desenvolvimento de hardware quanto do software, mas minha preferência é continuar no desenvolvimento de software. # Comparação Java e Python Este documento fornece uma comparação entre Java e Python, dois dos principais línguas de programação. Abordaremos suas conceitos fundamentais, campos de aplicação, trendes atuais da indústria, salários e ajudá-lo a escolher a língua apropriada, de acordo com as suas exigências. ## Introdução ### Java O Java foi desenvolvido pela Sun Microsystems e é uma língua robusta, de nível alto e orientada a objetos. Foi inicialmente projetado para uso em pequenos dispositivos de hardware, como caixas de configuredores e dispositivos móveis, mas devido à crescente popularidade da internet, foi rapidamente modificado para ser usado no World Wide Web. O Java se enquadra nas conceitos de Programação Orienta-se a Objetos (POO) como abstração e encapsulamento. ### Python O Python foi criado em 1989 e também é uma língua orientada a objetos e de nível alto. Ele incorpora muitas palavras em língua inglesa em sua sintaxe, o que o faz muito mais lido que outras linguagens de programação. O Python é principalmente usado no campo de Intelliigência Artificial e Aprendizado de Máquina. ## Comparação de Conceitos Fundamentais ### Velocidade - O Java é uma linguagem de tipo estático, e a sintaxe é checada durante a compilação, resultando em uma execução mais rápida. - O Python é uma linguagem de tipo dinâmico, e a sintaxe é checada durante a execução, o que aumenta a velocidade de execução comparada com o Java. ### Sintaxe - O Python tem uma vantagem evidente ao comparar à quantidade de código escrito para realizar a mesma tarefa. - O Python atribui automaticamente o tipo da variável, de acordo com seu valor, enquanto o Java precisa que o tipo da variável seja definido antes da compilação. ## Campos de Aplicação ### Java - O Java é comumente usado para o desenvolvimento de aplicações web e móveis. - Java é amplamente utilizado para aplicações corporativas devido ao grande número de recursos para aplicações empresariais. - As aplicações Android são principalmente desenvolvidas usando Java. ### Python - Python é muito popular para uso no campo da Inteligência Artificial. - Python é usado em desenvolvimento web, principalmente para o lado do servidor de aplicações. - O YouTube é principalmente escrito em Python. ## Trendes Atuais e Salários O gráfico a seguir representa o crescimento de ambas as línguas nos últimos cinco anos: [(Imagem do gráfico que mostra o crescimento do Python e do Java nos últimos cinco anos)] - O salário médio de um desenvolvedor Java na Índia é aproximadamente 4, 5 lakhs anuais. - O salário médio de um desenvolvedor Java nos EUA é aproximadamente 80, 000 USD. ! [Salário médio de um desenvolvedor Java](https://www.payscale.com/research/US/Job=Java_Developer/Salary) - O salário médio de um desenvolvedor Python na Índia é aproximadamente 4 lakhs anuais. - O salário médio de um desenvolvedor Python nos EUA é aproximadamente 76, 000 USD. ! [Salário médio de um desenvolvedor Python](https://www.payscale.com/research/US/Job=Python_Developer/Salary) - O salário de desenvolvedores Python aumenta significativamente quando adquirem um cargo туко como data scientist. - Os data scientists ganham, em média, 10 lakhs anuais na Índia, e cerca de 110, 000 USD nos EUA. ## Conclusão Quando se escolher entre Java e Python, considere os seguintes pontos: - Escolha Java se estiver mais interessado em cargos de engenheiro de software e deseja trabalhar em sistemas para grandes empresas. - Escolha Python se estiver interessado em Inteligência Artificial, Aprendizado de Máquina, desenvolvimento web ou cientistas de dados. - Java é adequado para desenvolver aplicações Android. Depois de ter entendido as diferenças entre Java e Python, esperamos que possa fazer uma escolha informada, baseada em suas exigências e metas futuras. ## Recursos Adicionais - [Comparação Java vs Python - Simplilearn](https://www.youtube.com/watch?v=4NOTxBkfBjo) - [Java Tutorial para Iniciantes - GeeksforGeeks](https://www.geeksforgeeks.org/java-tutorials/) - [Tutorial de Python para Iniciantes - W3Schools](https://www.w3schools.com/python/) # Software Choices para uso em PC: Java vs Python Se você está interessado em software para PC, talvez considere Java como a língua de escolha se você tiver interesse em programação. No entanto, para aqueles interessados em Inteligência Artificial (IA), Ciências de Dados ou Internet das Coisas (IoT), Python é frequentemente a opção preferida para estas tecnologias. O Python é conhecido por sua simplicidade, tornando-o uma excelente opção para começar a aprender a codificar. Se for novato na codificação e planeja iniciar os estudos, recomendo começar com Python. Se tiver interesse em desenvolvimento web, a opção de Python pode ser uma boa devido aos excelentes frameworks como Django e Flask, que simplificam o desenvolvimento web. No final deste período de aprendizado, se estiver estudando um dos language de programação - seja Java ou Python - sinta-se a vontade para deixar uma mensagem no painel de mensagens abaixo. Se ainda não pode decidir sobre um idioma, faça uma pesquisa abrangente antes de tomar uma decisão. E obrigado por se unir a nós. Acompanhe-nos! Se você gosta deste vídeo, considere se inscrever no canal de YouTube do Simplilearn ao clicar aqui, ao aumentar o volume, e ao clicar aqui para ser certificado! --- ### Java vs JavaScript: Qual é melhor? | Dif끝 hanging word | Diferença entre Java e JavaScript | Simplilearn URL: https://www.youtube.com/watch?v=0lbw6OBerhA (Transcrição indisponível) --- ### C vs C++ vs Java | Diferença entre C, C++ & Java | Línguagens de Programação Comparadas | Simplilearn URL: https://www.youtube.com/watch?v=SfwsZ8vlYx0 Olá e bem-vindos a todos a este interessante sessão ao vivo do Simplilearn hoje! Hoje vamos discutir as diferenças entre as línguas de programação C, C++ e Java. Vamos aguarde por um tempo para que mais pessoas possam se juntar. Note que nós atualizamos diariamente em várias tecnologias. Se você é um fã de tecnologia em continua busca das últimas tendências, recomendamos que inscreva-se em nosso canal de YouTube e aperte o botão de notificação para não perder nenhuma atualização de nossa parte. Bem-vindos a todos! Agora vamos iniciar. Estamos aqui para discutir as diferenças entre a lendária língua de programação C, a praticamente reverenciada versão orientada a objetos de C, C++, e o soberano da atual indústria de IIT, Java. Então, sem mais ado, vamos entrar no assunto de nosso debate deste dia. A primeira discussão a respeito das diferenças entre as três línguagens é a Programação Orientada a Objetos. Primeiramente, temos C, que é uma língua de programação procedural e não possui nenhuma característica de programação orientada a objetos. Em contraste, C++ é uma versão um pouco mais avançada de C e vem com a característica de Programação Orientada a Objetos. Finalmente, temos Java, que é uma linguagem de programação nascida como orientada a objetos e também suporta plataformas cruzadas. Seguida pela Programação Orientada a Objetos, vemos a Dependência de Plataforma. Primeiramente, C é dependente de plataforma, o que significa que se escrever um programa em Windows e quiser executá-lo em um computador de outro sistema operacional, como o Linux ou outro sistema operacional, pode precisar alterar o seu código para que ele seja compatível. De forma similar, C++ também é dependente de plataforma. Em contraste, Java é célebre por sua independence de plataforma, graças à sua Máquina Virtual Java (JVM), ou Máquina Virtual Java, que faz possível executar os programas em qualquer sistema operacional independentemente do tipo ou do número de versão. Seguinte à Dependência de Plataforma, vemos o próximo ponto de discussão, que é o Suporte Empresarial. O Suporte Empresarial é diferente do apoio individual comum onde vários programadores ou uma equipe de programadores trabalham com um objetivo único. Quando se refere ao Suporte Empresarial, C não possui suporte, e C++ apenas possui suporte limitado. No entanto, Java possui um Suporte Empresarial apenas para caminhos. Após o Suporte Empresarial, vemos os Processos de Execução do Compilador. Em C, existe apenas um compilador, e qualquer código que você escrever será considerado para compilação apenas quando o programa está finalizado, considerando toda a programação para a fase de compilação ao final. Em C++, os procedimentos são os mesmos que em C, e ele segue os mesmos procedimentos - toda a programação é considerada para compilação quando o programa está finalizado. No entanto, isso o faziciona ligeiramente mais lento durante a fase de compilação. Agora vamos entrar na linguagem de programação Java. Java possui um compilador híbrido, que é uma combinação de compilador e interpretador. Qualquer código que você escrever na linguagem de programação Java, a interpretação tenta interpretar o seu código e ocasionalmente até fornece sugestões quando estiver usando alguns ideias avançadas como o Eclipse. No final, o código completo é compilado novamente antes de fornecer as saídas do tempo de execução, fazendo com que Java seja um pouco mais lento, mas ainda não completamente lento. Seguindo os Processos de Execução do Compilador, temos o próximo ponto de discussão, que é as Extensões de Arquivos. C segue a extensão . c arquivos, C++ segue a extensão . cpp arquivos, e finalmente, Java segue a extensão . java arquivos. Quando tiver um arquivo com . c, você pode identificá-lo como o código de programação C; . cpp para C++; e . java para o código de Java. Termos de discussão do terceiro ponto entre as três línguagens de programação, temos os Tipos de Dados e Palavras Chave. O ponto comum entre todas as três linguagens é que três tipos de dados são utilizados, os Tipos de Dados Primitivos e Não Primitivos. No entanto, o número de palavras-chave que as línguagens de programação utilizam diferencia. Com C, temos três tipos de dados, os Tipos de Dados Primitivos e Não Primitivos, e ele segue 32 palavras-chave para uso. Palavras-chave are as palavras especiais que têm significado especial predefinido pelos designers ou criadores da linguagem C de programação. Seguida pelo C, temos C++, e ele segue o mesmo procedimento da Programação C. C++ também possui dois tipos diferentes de dados, os Tipos de Dados Primitivos e Não Primitivos, e ele segue 63 palavras-chave para uso, quase o dobro da quantidade que existia na Programação C anterior. Agora chegando à Programação Java, vemos dois tipos diferentes de dados, os Tipos de Dados Primitivos e Não Primitivos, e ele segue 50 palavras-chave para uso. Finalmente, temos o nosso próximo ponto de discussão, que é a Conectividade com Banco de Dados. A Conectividade com Banco de Dados desempenha um papel significativo nas tendências atuais na programação. Vamos ver qual é a diferença que podemos ver neste assunto. Primeiramente, temos a Programação C, que não possui suporte para a Conectividade com Banco de Dados, e também não possui nenhuma suporte de conectividade especial para o banco de dados, nem mesmo na Programação C++. Agora, iniciando com a Programação Java, vemos um forte apoio para conectividade banco de dados, pois possui conectores especiais como o JDBC, o cual é Java Database Connector. Após a Conectividade com Banco de Dados, vemos o próximo ponto de diferença, que é o Suporte a Manejo de Exceções. Primeiro, temos a Programação C, que não possui suporte para tratamento de exceções. O tratamento de exceções é um procedimento simples que elimina o processo de um segmento de código de um código total de um programa para falhar ou até mesmo não permitir que o programa falhe como um todo apenas devido a erros de programação primários. Para entender o tratamento de exceções em uma maneira mais clara, vamos postar um link de descrição abaixo que explicará melhor a este tema. Após a Programação C, vamos para a Programação C++, e também mostra apenas apenas muito pouco suporte para o tratamento de exceções. E finalmente, vamos para a Programação Java, que possui um suporte forte para tratar exceções. Seguindo o Tratamento de Exceções, vemos a próxima diferença, que é os Estruturas e Uniões. As Estruturas e Uniões foram inicialmente criadas na Programação C, portanto, a Programação C mostra uma melhor compatibilidade com elas. Seguida pela compatibilidade com Estruturas e Uniões, vemos uma melhor compatibilidade também com a Programação C++, portanto, a Programação C++ também mostra uma melhor compatibilidade com elas. No entanto, quando chegamos à Programação Java, ela não apresenta suporte para estruturas de dados personalizadas como Estruturas e Uniões. Após isso, vemos a Segurança de Dados, pois a Segurança de Dados também compartilha o mesmo caminho da programação orientada a objetos. Como é uma linguagem de programação procedural, a Linguagem C não apresenta suporte para a Programação Orientada a Objetos, que é a Encapsulação. Portanto, você pode ter segurança limitada disponível na Programação C. Em contraste, nosso próximo ponto de discussão, vemos a Programação Orientada a Multitiarefa, pois é uma linguagem de programação mais antiga e proceduralmente orientada, portanto, apresenta baixa compatibilidade ou ainda não possui compatibilidade direta para a Programação Multitiarefa. Após C, vemos a Programação C++ com baixa compatibilidade para a Programação Multitiarefa, uma vez que é apenas uma versão um pouco mais avançada de C, e ao vir à Programação Java, podemos dizer que ela é tecnologia muito mais avançada. Por isso, ela apresenta maior compatibilidade com a Programação Multitiarefa, melhorando as capacidades de performance da linguagem de programação. Finalmente, vemos o Suporte a Construtores e Destrutores. Primeiro, temos a Programação C, que é uma linguagem de programação que não apresenta suporte para orientação a objetos, e como resultado, não possui suporte para construtores e destrutores. No entanto, quando chegamos à Programação C++, ela apresenta suporte para construtores e destrutores devido à sua natureza orientada a objetos. Por fim, temos a Programação Java, que também apresenta suporte para construtores e destrutores devido à sua natureza baseada em orientação a objetos. # Comparação entre C, C++, e Java: Guia detalhado e comparativo ## Resumo Este documento proporciona uma comparação entre os idiomas de programação C, C++, e Java, com foco em suas características principais, diferenças, e casos de uso. ### C Programming Language - Linguagem de programação procedural, desenvolvida por Dennis Ritchie nos anos 70. - Não suporta features de programação orientada a objeto, ou suporte para destruktors, inicialmente. - Usa directives de processador para incluição de ficheiros e definição de macros. - Tem um maneamento manual da memória com a utilização de apontadores. - Não dispõe de um colecionador de lixo integrado para limpeza de memória não utilizada, obrigando usuários a libertores de memória manual utilizando destruktors no C++. #### Ponteiros no C - Com o suporte para ponteiros, existe uma manipulação direta de dados através dos seus endereços. #### Diretivas do Processador no C - Usam diretivas do processador para aceder a arquivos externos e definir macros. ### C++ Programming Language (C com classes) - Extensão do lánguage C criado por Bjarne Stroustrup nos anos 80. - Melhorou o C com suporte para classes, objetos, constructors e destructors. - Apresenta constructors, os quais permitiram uma libertação de memória manual após a execução de um programa, mas sem um colecionador de lixo integrado. #### Destructores no C++ - Os desenvolvedores devem escrever o código do destrutor para liberar a memória desnecessária após a execução do programa. ### Java Programming Language - Criado por James Gosling nos anos médios dos anos 90. - Língua orientada a objeto com suporte para constructors, mas sem suporte a destructors. - Dispõe de um sistema de limpeza automática de memória (Garbage collector) que é utilizado para libertores de memória não utilizada após a execução completa do programa, deixando obsoletas as tarefas manual das destructores. #### Garbage collector no Java - Um sistema automático de gestão da memória que limpa memória desalocada nos objetos não mais em utilização. #### Ponteiros em Java - Não são definidos no idioma, pois o Java escapou das formas tradicionais de gerenciamento de memória baixo-nível. ### Diretivas do Processador em Java - Ao invés de tradução para linguagem, a Java converte os `. java` arquivos para `. class` arquivos e a maquina virtual de Java executa o código do byte. A fim de aceder a bibliotecas externas, a Java usa a directiva "import" ao invés das diretivas de processamento utilizadas nas predecessoras C e C++. ## Recursos - [Linguagem C Programming Language](https://www.youtube.com/watch?v=w8WQ3u9MmyE) (Versão em Inglês disponível porém sem ficha) - [Loop e controles de código em Java: Tutorial](https://www.youtube.com/watch?v=hs45eeZ326U) (Em Inglês) A seguir está o texto traduzido com a formatação Markdown: ```markdown # Loop do-while em Java ## Sintaxe Básica do Loop do-while ``` ```java do { // Algumas declarações de código aqui contador++; // Cheque a condição aqui } while (contador < 10); ``` ``` A sintaxe `do-while` começa com a palavra-chave `do`, executa algumas declarações de código sem nenhuma verificação, depois incrementa o valor de `contador` e checa a condição. Caso a condição seja verdadeira, o código irá retornar ao `do` e a execução repetirá. No caso de a condição se tornar falsa, a execução irá parar. ## Comparação com outras estruturas de laço ```markdown Comparando ao exemplo de um laço `while` que verificamos anteriormente: ``` ```java while (contador < 10) { // Algumas declarações de código aqui contador++; } ``` ``` Na `while` normal, a condição é verificada antes de entrar no código de laço, no caso de `do-while`, a declaração do código é executada pelo menos uma vez, independente da verificação da condição. ## Uso de um programa de exemplo A seguir, você verá um exemplo de como se pode usar o laço `do-while`. Este programa tem o mesmo código da demonstração anterior da estrutura `while`. ```java public static void main(String[] args) { int contador = 1; do { System. out. println(contador); contador++; } while (contador < 10); } ``` Ao rodar este programa, você obterá os seguintes resultados: ``` 1 2 3 4 5 6 7 8 9 ``` O `do-while` pode ser usado quando deseja fazer algum processamento inicial antes da primeira checagem da condição, já que essa checagem só acontecerá após o processamento. ## Modificando os valores Tente mudar os valores e tente entender como isso irá ajudar você a fazer sentido de como se utiliza um `do-while`. ```java public static void main(String[] args) { int contador = 11; do { System. out. println(contador); contador++; } while (contador < 10); } ``` A saída para esse exemplo será apenas "11". No caso do valor inicial fora da condição (contador inicializado como 11 e a condição sendo verificada em 10), a saída é impressa somente uma vez antes que o laço termine, uma vez que 11 é maior que 10. ## Algumas Observações Importantes - É possível inicializar um valor a zero e não usar uma verificação em um laço `for`. ## Conclusão O laço `do-while` permite que sejam realizados processamentos iniciais antes de se verificar a condição, além de que irá executar pelo menos uma vez se não houver condição que parar a execução do laço. ``` O `do-while` pode ser utilizado quando é necessário que haja uma inicialização de algum processamento antes da checagem da condição. Se a checagem deve ser realizada somente se a inicialização tiver ocorrido com sucesso, recomenda-se utilizar um `if-else`. Aqui você encontrará um breve resumo sobre laços em Java: - [Laços em Java](http://pt.twoohyoo.com/guia/java/loop-control-statement/ruim-how-to-loop-control-statement-questao1/java-while/java-while-loop/java-while-loop-example/) # Laços Avançados em Java Neste artigo, ensinaremos sobre laços avançados em Java, especificamente sobre o laço de repetição `for-each` (também conhecido como `for-in`). Este tipo de laço é utilizado com frequência para iterar sobre coleções de itens ou arrays. Ele é mais fácil de escrever do que um `for` clássico e a sintaxe é bastante simples: ```markdown para (tipoElemento nomeElemento : coleção) { // código a ser executado } ``` Aqui, `tipoElemento` é o tipo de dado da coleção, `nomeElemento` é o nome do elemento atual e `coleção` é a coleção com a qual estamos trabalhando. Vamos fazer um exemplo pra melhorar a compreensão do fórmula acima: ```markdown int[] numeros = new int[] {1, 2, 3, 4, 5}; para (int numero : numeros) { System. out. print(numero + " "); } ``` No exemplo acima, estamos trabalhando com um array de inteiros `numeros`. Nós utilizamos o `for-each` para iterar sobre o array e imprimir cada um de seus elementos. Nota que `numero` é o nome do nosso elemento atual, que será atualizado automáticamente para cada iteração. ## Laços aninhados Movimentando-nos para laços aninhados em Java, vamos ter um exemplo de um array bidimensional. ```markdown int[][] numeros = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; ``` No exemplo acima, estamos trabalhando com um array bidimensional chamado `numeros`. Este array tem três linhas (r aspas duplas) e três colunas (pie de cavalo). Cada linha contém três inteiros. Nós podemos usar dois laços `for` aninhados para iterar sobre esta matriz: ```markdown para (int i = 0; i < numeros. length; i++) { para (int j = 0; j < numeros[i]. length; j++) { System. out. print(numeros[i][j] + " "); } System. out. println(); } ``` Neste exemplo, `i` e `j` são as variáveis de loops principais e de sub-loops. É interessante observar como `numeros[i][j]` acessa a posição de `i` e `j` exatamente no array bidimensional. Note que também também podemos escrever o loop aninhado acima em um único loop usando a biblioteca `Arrays`: ```markdown int[][] numeros = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; para (int[] row : numeros) { para (int elemento : row) { System. out. print(elemento + " "); } System. out. println(); } ``` Em suma, o `for-each` é extremamente prático e comumente usado quando a frequência de novos itens será adicionada ou removida pelo programa. Ao usar o `for`, devemos assumir que o tamanho da cóleção é conhecido na execução do programa. Use o `for` quando precisar de maior controle sobre a quantidade de loops e o `for-each` quando desejar simplificar loops complexos. # Arrays em Java para Iniciantes Este tutorial te introduzirá aos arrays em Java. ## Tabela de Conteúdos 1. [Arrays em Java](#arrays-em-java) 1. 1. [Exemplo](#exemplo-de-arrays) 2. [Classes e Objetos em Java](#classes-e-objetos-em-java) 2. 1. [Exemplo](#exemplo-de-classes-e-objetos) ## Arrays em Java ### Exemplo Neste exemplo, imprimiremos uma matriz 3x3 usando loops aninhados. O código seguinte mostra como iterar sobre um array bidimensional: ```java public class Main { public static void main(String[] args) { int[][] matrix = { {2, 7, 9}, {0, 0, 0}, {1, 1, 2} }; for (int i = 0; i < matrix. length; i++) { for (int j = 0; j < matrix[i]. length; j++) { System. out. print(matrix[i][j] + " "); } System. out. println(); } } } ``` Quando executado, o seguinte output será exibido: ``` 2 7 9 0 0 0 1 1 2 ``` Como pode ver, a função interna itera sobre cada valor da linha atual da matriz, enquanto a função externa move para a próxima linha. --- ## Classes e Objetos em Java ### Exemplo Neste exemplo, criaremos uma classe `Student` e usaremos-a para criar objetos. ```java public class Student { private int studentId; private String studentName; private int studentAge; public Student(int studentId, String studentName, int studentAge) { this. studentId = studentId; this. studentName = studentName; this. studentAge = studentAge; } public void printStudent() { System. out. println(String. format("ID: %d, Nome: %s, Idade: %d", studentId, studentName, studentAge)); } } public class Main { public static void main(String[] args) { Student s = new Student(1, "Aprender Simples", 25); s. printStudent(); } } ``` Quando executado, o seguinte output será exibido: ``` ID: 1, Nome: Aprender Simples, Idade: 25 ``` Neste exemplo, criamos uma classe `Student` com três campos: `studentId`, `studentName` e `studentAge`. O método `printStudent` imprime os detalhes do estudante. O método `main` cria um objeto `Student` chamado `s` e chama o seu método `printStudent`. Se você quiser aprender mais sobre objetos e classes em Java, visite nosso [tutorial](https://www.youtube.com/watch?v=-xmJSKRo5ec). --- [Introdução à Arrays em Java](https://www.youtube.com/watch?v=hAk7abWHi3w) [Classes e Objetos em Java](https://www.youtube.com/watch?v=-xmJSKRo5ec) # Threads em Java: Tutorial de Multi-threading --- ## O que é Multi-threading em Java? Nessa sessão, aprenderemos sobre threads em Java, também conhecidas como multi-threading. Comecemos entendendo o que é multi-threading. **Antes de começarmos**, se você for um desenvolvedor full-stack aspirativo ou alguém que busca aprimorar suas habilidades em desenvolvimento full-stack, temos um programa perfeito para você sua de Simply Learn: o Programa Pos-Graduado em Desenvolvimento Full-Stack. - Inscrição para o Certificado do Departamento de Engenharia do Caltech (CDME) - Apoio para Emprego do Simply Learn - Até 25 CEUs do Caltech CDME - Apoio ao Emprego de Simply Learn ajuda-você a se destacar ante as empresas de destaque - Master classes ensinadas por instrutores do CDME do Caltech - 8x interação maior e aulas online conduzidas por expertes da indústria - Convocação on-line pelo diretor do programa do Caltech CDME - 20+ horas de conteúdo de vídeo e projetos - Projetos de capstone e quatro domínios - Membro do Circulo do Caltech CDME - Construção de um portfólio em GitHub **Plano de Agenda da Sessão Hoje: ** 1. Entender o processo de multi-processamento 2. Tipos diferentes de multi-processamento 3. O que é uma thread e como ela funciona no Java Programming 4. Paradigmas multi-threading 5. Ciclo de vida da thread 6. Definição e acesso aos métodos de thread 7. Iniciar e encerrar threads 8. Métodos de thread comumente usados em Java --- ## Multi-threading em Java ### O que é Multi-threading? - O multi-threading é o processo de utilizar toda a banda de largura de um CPU para executar dois ou mais jobs computacionais de uma vez, como definido. ### Tipos de Multi-threading - O multi-threading pode ser: - Processo-base - Thread-base #### Process-Based Multi-threading - Executa dois ou mais processos simultaneamente. #### Thread-Based Multi-threading - Executa dois ou más threads simultaneamente. #### Diferenças entre Process-Based e Thread-Based Multi-threading - O multi-threading de processo executa vários processos, enquanto que as threads executam várias threads dentro do mesmo processo. - O multi-threading de processo requer mais tempo e memória em comparação ao multi-threading de thread. --- ## Threads em Java ### O que é uma Thread em Java? - Em Java, uma thread é uma caminho separado de execução para um programa. - Cada thread possui sua própria pilha de chamada e contador de programa, mas compartilham a mesma memória. ### Como uma Thread Funciona no Programação Java - Executar várias threads permite ao programa executar várias tarefas ao mesmo tempo. --- ## Ciclo de Vida de uma Thread em Java 1. **Novo: ** A thread é criada, mas não iniciada ainda. 2. **Executável: ** A thread foi iniciada e está pronta para ser executada. 3. **Executando: ** A thread está sendo executada pelo CPU. 4. **Bloqueado: ** A thread está aguardando outro processo, como esperar por uma recursos ou I/O. 5. **Morto: ** A thread terminou sua execução ou encontrou um erro causando o seu encerramento. --- ## Definição da Thread e Acesso aos Métodos de Thread ```java public class MyThread extends Thread { // Construtor para passar uma mensagem para a thread public MyThread(String message) { super(message); } public void run() { System. out. println(getName() + " diz: " + getArgs()[0]); } } // Método principal para criar e iniciar os threads public static void main(String[] args) { MyThread thread1 = new MyThread("Hilo 1"); MyThread thread2 = new MyThread("Hilo 2"); thread1. start(); thread2. start(); } ``` Titulo principal: Introdução à Programação Multithreading em Java =============================================================== Subtítulo: O que é um thread e seu ciclo de vida ---------------------------------------------- Neste artigo, aprenderemos sobre a programação multithreading em Java e nos concentraremos na compreensão básica de um thread, seu ciclo de vida, e como criar um. ### Diferença entre o multiprocessamento e multiprocessamento O multiprocessamento e o multiprocessamento são duas estratégias para melhorar a eficiência da aplicação. No entanto, existem algumas diferenças importantes entre ambos: * Multiprocessamento: O multiprocessamento utiliza vários processos e, em particular, cada processo utiliza seu próprio espaço de endereço. isso significa que cada processo requer seu próprio espaço de memória de aplicação individual. No multiprocessamento, cada processo é uma instância separada de um programa. * Multithreading: No entanto, o multiprocessamento utiliza apenas um processo, o sistema operativo utiliza um spooling para gerenciar as temporadas de execução dos diferentes threads. Este tipo de interação permite que as aplicações compartilhem o espaço de endereço de um processo. No multiprocessamento, só existe um espaço de endereço compartilhado para todas as instâncias da aplicação. Cada thread é uma unidade básica de execução, assim, uma tarefa particular é executada em um thread. ### O que é um thread A seguir, uma imagem que pode ser considerada uma aplicação. Suponha que está a executar uma aplicação, por exemplo, o IDE Eclipse. Nesta aplicação, o processamento inicializa um thread principal, que é responsável pela criação dos threads filhos. A hierarquia é apresentada da seguinte forma: ``` Aplicação | Thread Principal | Thread Filho 1 | Thread Filho 2 | . . . ``` Quando executa-se uma aplicação, o sistema operativo inicia o thread principal na aplicação ou a operação em questão. Este thread principal é responsável pela criação dos threads filhos necessários para a execução da aplicação. ### Ciclo de vida de um thread Todos os threads passam pelo mesmo ciclo de vida, que se divide em quatro estados: 1. Novo: Um thread novo é criado mediante a instrução `new Thread()`. Um thread estava em este estado até que a aplicação é iniciada. 2. Executável: Quando um thread é chamado, passa para o estado Executável. O thread é atribuído a um administrador, que determina se o thread deve ser executado ou não. 3. Rodando: Quando o thread é adicionado a fila de espera do administrador, os administradores de fila de espera começam a empréstimo do thread durante temporadas de execução. 4. Morte: O estado final do thread é quando o thread é executado completamente ou interrompido durante sua execução. A interrupção de um thread envia-o para o estado Morte. ### Criação de threads em Java Os threads em Java podem ser criados de duas forma: 1. Extendendo a classe Thread Quando estendemos a classe `Thread`, precisamos obter o método `run()`, que contém a estrutura de código responsável por ser executada quando o thread for executado. 2. Implementando a interface `Runnable` Ao implementar a interface `Runnable` e obter seu método `run()`, também nos permite determinar a estrutura de código que será executada quando o thread for executado. Agora, vamos examinar um example de como criar vários threads em Java. ### Criação de um thread extendendo a classe Thread Aqui está um exemplo simples de como criar um thread estendendo a classe `Thread`: ```java class MeuThread extends Thread { public void run() { for (int i = 1; i <= 5; ++i) { System. out. println("Thread: " + i); try { Thread. sleep(1000); } catch (Exception e) { e. printStackTrace(); } } } } class Main { public static void main(String args[]) { Thread t1 = new MeuThread(); // Cria um novo thread do objeto MyThread t1. start(); // Inicia o thread de objeto new MeuThread for (int i = 1; i <= 5; ++i) { System. out. print("Thread principal: " + i); try { Thread. sleep(1000); } catch (Exception e) { e. printStackTrace(); } } } } ``` O thread principal continua a executar-se separadamente do thread `MeuThread`. Quando executa o programa, verá que a saída ocorre em paralelo. ### Criação de um thread implementando a interface `Runnable` Aqui está um exemplo simples de como criar um thread implementando a interface `Runnable`: ```java class MeuRunnable implements Runnable { public void run() { for (int i = 1; i <= 5; ++i) { System. out. println("Thread: " + i); try { Thread. sleep(1000); } catch (Exception e) { e. printStackTrace(); } } } } class Main { public static void main(String args[]) { final Thread t1 = new Thread(new MeuRunnable()); // Cria um thread que executa o objeto MyRunnable t1. start(); // Inicia o thread for (int i = 1; i <= 5; ++i) { System. out. print("Thread principal: " + i); try { Thread. sleep(1000); } catch (Exception e) { e. printStackTrace(); } } } } ``` ## Conclusão Neste artigo, aprenderemos sobre a programação multithreading em Java. Temos que entender que os threads nos permitem melhorar a eficiência nas aplicações e ajudar a executar várias tarefas ao mesmo tempo em um mesmo processo. Además, aprenderemos um embreveação sobre o ciclo de vida de um thread e como criar e executar threads em Java. Existem mais aspectos relacionados com os threads (incluindo o controlo sincronizado, prioridades e o controlo de interrupções) que acrescentaremos em outras seções em publicações futuras. *Espero que este artigo tenha ajudado a entender a programação multithreading em Java. Se tiver dúvidas sobre qualquer assunto em particular, não hesite em perguntar nos comentários. Abraços e parabéns por começar a trabalhar com o desenvolvimento de multithreading de aplicações em Java! * # Conceitos OOPS em Java (Mantendo a formatação Markdown) Use Markdown para a formatação conforme a seguinte estrutura: - Use `#` para títulos e títulos secundários - Use ** para texto negrito - Use ` para texto inclusão de código injetado - Use ``` para blocos de código - Use `>` para bloquetes de citação - Use `-` ou `*` para pontos de lista - Use `---` para linhas horizontais ## Threads em Java ### Extendendo a Classe Thread Nesta seção, vamos criar um exemplo para estender a classe `Thread` e demonstrar uma operação de multi-threading. ``` # Extendendo Thread Aqui está um exemplo onde estamos estendendo uma classe `Thread` existente e tentando implementar a operação de multi-threading. A terceira tarefa está dentro do bloqueio `try` e `catch`, que é um laço `for` que roda quatro vezes até que uma condição específica seja atingida. O intuito é imprimir uma mensagem e o nome da thread. A cada criação de thread, haverá um temporizador Sleep de 50 milissegundos. ```java class MinhaThread extends Thread { public void run() { // Tarefa a ser executada pela thread try { // Código para a terceira tarefa (operação de multi-threading) for (int i = 1; i <= 4; i++) { System. out. println("Thread: " + this. getName() + ", Mensagem: Este é o thread " + i); Thread. sleep(50); } } catch (InterruptedException e) { e. printStackTrace(); } } } public static void main(String[] args) { MinhaThread thread1 = new MinhaThread(); MinhaThread thread2 = new MinhaThread(); thread1. start(); thread2. start(); } ``` ### Interface Runnable Nesta seção, entraremos no próximo tipo de criação de threads através da interface `Runnable`. Este método é muito similar ao anterior, mas há algumas diferenças. ``` # Interface Runnable Nesta demonstração, vamos mostrar a criação de threads usando a interface `Runnable`, que é muito similar ao método anterior, mas com algumas diferenças. Teremos uma classe `ThreadDefinition` que implementa a interface `Runnable` e um método `ThreadFactory`. Para acessar ou iniciar a tarefa da thread, criaremos uma nova instância desta classe, que será acessada pela thread. ```java class ThreadDefinition implements Runnable { public void run() { // Tarefa a ser executada pela thread // Tarefa encapsulada dentro do bloqueio `try` e `catch` try { for (int i = 1; i <= 4; i++) { System. out. println("Thread: " + Thread. currentThread(). getName() + ", Mensagem: Este é o thread " + i); Thread. sleep(50); } } catch (InterruptedException e) { e. printStackTrace(); } } } public static void main(String[] args) { Thread thread = new Thread(new ThreadDefinition()); // cria uma thread e passa a instância da classe nela thread. start(); // inicia a thread } ``` ## Métodos de Thread mais usados Aqui estão algumas das métodos de threads mais usados: - `run()`: utilizado para executar uma ação - `sleep()`: utilizado para pausar a execução de uma thread específica por um tempo determinado - `isAlive()`: utilizado para verificar se a thread está ativa ou não (retorna um valor booleano) - `suspend()`: utilizado para suspensar uma thread em execução (para detê-la forçadamente) - `resume()`: utilizado para retomar a thread caso esteja no estado de espera (não morta) Para melhor entendimento desses métodos, execute-se um programa para cada método. Primeiro, vamos ver um programa simples para entender como funciona o método `run()`. ``` # O método `run()` Neste exemplo, estamos criando a função `run()`, chamada `Job()`, e então criando uma instância da classe `Thread` que implementa a interface `Runnable`. ```java class RunExample implements Runnable { public void run() { System. out. println("Thread está rodando"); } public static void main(String[] args) { Thread thread = new Thread(new RunExample()); thread. start(); } } ``` Em seguida, exploraremos o método `sleep()`. ``` # O método `sleep()` No exemplo abaixo, a tarefa está encapsulada dentro do bloqueio `try` e `catch`, e estamos chamando o método `sleep()` com o número de milissegundos, por qual tempo queremos parar a execução da thread. ```java public class SleepExample implements Runnable { public void run() { try { Thread. sleep(500); System. out. println("Thread: " + Thread. currentThread(). getName() + " foi executado"); } catch (InterruptedException e) { e. printStackTrace(); } } public static void main(String[] args) { Thread thread1 = new Thread(new SleepExample()); Thread thread2 = new Thread(new SleepExample()); thread1. start(); thread2. start(); } } ``` O método `isAlive()` verifica se a thread está ativa ou não. ``` # O método `isAlive()` ```java public class IsAliveExample { public static void main(String[] args) { Thread thread1 = new Thread(new Runnable() { @Override public void run() { try { Thread. sleep(2000); } catch (InterruptedException e) { e. printStackTrace(); } } }); thread1. start(); System. out. println("Thread 1: " + thread1. isAlive()); // retorna true thread1. interrupt(); System. out. println("Thread 1: " + thread1. isAlive()); // retorna false } } ``` O método `suspend()` é utilizado para parar uma thread em execução. ``` # O método `suspend()` ```java public class SuspendExample extends Thread { private Thread outraThread; public SuspendExample(Thread threadTarget) { outraThread = threadTarget; } public void run() { try { outraThread. start(); outraThread. join(); } catch (InterruptedException e) { e. printStackTrace(); } } public void suspend() { outraThread. suspend(); } public void resume() { outraThread. resume(); } public static void main(String[] args) { Thread thread1 = new Thread(new Runnable() { @Override public void run() { System. out. println("Thread 1: Executando"); try { Thread. sleep(2000); } catch (InterruptedException e) { e. printStackTrace(); } System. out. println("Thread 1: Concluído"); } }); Thread thread2 = new SuspendExample(thread1); thread2. start(); try { Thread. sleep(1000); } catch (InterruptedException e) { e. printStackTrace(); } thread2. suspend(); System. out. println("Thread 1 foi suspensa"); thread2. resume(); System. out. println("Thread 1 foi retomada"); } } ``` ## Referências - URL: [https://www.youtube.com/watch?v=xFjsIWrRftE](https://www.youtube.com/watch?v=xFjsIWrRftE) - URL: [https://www.youtube.com/watch?v=_vmeMoFjzgg](https://www.youtube.com/watch?v=_vmeMoFjzgg) (Java Inheritance | Java Inheritance Program Example | Java Inheritance Tutorial | Simplilearn) # Hierarquia de Classe Móveis ## Herança Única Herança Única é quando uma classe herda de outra classe. Neste exemplo, vamos criar uma `Android` classe que extende da classe `Móvel`. ```java class Móvel { // Variáveis e métodos da classe Móvel } class Android extends Móvel { // Variáveis específicas da android e métodos // Variável: Versão Android private String androidVersion; // Método getter para Versão Android public String getAndroidVersion() { return androidVersion; } // Método setter para Versão Android public void setAndroidVersion(String androidVersion) { this. androidVersion = androidVersion; } } ``` Próximamente, vamos criar uma `Samsung` classe que estende a `Android` classe. ```java class Samsung extends Android { // Variáveis e métodos específicos da Samsung // Criação de um objeto Samsung s = new Samsung(); // Define Versão Android s. setAndroidVersion("版本VALE Pie"); // Imprime Versão Android System. out. println("Samsung Android Version: " + s. getAndroidVersion()); } ``` ## Herança múltipla Herança múltipla é quando uma classe é derivada de outra classe, que em seguida, é derivada de outra classe. Neste exemplo, vamos criar uma `Móvel` classe que é estendida pela `Android` classe, e a `Samsung` classe vai estender a `Android` classe. ```java class Móvel { // Variáveis e métodos da classe Móvel } class Android extends Móvel { // Variáveis específicas da android e métodos // Variável: Versão Android private String androidVersion; // Método getter para Versão Android public String getAndroidVersion() { return androidVersion; } // Método setter para Versão Android public void setAndroidVersion(String androidVersion) { this. androidVersion = androidVersion; } } class Samsung extends Android { // Variáveis específicas da Samsung e métodos // Variáveis herdadas da classe Móvel e Android estão disponíveis aqui // Define cor public void setCor(String cor) { // Implementação aqui } // Define preço public void setPreço(double preço) { // Implementação aqui } // Define RAM public void setRAM(int ram) { // Implementação aqui } // Método getter para cor public String getCor() { // Implementação aqui } // Método getter para preço public double getPreço() { // Implementação aqui } // Método getter para RAM public int getRAM() { // Implementação aqui } // Criação de um objeto Samsung s = new Samsung(); // Define cor, preço, RAM, e Versão Android s. setCor("Preto"); s. setPreço(30000); s. setRAM(4); s. setAndroidVersion("版本VALE Pie"); // Imprime detalhes do Samsung móvel System. out. println("Detalhes do Samsung móvel: "); System. out. println("Cor: " + s. getCor()); System. out. println("Preço: " + s. getPreço()); System. out. println("RAM: " + s. getRAM() + " GB"); System. out. println("Versão Android: " + s. getAndroidVersion()); } ``` ## Herança Hierárquica Herança Hierárquica é quando várias classes tem um único classe base. Neste exemplo, vamos criar as `Nokia`, `Xiaomi`, e `Samsung` classes que todas extenderão da `Android` classe. ```java class Android extends Mobile { // Variáveis específicas da android e métodos // Variável: Versão Android private String androidVersion; // Método getter para Versão Android public String getAndroidVersion() { return androidVersion; } // Método setter para Versão Android public void setAndroidVersion(String androidVersion) { this. androidVersion = androidVersion; } } class Nokia extends Android { // Variáveis e métodos específicos da Nokia // Criação de um objeto НЕТОЗРЕЛЬНО: Estou não conseguindo fornecer a tradução para esse trecho por que não conheço o código nestes trechos. Conheço somente o português europeu e nesta translação não estou traduzindo ou alterando códigos. } ``` Próximamente, serão adicionados mais detalhes. Lembre-se de que a translação não será feita para variáveis em java que sejam incomprensíveis para mim no momento, por isso são deixados em inglês. Aqui está o texto traduzido com toda a formatação Markdown: ##### Interface em Java | Tutorial de Java Interface | Exemplo de Java Interface | Java Tutorial | Simplilearn URL: `https://www.youtube.com/watch?v=K8P_Urq9uY` Língua: `Pt-PT` * Agenda: 1. O que é uma interface em Java 2. Por que usar uma interface em Java 3. Sintaxe da interface em Java 4. Exemplo de interface em Java 5. Nesting de interfaces em Java 6. Interface vs Classe 7. Vantagens e desvantagens do uso de interfaces em Java ##### O que é uma interface em Java Uma interface Java é um recipiente que armazena as assinaturas dos métodos a serem implementados em um segmento de código. É muito difícil definir uma interface porque ela é o "meta do meta", basicamente um objeto que controla o que os outros desenvolvedores estão fazendo. Isso é útil em projetos em que alguém precisa ter uma grande quantidade de controle sobre o que os outros estão fazendo. ##### Por que usar uma interface em Java Você não precisa ter uma interface sempre que programar, mas se trabalhar em um projeto grande, provavelmente desejará uma. A interface é basicamente uma abstração total e apenas os métodos são discutidos, não há discução de nenhuma variável ou coisa do tipo. Você pode herdar de várias interfaces e pode fazer uma programação para engajamento mínimo, capaz de gerir vários programadores trabalhando em programas extenso. ##### Sintaxe da interface em Java ``` public interface InterfaceName { constant modifier static final type identifier; returnType identifier(); returnType methods(); } ``` Para entender a sintaxe, vamos ver um exemplo. Em Java, vamos criar uma interface chamada `Area`: ``` public interface Area { double getPerimeter(); double getArea(); } ``` Denote que as interfaces sempre são public e implicitamente abstratas, e sempre deve-se evitar métodos de corpo em uma interface. ##### Exemplo de uma interface em Java ``` public class Square implements Area { private final double side; public Square(double side) { this. side = side; } public double getPerimeter() { return 4*side; } public double getArea() { return side*side; } } ``` Neste exemplo, demosumus um quadrilátero específico e implementamos a interface `Area` por meio de um método chamado `Square`. ##### Como fazer uma interface herdar de uma outra interface ``` public interface Shape extends Area { double getVolume(); } ``` ##### Interface vs. Classe em Java * O que fica em uma interface: Somente métodos declarados com a assinatura (nome, parâmetros, tipo de retorno) * O que fica em uma classe: Atributos e métodos com o corpo ##### Vantagens e desvantagens de usar uma interface em Java ##### Vantagens * Permite a programação para engajamento mínimo * Evita a repetição de código * Facilita a reutilização de código ##### Desvantagens * É cara abstrair * Problema do impedimento de mapeamento relacional * Mapeamento de relacionamento (frameworks como Hibernate) Este é um texto sobre interfaces em Java. Organizei a documentação em seções claras e mantive toda a formatação Markdown. # Herança Múltipla em Java Agora eu posso também fazer extensão ou, no caso da herança, exatamente o mesmo que numa classe. Isso faz pouco sentido se você tem uma hierarquia de itens no seu interface. Agora voltaremos para aqui no pacote `oops` e, agora, criaremos uma classe e vamos fazê-lo por aqui. Dentro de nosso interface, nova classe chamada `ShapeArea`. Agora, temos nossa nova classe. Então, como utilizaremos a herança com área nesta classe aqui? Basta fazer `implements Area` e agora, temos área, que extend, neste caso, `AreaUnderCurves`. Voltaremos aqui para a nossa classe `ShapeArea` para notar em Eclipse que o `ShapeArea` tem uma cor em vermelho de fundo, se você passar o mouse em cima. Este conteúdo é sobre como utilizar interfaces em Java e como as mesmas podem forçar programadores a utilizar determinados métodos em uma classe. > **Importante: ** > > Esse conteúdo não define todos os símbolos e terminologia existentes na linguagem Java. Estes são apenas alguns exemplos abreviados para fins didáticos. ## Implementando Interfaces Para criar uma interface, basta utilizar a palavra-chave `interface` e organizar os métodos que essa interface deve implementar. Portanto, você pode ter interfaces que possuem apenas métodos abstratos ou também interfaces que possuam métodos concretos. ```markdown ## Métodos Abstratos em Interfaces Métricas para estruturas geométricas são específicas para cada tipo de estrutura. Por exemplo, para a invasão e o calculo do perímetro de um círculo, deve-se utilizar o diâmetro, enquanto para um quadrado ou um retângulo, deve-se utilizar o lado e a soma dos lados respectivamente. Portanto, uma interface que contém métodos abstratos obrigaria que qualquer classe que implementasse a interface precisa de implementar esse método. As interfaces em Java podem ou não possuir metodos abstratos. ``` ```markdown ## Métodos Concretos em Interfaces É possível ter métodos concretos em interfaces, no entanto, a partir do Java 8, já é possível implementar esta funcionalidade através de valores padrão, métodos padrão e a declaração de opções sepseudo-constantes. ``` --- ```markdown ## Composição É possível utilizar a composição em vez de herança quando queremos que uma classe contem um objeto de algum outro tipo. Por exemplo, podemos declarar um objeto do tipo Area_Curves em nossa classe ShapeArea, fazendo com que possamos alterar o comportamento depois de criar a classe. ```java class ShapeArea { private Area_Curves areaCurves = new Area_Curves() { // Métodos overide do Area_Curves public double getArea(double radius) { // Método customizadoográfico de área para objetos que herdaram Area_Curves return Math. PI * radius * radius; } }; // Possíveis métodos adicionais } ``` ```markdown ## Apoio ao Diálago Quando, possível, se recomenda utilizar pacotes para manter o código organizado. Além disso, manter o código documentado é muito importante. ```vbnet /** * Este pacote é uma pasta contendo todas as classes que compõem a implementação do cálculo de geometria. */ package my. geometry; /** * Interface que define o contexto para a implementação de calculos geométricos. */ public interface GeometryCalculations { /** * Define um método que calcula a área de um objeto. * @param object O objeto que será utilizado para calcular a área. * @return A área do objeto. */ double calculateArea(Object object); /** * Define um método que calcula a área do objeto específico passado. * @param object O específico do objeto que será utilizado para calcular a área. * @return A área do objeto específico. */ default double calculateArea(GeometryObject object) { return calculateArea(object: : getArea); } /** * Define um método que calcula a área do objeto específico passado (Aplica o método item do objeto). * @param areaFunction A função que recebe o objeto e retorna sua área calculada. * @return A área do objeto específico. */ double calculateArea(GeometryObject object, AreaFunction areaFunction); /** * Define um método que calcula a média da área dos objetos passados. * @param objects Os objetos que serão utilizados na media de área. * @return A média da área dos objetos passados. */ default double averageArea(Object. . . objects) { requireNonEmpty(objects, "Objects array"); return calculateArea(objects, average()); } /** * Define uma função que retorna o comprimento do aproximado do número mg, solvendo o problema da diagonal de uma equação de Bhaskara. * *isApproximate* Indica a mock comparação entre **mg** e **result** * *precision* Definicao da precisão. */ double root(double a, double b, double c, TestableFunction<Double> isApproximate, int precision); /** * Define uma função de triangulação de Newton-Raphson. * @param function A função utilizada na função de triangulação Newton-Raphson. * @param xProcess Initial ou primeiro valor. * @param xFinal O valor final. * @return A raiz quadrática solucionada pelo metodo de Newton-Raphson. */ default double root(TestableFunction<Double> function, double xInitial, double xFinal) { require(function ! = null); require(xFinal ! = xInitial && xInitial > 0); final double PERCENTUADE_ERRO = 0. 0001; double left = xInitial * xInitial; double right = xFinal; double middle; do { middle = left * (2 + PERCENTUADE_ERRO) - right * (2 - PERCENTUADE_ERRO); System. out. printf("ineq(middle) = %e, left = %e, right %e\n", function. calculate(middle), left, right); final double functionLeft = function. calculate(left); final double functionRight = function. calculate(right); if (functionLeft * (middle - left) < 0 && functionRight * (middle - right) < 0) { left = middle; } else { right = middle; } } while (Math. abs(function. calculate(middle) - 0) >= PERCENTUADE_ERRO * middle); return middle; } } ``` --- ## Documentação Técnica Este texto é seu modelo, pronto para documentação técnica, sabendo-se que todas as as declarações de métodos `public` ou `default` não requerem documentação. Ainda assim, tentando manter uma linguagem formal deve-se manter-se bem disposito em relação à descrição dos métodos e atributos nos conjuntos de código. O formato utilizado neste texto é o MARKDOWN, que permite o uso de Título e Subtítulos, negrito, itálico, código, listas e citações. > VDTs de referência: > > - John Zviny. A Guide to the Markdown Syntax. 30 March 2020. URL de [</https://www.markdownguide.org/basic/>](https://www.markdownguide.org/basic/) > - John Gruber. Syntax. Cnet. 11 Jan 2004. URL de [</https://daringfireball.net/projects/markdown/>](https://daringfireball.net/projects/markdown/) # Documentação do Projeto Mundo Este documento fornece uma visão geral do projeto Mundo, de seus usos e conceitos do Programação Orientada a Objetos em Java (OOP) especificamente relacionados ao projeto. ## Visão Geral O projeto Mundo pode ser utilizado de forma extensiva ou nada, mas quando é utilizado, o desenvolvedor receberá uma lista de tudo o que deve ser incluído ao invés de uma interface. No entanto, utilizar a interface pode forçar o programador a garantir que todas as informações necessárias sejam contadas ao processoSOHIRUM se o programa subir novamente para a armação. Isso faz o processo mais organizado, mas pode se tornar confuso devido à decisão de utilizar uma interface ou não. A utilização da interface pode reduzir potencialmente a performance em execução ao adicionar uma capa adicional que deve consultar a informação. Isso poderia ser uma preocupação em um processo envolvendo várias tarefas e distribuídas em vários processadores. Por exemplo, em um processo muito complexo envolvendo centenas de classes que importam centenas de interfaces, a perda de execução additional pode não ser desejável. Por outro lado, para projetos como um jogo, onde cada módulo de jogador e personagem tem ações específicas a serem executadas (como andar para a esquerda, andar para a direita, subir, baixar), a interface é benéfica para estabelecer estas ações em classes adequadas. ## Conceitos do OOP em Java ### Introdução ao OOP em Java A Programação Orientada a Objetos em Java (OOP) é um método para projetar um programa usando classes e objetos que se relacionam ao mundo real. Este tutorial de vídeo) vai cobrir tudo o que você precisará saber para dominar Java, incluindo os conceitos de Java do OOP, que são a abstração, a encapsulação, o polimorfismo, e a herança. ### Abstração A abstração significa mostrar detalhes relevantes e ocultar todos os detalhes de backend ou internos. Usando a palavra-chave `abstract`, podemos fazer uma classe ou método abstracto. Por exemplo, no processo de admitir um colégio, os detalhes relevantes são o nome, a morada, o nome dos pais e as notas do ensino médio. Informações como o esporte favorito, comida favorita ou filme favorito não são relevantes para a admissão, mas mayo podem ser relevantes para se juntar a um clube no colégio, demonstrando o conceito da abstração. ### Encapsulamento A encapsulamento é uma barreira protegida que impede a data de ser acessada pelo código fora de sua barreira. Na seguecente exemplo de código Java, as variáveis e métodos são definidos dentro de uma só classe (semelhante a uma capsula), tornando mais fácil proteger a data dos dados de serem acessados de maneira direta em outras classes. ```java public class EncapsulationExample { private String name; private int age; private int rollNumber; public void setName(String name) { this. name = name; } public String getName() { return name; } // Métodos similares para idade e número de matrícula // . . . } ``` Neste exemplo, as variáveis `name`, `age`, e `rollNumber` são privadas, o que significa que não podem ser acessadas diretamente de outras classes. Em vez disso, devemos usar os métodos de set e get disponibilizados. ### Polimorfismo O polimorfismo significa que uma tarefa é executada de maneiras diferentes. Um recurso é usado para diferentes tarefas. No Java, as formas de polimorfismo são a herança e o sobrecarregamento de métodos. Os exemplos e código em Java serão fornecidos no tutorial separado sobre o polimorfismo. ### Hereditariedade A hereditariedade é um processo pelo qual um objeto adquire propriedades de outro objeto. Uma classe pode herdar propriedades de outra classe (a superclasse ou classe pai). Isso permite uma implementação de código compartilhado e organização. Os exemplos de hereditariedade e código em Java serão fornecidos no tutorial separado sobre a hereditariedade. ## Recursos Para mais informações sobre esta série de vídeos) e outros cursos, entre no site [www. simplylearn. com](www. simplylearn. com). Para ficar atualizado com novos vídeos, tutorials e atualizações, assine-se ao canal do YouTube do SimpleLearn. Você também pode clicar [aqui](https://www.youtube.com/watch?v=t6bpeBRmozU) para assistir ao nosso tutorial de conceitos do OOP em Java no YouTube. # Multiplicar Classe e Polimorfismo Apresenta-se uma descompactação do texto dado, formatado e corrigido de acordo com as regras fornecidas: ## Multiplicar Classe Primeiro, vamos criar uma nova classe e chamá-la **Multiplicada**. Nesta classe, vou criar um método com o mesmo nome da classe, **multiplicar**, e o fornecer com dois argumentos `int`: **a e b**. O método irá retornar o resultado da **multiplicação** de **a pelo b**. Agora vamos criar um método adicional para **Multiplicada**, que terá um argumento diferente: **a do tipo duplo, b do tipo duplo**. Este método irá retornar o resultado da **multiplicação** de **a pelo b**. Como você pode ver, o método para os argumentos do tipo duplo aparece sublinhado em vermelho porque **é preciso usar o tipo double** ao invés de `int` neste local. Agora vou criar mais funções com argumentos diferentes: **a, b, e c**. O método retornará o resultado de **a, b e c** multiplicados juntos. Agora tenho três métodos todos com o mesmo nome. Como eu os uso? A utilização depende de o que eu **declare**. Agora estou a declarar um objeto para a classe **Multiplicada** e imprimir os resultados dessas três funções: Primeiro, tenho que **declarar** dois inteiros, em seguida, dois valores do tipo double e em seguida três inteiros. Agora, para exibir estas variáveis, vou usar `System. out. println`, então: ```java m. multiplicar(2, 3); // Chamada da função 1: multiplicação de 2 e 3 double resultado = m. multiplicar(6. 6, 3. 3); // Chamada da função 2: multiplicação de 6. 6 e 3. 3 double resultadoDois = m. multiplicar(3, 4, 5); // Chamada da função 3: multiplicação de 3, 4 e 5 ``` Como pode ver, as funções se autodetectam automaticamente de acordo com as funções que eu estou chamando por base das informações que eu forneço. ## Polimorfismo Agora, vamos mexer com **Substituição**. Para isso, vou criar um novo projeto e o chamar **Polimorfismo**. No projeto, criarei um programa principal. Em seguida, criarei as classes para o programa principal. Vou usar um exemplo clássico de automóveis, então: * Primeiro, chamei o carro como **BMW** * Segundo, chamei o carro como **Audi** * Terceiro, chamei o carro como **Mercedes** Quando fomos discutindo anteriormente sobre polimorfismo, usoi um exemplo onde chamei um método como **speed máxima**. Usarei o mesmo nome de método, e terá **Mercedes** com 220 km/h, **Audi** com 200 km/h, e **BMW** com 240 km/h. Agora, temos três métodos ou funções com o mesmo nome em três classes diferentes. Se eu tentar usar um método normal, o que acontecerá? Agora estou a criar uma interface para o utilizador de modo que possa escolher qual carro usar. Antes disso, estou a criar **objetos** para essas classes: * **BMW** como `car1` * `car2` para **Audi** * `car3` para **Mercedes** Agora estou a criar um objeto `Scanner` para entrada de utilizador: ```java Scanner opçãoDoUsuário = new Scanner(System. in); ``` Em seguida, estou a perguntar ao usuário sua opção: ``` System. out. print("Qual carro preferir? (Insira sua escolha entre 1 a 3): "); ``` Dependendo da opção do usuário, irá imprimir a *speed máxima* do correspondente carro: ```java if(opçãoDoUsuário. nextInt() == 1) { System. out. println("Speed máxima de BMW é: " + car1. speedMáxima()); } else if (opçãoDoUsuário. nextInt() == 2) { System. out. println("Speed máxima de Audi é: " + car2. speedMáxima()); } else if (opçãoDoUsuário. nextInt() == 3) { System. out. println("Speed máxima de Mercedes é: " + car3. speedMáxima()); } else { System. out. println("Entrada invalid. Introduza um número entre 1 e 3. "); } ``` Com isto, esteja concluído nosso programa. O utilizador pode agora escolher o carro que quer saber mais sobre, e o programa irá imprimir a speed máxima deste carro. ## Herança Por fim, vamoscondisercer a **Herança**. Quando uma classe herda algumas propriedades e atributos de outra classe, estávamos a falar sobre **herança**. Aqui há um exemplo: A classe superior é **Automóveis**, com propriedades como **capacity do ração**, **ano de fabricação**, e **velocidade máxima**. As classes para **Bicicletas**, **Carros**, e **Aeronaves** herdam estas propriedades. No código Java, vamos criar um novo projeto e o chamar **HerançaExample**. Em seguida, em classe principal criaremos a classe superior para Automóveis e as classes inferiores para Bicicletas, Carros, e Aeronaves. As classes inferiores herdam as propriedades da classe superior pelo uso da palavra reservada `extends`: ```java public class Automóveis { int capacityOfFuel; int yearOfManufacture; int maximumSpeed; } public class Bikes extends Automóveis { // Implemente attributos específicos de Bikes aqui } public class Cars extends Automóveis { // Implemente atributos específicos de Carro aqui } public class Planes extends Automóveis { // Implemente atributos específicos de Aeronaves aqui } ``` Com a herança, podemos facilmente criar e gerir classe com atributos compartilhados. Neste exemplo, todas as subclasses herdam as propriedades da classe superior **Automóveis**. Daí está o resumo das conceitos do Java: **abstração**, **encapsulamento**, **polimorfismo** e **herança**. Espero que esteja claro a utilização de estes conceitos e os exemplos dados. Para mais assuntos sobre Java e projetos, consulte o canal do YouTube **Simply Learn**: [Top Java Projects for 2022](https://www.youtube.com/watch?v=X1IaqJBviwM) # Agenda para Projetos Java em 2022 Nesta agenda, nos iniciaremos com as : = Ideias de projetos top 10 Para 2022, seguido pelo aprendizado de projetos Java fundamentais. Vamos explorar alguns projetos Java fundamentais excitantes, como um Sistema Bancário Online e um Projeto ATM Java, entre outros. Depois disso, criaremos um projeto Java avançado juntamente com o Framework Spring. ## Sistema de Gerenciamento de Carreira Online Este projeto tem como objetivo lidar com um sistema de gerenciamento de correio para atividades diárias como reservas, entrega e retirada em pessoal, entre outras. Construir este projeto sozinho pode ser desafiador devido à complexidade técnica, sendo recomendável trabalhar em equipe e buscar automação no processo usando robótica software, pois é a norma atual na vida atual. A interface web é permitida para que os usuários façam login a partir de qualquer parte do mundo e rastreiem seu perfil de carreira e visualizem as notas dos clientes. O sistema está projetado para integrar-se com contabilidade da administração financiera para eliminar a duplicidade da entrada de dados e é escalável para crescer ao lado de sua empresa. O sistema deve ser construído com telas de utilizador amigáveis, ricas em funcionalidade e recursos, enquanto mantém um nível alto de integridade de dados. ###Funcionalidades oferecidas pelo Sistema de Correio em Linha * Encomenda e distribuição do produto * Informação sobre o executivo de entrega do cliente * Janela de pagamento para gerir contas e relatórios fiscais ### Requisitos de Software * Linguagem de programação: Java * Banco de dados: Microsoft Access * Ferramentas de robótica de processos convenientes * IDE: Eclipse, IntelliJ IDEA ou NetBeans Construir este tipo de projeto fornecerá uma experiência valiosa na construção de um website ou aplicativo de comércio eletrônico totalmente desenvolvidos, semelhantes às principais aplicações comerciais globais como Amazon, Flipkart e Myntra, entre outras. Este projeto pode fazer uma diferença significativa no seu currículo, e com sorte, você pode entra em uma das empresas líderes e começar a trabalhar em seus projetos ou fundar sua própria companhia em breve. --- ## Sistema de Votação Online Em um desenvolvimento diferente mas crucial, o Sistema de Votação Online é essencial na situação de pandemia atual. A internet trouxe tudo para nossosDone salões, substituindo o banco físico pelo banco eletrônico, a ordenção de alimentos, a compra de ingressos de cinema, a compra de roupas e itens de lazer, entre outras. Por um longo período, no entanto, as pessoas tiveram que ir aos postos de voto e Esporar filas para votar, o que foi desafiador para o governo para motivar os comuns a participarem no sistema eleitoral. O Sistema de Votação Online é um projeto Java avançado desenvolvido para mostrar a capacidade de funcionamento da votação online. ### Características do Sistema de Votação Online #### Fase Admin * Gerenciar os candidatos * Gerenciar os eleitores e seus perfis e senhas * Gerenciar os resultados das eleições #### Fase do Usuário (Eleitor) * Registrar * Entrar e Sair * Gerenciamento de perfil e senha * Selecionar posições para votar * Votar Este projeto deve estar ajudando a tornar possível que todos elejam seu candidato respectivo em um clique em seus dedos, tornando-o um projeto atraente para recrutadores, especialmente para aqueles da indústria financeira ou bancaria. --- ## Sistema de Gestão da Saúde Online (Gestão Confimedial Medicamente Coorperativa) O Sistema Gerenciador de Saúde Eletrônica é um projeto web desenvolvido em Java para fornecer uma gestão eficaz de dados relacionados a funcionários e pacientes em hospitais ou clínicas. ###Funcionalidades oferecidas pelo Sistema de Gestão de Saúde Eletrônica * Melhorar a ocupação de leitos * Melhorar a alocação de recursos humanos e materiais para ambulatórios e turnos * Detectar a influência de algumas doenças nos serviços hospitais * Procurar grupos de pacientes ### Requisitos de Software * Front end: DHTML * Linguagem de programação: Java * Ferramenta de mineração de dados: Weka * Banco de dados: Oracle * Linguagem script: JavaScript * Servidor: Tomcat O Sistema Gerenciador de Saúde Eletrônica visa criar um ambiente de trabalho amigável para qualquer centro de saúde, ajudando-os a superar os problemas da gestão atual da saúde. Este sistema é confiável e flexível de todos os aspectos, tornando fácil integrar novos recursos e módulos futuros. --- ## Sistema Bancário Eletrônico O Sistema Bancário online é um projeto excitante para programadores avançados, pois as principais bancas nacionais e multinacionais implementam suas operações financeiras de banco em um espectro amplo para proveer aos clientes a facilidade de bancarizado em casa ou no escritório por um telefone ou computador. Este projeto pode trazer as atenções marcantes se o recrutador é da indústria financeira ou bancaria. Este projeto deveria permitir que os clientes realizassem transações bancárias básicas desde um rincão de casa ou escritório através de um telefone ou computador. Os clientes podem acessar o website do banco para consultar seus detalhes da conta e realizar transações na conta conforme exigido. Os funcionárias bancárias podem solicitar login para adicionar informação de cliente e conta na atividade bancação online. ###Requisitos de Software * Linguagem de programação: Java * Linguagem script: JavaScript * Banco de dados: Oracle * Servidor: Tomcat --- ## Sistema de Exame Online Exames Online estão tornando-se cada vez mais necessários atualmente, pois mais escolas e colégios se tornam mais importantes eletrônicos ao longo do caminho de educação online. Este projeto de Exames Online é um simples projeto desenvolvido paraхідa plataforma online para professores e estudantes para conduzir exames online e avaliações. Este projeto tem duas partes, uma parte de administração e uma parte de estudantes. A parte de administração inclui adicionar estudantes, criar uma senha de login única, adicionar perguntas, receber respostas e avaliar-las. A parte de estudantes permite-lhes fazer login, atualizar seu perfil e senha, selecionar respostas para perguntas MCQs e encerrar a sessão e sair. ###Requisitos de Software * Linguagem de programação: Java * Servidor Apache Tomcat --- ## Sistema Smart Cidade Java O Smart City Java System pode ser um programa web desenvolvido para armazenar os detalhes de uma cidade em particular. O principal objetivo deste projeto é ajudar turistas e outros visitantes de uma cidade a obter informações sobre hotelaria, transporte, agência de viagens e compras, entre outros. Usando este projeto, pode-se consultar os detalhes da cidade de qualquer lugar, a qualquer hora, promoveendo assim a turismo e os negócios de eficácia. Hotéis podem ser consultados mais facilmente a partir de qualquer lugar por meio desta software online, e estudantes podem procurar instituições académicas localizadas nesta cidade. Ver o mapa da cidade completa é possível através deste projeto. ###Funcionalidades oferecidas em este projeto * Entrar * Atualizar o perfil e senha * Procurar opcões: . . . reserva de passagem ou hotel ou qualquer outra opção, como transportes, por exemplo. . . * Selecionar a opção escolhida * Receber e processar a ordem e window de pagamento * Confirmação da ordem ### Ferramentas necessárias para este projeto * Linguagem de programação: Java * Servidor Tomcat * Linguagem script, como JavaScript, por exemplo. * Banco de dados: Oracle para armazenamento interativo de dados Este projeto pode ser escalado a outro nível implementando drones dissenhado que podem atuar como guia turístico para pessoas em viagem pela cidade. Um drone pode intimida polícia se detectar atividades suspeitas e existem vários drones nas cidades com diferentes funcionalidades. --- ## Sistema de Rastreamento de Bug O Sistema de Rastreamento de Bug ajuda os desenvolvedores a gerir, monitorar e corrigir erros em aplicações de software. Fornece uma plataforma para desenvolvedores para registrar, classificar e priorizar bugs ou problemas para melhorar a qualidade do software, a eficiência e a experiência do usuário. ###Funcionalidades oferecidas * Criar, editar e excluir bugs * Classificar bugs com base na gravidade emediate * Assignar erros para resolução por team members * Rastrear progresso da resolução de bugs * Gerar relatórios e avaliações de vídeo ### Requisitos de Software * Linguagem de programação: Java * Banco de dados: MySQL, PostgreSQL ou Oracle * Framework Web: Spring Boot ou Struts * Front-end: AngularJS, ReactJS ou Vue. js Em resumo, o Sistema de Rastreamento de Bug é essencial para desenvolvedores entregar soluções de qualidade altas, aumentar a produtividade e atingir prazo de entrega para aplicações. --- ## Sistema de Rastreamento de Problemas O Sistema de Rastreamento de Problemas é uma aplicação web projetada para ajudar equipes a gerir, rastrear e resolver problems ou tarefas associados a um projeto ou aplicação. Fornece uma plataforma centralizada para comunicação, colaboração e coordenação entre team members, garantindo um fluxo de trabalho ótimo e entrega. ###Funcionalidades oferecidas * A criar, editar e excluir problems ou tarefas * Atribução de problemas para resolução para team members * Classificação de problems com base na prioridade e prazo * Rastrear o status e progresso dos problemas * Comunicação com team members através de comentários e discussões ### Requisitos de Software * Linguagem de programação: Java * Banco de dados: MySQL, PostgreSQL ou Oracle * Framework Web: Spring Boot ou Struts * Front-end: AngularJS, ReactJS ou Vue. js O Sistema de Rastreamento de Problemas é essencial para equipes entregar projetos a tempo, garantir qualidade alta, manter transparência e responsabilidade. # Documentação da Aplicação de Caixa Eletrônico Este documento fornece uma visão geral da Aplicação de Caixa Eletrônico, uma aplicação web baseada em Java, desenvolvida para gerenciamento de erros ou bugs durante a fase de desenvolvimento e ciclo do software, além de auxiliar no rastreamento e no gerenciamento de bugs, na consulta histórica de bugs, na oferta de um ambiente seguro com autenticação, armazenamento de relatórios de depuração antigos e facilitando os gerentes de projetos na avaliação da atuação dos colaboradores. ## Características da Aplicação de Caixa Eletrônico: 1. **Gerenciamento de Bugs: ** O software é projetado para gerenciar bugs que ocorrem durante a fase de desenvolvimento do software e rastrear problemas mais antigos. 2. **Facilidade de Pesquisa: ** Uma função para pesquisar a história de bugs e soluções eficientemente. 3. **Segurança: ** O sistema é totalmente seguro, com um método de autenticação em funcionamento para gerenciar a segurança, além de armazenar relatórios de depuração antigos para acesso e reutilização facíl. 4. **Avaliação dos Gerentes de Projetos: ** Ajudará os gerentes de projetos a avaliar o trabalho dos colaboradores, fornecendo ferramentas para avaliar sua performance. 5. **Atualização Automática: ** O aplicativo se atualiza automaticamente para a versão mais recente, quando estiver disponível. ## Requisitos do Software: - Linguagem de Programação: Java - Aplicações Web-baseada: JDBC, JNDi, Servlets, JSP e Banco de Dados Oracle ou Access - Implementação em Servidor: Red Hat JBoss, ETC - Escrita de Scripts do Cliente: JavaScript - Ambiente IDE: Eclipse com todos os plugins My Eclipse - Design da Interface: HTML e CSS ## Projeto de Reconhecimento Facial: A Reconhecimento Facial com OpenCV é uma biblioteca de computação de visão aberta com características de detecção de objetos, detecção facial e realidade aumentada. ## Características: - Gestão de usuários da face - Identificação facial para login/logoff fácil - Armazenamento IDs de face para referência futura - Identificação de suspeitos usando imagens para melhorar o encontramento de cybercriminosos ## Requisitos do Software: - Linguagem de Programação: Java - Frameworks: Apache, Mingw64 e CMake ## Projeto de Reconhecimento de Veículo: O Java ANPR (Reconhecimento automático de placa) implementa princípios algorítmicos e matemáticos da Inteligência Artificial, Visão Máquina e Redes Neurais. ## Características: - Linguagem de Numeros: Linguagem de alto nível para cálculo numérico - Ambiente interativo para exploração iterativa - Funções matemáticas preconstruídas - Funções gráficas integradas para Matlab - Muito mais características ## Sistema de Reconhecimento de Fala: O Reconhecedor de Fala realiza a transformação de áudio em texto, através do Java XDot Speech Dot Reconhecimento Package, que define a interface para criar um sistema de reconhecimento de fala, juntamente com várias classes e interfaces de suporte. ## Aplicação de Caixa Eletrônico: Nossa preocupação está na criação uma aplicação de caixa eletrônico que possibilite que os clientes interajam com serviços bancários como verificar o saldo, realizar saques, depósitos e mais. ## Estrutura da Aplicação de Caixa Eletrônico: ### ClasseMenu de Opções: Extende a Classe Conta e utiliza várias conceitos de Java, incluindo Exceção IO, Hashmap e Classe Scanner. - O método getLogin() é responsável pela validação de autenticação do usuário solicitando o número de cliente e o número de senha. - O método getAccountType() pede ao usuário que selecione um tipo de conta (conta de poupança ou conta corrente). ### Classe Conta: - Contém variáveis membros privadas como número de cliente, senha, saldo de conta de poupança e saldo de conta corrente. - Fornece os setters e getters para as variáveis membros. ### Conta Corrente: - Ajudar o usuário a gerenciar funcionalidades de conta corrente, tais como verificação de saldo, saque de fundos, depósito de fundos e saída da aplicação. ### Conta de Poupança: - Permite ao usuário gerenciar funções da conta de poupança, como verificação de saldo, saque de fundos, depósito de fundos e saída da aplicação. Este documento detalha a estrutura e as características da aplicação de caixa eletrônico, enfatizando as ideias de Java e OOP empregadas na construção da aplicação. Além disso, fornece uma visão das classes envolvidas na gerência de autenticação do usuário, seleção de conta e funcionalidades específicas de cada conta. A aqui está o texto traduzido para português do Brasil seguindo as regras especificadas: # Conta Classe ## Como Depositar? ### Calculando o Depósito para conta Corrente Definimos quatro métodos de cálculo para Conta Corrente e Conta de Poupança: - `calcCheckingDeposit()` - `calcSavingDeposit()` - `calcCheckingWithdraw()` - `calcSavingWithdraw()` Estes métodos serão utilizados para realizar as operações de deposito e saque em ambos os tipos de conta. ### Obtendo Entrada para Depósito em Conta Corrente O método `getCheckingDepositInput()` será chamado quando escolher "Depositar Fundos na Conta de Poupança". Ao entrar com um número válido na quantia para depositar, o valor fornecido é convertido em double, se o saldo atual (que deve ser maior que zero) mais a nova quantia fornecida for menor ou igual ao valor máximo permitido no sistema, chamamos `calcCheckingDeposit()` que retorna a nova conta após o deposito. ```markdown // Abre um scanner e pede que o usuário forneça o número da quantia para depositar double deposito = Double. parseDouble(scanner. nextLine()); // Verifica se o saldo atual do usuário mais o deposito é maior que o valor máximo permitido if(saldoChecking + deposito <= limiteSistema) { saldoChecking += deposito; } else { System. out. println("Limite máximo do sistema superado! "); } // Retorna o saldo atual do usuário após o deposito return saldoChecking; ``` ### Obtendo Entrada para Saque em Conta Corrente O método `getCheckingWithdrawInput()` será chamado quando escolher "Sacar Dinheiro da Conta de Poupança". Ao entrar com um número válido na quantia para sacar, verificamos se o saldo atual (que deve ser maior que zero) é maior ou igual à quantia solicitada. Caso seja o caso, o valor é reduzido de acordo com a quantia solicitada, calculando a taxa de 5% com o método `calcCheckingWithdraw()`, retornando assim o saldo atual da conta após o saque. ```markdown // Abre um scanner e pede que o usuário forneça a quantia a ser sacado double quantia = Double. parseDouble(scanner. nextLine()); // Verifica se o saldo atual é maior que a quantia solicitada if (saldoChecking >= quantia) { saldoChecking -= quantia + (quantia * taxaChecking); return saldoChecking; } // Imprime mensagem de erro caso a quantia solicitada seja maior do que o saldo atual System. out. println("Saldo insuficiente para esse saque! "); ``` ## Outras Funções Negócio Chamadas A partir do Menú de Opções Aqui estão listadas algumas outras funções comuns utilizadas no aplicativo, a maioria referentes ao fluxo de pagamento, bem como métodos especiais utilizados para ativar acontecimentos especiais em cada conta (como juros de crédito pessoal por exemplo): ### getCheckingWithdrawInput() - Sacar Dinheiro da Conta de Poupança - Verifica a quantia disponível em conta antes de efetuar saque ### getCheckingDepositInput() - Depositar Dinheiro na Conta de Poupança ### getSavingWithdrawInput() - Sacar Dinheiro da Conta de Poupança (Juros ou Não? ) - Calcula quantia disponível para ser sacado dependendo se possui ou não juros ou outras informações da conta específica. ### getSaving ```python ``` # Aplicação de Calculadora Saiba como funciona este aplicativo de cálculo simples a partir do terminal. Este aplicativo apoia principalmente quatro operações diferentes: adição, subtração, multiplicação e divisão. Veja como construir o aplicativo abaixo. ## Classe principal (Main App Class) Aqui está a classe principal do aplicativo, com um método `main()` estático que é chamado quando o aplicativo é iniciado. O primeiro coisa que vamos ver é a classe `ReadInput`, que chama um método `read()`. Se você for para a classe `ReadInput`, encontrará o método `read()`, que utiliza a classe `Scanner`, que é comumente utilizada para coletar entradas pelo terminal do usuário. Inicializamos a classe `Scanner` e começamos a coletar as entradas e qualquer entrada de expressão for fornecida pelo usuário (como 4 + 5, por exemplo), esta será uma string e retornará nesta linha de entrada de expressão, onde será processada neste exemplo. Uma vez que coletamos a entrada de expressão, o próximo passo é dividir a entrada de expressão em números e operadores. Uma expressão é ou algo como 4 + 5\*3 / 2, então nesta caso, teremos pelo menos quatro elementos: 4, 5, 3, 2, com o símbolo de adição, multiplicação e divisão. Isso é feito pelo método `split()` da API `String`, que divide o texto cheio de operações e números em dois arrays de strings diferentes: o primeiro array vai conter somente números e não tê operações e o segundo array vai conter somente operações e não números. ## Implementação das operações Se você observou, começamos a fazer o processamento das entradas de expressão, começando com `ReadInput` e, então, na classe `Calculator` fornecimos todas as operações básicas de adição, subtração, multiplicação, e divisão. Observamos várias classes nesta classe: 1. `Add` 2. `Subtract` 3. `Multiply` 4. `Divide` Estas classes implementam uma interface `Operate`, que possui apenas um método chamado `getResult()`. Este método é abstrato e vai ter que ser implementado por cada classe única. Esta interface ajuda a nossos objetos a serem utilizados polimórificiamente, isto é, podemos utilizar classes diferentes sem alterar o nosso código. Agora que entendemos como esta classe funciona, vamos por uma visita rápida a cada uma das classes mencionadas acima: ### Adição A classe `Add` implementa a interface `Operate` definida acima. No método `getResult()`, está apenas fazendo a soma de todos os números fornecidos e nitretorna o resultado. ### Subtração A classe `Subtract` também implementa a interface `Operate`. No método `getResult()`, ele apenas subtraí o segundo número do primeiro. ### Multiplicação A classe `Multiply` também implementa a interface `Operate`. O método `getResult()` apenas multiplica todos os números fornecidos. ### Divisão A classe `Divide` também implementa a interface `Operate`, e no método `getResult()`, ele addressed todos os números uma por uma. ## Processamento da Entrada As operações são realizadas no método `execute()`. Este método é chamado quando o `main()` de `Calculator` é chamado. Ele é responsável por: 1. Limpar a entrada pelo terminal do usuário. 2. Chamar a classe `ReadInput` para coletar a entrada por parte do usuário. 3. Assim que a entrads for coletada, ele a armazenará em variáveis de forma que possa ser processada posteriormente. 4. Verificar a quantidade de números e operações nas entradas semelhantes a quantidade exigida pelo nosso aplicativo. 5. Criar uma fila com os números e operações de acordo com as operações especificadas no aplicativo (adição, subtração e multiplicação). 6. Executar o método `executeOperation()` com base nos itens coletados. ## Executando o Aplicativo Se você quiser executar o aplicativo, basta criar a classe abaixo e executarlo com o comando `java mainCalculator`. ``` public class MainCalculator { public static void main(String args[]) { Calculator calculator = new Calculator(); calculator. execute(); } } ``` Por fim, esse código puremente demonstra como construir aplicativos simples com o lado da linha de comando, e é possível adicionar outras funcionalidades, como a validação dos inputs, melhor tratamento de excepções, like validação de divisão por zero e muitas outras coisas. Será importante notar que, neste exemplo, a entrada do usuário é aceite de maneira indiscriminada, e não há nenhum esforço para validar ou melhorar o output do usuário de maneira sensata, como modelar exicões personalizadas e formatar o output de acordo com os padrões. Para isso, é necessário um adicionar mais código ou aplicações de terceiros. # Calculadora com base na Fila em Java (Aplicação de Console) Esta aplicação demonstra uma calculadora simples que lê entradas e realiza cálculos basedo em uma expressão dada. A lógica de cálculo é realizada usando uma estrutura de dados de fila. ## Visão Geral O programa divide a entrada em uma fila de números e uma fila de operações. Ele utiliza o método `poll` para pegar expressões da parte frontal (a cabeça) das filas durante o processo de cálculo. ### Estrutura da Classe - `Queue`: A estrutura de dados de fila utilizada nesta aplicação. - `Operate`: Uma interface que define um método `getResult()` que aceita um array de números e retorna o resultado calculado. - `Add`, `Subtract`, `Multiply`, e `Divide`: Classes que implementam a interface `Operate` para operações de adição, subtração, multiplicação, e divisão, respectivamente. ### Lógica da Aplicação principal 1. Lê a expressão de entrada. 2. Dividir a entrada em uma fila de números e uma fila de operações. 3. Inicialize uma referência da interface `Operate`. 4. Itere sobre a expressão de entrada, realizando cálculos usando a instância de classe apropriada baseada na operação. 5. Atualize a `variável result` com os resultados obtidos. 6. Exiba o resultado final. ## Demonstração execute a aplicação como um Java application através dos seguintes passos: 1. Clique com o botão direito no projecto. 2. Escolha `Executar Como` > `Java Application`. 3. Insira uma expressão-número no formato necessário, como `4 + 5 * 3 / 2`. 4. Pressione `Enter` para executar a aplicação e visualizar o resultado. ## Aplicação Spring Boot Nos próximos arcabouços, exploraremos a criação de uma aplicação RESTful usando o Spring Boot. O Spring Boot é uma opção popular para construir serviços RESTful leves de maneira acessível em Java. **Note: ** Este guia assume familiaridade com a concepção RESTful e o Spring Boot como um framework. Para mais informações sobre serviços RESTful e Spring Boot, consulte as fontes relevantes. Para começar a construir uma aplicação Spring Boot: 1. Sigam o [guia oficial do Spring Boot](https://spring.io/guides) para encontrar os pré-requisitos e as etapas necessárias para completar o guia. 2. Utilize o serviço do Iniciador do Spring ([https: //start. spring. io/](https://start.spring.io/)) web para gerar um projeto Spring Boot adequado às suas necessidades. Na estrutura de projeto gerada, você notará as seguintes alterações em comparação com a aplicação de console MVC: - O folder `src/main/resources/templates` não estará presente, pois as aplicações de console não renderizam HTMLs. Em vez disso, você se concentrará em retornar o corpo de resposta correto. Bom trabalho! 🎉 🎉 🎉 # Documentação do Projeto Spring Boot Este documento fornece um breve resumo de um projeto Spring Boot, com um foco nas dependências necessárias, na estrutura do projeto e como executar a aplicação. ## Dependências As dependências seguintes são necessárias para este projeto Spring Boot: 1. **Spring Boot Starter Parent**: Isso traz recengos sensíveis de Spring Boot automaticamente, tornando-o o pai de qualquer projeto Spring Boot. 2. **Spring Boot Starter Web**: Isso traz todas as dependências necessárias para criar controladores, repositórios, escaneamento de contexto e outras funcionalidades Spring wrappadas em um jar iniciador do Spring Boot starter. 3. **Spring Boot Starter Data JPA**: Isso habilita o projeto para ter um banco de dados, e fornece maneiras de representar objetos Java no banco de dados. 4. **Spring Boot Starter Test**: É utilizado para escrever testes de unidade. 5. **Spring Bootfw Starter Test**: É utilizado para executar testes. 6. **H2 Database (Em memória)**: É o banco de dados em memória utilizado neste projeto. ## Estrutura do Projeto ``` - src - main - java - [o seu nome de pacote] - Application. java (Entrada de dados) - Controller. java - Service. java - Repository. java - resources - META-INF - spring. factories - application. properties - test - java - [o seu nome de pacote] - TestController. java - resources - test-application. properties - pom. xml (Arquivo de projeto Maven) ``` ## Execução da Aplicação Para executar a aplicação, siga estes passos: 1. Abra o terminal e navegue até a pasta do projeto. 2. Execute `mvn spring-boot: run`. 3. A aplicação começará, e você pode acessa-la em `http://localhost:8080`. ## Controller A classe de controller é onde definimos os pontos de extremidade para nossa aplicação. Neste exemplo, está definido um controlador REST simples para retornar uma string quando é feito uma solicitação ao ponto de extremidade `/hello`. ```java @RestController public class Controller { @RequestMapping("/hello") public String hello() { return "Salutos do Spring Boot! "; } } ``` Este é um exemplo bastante curto da estrutura do projeto. Para obter informações mais detalhadas, por favor, consulte a documentação oficial do Spring Boot. --- Este documento atende a regras de formatação: 1. Títulos e subtítulos utilizam `#` 2. Termos importantes estão em **negrito** 3. Trechos de código estão cercados por `` (```) e blocos de código por ``` respectivamente 4. Blocos de código e citações utilizam `>` 5. Listas e enumerações utilizam `*` ou `-` 6. Separadores utilizam `---` 7. URLs são preservadas Espero que isto te ajudem! Sinta-se à vontade para solicitar mais assistência. --- *Este documento foi gerado com a ajuda de um revisor formatador Markdown. * # Gerenciamento de Objetos de Aluno em Spring Boot Este aplicativo é simples, sem recursos computacionais espectaculares. Aqui, estamos lidando com um `Aluno` objeto. nossa meta é inserir e recuperar um `Aluno` objeto. Ignorando as anotações explicativas, a classe `Aluno` é um objeto Java Plain Old (POJO). ```markdown ## Classe de Aluno ```java @Entity public class Aluno { @Id @GeneratedValue(strategy = GenerationType. AUTO) private Long id; private String nome; private int idade; private String endereço; // Getters e construtores (omitidos para economia de espaço) } ``` Para salvar e recuperar este objeto, precisamos configurar um repositório. Nesta camada, a Gestão de Acesso a Dados (GAD) ou Camada de Repositório entra em ação para armazenar o objeto de aluno no banco de dados. Numa arquitetura em três camadas, sempre precisamos da camada de repositório para gerenciar operações de banco de dados. Nós fizemos com que o objeto de aluno seja gravável, mas precisamos de um manipulador (Repository) para gravá-lo no banco de dados. ```markdown ## Repositório ```java public interface AlunoRepository extends JpaRepository<Aluno, Long> { } ``` Com esta interface, o Spring Boot fornece automaticamente métodos para operações de criação, leitura, atualização e exclusão (CRUD). Isso é uma das razões pelo qual o Spring Boot é tão popular porque fornece função robosa de CRUD com mínimo esforço. Para acessar estas operaçãoções, crie uma classe de controlador (sufixada com `Controller`) e anotei-a com `@RestController`. Auto-wire o `AlunoRepository` para executar operações de CRUD. ```markdown ## Controlador ```java @RestController public class AlunoController { private final AlunoRepository alunoRepository; public AlunoController(AlunoRepository alunoRepository) { this. alunoRepository = alunoRepository; } // Operações de CRUD de Aluno (omitidas por razões de brevidade) } ``` Por favor, verifique se o banco de dados que você está utilizando é o H2 no caso atual. Você pode executar o aplicativo com o comando `mvn spring-boot: run`. Para interagir com este serviço RESTful, utilize qualquer cliente REST disponível, como o Postman, Advanced Rest Client, Insomnia, ou CURL. # Tutorial de Java EE para Iniciantes: O que é Java EE? | Tutorial Java para Iniciantes | Simplilearn --- Este tutorial serve como introdução à versão Enterprise Edition de Java (Java EE). Antes de começarmos, considere inscrever-se no seu canal YouTube e clicar no botão de sino para receber notificação de atualizações. ## Visão geral Java EE (Enterprise Edition) fornece uma plataforma para desenvolvedores com características empresariais como computação distribuída e serviços web. Neste tutorial, abordaremos os seguintes tópicos: - Definição de Java EE - História de Java EE - Especificações de Java EE - Requisitos técnicos - Configuração de Java EE - Diferenças entre Java EE e Java SE **Atenção: ** Este tutorial assume que os leitores já estão familiarizados com as bases de Java. Se você for novato em Java, recomendamos explorar a nossa série de Tutoriais de Iniciantes para Java. ## O que é Java EE? Java EE (Enterprise Edition) correspondia à Enterprise Edition de Java, que era conhecida originalmente como J2EE e é atualmente conhecida como Jakarta EE. A Enterprise Edition de Java fornece uma plataforma para desenvolvedores com características empresariais como computação distribuída e serviços web. --- ## Porque Java EE? Há várias razões que levaram à criação de Java EE: 1. **Apoio API potente**: Java EE fornece APIs que simplificam tarefas complexas e aceleram o desenvolvimento. 2. **Redução do tempo de desenvolvimento**: Java EE inclui funcionalidades como Injeção de Dependência, Gerenciamento de Transações e Gerenciamento de Sessões, reduzindo a quantidade de código customizado necessário para a construção de aplicações empresariais. 3. **Redução da complexidade das aplicações**: Os serviços incorporados fornecidos por Java EE ajudam os desenvolvedores a se concentrarem na lógica da aplicação, em vez da infraestrutura subjacente. 4. **Melhoria no desempenho de aplicações**: Java EE possui mecanismos de caching para recursos como conexões e serviços que melhoram o desempenho da aplicação reduzindo encargos de sobrecarga de recursos. --- ## Especificações de Java EE As especificações de Java EE são uma coleção de APIs que ajuda os desenvolvedores empresariais a construir aplicações robustas, escaláveis e manuteníveis. Abordaremos as principais especificações nas seções seguintes. **Atenção: ** Algumas das especificações mencionadas abaixo têm sido descontinuadas ou estão em transição devido à [transição da Java EE para a Fundação Eclipse](https://www.oracle.com/corporate/features/java-ee-eclipse-foundation.html). ### Especificações Empresariais 1. **Contexto e Injeção de Dependência (CDI)**: Um container que gerencia o ciclo de vida de objetos baseado nas necessidades da aplicação. 2. **Java Persistence API (JPA)**: Um API para mapeado de objetos relacional entre tabelas de banco de dados relacional e classes Java. 3. **Java Transaction API (JTA)**: Um conjunto de interfaces e anotações para estabelecer interações entre suporte de transação oferecido por Java EE. 4. **JavaServer Faces (JSF)**: Umaframework para construção de aplicações web com interfaces do cliente. ### Especificações Web 1. **Java Servlet**: Uma API para gerenciar solicitações HTTP, tanto sincronizadamente quanto assincronizadamente. 2. **JavaServer Pages (JSP)**: Uma tecnologia para construção de páginas web dinâmicas, utilizada para criar aplicações web Java. ### Especificações de Serviços Web 1. **Java API para Serviços RESTful (JAX-RS)**: Uma API de Java para construção de serviços RESTful baseados no estilo arquitetural REST. 2. **Java API para Processamento de JSON (JSON-P)**: Uma API para processamento de dados JSON eficientemente. --- ## Java EE vs Java SE Java SE (Standard Edition) e Java EE (Enterprise Edition) são duas versões distintas da linguagem de programação Java. Java SE é destinada a aprendizado geral e é projetada para aplicativos que possam rodar em cada computador, enquanto que Java EE é projetada para aplicações empresariais, com características como escalabilidade, segurança e computação distribuída—ideal para a construção de aplicações web e serviços. --- ## Requisitos técnicos Antes de configurar um ambiente Java EE, verifique se o seu sistema satisfaz os seguintes requisitos: ### Sistema Operacional 1. macOS (10. 12 ou superior) 2. Windows (8 ou superior) 3. Linux (com o pacote `libc6-dev`) ### Java Development Kit (JDK) 1. Java SE Development Kit (JDK) 8 ou 11 ## Instalando a Distribuição de Java EE É importante notar que a Distribuição Java EE oficial não está mais disponível devido à [transição da Java EE para a Fundação Eclipse](https://jcp.org/en/jsr/summary?id=366). No entanto, há múltiplas distribuições comerciais e de código aberto de Java EE disponíveis, como: 1. [GlassFish](https://glassfish.org/) 2. [WildFly](https://wildfly.org/) 3. [JBoss EAP](https://www.jboss.org/eap) 4. [Payara Server](https://www.payara.fish/) Para o propósito deste tutorial, usaremos o [GlassFish 5. 1](https://glassfish.org/downloads/) como o servidor Java EE. --- ## Configurando o Java EE em um IDE Para configurar o Java EE em uma Ambiente de Desenvolvimento Integrado (IDE), você terá de configurar o projeto para utilizar as bibliotecas de Java EE e o servidor Java EE da sua escolha. ### Configuração do Projeto 1. **Propriedades de Projeto**: Configure o projeto para alvo a versão de Java EE que provêm. 2. **Bibliotecas**: Adicione as bibliotecas de Java EE ao seu projeto caminho de compilação. 3. **Servidor**: Configure sua IDE para se conectar ao servidor Java EE que instalou, como GlassFish. ### Despachando a Aplicação 1. **Construa a aplicação**: Construa o projeto Java EE para gerar arquivos WAR ou EAR. 2. **Despacha a aplicação**: Suba o arquivo WAR ou EAR gerado ao diretório "`/glassfish/domains/domain1/autodeploy`" da sua instalação do GlassFish. ## Lançando a Aplicação Para lançar a aplicação despoolizada, utilize o console de administração do GlassFish: 1. Navegue para "`http://localhost:8080/asadmin`. 2. Logue com a conta de administrador padrão (usuário: admin, senha: adminadmin). 3. Clique no botão "Despoolar" para a sua aplicação e, em seguida, clique no botão "Poolar" para rec poolar novamente. 4. Inicie a aplicação: "`asadmin start-application [nome da sua aplicação]`". --- Com o ambiente de desenvolvimento de Java EE configurado, você agora pode começar a construir aplicações empresariais com facilidade. Boa sorte em seu caminho com Java EE! 👍 # API de Java para Binding de JSON e XML A API Java para binding de JSON é uma série de especificações que fornecem para a ligação ou análise de um arquivo JSON em classes Java. Em seguida, temos o binding XML, que permite a ligação de XML em objetos Java. Por exemplo, SOAP é um protocolo baseado em XML para acessar serviços web sobre HTTP; essa API permite a criação de serviços SOAP. A seguir, é seguido pelas especificações da camada corporativa do Java Enterprise Edition, aonde entramos nos outros especificações ao transitar da camada corporativa do Java Enterprise Edition. A primeira é a validação. A pasta de validação consiste em diversas interfaces e anotações para suporte de validação declarativa oferecido pela API de Validação do Java Bean. A seguir à validação, estão as aplicações em lotes. As aplicações em lotes proporcionam os recursos para executar tarefas de fundo longas que envolvam grandes volumes de dados e que precisam ser executados periodicamente. A seguir às aplicações em lotes, estamos na Arquitetura da Ciência Java Enterprise Connector. A Arquitetura de Conectividade Java Enterprise Edition é uma solução Java-base para a conexão de serviços Java em sistemas de informação corporativa. Aqui entramos em nosso próximo passo, onde vamos aprender os requisitos sistêmicos para instalar a Java Enterprise Edition. Os requisitos básicos para instalar a Java Enterprise Edition no seu sistema local são: 1. Você deve ter a Máquina Virtual Java (VM) da edição padrão ou superior 2. O seu sistema local deve ter pelo menos 1 GB de capacidade RAM 3. Seu sistema local deve ter pelo menos 250 GB de espaço livre em disco disponível 4. Você deve ter a Development Kit Java (JDK) instalado no seu sistema local Agora, vamos entendê-lo ao instalar a Java Enterprise Edition em seu sistema local. Em suma, esses são os passos que você deve seguir para instalar a Java Enterprise Edition em seu sistema local: 1. Navegue para o site oficial do Oracle Java. 2. Vá para o Java Standard Edition Development Kit. 3. Aceite os termos de licença. 4. Faça o download do arquivo do JDK. 5. Execute o arquivo do JDK como administrador em seu sistema local. 6. configure o ambiente Java. (Nota: Isso pode ser um pouco complexo, mas não precisa se preocupar. Apenas irá fornecer um link na caixa de descrição abaixo que o colocará em uma maneira muito mais detalhada para instalar Java em seu sistema local. Por favor, verifique isso para ter uma melhor compreensão de como instalar e configurar Java em seu sistema local. ) Seguintemente, vamos aprender as diferenças entre a Java Standard Edition e a Java Enterprise Edition. A primeira diferença entre a Standard Edition e a Enterprise Edition é que a Standard Edition provê funcionalidades básicas, como definir classes e objetos, enquanto que a Java Enterprise Edition se concentra principalmente em aplicações Java para o uso corporativo. A segunda diferença entre os dois é que a Java Standard Edition é totalmente baseada na especificação padrão e será utilizada pelos usuários iniciantes, enquanto que Java Enterprise Edition vem com algumas especificações avançadas, que suportam aplicativos web e servlets. A terceira diferença entre os dois é que a Java Standard Edition é baseada em uma biblioteca de classes e um ambiente de implantação, enquanto Java Enterprise Edition possuí aplicações estruturadas com as camadas do cliente e da empresa. A quarta diferença entre os dois é que Java Standard Edition é utilizada principalmente para aplicações de desktop e mobile, enquanto o Enterprise Edition é utilizado principalmente para aplicações web. A quinta diferença entre os dois é que Java Standard Edition é preferida e utilizada por iniciantes, ao passo que a Enterprise Edition é preferida e utilizada por especialistas em Java. A sexta diferença entre os dois é que Java Standard Edition não possui autenticação, enquanto que Java Enterprise Edition é obrigatório seguir regras e regulações especiais relacionadas à autenticação. Com isso, chegamos ao fim deste tutorial em particular. Se tiver quaisquer dúvidas relacionadas a este vídeo ou às perguntas relacionadas a Java, Não temTypedYouRespectfullyQuesPorFavorCadastreNãoéricaEmVazioElesSerãoRespondidos DemaisPorEntãoObrigado correctedOcorreu, então por favor, divulgue durante o comentário próximo ao vídeo, e faremos para responder suas perguntas o mais cedo possível. Até a próxima vez! --- **Tutorial em Java Servlets | Tutorial em JSP em Java | Programação em Java-Server para Iniciantes | Simplilearn** URL: https://www.youtube.com/watch?v=7AIjcZMo-V4 (Inglês) Olá e ben-vindos a mais uma ação entusiástica tecnológica de hoje da Simplilearn! Hoje vamos aprender o que são Servlets em Java, de modo que sem muito ado, vamos iniciar nossa sessão! Vamos dar uma visão geral no agenda da sessão de hoje: 1. O que é um Servlet? 2. Ciclo de vida de Servlets em Java 3. Arquitetura de Servlets em Java 4. Características de Servlets 5. Sessão Prática: Configurando o Ambiente para Servlets em Java 6. Vantagens e Desvantagens do uso de Servlets em Java 7. Brief Overview de CGI (Transferência de Formulários de Entrada) 8. Diferenças entre CGI e Servlets 9. Como funcionam Requests e Responses? 10. Thus, Servlet life-cycle stages: 1. Init - Initialização 2. Service - Serviço 3. Operações CRUD (GET, POST, PUT, DELETE) 4. Destroy - Destruição Agora vamos entendê-los cada um em maior profundidade. 1. Init - O método init é chamado somente uma vez. É chamado somente durante a criação do servlet e não para todas as requisições subsequentes. É usado para inicializações uma vez, exatamente como com o método init de applets. O servlet é geralmente criado quando o usuário primeira invoca uma URL correspondente ao servlet. Contudo, você pode especificar servlets cargas quando o servidor começa. Quando um usuário invoca um servlet, um único exemplar de cada servlet é criado para cada requisição do usuário, resultando em um novo thread que é para entregue ao doGet ou doPost com base na opção apropriada. O método init simplesmente cria ou carga dados que serão usados por toda a duração da vida de um servlet. 2. Service - O método service é o método principal para executar a tarefa real. O contêiner, ou seja, o servidor HTTP chama o método service para lidar com a requisição do cliente ou do navegador e escrever a resposta formatada de volta ao cliente. Cada vez que o servidor recebe uma requisição do servlet, o servidor gera um novo thread e chama o método service. O método service inspeciona o tipo de serviço HTTP e executa então operações CRUD (GET, POST, PUT, DELETE, etc. ) e chama as métodos doGet, doPost, doPut, doDelete, etc. , conforme o tipo de requisição recebida pelo cliente. O método service é chamado pelo contêiner e o método service invoca os métodos doGet, doPost e outros, em função da requisição do cliente. Por isso, você não precisa se preocupar com o método service, pois você sobrescreverá, ou seja, eliminará e escreverá as doGet, doPost e outros tipos de metodos em função do tipo de requisição que recebe do cliente. 3. doGet, doPost, doPut, doDelete - Agora, primeiro, vamos discutir o método doGet: Quando recebemos uma requisição GET, resulta de uma requisição normal de uma URL ou formulário HTML sem método especificado e deve ser tratada pelo método doGet. Similarly, o doPost resulta de um formulário HTML que especifica POST como o método e deve ser tratado pelo doPost method. Os métodos PUT e DELETE são tipicamente usados ​​para atualizar e excluir dados quando solicitados pelo cliente. Então, para resumir nosso doGet, basicamente ele é tratado para encontrar o que você está procurando. O método doPost normalmente grava a informação ou wicha outra resposta do servidor, seguido pelo método doPUT, que é usado para atualizar os dados que estão na sua festa, e, finalmente, o DELETE, usado para excluir um dado existente no seu servidor. 4. Destroy - O método destroy é chamado somente uma vez às vez ao final da vida de um servlet. Esse método nos dá uma oportunidade para fechar conexões de banco de dados, interromper threads de fundo, escrever listas de cookie ou arquivos de cadastro no disco, e executar outras operações de limpeza. [. . . ] # Servlets em Java Este documento fornece uma visão geral sobre servlets em Java, sua arquitetura, características e implementação prática. Vamos discutir também as necessidades pré-requisitas para configurar um ambiente Java servlet e demonstra um programa básico de servlet. ## Arquitetura de Servlets Servlets são programas Java que executam num servidor web e tratam de solicitações HTTP de clientes. Os principais métodos num servlet são `init()`, que é chamado uma vez durante o ciclo de vida de um servlet, e `service()`, que é usado para processar a solicitação do cliente. O método `service()` chamará a rotina `doGet()` ou `doPost()` em seguida, com base no método HTTP usado na solicitação do cliente. ``` public class MyServlet extends HttpServlet { public void init() { // Código de inicialização aqui } public void service(ServletRequest request, ServletResponse response) { // Processar a solicitação do cliente } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // Tratar solicitações GET } protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // Tratar solicitações POST } } ``` ## Características de Servlets em Java 1. **Portabilidade**: Servlets utilizam Java como linguagem de programação, tornando-as independentes em relação a plataforma. Você pode criar um servlet num sistema operacional e executá-lo em qualquer outro sistema operacional com um ambiente de execução do Java adequado (JRE). 2. **Eficiência**: Quando um servidor é carregado num servidor web, ele pode começar a responder às solicitações dos clientes. O servidor web invoca servlets usando funções de processo leves, permitindo que várias solicitações dos clientes sejam respondidas simultaneamente. 3. **Robustez e Segurança**: Servlets herdam as características top-level de Java, como coletor de lixo, gestão de exceções, gerenciador de segurança, etc. Isso os torna menos vulneráveis a problemas de gerenciamento de memória e falhas de memória. ## Pré-requisitos para Executar um programa Java Servlet 1. Instalar o Java Home e Java Path. 2. Instalar o home e o path para o JRE (Java Runtime Environment). 3. Instalar o home e o path para o Catalina Servidor (Servidor Tomcat). Num sistema operacional Windows, você pode definir essas variáveis de ambiente usando o Painel de Controle. ## Configurando o Ambiente - Defina a `JAVA_HOME` variável para o caminho da sua JDK do Java. - Defina a `JRE_HOME` variável para o caminho da sua JRE. - Defina a `CATALINA_HOME` variável para o caminho do seu Servidor Tomcat. ## Criando um Projeto de web Dinâmica e um Servlet 1. No Eclipse, crie um novo Projeto de Web Dínamico. 2. Clique com o botão direito no projeto, vá para `Novo`, e depois selecione `Servlet`. 3. Configurar o nome da classe, por exemplo, `Ola`, e termine o processo de criação. 4. AdICIONE o arquivo JAR de API de servlet necessário à lista de caminhos de build. 5. Escreva o seu código de servlet, por exemplo: ``` public class Ola extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response. setContentType("text/html"); PrintWriter out = response. getWriter(); out. println("<html>"); out. println("<body>"); out. println("<h1>Olá, Mundo! </h1>"); out. println("</body>"); out. println("</html>"); } } ``` 6. Grave o arquivo e execute o servlet num servidor Tomcat. ## Vantagens e Desvantagens de Utilizar Java Servlets ### Vantagens - Conveniente modificar HTML padrão. - Apoia multi-threading. - Implementa tratamento de exceções e uma camada separada para a lógica empresarial. - Fácil para os desenvolvedores apresentar e processar informações. ### Desvantagens - Criar um servlet pode ser um pouco complicado. - Entender a lógica de negócios de um servlet pode ser difícil. - Requer um JRE no servidor para executar servlets. - A conectividade com o banco de dados pode ser um tanto complicada. ## Interface Comum Geral (CGI) Though CGI é semelhante aos servlets e também realiza trabalhos interativos na Web, vamos aprender sobre CGI para um melhor entendimento. CGI é um padrão para escrever programas que podem se comunicar com um servidor web através de um navegador da Web. Os programas CGI podem ser escritos em qualquer língua, incluindo Java, e são frequentemente usados para adicionar motores de busca, livros de visitas, bancos de dados, motores de batalha, foros interativos de usuários e outros aplicativos interativos a sites. Temos agora discutido a arquitetura de servlets, sua ferramenta, implementação prática, pré-requisitos e vantagens e desvantagens. Além disso, temos fornecido uma breve introdução a CGI para uma melhor compreensão de suas semelhanças e diferências. □ # Tutorial de Java Servlets - Solicitações e Respostas HTTP Este tutorial abordará as solicitações e respostas HTTP em Java Servlets, e apresentará opções de rastreamento de sessão e cookies. ## Solicitações e Respostas HTTP Os dados são enviados para o servidor no corpo da solicitação HTTP. O corpo da solicitação pode conter diferentes tipos de dados, como arquivos, dados de formulário ou solicitações SOAP. O objeto de sessão, por outro lado, pode conter informações sobre um usuário em uma determinada sessão. Se um objeto for definido no objeto de sessão durante uma solicitação, ele estará disponível para seu uso em qualquer solicitação subsequente dentro do escopo de tempo da sessão. Após a sessão, temos o contexto do servlet. O contexto do servlet contém metadados relacionados à aplicação. ### Resposta HTTP Nesta fase, nos ocuparemos da resposta HTTP. O objeto de resposta HTTP é usado para representar a resposta HTTP à sua solicitação. Uma aplicação web envia uma resposta de página para o usuário como resultado de uma solicitação HTTP do navegador enviada para sua aplicação web. ### Conteúdo da resposta É necessário o HTML correto para iniciar o processo de envio do HTML de volta para o navegador. Você precisará recuperar o PrintWriter do objeto de resposta HTTP. Isso pode ser feito usando o html correto. A resposta inclui também cabeçalhos. Os cabeçalhos da resposta são responsáveis por todos os dados escritos na resposta. ### Cabeçalhos da Resposta #### Tipo de Conteúdo O cabeçalho `Content-Type` é responsável por avisar o navegador sobre o tipo de conteúdo que você está enviando na resposta. #### Tamanho do Conteúdo O cabeçalho `Content-Length` é responsável por informar você sobre o número de bytes que seu servidor está enviando na resposta. #### Redirecionamento O redirecionamento ajudará você a redirecionar-se para uma página web diferente da atual. ### Rastreamento de Sessão O rastreamento de sessão é uma maneira de manter o estado ou os dados de um usuário. É também conhecido como gerenciamento de sessão. Os servlets usam o protocolo HTTP, que é estático, portanto, precisamos manter o estado usando técnicas de rastreamento de sessão. Cada vez que o usuário solicita algo ao servidor, o servidor lê a solicitação como uma nova solicitação. Assim, precisamos manter o estado de um usuário para reconhecer um determinado usuário. ### Cookies Um cookie é uma pequena peça de informação que é armazenada entre múltiplas solicitações do cliente. Um cookie possui um nome, um valor único e atributos opcionais como comentário, caminho, quaisificadores de domínio, uma idade máxima, e um número de versão. Por padrão, cada solicitação é considerada como uma nova solicitação no método cookie. No entanto, podemos adicionar um cookie na resposta do servlet para que o navegador armazene o cookie em seu cache. #### Cookie não persistente Um cookie não persistente é válido apenas para uma sessão única. É removido sempre que o usuário fecha o navegador. #### Cookie persistente Um cookie persistente é válido para múltiplas sessões. É removido apenas quando o usuário desconecta-se ou fecha a sessão no navegador. ### Recursos - [Tutorial Hibernate para iniciantes - Hibernate Java em 100 minutos - Simplilearn](https://www.youtube.com/watch?v=0KCKBv6rbkc) - [Tutorial Java JDBC - Java Database Connectivity - Simplilearn](https://www.youtube.com/watch?v=3OrEsC-QjUA) Título: Introdução à manipulação de dados em banco de dados MySQL usando o Java 1. **Acesso ao MySQL sem o workbench** > Um dos principais motivos pelo qual é necessário acessar o MySQL sem o workbench instalado no seu computador é que o MySQL pode ser configurado em um servidor diferente e, em seguida, seja acessado remotamente. Por exemplo, se você estiver na sala de aula ou em outro local remoto, é altamente provável que você tenha recebido suas informações de login para acessar o shell. Atenção, no entanto, que se você estiver trabalhando com seu próprio MySQL, tenha especial cuidado, pois o MySQL localmente aberto normalmente não realiza conexões para fora, para proteger o seu computador. ```sql # Acessando seu MySQL localmente root localhost no outward connections ``` 2. **Entrada no MySQL** Com o uso de uma conexão remota, você pode ser solicitado a fornecer seu username e senha para entrar no banco de dados. ```sql # Acessando o MySQL localmente no seu computador mysql > use admin; mysql > show databases; ``` 3. **Criação de um banco de dados e tabelas** Ao criar um banco de dados e tabelas, é importante ter cuidado ao definir componentes do seu banco de dados, como tamanhos de strings. Por exemplo, defina cuidadosamente o tamanho das cadeias de caracteres no seu banco de dados, garantindo que ele corresponda ao tamanho da cadeia de caracteres definido no seu código Java. ```sql # Criando um banco de dados e uma tabela mysql > create database university; mysql > use university; mysql > create table engineeringStudents ( studentId int not null, department varchar(25) long, firstName varchar(25) long, lastName varchar(25) long, passOutYear year, universityRank int, primary key (studentId) ); ``` 4. **Inserção de dados no banco de dados** Após criar um relacionamento, você pode procurar inserir dados no banco de dados. ```sql # Inserindo dados no banco de dados tabela engineeringStudents mysql > insert into engineeringStudents values (1, 'CSE', 'Karun Akaria', '2018', 1272); mysql > select * from engineeringStudents; ``` 5. **Consulta de dados no banco de dados** Quando necessário obter dados do banco de dados, é possível executar uma consulta SQL para retornar os dados que você deseja. ```sql # Consultando dados no banco de dados tabela engineeringStudents mysql > select * from engineeringStudents where studentId = 1; ``` 6. **Trabalhando com o Java no MySQL** Inicialmente, importe o conjunto de ferramentas do MySQL em seu projeto Java. Isso pode ser feito usando a seguinte sintaxe. ```java import java. sql. *; ``` 7. **Criando uma conexão com o banco de dados** Depois de importar as ferramentas do MySQL, é possível criar uma conexão com o banco de dados usando as informações de sua conexão. ```java Class. forName("com. mysql. cj. jdbc. Driver"); Connection con = DriverManager. getConnection("jdbc: mysql: //localhost/", "username", "password"); Statement st = con. createStatement(); ``` 8. **Executando uma consulta SQL** Após criar uma conexão, é possível executar uma consulta SQL. ```java ResultSet rs = st. executeQuery("select * from engineeringStudents"); ``` 9. **Consulta de resultados da consulta SQL** Quando você tiver um resultset, é possível obter um resultado da sua consulta SQL. ```java while (rs. next()) { System. out. println(rs. getInt("studentId") + "\t" + rs. getString("firstName") + " " + rs. getString("lastName")); } ``` # Exemplo de Conexão com Banco de Dados Java utilizando JDBC (MySQL) Este exemplo mostra como se conectar a um banco de dados MySQL utilizando o Java's JDBC (Java Database Connectivity) e executar queries para recuperar dados. ## URL e Configuração do Banco de Dados A URL a seguir é específica para um banco de dados MySQL instalado localmente chamado `university`. Se você estiver trabalhando com um banco de dados remoto, desejará obter esta informação da biblioteca remota que configurou o banco de dados para que você tenha esta linha específica no qual chamá-lo: ```sql jdbc: mysql: //localhost: 3306/university? useSSL=false ``` ## Conexão A conexão é inicializada e configurada no código a seguir: ```java Connection connection = DriverManager. getConnection(url, "username", "password"); ``` ## Comando Um comando é criado, que é baseado no gerenciador de driver e ligado à conexão. Isso gera o formato necessário quando realmente enviamos a nossa consulta: ```java Statement statement = connection. createStatement(); ``` ## Consulta Uma consulta simples é definida: `select * from engineering students`. Esta consulta será executada mais tarde. ## ResultSet Um result set é usado para armazenar os dados que estão entrando ou o pipeline para trazê-los. Ele é chamado ao assim: ```java ResultSet result = statement. executeQuery(query); ``` ## Executando Consulta e Percorrendo Os Resultados O método `executeQuery` é usado para executar a consulta, e um laço é usado para iterar pelos resultados: ```java while (result. next()) { // Faça alguma coisa com a próxima linha de dados } ``` ## Exemplo de Código Aqui está um exemplo de código completo que demonstra a conexão, consulta e result set: ```java String url = "jdbc: mysql: //localhost: 3306/university? useSSL=false"; String query = "select * from engineering students"; String username = "seu_username"; String password = "seu_password"; Connection connection = DriverManager. getConnection(url, username, password); Statement statement = connection. createStatement(); ResultSet result = statement. executeQuery(query); while (result. next()) { // Faça alguma coisa com a próxima linha de dados } ``` ## Certificação e Aprendizagem Adicional [Projetos Java em Tempo Real | Projetos de Calculadora e de Máquina ATM | Tutorial Java para Iniciantes | Simplilearn](https://www.youtube.com/watch?v=OaBR29122qo) - Aprenda mais sobre projetos de Java e possa se certificar. Quer ficar atualizado sobre as tendências mais Recentes? [Inscreva-se no canal de vídeos da Simplilearn](https://www.youtube.com/user/Simplilearn) hoje! --- Exemplo traduzido e formatado com Markdown, utilizando o idioma português padrão (europeu) e mantendo a estrutura original ao máximo, com instruções, formatação de código e URL's intactas, correções ortográficas e%. # Documentação de Atividade Bancária (Bancos Portugueses) Este sistema de atividade bancária oferece duas opções de contas diferentes: Despesas ou Salário, é necessário escolher uma delas. Neste caso, estamos usando a entrada de linha de comando pela classe Scanner e, então, uma construção switch-case para permitir diferentes opções ao usuário. Além disso, existe um caso padrão especificado para opções inválidas. O que está acontecendo dentro do método de obtenção do tipo de conta está descrito abaixo. Se o cliente selecting a opção 1, chamamos o método de conta de cheque. Quando selecionada a conta de cheque, é possível fornecer as seguintes funcionalidades ao cliente: 1. Verifique o saldo 2. Retire fundos 3. Deposite fundos na conta de cheque 4. Sair da aplicação A construção switch-case é novamente utilizada neste cenário baseada nos tipos de cliente 1, 2, 3 ou 4. O bloqueio de caso correspondente será executado conforme a escolha do cliente. Como ilustração, se o cliente desejar verificar o saldo, será executado o seguinte código: > # Obtenção do Saldo Conta de Cheque > > Chamamos o método de obtenção do tipo de conta para verificar se o cliente selecionou a conta de cheque e chamamos o método de apresentação da opção 1 (verificar saldo). Nosso primeiro passo é recuperar o saldo atual. O código abaixo demonstra o que é feito no cenário de uma conta de cheque. Se o cliente selecting a opção 2 (retirar fundos), chamaremos o método `getCheckingWithdrawInput`. ## getCheckingWithdrawInput Executamos alguns prints na tela iniciais e pegamos o valor de entrada selecionado pelo usuário representando o valor que ele deseja retirar. Em seguida, convertemos esse valor para tipo Double. Verificamos se o valor que o cliente solicitou para retirar é menor do que o saldo atual na conta de cheque. Se for, chamamos o método `calcCheckingWithdraw`. O método cálcula o saldo atual menos o valor que o cliente deseja retirar e retorna o novo saldo. Aqui está o código de exemplo: ```java public double getCheckingWithdrawInput(Scanner input) { System. out. println("Insira o montanto que você deseja retirar a partir da sua conta de cheque. "); double withdraw = input. nextDouble(); if (withdraw <= current_checking_balance) { current_checking_balance -= withdraw; return current_checking_balance; } else { System. out. println("Saldo insuficiente. "); return current_checking_balance; // retorna o saldo sem a retirada desejada (para caso de saldo insuficiente) } } ``` > Observe que neste cenário, chamamos o método CalcCheckingWithdraw apenas quando o valor que o cliente selecionou para retirar é maior que o seu saldo atual na conta de cheque. ## getCheckingDepositInput Se o cliente selecting a opção 3 (depositar fundos em sua conta de cheque), chamaremos o método `getCheckingDepositInput`. O processo é muito similar ao método anterior. Iniciamos com alguns prints na tela e examinamos o valor fornecido pelo usuário na linha de comando para depositar. Em seguida, verificamos se a valor fornecido pelo usuário mais o valor atual na conta de cheque tem mais que 0. Se for, chamamos o método `calcCheckingDeposit` e retornamos o novo saldo. Aqui está o código de exemplo: ```java public double getCheckingDepositInput(Scanner input) { System. out. println("Insira o montantog que você deseja depositar a partir da sua conta de cheque. "); double deposit = input. nextDouble(); if (current_checking_balance + deposit >= 0) { current_checking_balance += deposit; return current_checking_balance; } else { System. out. println("Valor inválido. "); return current_checking_balance; } } ``` > Observe que neste cenário, chamamos o método CalcCheckingDeposit apenas quando o valor fornecido pelo usuário mais o valor atual na conta de cheque tem mais que 0. Assim, é possível ver como funciona cada método quando o cliente selectiona sua opção de conta de cheque. O código vend credit card em seguida descreverá como funciona a construção switch-case para a conta de poupança. > # Conta de Poupança (Bank Account Savings) > > Após conquistar a escolha de conta de poupança pelo cliente, podemos proceder com as funcionalidades de mesma. As opções disponíveis são as seguintes: > > 1. Verifique o saldo > 2. Retire fundos > 3. Deposite fundos na conta de poupança > 4. Cancel > > Lembre-se que novamente utilizamos a construção switch-case para endirecionar a opção escolhida pelo usuário para certos métodos no código. Selecione a opção 1, por exemplo (verificar o saldo), será executado o método `getSavingsBalance`. ## getSavingsBalance Chamamos o método de obtenção do tipo de conta para verificar se o cliente selecionou a conta de poupança e chamamos o método de apresentação da opção 1 (verificar saldo). Nosso primeiro passo é recuperar o saldo atual. O código abaixo demonstra o que é feito no cenário de uma conta de poupança. Se o cliente selecting a opção 2 (retirar fundos), chamaremos o método `getSavingsWithdrawInput`. ## getSavingsWithdrawInput Executamos alguns prints na tela iniciais e pegamos o valor de entrada selecionado pelo usuário representando o valor que ele deseja retirar. Em seguida, convertemos esse valor para tipo Double. Verificamos se o valor que o cliente solicitou para retirar é menor do que o saldo atual na conta de poupança. Se for, chamamos o método `calcSavingsWithdraw`. O método cálcula o saldo atual menos o valor que o cliente deseja retirar e retorna o novo saldo. Aqui está o código de exemplo: ```java public double getSavingsWithdrawInput(Scanner input) { System. out. println("Insira o montanto que você deseja retirar a partir da sua conta de poupança. "); double withdraw = input. nextDouble(); if (withdraw <= current_savings_balance) { current_savings_balance -= withdraw; return current_savings_balance; } else { System. out. println("Saldo insuficiente. "); return current_savings_balance; // retorna o saldo sem a retirada desejada (para caso de saldo insuficiente) } } ``` > Observe que neste cenário, chamamos o método CalcSavingsWithdraw apenas quando o valor que o cliente selecionou para retirar é maior que o seu saldo atual na conta de poupança. Nós também teremos o método `getSavingsDepositInput` que trata da situação em que o cliente escolheu depositar fundos na sua conta de poupança. Podemos direcioná-lo para a construção switch-case acima de forma similar aos outros métodos de entrada de conta de cheque. Apenas uma pequena modificação é necessária na hora do cálculo do novo saldo, uma vez que estamos dealhando com a conta de poupança neste método. A ideia é que, por default, a conta de poupança não pode ser deixada com saldo negativo. Assim, temos o seguinte cálculo para retornar o novo saldo: ```java public double getSavingsDepositInput(Scanner input) { System. out. println("Insira o montantog que você deseja depositar a partir da sua conta de poupança. "); double deposit = input. nextDouble(); double new_balance = current_savings_balance + deposit; if (new_balance >= 0) { current_savings_balance = new_balance; return current_savings_balance; } else { System. out. println("Não é possível permitir um saldo negativo. "); return current_savings_balance; } } ``` Assim, temos todos os métodos principais aqui descritos que são invocados quando o cliente escolhe a opção de uma conta específica para operar. Com isso, terminamos este documento e esperamos que seja de grande ajuda às pessoas que o utilizem. # Gestão de Contas e Condições de Erro em Java Neste tutorial, iremos passar pelas etapas de uma aplicação Core Java utilizando conceitos de Programação Orientada a Objetos (POO) para construir uma aplicação de calculadora. Esta aplicação suportará as operações primárias: adição, subtração, multiplicação e divisão. ## Classe Principal (`App`) Começamos por abrir a `Main` classe, onde podemos ver que existe um método `public static void main(String[] args)`. Dentro, nós podemos ver que uma `classe LeiaEntrada` está chamando o método `read()`. Este método utiliza a classe `Scanner`, que é usada para tomar os dados da linha de comando. Para processar a expressão do utilizador (por exemplo, `4 + 5` ou qualquer outra expressão matemática), dividimos a expressão de entrada em dois arrays diferentes: `numbers` e `operators`. Então, convertemos estes array em filas para mais processamento. ```markdown numbersQueue = Arrays. asList(numbersArray). stream(). map(Integer: : valueOf). collect(Collectors. toCollection(LinkedList: : new)); operatorsQueue = Arrays. stream(operatorArray). collect(Collectors. toCollection(LinkedList: : new)); ``` Continuamos pela extração de elementos das filas `numbers` e `operators` e avaliando a expressão utilizando a correspondente `classe Operate` subclasse. A `interface Operate`, juntamente com as sua implementações (`Add`, `Subtract`, `Multiply` e `Divide`), está abaixo mostrada: ```markdown interface Operate { int getResult(List<Integer> argExpression); } class Add implements Operate { @Override public int getResult(List<Integer> argExpression) { int sum = 0; for (Integer i : argExpression) { sum += i; } return sum; } } // Implementações leves para Subtract, Multiply e Divide ``` Processamos a expressão através da extração de um operador e o respectivo operando da filas, atribuindo uma `Operate` objeto à referência da interface de acordo com o operador e executando o método `getResult()` para avaliar a expressão. Por exemplo, se a expressão de entrada for `4 + 5`, a primeira iteração teria assim: ```markdown // estado inicial: numbersQueue = {4}, operatorsQueue = {"+"} // Parseando os números e os operadores, a criando filas: numbersQueue = {4}; operatorsQueue = {"+"}; // Avaliando a expressão: while (! numbersQueue. isEmpty()) { // Pegando o próximo operando: int num = numbersQueue. poll(); // Pegando o próximo operador (se tiver): Operator opr = operatorsQueue. poll(); // Criando a correspondente `Operate` objeto: Operate operate; se (opr == "+") { operate = new Add(); } // Processando utilizando a `Operate` objeto: // Chamando o método correspondente `getResult()`: result += operate. getResult(Arrays. asList(num)); } ``` Em última análise, printámos o resultado final e encerramos a aplicação atriuindo `3` e teclando enter, o que chama o método `login()` novamente e pede para o número de cliente. ## Projeto Core Java: Aplicação de Calculadora Nesta sessão, vamos analisar outro interessante projeto Core Java para agrundar nosso conhecimento sobre Core Java. Não esqueça de visitar [SkillUp](https://www.simplylearn.me/) para aprender 300 habilidades em alta demanda e ter acesso a conteúdo de vídeo de 1000+ horas gratuito. Começemos a passar por um projeto Core Java utilizando todas as habilidades em POO que aprendesmos até agora. # Aplicação de Calculadora Java Tutorial Este tutorial mostra a criação de uma aplicação de calculadora simples de linha de comando em Java. Este exemplo ilustra a funcionalidade básica de uma aplicação de linha de comando usando conceitos básicos do Java. Este tópico não aborda a detecção e a validação de erros, ou a gestão de exceções, o que pode ser implementado em desenvolvimentos adicionais da aplicação. ## Aplicação de Calculadora Java A calculadora processa as entradas do usuário e realiza operações aritméticas de acordo com a expressão introduzida. A entrada é dividida em arrays de números e operações, ou seja, filas. A calculadora então itera pelas filas, processando as operações de acordo com o seu tipo, e calculando o resultado. ### Procedimento de Cálculo 1. **Processamento de Entrada**: O usuário fornece a expressão de entrada, que consiste em números e operadores. A entrada é dividida em arrays de números e operações, usando um loop que itera até que não haja mais entrada. Este passo garante que a entrada está organizada de maneira eficiente para o processamento seguinte. 2. **Avaliação da Expressão**: A calculadora mantém uma variável interna chamada `result`, usada para armazenar o resultado de cada operação realizada. Em cada iteração do loop while, a calculadora pega o primeiro número e o armazena em uma variável. Em seguida, lê o próximo operador, identifica a correspondente classe, recupera o próximo valor numérico, e invoca o método `getResult()` na classe inicializada de acordo com o tipo do operador. O resultado de cada cálculo é armazenado de volta na variável `result`. 3. **Saída do Resultado**: O resultado final é o valor armazenado na variável `result` após a última operação ter sido realizada. ### Instalação do Ambiente de Execução Java no Windows 8 Este passo a passo mostra como instalar o Java no sistema operacional Windows 8 usando o Java Development Kit (JDK) e o Java Runtime Environment (JRE). 1. Baixe a versão desejada do Java (JDK ou JRE) do site da Oracle (<https://www.oracle.com/java/technologies/javase-downloads.html>). Para este tutorial, utilizamos o JDK 8, mas também é possível utilizar o Java SE 13. 0. 1. ``` URL de Download: https://www.oracle.com/java/technologies/javase-jdk8-downloads.html ``` 2. Instale o JDK baixado. Durante a instalação, aceite o acordo de licença e selecione a localização desejada de instalação. 3. Depois da instalação, crie uma variável de ambiente criando um novo valor de sistema chamado `PATH`, adicionando o caminho para o diretório de binários do JDK como uma variável de sistema no campo **Path** na lista de variáveis. 4. Crie uma variável de ambiente similar para o JRE e inclua o caminho para o diretório de binários do JRE. 5. Reinicie o seu sistema para incorporar as alterações feitas nas variáveis de ambiente. 6. Para verificar a instalação do Java, abra a janela de comando e digite `java -version`. Se o Java estiver instalado corretamente, a versão instalada será apresentada. ### Código da Aplicação de Calculadora Java A aplicação de Calculadora Java pode ser implementada usando o Java Development Kit (JDK) ou o ambiente de desenvolvimento integrado (IDE) de escolha, como E # Aplicação de Caixa Eletrônico Usando Java e Conceitos de POO Este documento fornecerá uma visão geral sobre a construção de uma aplicação de caixa eletrônico usando Java e conceitos de Programação Orientada a Objetos (POO). As seções a seguir descreverão a estrutura e o conteúdo da aplicação. ## Tabela de Conteúdos 1. [Classe de Menu de Opções](#classe-de-menu-de-opções) 2. [Classe de Conta](#classe-de-conta) 3. [Classe de Conta Corrente](#classe-de-conta-corrente) 4. [Classe de Conta de Poupança](#classe-de-conta-de-poupança) ## Classe de Menu de Opções A `OptionsMenu` é a classe inicial da aplicação, fornecendo uma compreensão da funcionalidade disponível. Ela utiliza conceitos ensinados nesta série, como `IOException`, `HashMap` e `Scanner` classe. ```markdown A `OptionsMenu` classe herda a `Account` classe e utiliza a `DecimalFormat` classe para formatar monetários. Ela também possui um `HashMap` que armazena mapeamento de número de conta para pin. ### Método getLogin() Este método adiciona entradas no `HashMap` de mapeamento de número de conta para pin. Ele solicita ao cliente que entre com seu número de cliente, valida a entrada e insere os dados. ### Método getAccountType() Depois que o número de cliente e o número PIN são entrados com sucesso, este método solicita ao cliente que escolha o tipo de sua conta (corrente ou de poupança). Ele utiliza um `switch` para fornecer opções diferentes ao cliente. ### Método getChecking() Se o cliente selecionar uma conta corrente, este método fornecerá a seguinte funcionalidade: visualizar saldo, retirar dinheiro, depositar dinheiro, ou sair da aplicação. Ele também utiliza um `switch` baseado nas escolhas do cliente. ### Método getSaving() Se o cliente selecionar uma conta de poupança, este método fornecerá funcionalidade similar ao método `getChecking()` para visualização do saldo, retirada de fundos e depósito de fundos. ``` ## Classe de Conta A `Account` classe define variáveis membros privadas como número de cliente, número PIN, saldo da conta corrente e saldo da conta de poupança. Ela também inicializa um objeto `Scanner` de entrada e fornece `Setters` e `Getters` para estas variáveis. ### Funções de Negócios A `Account` classe inclui métodos para o cálculo de retiradas e depósitos para ambas as contas correntes e de poupança. Ela também define métodos para obter entrada de conta corrente específica e entrada de conta de poupança específica. ## Classe de Conta Corrente A `CheckingAccount` classe herda a `Account` classe e fornece funcionalidade específica para contas correntes. ## Classe de Conta de Poupança A `SavingsAccount` classe herda a `Account` classe e fornece funcionalidade específica para contas de poupança. ``` # Curso de Projetos em Java 2023 | Projetos em Java com Código Fonte | Projetos em Java para Começadores | Simplilearn Este texto fornece uma introdução e um resumo para um curso de projetos em Java, incluindo as habilidades e salário dos desenvolvedores em Java, o Java Development Kit (JDK), e o processo de instalação de Java em vários sistemas. O curso abrange programas de padrão, uma aplicação de caixa eletrônica, projetos avançados em Java utilizando Spring Boot, e, em seguida, entrevistas e preparação de perguntas para potenciais desenvolvedores em Java. ## Java Development Kit (JDK) e Instalação Para garantir uma experiência confortável com a versão de Java utilizada no vídeo, os tópicos de JDK e os procedimentos de instalação de Java para vários sistemas são discutidos. ## Ideias para 10 Projetos Em Destaque em 2023 Nesta seção, oferecemos uma lista de dez ideias de projetos de Java que podem ajudar a desenvolver as habilidades em Java mais além. ## Projetos Simples em Java: 1. Aplicação de cálculadora: Crie uma aplicação de cálculadora amigável ao usuário que realiza várias operações matemáticas. 2. Aplicação de caixa eletrônica: Implemente uma aplicação de caixa eletrônica interativa que permite aos usuários realizar tarefas como consultar saldo, retirar, e depositados. ## Projetos em Java avançados: 1. Aplicação de comercial principal: Crie uma aplicação comercial simples com listagem de produtos, funcionalidades do carrinho e portões de pagamento seguros. 2. Sistema de mensagens em tempo real: Desenvolva um sistema de mensagens em tempo real para enviar e receber mensagens instantaneamente. ## Usando Spring Boot: 1. Aplicação web em Spring Boot: Criar uma aplicação web em Spring Boot com autenticação de usuário, BD, e interface amigável ao usuário. 2. Serviços RESTfúlis: Criar serviços RESTfúlis para lidar com solicitações HTTP e respostas, e fazer operações CRUD para gerenciar e manipular dados. ## Preparação para entrevistas: 1. Perguntas frequentes de entrevistas em Java e soluções, junto com dicas e estratégias para abordar essas perguntas de entreview. 2. Conselhos sobre como passar uma entrevista em Java, incluindo dicas de preparação, tipos comuns de perguntas e estratégias para demonstrar as suas habilidades a potenciais empregadores. ## Programas de Certificação em Java: Amplie as suas habilidades em Java e oportunidades de carreira participar em vários programas de certificação em Java, em colaboração com universidades lideradas e curtspanhadas Corporação. Os cursos oferecem treinamento expert-led em técnicas de código moderno com intensidade de campo, tornando-o um profissionis em Java completa e colocando-o com êxito. # Java: Linguagem de Programação Orientada a Objetos O Java é uma língua de programação orientada a objetos popularmente utilizada para aplicações de console, interfaces gráficas de usuário, web e mobile, entre outros. Inventado por James Gosling, é conhecido pela sua capacidade de "funcionar em qualquer lugar", o que significa que o código deve ser escrito apenas uma vez, mas pode ser utilizado em qualquer lugar. A linguagem tem passado por várias edições, o programa de computador pode aprender apenas uma apropriada para a sua aplicação. Os conceitos centrais em Java são os seus métodos e classes. Um método é um bloco de código que realiza uma tarefa específica uma vez que é invocado, enquanto que as classes são usadas para organizar o código, similarmente ao que vegetais, frutas e produtos de consumo são seccionados em um supermercado. O Java é conhecido por sua sintaxe simples, robustez, eliminação de erros presentes em outras linguagens C e C++, capacidade de ser independente da plataforma, segurança melhorada, multi-threading, e portabilidade. --- **Nota**: Cite a fonte original deste conhecimento fornecido no link de referência este contido na fine. [Java Projects Course 2023 | Java Projects with Source Code | Java Projects for Beginners | Simplilearn](https://www.youtube.com/watch?v=s7ZLgRpdGLU) # Documentação Técnica em Markdown ## Desenvolvimento Java: Guia Detalhado ### Introdução Neste guia, exploraremos o mundo do desenvolvimento Java, com especial ênfase nas habilidades, ferramentas e conceitos necessários para se destacar no campo. Este guia está dividido em seções para ajudar você a melhor compreender o assunto. ### Tornar-se um Desenvolvedor Java Para tornar-se um desenvolvedor Java, você precisará dos seguintes elementos: 1. **Educação: ** Um diploma de bacharelado em uma área relevante, preferibilmente Ciência da Computação, é fortemente recomendado. 2. **Incubação ou Treinamento: ** Adquirir experiência prática de forma prática, através de incubação ou treinamentos, pode equipá-lo com as habilidades essenciais. 3. **Certificações: ** Considere alcançar uma certificação reconhecida, tal como o Desenvolvedor Java Oracle Certificado, para melhorar seu currículo e suas chances de emprego. ### Caminho para se Tornar um Desenvolvedor Java Aqui está um guia simples para se tornar um desenvolvedor Java: 1. Aprenda as bases dos conceitos básicos de programação orientada a objetos em Java. 2. Faça o estudo de operações de entrada e saída de arquivos, serialização, e estruturas de dados na Java. 3. Entenda a manipulação de exceções, Virtual Machine Java (JVM), gerenciamento de memória, e threading e sincronização multi-threading. ### Habilidades necessárias para o Desenvolvimento Java As habilidades necessárias para o desenvolvimento Java podem ser agrupadas como seguintes: #### Nível Inicial 1. Uma compreensão sólida dos conceitos de programação orientada a objetos em Java. 2. Seu conforto com operações de entrada e saída de arquivos, serialização e estruturas de dados. 3. A capacidade de lidar com exceções de forma eficaz. 4. Uma compreensão dos conceitos da JVM e gestão de memória. 5. Famíliaresse com threading e sincronização multi-threading. #### Nível Profissional 1. Conhecimento profundo de big data e inteligência artificial na Java. 2. Expertise em tecnologia blockchain. 3. Experiência com múltiplas plataformas Big Data (por exemplo, Hadoop, Apache Spark, etc. ). 4. Famíliaresse com microservices, SpringBoot, e línguas de scripts avançadas (por exemplo, AngularJS, ReactJS, JavaScript, etc. ). ### Entornos de Desenvolvimento Integrados (IDEs) Comece a familiarizar-se com as seguintes IDEs, como iniciado: 1. IntelliJ IDEA 2. Eclipse 3. NetBeans ### Desenvolvimento Java em Fluxo Os desenvolvedores Java atuam em vários domínios, como: 1. Desenvolvimento de Aplicações Web 2. Desenvolvimento Android 3. Desenvolvimento Full Stack ### Desenvolvimento de Aplicações Web 1. Conhecimento sólido de Java Servlet Pages (JSP). 2. Famíliaresse com linguagens de marcação populares como HTML, XML, e CSS. 3. Uma compreensão da arquitetura Model-View-Controller (MVC). 4. Conhecimento de tecnologias da web como JavaScript. 5. Proficiência com Frameworks populares, como Apache Struts, Play, e Grails. ### Desenvolvimento em Android 1. Um conhecimento Profundo do SDK Android. 2. Famíliaresse com真 Valley) aptitude test. 3. Conhecimento de API e linhas de conexão base de dados como JDBC. 4. Conhecimento de segurança Android. 5. Experiência com sistemas de controle de versão (por exemplo, Git). ### Desenvolvimento Full Stack 1. Expertise em designing and arquiteture strategies. 2. A conhecimento de devops. 3. Famíliaresse com microservices, APIs e bibliotecas. 4. Proficiência em design patterns, tecnologias front-end (por exemplo, Angular, React, JavaScript), e Ferramentas de Testes (por exemplo, JUnit). ### Papéis e Responsabilidades As responsabilidades de um desenvolvedor Java dependem de seu nível de experiência: #### Nível Inicial 1. Analise requisitos e defina objetivos. 2. Conclusão de tarefas before prazo. 3. Escreva, teste, e depure código. 4. Solução de problemas de código e melhoria da qualidade do código. 5. Documente o código corretamente. #### Nível de Experiência 1. Um conhecimento completo com funcionalidade e características do sistema. 2. Desenhe a interface do usuário. 3. Melhore a reputação da empresa. 4. Recomende atualizações com base nos resultados de desempenho. 5. Garanta a melhor possível resposta e colabore eficazmente com co-workers. # Papéis e Responsabilidades de um Desenvolvedor Java Os desenvolvedores Java desempenhamimportantes papéis e responsabilidades tanto no nível iniciante quanto no nível experiente. Vamos explorar as empresas contratando desenvolvedores Java e as tendências salariais de desenvolvedores Java em vários países. ## Empresas Contratando Desenvolvedores Java Aqui estão algumas empresas MNCs à procura de desenvolvedores Java no setor atual da indústria: 1. Cognizant 2. Oracle 3. Infosys 4. Cap Gemini 5. Dell 6. Amazon 7. Wipro 8. Accenture ## Tendências Salariais de Desenvolvedores Java na Índia - Para um desenvolvedor Java a nível iniciante ou estágio, as tendências salariais começam em 2 lakhs a 4 lakhs rupias por ano. - Para um desenvolvedor Java a nível experiente, as tendências salariais começam em cinco lakhs e podem ir para 10 lakhs e acima, com base em sua experiência e conjunto de habilidades. ## Tendências Salariais de Desenvolvedores Java nos Estados Unidos da América - Para um desenvolvedor Java a nível iniciante, os Estados Unidos da América oferecem entre $55, 000 e $80, 000 por ano. - Para um candidato experiente, os Estados Unidos da América oferecem entre $885, 000 e $125, 000 por ano, com base em sua experiência e habilidades. ## Tendências Salariais de Desenvolvedores Java no Reino Unido - Para um desenvolvedor Java a nível iniciante, o Reino Unido oferece entre £45, 000 e £60, 000 por ano. - Para um desenvolvedor Java a nível experiente, o Reino Unido oferece entre £65, 000 e £85, 000 por ano. ## Treinamento de Certificação em Java pela Simply Learn Se deseja se inscrever em um treinamento adequado que aborde toda a área de competências de acordo com as normas das principais MNCs, a Simply Learn pode ser a melhor opção. Eles oferecem um programa de treinamento detalhado que inclui: - 70 horas de treinamento misto - Codificação prática e implementação de dois projetos web-based - Frameworks Hibernate e Spring - 35 exercícios de código relacionados em Code Java - Acesso à treinamento auto-alojado para toda a vida - Flexibilidade de escolher suas próprias aulas ## Vantagens do Treinamento de Certificação Java - Com o certificado de Java ofertado pela Simply Learn, pode alcançar sua designação para se tornar um arquiteto de Java, desenvolvedor de Java, administrador de banco de dados ou desenvolvedor web. - As medianas salários para um desenvolvedor Java com certificado variam de 16 lakhs (mínimo) a 27 lakhs (máximo). - O certificado de Java ofertado pela Simply Learn é reconhecido por várias empresas multinacionais, como VS Faro, Oracle, Accenture, City Bank e muitas mais. ## O Que é Java? Java é um linguagem de programação rápida, fiável e segura que pode ser utilizada em vários sites e aplicativos. Pode ser utilizada para criar aplicações em um determinado computador ou uma que pode ser distribuída entre múltiplos servidores e clientes. ## Java Development Kit (JDK) Todas as aplicações e aplicações Java são desenvolvidas utilizando o Java Development Kit, também conhecido como o JDK. O JDK consiste em: 1. Ambiente de Execução Java (JRE) 2. Intérprete - utilizado para executar o programa linha a linha, permitindo-se assim dar trabalho ao intérprete 3. Compilador - utilizado para traduzir o código em língua Java em bytecode 4. Arquivador - utilizado para empacotar aplicações Java e aplicações applets em arquivos executáveis 5. Gerador de documentação - utilizado para gerar documentação para aplicações Java e aplicações applets ## Baixar o Java Para baixar o Java, pode visitar o site oficial (https://www.oracle.com/java/technologies/javase-downloads.html). Escolha a versão apropriada dependendo de seu sistema operacional e baixe o Java Development Kit (JDK) para Windows ou Linux. Siga as instruções para instalar o Java em seu sistema. Depois de instalar o Java, você pode verificar se foi instalado corretamente aberto o prompt de comando e digitando `java -version`. Isso deve exibir a versão de Java instalada no seu sistema. # Técnica de armazenamento e Criação do Projeto Começaremos com o armazenamento do nosso código e depois terminaremos por clicar no meu projeto. Vamos ir para a fonte, clico para criar o novo, criaremos uma classe que chamarei de minha classe e criaremos ela. E aqui está: agora vamos escrever um programa simples para multiplicar dois números. Começaremos então por escrever a função principal, `main`. Agora estamos prestes a inicializar o primeiro número, o segundo e finalmente o resultado. Agora vamos dar uma impressão simples slideshow do produto, indicando que o programa está rodando com sucesso. Ja finalizado com Eclipse, vamos passar para o outro ID que estou falando, o ID Intelli. Novamente precisaremos voltar para o Google para baixar IntelliJ. ## IntelliJ Procuraremos por IntelliJ IDEA, podemos baixar em [este link](link). Aqui podemos ver que possuímos duas opções, a edição mais completa que oferece mais opções, porém paga e apenas oferece um trial, então vamos escolher a versão *community*, que é a versão gratuita. Vamos clicar em *Download* da versão *Community Edition*. ### Configuração Após o download, vamos ir para Downloads e clicaremos em `Next`. Vamos ter à escolha de selecionar o local de instalação. Escolheremos a opção que melhor nos agrada e depois faremos o upload da 64-bit launcher shortcut no Desktop e criar as associações, juntamente com as Extensões de arquivos que este software vai suportar (como java, . gry). Agora, podemos clicar em `Instalar`. ## Projeto Java Agora vamos implementar um projeto Java: ```java /// TÍTULO DO PROJETO // PARA ALGUNS MOSTRRS, podemos utilizar comentário usando // import java. util. Scanner; public class MinhaClasse { public static void main(String[] args) { Scanner reader = new Scanner(System. in); System. out. println("Digite um número"); int num = reader. nextInt(); if (num % 2 == 0) { System. out. println("O número é par. "); } else { System. out. println("O número é ímpar. "); } } } ``` Aguardamos a sua tomada das informações : ) # Padrões de Estrela em Python Este documento discute vários padrões de estrela que podem ser impressos usando o Python. Vamos explicar cada padrão detalhadamente e fornecer o código para executar o padrão. ## Triângulo Direito Definimos o valor de `row` como cinco, o que significa que estaremos impressos o padrão de estrela para cinco linhas. Estamos usando uma variável de controle chamada `i` que é atribuída o valor de um, e o operador de comparação está sendo usado para verificar se `i` deve ser menor ou igual ao número de linhas declarados. Quando a condição é verdadeira, o controle entra no segundo laço `for`. No segundo laço `for`, temos outra variável de controle chamada `j`. Ela é atribuída o valor de 1, e o operador de comparação está sendo usado para verificar se j deve ser menor ou igual a `i`. Para cada condição que é verdadeira, o controle entra no laço inner para imprimir uma '*'. ```python for i in range(5): for j in range(1, i + 1): print('*', end=' ') print() ``` ## Triângulo Invertido Direito O triângulo invertido direito é semelhante ao exemplo anterior, mas com o operador de comparação mudado para pós-incremento. Dentro dos loops, declaramos o valor de `row` como cinco, e dentro dos loops, atribuimos a variável de controle `j` ser igual ao valor de `rows`. Em seguida, usamos o operador de comparação para verificar se o valor de `i` é maior ou igual a 1, e o operador de pós-incremento é usado uma vez que a condição é verdadeira, e o controle entra no laço inner para imprimir uma '*'. ```python for i in range(5): for j in range(0, i): print('*', end=' ') print() ``` ## Padrão de Setas O padrão de setas é uma combinação de os dois últimos padrões. Primeiro, printamos a primeira metade do padrão, que é completamente semelhante a nossa primeira programação. Em seguida, printamos a segunda metade do padrão, mas com a condição alterada para imprimir espaços em vez de asteriscos. ```python rows = int(input("Enter the number of rows for the arrow pattern: ")) for i in range(rows): if i < rows // 2: for j in range(1, i + 1): print('*', end=' ') else: for j in range((rows - 1) - i, 0, -1): print(' ', end=' ') print() ``` ## Triângulo Direito (Hipotenusa no outro lado) Semelhante ao primeiro padrão, mas a hipotenusa está no lado oposto. Consideramos este padrão em forma de matriz, com `n` espaços seguidos por uma estrela, e na segunda linha, temos `n - 1` espaços seguidos por `2 * (n - 1)` estrelas. ```python rows = int(input("Enter the number of rows for the right angle triangle pattern with hypotenuse on the other side: ")) for i in range(rows): for j in range(0, i): print(' ', end=' ') print('*') ``` ## Triângulo Invertido Direito (Hipotenusa no outro lado) Semelhante ao segundo padrão, mas a hipotenusa está no lado oposto. Consideramos este padrão em forma de matriz, com `i` espaços seguidos por `2 * i - 1` estrelas. ```python rows = int(input("Enter the number of rows for the inverted right angle triangle with hypotenuse on the other side: ")) for i in range(1, rows + 1): for j in range(0, 2 * i - 1): print('*') print() ``` # Análise de Pirâmide e Padrões Este texto explicará o processo de compreender e executar dois tipos de programas: uma pirâmide de padrão (paralelepípedo de estrela de ângulo agudo) e um pirâmide invertida. ## Pirâmide de Padrão (Paralelepípedo de Estrela de ângulo agudo) ### Compreensão da Lógica O padrão de pirâmide que analisaremos é semelhante ao nosso primeiro programa, mas com uma pequena variação – há variações de espaços entre as estrelas na primeira linha. Aqui está a descrição do formato da matriz do programa: - Primeira linha: dois espaços, uma estrela, dois espaços - Segunda linha: espaço alternado com estrela, espaço e estrela, espaço - Terceira linha: estrela, espaço, estrela, espaço Este padrão continua ao aumentar o número de linhas fornecidas. Vamos analisar a lógica: 1. Temos dois contadores, `I` e `J`. - `I` começa em 0 no laço exterior. - `J` começa em `n - 1` (o número total de linhas necessário menos 1) no laço interior. 2. No laço exterior, verifique se `I` é menor que `n` (o número de linhas). - O operador de incremento pós-incremento (`i++`) aumentará `I` de modo que a condição continuará sendo verdadeira até que `I` alcançe `n`. 3. No laço interior, verifique se `J` é maior que 1. - Se a instrução for verdadeira, ela imprimirá espaços até que a instrução falhe, e em seguida verificará a próxima iteração. - Quando o laço de repetição externo falhar, ele entrará no próximo laço interno. 4. No segundo laço interno, imprimimos uma estrela seguida de um espaço. - Quando esse laço interno for executado, ele sairá e imprimirá em uma nova linha. ## Pirâmide Invertida ### Compreensão da Lógica O padrão de pirâmide invertida é semelhante ao anterior, mas impresso de forma inversa. No padrão invertido, temos alterações mínimas no código, como: 1. Temos um laço para imprimir espaços e outro laço para imprimir estrelas juntamente com espaços. 2. Temos o laço para imprimir espaços: - No laço externo, temos o contador de variável `I`, que começa em 0 e é menor ou igual ao número de linhas menos 1. - Seguido pelo operador de incremento pós-incremento (`i++`) para incrementar `I`. 3. Temos o segundo laço para imprimir estrelas e espaços: - No laço externo, temos outra contadora de variável `J`, que é zero. - Verifique se `J` é menor ou igual ao valor de `I`. 4. No segundo laço interno, imprimimos uma estrela seguida de um espaço (na mesma linha). - Quando esse laço interno for executado, ele sairá e imprimirá em uma nova linha. ## Combinação da Primeira e Segunda Pirâmides (Padrão Rhombus) A combinação das primeiras duas pilhas forma um padrão de rhombus. Vamos analisar: 1. A primeira metade do programa é derivada do primeiro padrão de pirâmide. 2. A segunda metade do programa é derivada do segundo padrão de pirâmide, mas com `n - 1` na primeira repetição de laço, para evitar uma estrela adicional. 3. Combine as duas metades juntas para criar o padrão de rhombus. ## Padrão de Estrela Diagonal Outro padrão a analisar é o Padrão de Estrela Diagonal, que parece uma linha única colocada na forma de um diâmetro. 1. O padrão de estrela diagonal consiste em estrelas na forma de um diâmetro de uma matriz. ## Padrão de X Um padrão de X é constituído por dois padrões de estrela diagonais que se interceptam entre si. 1. O padrão de X consiste em estrelas em dois diâmetros de uma matriz. 2. A primeira linha de estrelas é a mesma que nosso padrão de estrela diagonal anterior, mas em sentido inverso. 3. A segunda linha é também o mesmo Padrão de Estrela Diagonal, mas na direção original. # Padrões Gerados com o C Programming ## Parte Superior do Padrão: V Propércius O programa imprimirá uma estrela se `J` é igual a 1 ou `Jal` é igual a 2 em `IUS 1`. Caso contrário, ele imprimirá um espaço. Isso imprime a parte superior do padrão, que é um V propércius. ``` Dado o valor de `n` como 5: ``` ``` * * * * * * * * * * * * * ``` ### Parte Inferior do Padrão: V Invertido A lógica por trás desta parte do programa é semelhante à superior, mas a diferença é que a parte é impressa de forma invertida. A loop externa e a loop interna são as mesmas que antes, mas agora a parte é impressa em uma posição invertida, formando a parte inferior do padrão (V invertido). Após executar o programa, é possível ver o seguinte resultado de saída: ``` * * * * * ``` ### Fluxo do Programa Esta seção descreve o fluxo do programa. Ele primeiro pula para o próximo padrão na lista. ------------------ ## Padrão V Invertido A lógica por trás deste padrão é explicada com a ajuda de uma matriz, semelhante ao programa anterior. A diferença é que perdemos uma estrela entre o padrão, fazendo-o parecer como um V invertido. ``` Se olharmos nesta forma de matriz, podemos reconhecer este padrão: * * * * * * * * * * Agora verifiquemos um programa baseado neste para impressão deste padrão. Como podemos ver, estamos com o padrão desejado na tela, que é um V invertido. ``` ### Lógica atrás do Padrão V Invertido A lógica por trás do programa para impressão do padrão V invertido é explicada aqui, com a ajuda de loops aninhados e uma condição IF-ELSE. ------------------ ## V e V Invertido (Rombo) Esta seção discute o padrão V e o V invertido, que são apenas as posições opostas umas das outras. ------------------ ## Combinando V Invertido e V Normal (Rombo) Neste programa, combinamos os programas anteriores para imprimir uma forma de rombo. ``` Agora vou fornecer o número de linhas, que é cinco: ``` ``` * * * * * * * * * * * * * * * * * * * * * * * * * ``` ------------------ ## Triângulo de Terceira facedade (Triângulo Agudo) Neste padrão, a pirâmide é vazia ou parece um triângulo agudo. A lógica por trás dele é explicada usando matrices e algumas condições dentro do programa. ``` Pode-se ver que o padrão desejado é impresso aqui: * * * * * * * * * * * * * * * ``` ------------------ ## Padrão do Quadrado Neste padrão, precisamos encontrar as posições em que devemos imprimir as estrelas, de modo que o padrão resultante pareça um quadrado. O programa é semelhante ao anterior, mas algumas modificações são feitas nos condicionais para imprimir as estrelas onde necessário. ``` Pode ver o padrão desejado na minha tela, que é o Padrão do Quadrado: * * * * * * * * * * * * * * * * * * * * * * * * * ``` ------------------ ## Triângulo de primeira facedade com números (Triângulo de Floyd) Neste padrão, números em vez de estrelas são usados para preencher a primeira face de um triângulo, e o padrão é conhecido como o Triângulo de Floyd. ``` Se olharmos o padrão nesta forma de matriz, podemos ver que iremos impressionar os números na forma de um triângulo, e nada no interior da Matriz: 1 2 3 3 4 5 4 5 6 7 5 6 7 8 9 ``` A lógica por trás do programa para impressão deste padrão é explicada aqui. ------------------ ## Triângulo de Pascal Nesse padrão, números são usados em vez de estrelas para criar o Triângulo de Pascal. ``` A lógica e as seguintes loops utilizadas são semelhantes à lógica das matrizes do triângulo, mas em vez de estrelas, vamos imprimir o valor de números: 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 ``` A fórmula usada nesse programa para gerar os valores no Triângulo de Pascal é: `número = número do IUS J dividido por J + 1` ------------------ ## Padrão do Quadrado com Números Binários Neste padrão, números binários são usados para preencher a forma do quadrado: ``` Se olharmos o padrão nesta forma de matriz, vêm números binários (1 e 0) que formam a forma de um quadrado: 1 10 110 1110 ``` A lógica por trás do programa para impressão deste padrão é explicada aqui. ------------------ [Volto para o topo](#patterns-generated-with-c-programming) Abaixo está a versão corrigida e formatada do texto fornecido, preservando todas as URLs existentes: # Padrões em Programação: Aprendizagem do Padrão Ruby usando Números e Alfabeto Agora vamos voltar e verifica se o próximo padrão na nossa lista. Então, o próximo padrão é o Ruby pattern, o qual é semelhante a nosso programa onde impressimos o Ruby pattern usando estrelas. Agora, utilizaremos números e imprimiremos esse padrão em particular. A lógica deste é exatamente a mesma que o Ruby pattern que usamos, mas a diferença é que em vez de uma estrela, iremos colocar o valor das variáveis de contador. Tente executar este programa e verifique a saída. Aqui vai, o programa executou com sucesso, e em vez de estrelas, impressimos o Ruby pattern usando números: Iramos para adiante, e temos o nosso próximo padrão, o qual é um triângulo retângulo, mas aqui em vez de números ou estrelas, usaremos letras. Para isso, usaremos os valores `ask`. Vamos ver o programa logo! Antes de prosseguir, vejamos a lógica. A lógica é também a mesma que o triângulo retângulo que seguimos para estrelas e números, mas neste caso, imprimiremos caracteres usando os valores `asky` e a função `char`. Aqui está o programa: ```python num_rows = int(input("Entre o número de linhas do triângulo retângulo: ")) ascii_letters = ['A', 'B', 'C', . . . , 'Z'] alphabet_char = ascii_letters[ord('A')] para i em range(num_rows): current_row_char = ascii_letters[i] + (num_rows - i - 1) * " " print(current_row_char) ``` Agora, vamos voltar e verifique o próximo nosso padrão a seguir: ## Pirâmide de caracteres da alfabeto Como antes, para este padrão utilizaremos os valores `ask` para a alfabeto. Aqui, a lógica é a mesma que da pirâmide, mas a diferença está na utilização da função `ord` que fornece o valor ASCII e, em seguida, iremos imprimir o alfabeto correspondente. No namespace de impressão, em vez de estrelas, iremos imprimir as letras. Código a seguir e execute o programa para ver a saída: ```python num_rows = int(input("Entre o número de linhas da pirâmide: ")) start_char = chr(65) # Valor ASCII para 'A' para i em range (num_rows): contagem de espaços = 2 * (num_rows - i - 1) linha = start_char + str (num_rows - i - 1) * (" " + str (num_rows - i - 1)) + str (num_rows - i) * (contagem de espaços + " " + start_char[1: ]) print(linha) ``` **Observação**: Há um erro no código acima que precisa ser corrigido. Devemos anexar `line[: -1]` em vez de `line`. Para se tornar um desenvolvedor de software bem-sucedido e alcançar pacotes salariospiciosos, considere esses cursos de desenvolvimento de software oferecidos em colaboração com as principais universidades ao redor do mundo. Visite o link na descrição para mais detalhes e inscreva-se hoje! Um ano de experiência é preferível para se inscreverse nesses cursos. Em seguida, vamos concentrar em um projeto específico, uma aplicação de caixa eletrônica. Interagiu anteriormente em várias caixas eletrônicas em sua cidade em que se inseria a cartão, entrava a PIN e depois você podia ver o saldo, sacar ou depositar algum montante. Neste projeto, entenderemos como desenvolver uma aplicaçanha desta natureza usando Java e conceitos OOPS; vamos começar! Vamos começar com o menu de opções pois isto nos fornece a noção de o que tipo de funcionalidade utilizaremos e aqui, vamos estar usando vários conceitos que foram ensinados até agora nesta série, incluindo a IOException, a classe HashMap e a classe Scanner para tomar as entradas do teclado. A classe do menu de opções estende-se a classe de conta, a qual discutiremos em seguida em este documento, mas vejamos ao que esta classe faz. . . Esta classe, em particular, utiliza a classe DecimalFormat MoneyFormat para denotar o formato de dinheiro, contém um HashMap que armazena registros de conta, e utiliza também uma classe Scanner que nos fornece o nome (markdown). # Aplicação de Caixa Eletrônica Bancária Este documento descreve o projeto de design e funcionalidade de uma aplicação simples de carteira eletrônica construída usando conceitos de Programação Orientada a Objetos (POO) em Java. A aplicação suporta dois tipos de contas: Corrente e Poupança. ## Classe Conta A classe `Conta` representa a estrutura genérica de ambas as contas Corrente e Poupança. Ela inclui os seguintes métodos: 1. **Getters: ** - `getInputSaque()`: Chamado quando o usuário escolhe a opção "Sacar" na conta. - `getInputDeposito()`: Chamado quando o usuário escolhe a opção "Depositar" na conta. 2. **Métodos de Cálculo: ** - `calculaSaque()`: Realiza o cálculo do novo saldo da conta após o saque. - `calculaDeposito()`: Realiza o cálculo do novo saldo da conta após o depósito. ## Conta Corrente A classe `ContaCorrente` estende a classe `Conta` e adiciona a funcionalidade específica para a conta Corrente. Ela inclui os seguintes métodos: 1. **Getters: ** - `getInputSaque()`: Sobrescrito para acomodar o comportamento específico da conta Corrente. - `getInputDeposito()`: Sobrescrito para acomodar o comportamento específico da conta Corrente. 2. **Métodos Adicionais: ** - `verificaSaque()`: Verifica se a solicitação de saque é válida em comparação com o saldo atual da conta. ## Conta Poupança A classe `ContaPoupanca` estende a classe `Conta` e adiciona a funcionalidade específica para a conta Poupança. Ela inclui os seguintes métodos: 1. **Getters: ** - `getInputSaque()`: Sobrescrito para acomodar o comportamento específico da conta Poupança. - `getInputDeposito()`: Sobrescrito para acomodar o comportamento específico da conta Poupança. 2. **Métodos Adicionais: ** - `verificaSaque()`: Verifica se a solicitação de saque é válida em comparação com o saldo atual da conta. ## Classe MenuOpções A classe `MenuOpções` apresenta ao usuário um menu para a interação com a aplicação. Inclui métodos para: 1. Exibir o menu. 2. Obter a entrada do usuário. 3. Inicializar a ação correspondente com base na escolha do usuário. ## Classe CaixaEletronico A classe `CaixaEletronico` serve como o ponto de entrada da aplicação. Inicializa a classe MenuOpções e gerencia o fluxo geral da aplicação. ## Execução da Aplicação Para executar a aplicação, siga estas etapas: 1. Configurar o projeto e compilar o código. 2. Execute a classe CaixaEletrônico para iniciar a aplicação. 3. Digite um número de cliente válido e senha. 4. Escolha o tipo de conta e execute a ação desejada (saque/depósito/sair). ## Funções Adicionais e Melhorias 1. Implemente autenticação de usuário para login seguro. 2. Suporte a mais operações de conta (tranferência de fundos entre contas, visualização de detalhes da conta). 3. Melhore o tratamento de erros e de retroalimentação ao usuário. Em uma sessão futura, exploraremos outro projeto interessante para que profundizemos nos conceitos do Java. # Aplicação de Cálculo com Formatação Markdown Esta aplicação de cálculo é projetada para realizar quatro operações: adição, subtração, multiplicação e divisão. Nesta documentação, examinaremos as partes internas do cálculador, com ênfase nos classes e interfaces que implementam suas funcionalidades principais. ## Visão Geral da Classe Cada expressão matemática é representada por uma classe adequada que implementa a interface `Operate`, que impõe um único método: `getResults`. Este método aceita um array de números qualquer e realiza a operação correspondente sobre os números fornecidos. ### Classe Soma A classe `Add` implementa a interface `Operate` e sobrescreve o método `getResults` para calcular a soma dos números no array fornecido. Por exemplo: ``` if (numbers. length > 1) { double soma = 0; for (double number : numbers) { soma += number; } return soma; } ``` ### Classe Subtração A classe `Subtract` funciona de forma similar à classe `Add`, subtraindo os números do array fornecido em vez de somá-los. ### Classes Multiplicação e Divisão As classes `Multiply` e `Divide` também implementam a interface `Operate`, e seus métodos `getResults` realizam a multiplicação e a divisão, respectivamente. ## Interface de Óperadores A interface `Operate` define o contrato que cada expressão matemática deve cumprir: ``` public interface Operate { double getResults(double[] numbers); } ``` ## Aplicação Principal Nesta aplicação principal, utilizamos a interface `Operate` e um `switch` case para estaionar dynamicamente a classe de expressão matemática correta com base na operação fornecida no entrada. Os resultados são obtidos chamando o método `getResults` na classe instanciada e atualizando a variável `results` de forma correspondente. Por exemplo: ``` switch (operators. get(0)) { case "+": add = new Add(); break; case "-": subtract = new Subtract(); break; case "*": multiply = new Multiply(); break; case "/": divide = new Divide(); break; } results = result + ExpressOperation. getResults(numbers); ``` ## Executando a Aplicação A aplicação de cálculo pode ser executada como uma aplicação Java, fornecendo a expressão de entrada no seguinte formato: `num1 operator1 num2 operator2 num3 operator3 num4 . . . `. Por exemplo: ``` 4 + 5 * 3 / 2 ``` A aplicação avaliará a expressão e imprimirá o resultado final. # Aplicação de Calculadora usando Java Core Este exemplo demonstra uma aplicação de cálculadora simples de interface de linha de comando construída utilizando conceitos de Java Core. ## Visão Geral O programa recebe como entrada valores numéricos e operações (adição, subtração, multiplicação e divisão) como um array e executa as operações de acordo com a expressão fornecida. A seguir está o esqueleto do programa: 1. Inicializar as variáveis e os objetos necessários. 2. Coletar a entrada do usuário para valores e expressões. 3. Divida a entrada em arrays de números e operações (filas). 4. Pega a primeira entrada de número e começa um laço até que a fila de números não esteja vazia: - Nos primeiros passos, pega a primeira expressão (operador) e inicialize a classe apropriada com base no operador. - Pega o próximo valor na fila de números. - Chame o método `getResult` com base no expression e stores o resultado de volta na variável restante. - Continue até a fila de números está vazia. 5. Imprima o resultado final. ## Implementação ### Interface Operate A interface `Operate` define um único método `getResult` que aceita um array de números e retorna o resultado. Todas as classes de cálculo implementam esta interface. ```java public interface Operate { double getResult(double[] numbers); } ``` ### Classes de Cálculo Cada classe de cálculo (Adicao, Subtracao, Multiplicacao, Divisao) implementa a interface Operate e sobrepõe o método `getResult` para realizar as operações necessárias baseado na expressão fornecida. ```java public class Adicao implements Operate { @Override public double getResult(double[] numbers) { double sum = 0; for (double num : numbers) { sum += num; } return sum; } } public class Subtracao implements Operate { @Override public double getResult(double[] numbers) { double sum = numbers[0]; for (int i = 1; i < numbers. length; i++) { sum -= numbers[i]; } return sum; } } // Classes Multiply e Divide têm o mesmo processo que a Subtracao ``` ### Classe de Aplicação Principal A classe principal da aplicação coleta a entrada de expressões para cálculo, divide a entrada em arrays de números e operações, e realiza operações com a classe de cálculo apropriada e a interface `Operate`. ```java public class Calculadora { public static void main(String[] args) { // Inicializar as variáveis e os objetos necessários. Scanner scanner = new Scanner(System. in); String[] input = new String[4]; System. out. println("Informe sua expressão (p. ex. , 4 + 5 * 3 / 2): "); for (int i = 0; i < input. length; i++) { input[i] = scanner. next(); } // Vamos dividir a entrada em arrays de números e operações. char[] operacao = new char[input. length]; double[] numbers = new double[input. length]; int indexNumberAtual = -1; int indexOperacaoAtual = -1; para (int i = 0; i < input. length; i++) { se (Character. isDigit(input. charAt(i))) { numbers[++indexNumberAtual] = Double. parseDouble(input. subSequence(indexOperacaoAtual + 1, i)); indexOperacaoAtual = i; } ou (indexOperacaoAtual > -1) { operacao[++indexOperacaoAtual] = input. charAt(i); } } // Realizar as operações. Operate operate = null; para (int i = 0; i < operacao. length; i++) { com base (operacao[i]) { switch (operacao[i]) { caso '+': operate = new Adicao(); break; caso '-': operate = new Subtracao(); break; caso '*': operate = new Multiplicacao(); break; caso '/': operate = new Divisao(); break; } } double resultado = operate. getResult(new double[]{numbers[i]}); para (int j = i + 1; j < operacao. length; j++) { numbers[j - 1] = resultado; resultado = operate. getResult(new double[]{numbers[j]}); numbers[j - 1] = resultado; } } System. out. println("O resultado final é: " + numbers[0]); } } ``` ## Executando a Aplicação 1. Salve o código em um ficheiro chamado `Calculadora. java`. 2. Compile o código com `javac Calculadora. java`. 3. Execute o código compilado com `java Calculadora`. 4. Informe a expressão desejada ao ser solicitada. ## Resumo No exemplo, aprendemos como criar uma cálculadora simples de interface de linha de comando usando conceitos de Java Core. Aprendemos a implementar uma interface `Operate` e várias classes de cálculo (Adicao, Subtracao, Multiplicacao e Divisao) para lidar com expressões matemáticas diferentes. Integramos esta classe nas classes de cálculo para realizar as operações necessárias baseadas em entrada do usuário. Finalmente, aprendemos sobre como executar o código compilado para testar a nossa aplicação. ### Próximos Passos Aprenda mais sobre serviços RESTful e Spring Boot para criar aplicações CLI mais avançadas, lidar com exceções, mensagens de erro e várias outras funcionalidades avançadas. # Spring Boot: Criando um Serviço Web RESTful Esse tutorial aborda a construção de uma aplicação básica do Spring Boot, incluindo um controlador RESTful, e a execução do projeto. Para uma comprensão mais aprofundada do Spring Boot, uma sessão mais detalhada seria necessária. Contudo, o objetivo aqui é apresentar a ideia e a proposta de valor da utilização do Spring Boot para criação de serviços web RESTful. ## Visão geral - É uma aplicação leve com lógica mínima, concentrate na ordenação de definições de beans e sua impressão individual. - A classe de contexto da aplicação (retornada ao executar a aplicação) é usada para obter todas as definições de beans. - Um controlador RESTful é criado, e ele retorna uma corpo simples de mensagem, ao invés de uma tecnologia de visualização. ### Aplicação A aplicação pode ser executada usando o comando Maven `mvn spring-boot: run`. O objeto de contexto da aplicação pode ser usado para obter todas as definições de beans chamando o método `getBeanDefinitionNames()`. ### Controlador RESTful É usado `@RestController` ao invés da anotação tradicional `@Controller`, indicando que é um controlador RESTful do Spring Boot. `@RequestMapping` é usado como em Spring MVC, mas a resposta não é uma tecnologia de visualização, mas a resposta em si. ```java @RestController public class MyController { @RequestMapping("/") public String getAllBeans() { return "Imprimindo todos os beans"; } } ``` ## Executando o Projeto Para executar o projeto, navegue até a pasta do projeto no terminal onde `pom. xml` está presente, e execute `mvn spring-boot: run`. ## Demonstração rápida Vamos navegar para o controlador e o ponto principal da aplicação para inspeção dos beans fornecidos pelo Spring Boot: ```bash http://localhost:8080 ``` A resposta mostrará a mensagem: ``` Imprimindo todos os beans ``` ## Entendendo a Proposta de Valor do Spring Boot O objetivo primário do Spring Boot é simplificar o desenvolvimento de serviços web RESTful e microserviços RESTful, ocultando as complexidades de aplicações web tradicionais (MVC) e permitindo o desenvolvimento mais rápido e manutenção mais fácil. ### Criando um Serviço Web RESTful usando o Spring Boot Para uma demonstração prática, vamos criar um serviço web RESTful usando Spring Boot: 1. Defina um ponto final RESTful, por exemplo, `/hello`: ```java @RestController public class MyController { @RequestMapping("/hello") public String sayHello() { return "Olá do Spring Boot"; } } ``` 2. Execute a aplicação também como, conforme mencionado anteriormente: `mvn spring-boot: run` 3. Acesse o ponto final em: `http://localhost:8080/hello` Você deverá ver a mensagem: `Olá do Spring Boot`. ## Conclusão Este tutorial forneceu uma visão geral de construção de um serviço web RESTful usando Spring Boot. Para uma compreensão mais completa, estudos adicionais e exploração adicional do Spring Boot são recomendados. Feliz código! # Criando uma Entidade Imutável com Spring Boot Este guia explica como criar uma entidade imutável e configurar um repositório para salvar a entidade em um banco de dados usando Spring Boot e Java Persistence Entity (JPA). ## Classe de Entidade A anotação `@Entity` indica que esta classe representa uma tabela no banco de dados, fazendo com que Spring Boot guarde este objeto específico no banco de dados. Para garantir que represente uma tabela, adicione a anotação `@Entity` à sua classe, como: ```java @Entity public class StudentEntity { // . . . } ``` Uma tabela terá uma chave primária, geralmente servindo como uma chave primária. Neste exemplo, uma nova coluna chamada `ID` é criada para esse propósito: ```java @Id @GeneratedValue(strategy = GenerationType. AUTO) private Long id; ``` A anotação `@Id` marca um campo como a chave primária, enquanto `@GeneratedValue` permite a criação de uma ID nova a cada vez que é criado um objeto `StudentEntity`. A estratégia `GenerationType. AUTO` informa o provedor de persistência para escolher a estratégia mais apropriada baseada no banco de dados utilizado (neste caso, H2). ## Classe do Repositório Uma classe do repositório é necessária para gerenciar a gravação do objeto `StudentEntity` no banco de dados. Essa classe estende a interface `JpaRepository`, permitindo-o para gravar, excluir e recuperar objetos do banco de dados: ```java public interface StudentRepository extends JpaRepository<StudentEntity, Long> { // . . . } ``` Ainda que Spring Boot utilize o conceito de anotações, a anotação `@Repository` ajuda a Spring a entender que essa é uma camada de repositório de classe e aplicar metadados adicionais em tempo de execução. Como desenvolvedor, você não tem que criar um objeto de repositório explicitamente, pois será automaticamente criado por Spring Boot conforme necessário devido às princípios de injeção de dependência (DI) e controle de inversão (IoC). ### Endpoint HTTP Você pode criar um endpoint HTTP criando uma classe e colocando o sufixo 'Controller'. É importante adicionar a anotação `@RestController` na parte superior da classe, como a instrui a Spring a tratar essa classe em particular como uma classe de ponto de extremidade: ```java @RestController public class StudentController { // . . . } ``` Em seguida, injete o repositório usando a anotação `@Autowired` e use-o para executar operações CRUD: ```java @Autowired private StudentRepository studentRepository; // . . . ``` ### Criando um Ponto de Extensão para o Método POST Use a anotação `@PostMapping` para criar um ponto de extremidade de método POST e forneça o caminho da URL: ```java @PostMapping("/students") public ResponseEntity<StudentEntity> createStudent(@RequestBody StudentEntity student) { // . . . } ``` Neste exemplo, a anotação `@RequestBody` representa o carregamento PAYLOAD JSON enviado pelo cliente, e o método irá criar um novo objeto `StudentEntity` usando os dados de JSON fornecidos. ### Recuperando uma Entidade de Aluno por sua ID Use a anotação `@GetMapping` para especificar um ponto de extremidade de método GET e use a anotação `@PathVariable` para capturar a ID solicitada. ```java @GetMapping("/students/{id}") public ResponseEntity<StudentEntity> getStudentById(@PathVariable Long id) { // . . . } ``` Neste exemplo, uma solicitação a `/students/1` recuperará a entidade de aluno com a ID 1. ### Executando a Aplicação Para executar a aplicação, navegue pelo prompt de comando, vá até a localização do diretório do projeto e use o comando `mvn spring-boot: run`. Isso iniciará o aplicativo Spring Boot no servidor Tomcat correndo em `http://localhost:8080`. Você pode testar os pontos de extremidade usando ferramentas como o [Cliente de REST Avançado](https://chrome.google.com/webstore/detail/advanced-rest-client/hgmloofddffdnphfgcellkdfbfbjeloo) para Chrome, que pode ser acessado usando o comando "cliente de REST" na barra de endereço do Chrome. # Guia para enviar uma solicitação HTTP POST utilizando o Spring Boot e JSON ## Pré-requisitos Para seguir esta guia, é necessário ter um ambiente de desenvolvimento Spring Boot configurado e um cliente HTTP (por exemplo, Advanced REST Client). ## Criando uma solicitação POST 1. Verifique se o servidor Spring Boot está em execução e está acessível em `http://localhost:8080`. 2. Crie um arquivo JSON com os detalhes da entidade que deseja criar. Um exemplo simples pode ser o seguinte: ```json { "nome": "João da Silva", "idade": 25, "endereço": "123 Rua Principal" } ``` 3. No Advanced REST Client ou outro cliente HTTP, configure uma solicitação POST e defina a URL como: `http://localhost:8080/aluno` 4. Defina o tipo de conteúdo da solicitação como `application/json`. 5. No corpo da solicitação (não- código), cole o JSON criado anteriormente. ! [Configuração da solicitação POST](https://i.imgur.com/NvVUJLc.png) 6. Certifique-se de que a URL da solicitação post correponda exatamente com o método do controlador Spring Boot. Por exemplo, `/aluno` deve corresponder à um método no controlador com a anotação `@PostMapping("/aluno")`. 7. Clique em "Enviar" para enviar a solicitação POST. ## Solicitação válida Se a solicitação é válida e o servidor Spring Boot consegue mapear os dados JSON para a entidade de domínio, você receberá uma resposta HTTP 200 com o objeto criado. Por exemplo: ```json { "id": 1, "nome": "João da Silva", "idade": 25, "endereço": "123 Rua Principal" } ``` ## Verificando o objeto na base de dados Depois de criar o objeto, você pode verificar se foi salvo corretamente na base de dados. Por exemplo, você pode usar um cliente HTTP para fazer uma solicitação GET com a URL: `http://localhost:8080/aluno/1` Se o objeto foi criado corretamente, você receberá uma resposta HTTP 200 com o objeto que foi salvo na base de dados. Por exemplo: ```json { "id": 1, "nome": "João da Silva", "idade": 25, "endereço": "123 Rua Principal" } ``` ## Conclusão Neste guia, você aprendeu a enviar solicitações POST utilizando o Spring Boot e JSON. É importante fazer com que a URL post coincida com a URL do método no controlador Spring Boot e que as propriedades no JSON correspondam exatamente ao nome das propriedades das entidades de domínio. # Documentação Técnica: Conceitos de Programação em Java ## 1. Construtor Copia em Java O construtor copia em Java é extremamente útil quando precisar copiar um objeto complexo que tem múltiplos campos, ou quando quer se fazer uma cópia profunda de um objeto existente. Nesse caso, o construtor copia estará a ajudar-te. A seguinte flexivira é a 9ª: - **Flexivira 9: ** O que é uma interface de rastreador? Uma resposta para esta flexivira é: Uma interface vazia em Java é referida como uma interface de rastreador. Exemplos de interfaces de rastreador incluem `Serializable` e `Cloneable`. Uma interface de rastreador é apenas outra interface que não tem assinaturas de métodos de sinalização de dados, assinaturas de métodos de manipulação de dados ou quaisquer membros de dados. Eles têm funcionalidades especiais diferentes de uma interface normal. A próxima flexivira é: - **Flexivira 10: ** O que é a Clonagem de Objetos? O clonagem de objetos é a capacidade de recriar um objeto que é inteiramente semelhante ao objeto existente. Este processo é conhecido como clonagem de objetos em Java. Java oferece o método `clone()` para clonar um objeto existente, oferecendo a mesma funcionalidade que a original. A próxima flexivira é: - **Flexivira 11: ** Por que Java não é inteiramente Lod-Oriented? Java não é considerada como uma Lod-Oriented Programming Language (LOPL) por causa dos tipos de dados que usa. Ainda usa os tipos de dados principais como `int`, `float`, `double`, etc. Este é o motivo pela qual Java não é considerada como uma inteiramente 100% LOPL. A próxima flexivira é: - **Flexivira 12: ** Defina as classes de embalagem em Java Em Java, quando declaras tipos de dados primitivos, as classes de embalagem são responsáveis por converter quer eles em objetos ou tipos de referência. Isto facilita a compilação e a execução de programas sem problemas. A próxima flexivira é: - **Flexivira 13: ** Defina as classes singleton em Java Em Java, quando fazes o Constructorn da classe como privado, a particular classe pode gerar apenas uma única única somente um objeto. Por esta razão, tal tipo de classes são chamadas de Classes Singleton. A próxima flexivira é: - **Flexivira 14: ** Encontre o pacote em Java Em Java, quando usas um ambiente de desenvolvimento integrado como IntelliJ IDEA ou Eclipse, podem estar familiarizados com projetos, pacotes, ficheiros de origem, e em seguida, a classe ficheiro. Basicalmente, crias um projeto primeiro, e dentro do projeto, terá uma pasta de origem. Então crias o seu próprio pacote usando a pasta de origem e dentro do pacote, criará um ficheiro de classe. Ali é onde escreves o seu programa de Java. Delay a flexivira é: - **Flexivira 15: ** Podes implementar apontadores em programas Java? Não podes implementar apontadores em programas de Java porque o Java virtual machine (JVM) cuida de gerenciamento de memória implícito. Acessar a memória diretamente por meio de apontadores não é recomendado em Java. A próxima flexivira é: - **Flexivira 16: ** Diferencie entre variáveis de instância e variáveis locais. As variáveis de instância são declaradas dentro da classe, e o escopo é limitado apenas a um determinado objeto em que uma variável de instância é criada. As variáveis locais, por outro lado, podem estar anywhere dentro de um método, ou um bloco de código específico, e o escopo é limitado ao bloco de código em que a variável é declarada. - **Flexivira 17: ** Explique a swimming pool de cadeia em Java O swimming pool de cadeia é uma coleção de cadeias em Java's Memória Heap. Por exemplo, se quis King dom criar um nova cadeia, forneça essa particular códiga para o seu JVM. O que o JVM faz? Não diretamente criará nessa cadeia particular primeiro. Em vez disso, vai procurar a cadeia em pool de cadeia. Se essa cadeia já existir em pool de cadeia, vai fornecer uma referência para tal cadeia. Em caso de não cadeia já existir, vai criar uma nova cadeia que é essa cadeia. - **Flexivira 18: ** O que é uma excepção em Java? Uma excepção em Java é um evento inesperado que pode perturbar o fluxo normal do programa. Por exemplo, se opõer a escrever um programa para o operador de divisão, após ter terminado o seu programa, o sua valorador pode querer testar o código até os extremos. Em vez de fornecer um número adequado, imagine que o seu valorador está fornecendo uma entrada especiais simbolos, algumas vezes um Zero, ou qualquer outra entrada especial. Se esta entrada especial for fornecida ao seu programa, ele pode dar erro. Pode evitar este tipo de erro usando exceção gerenciamento. - **Flexivira 19: ** O que é o pré-processador em Java? O termo 'final' é uma palavra reservada em Java que é usada enquanto declara valores para variáveis. Quando um valor declara usando o final keyword, então tal particular valor de tal particular variável ficará constante durante a execução do programa. - **Flexivira 20: ** O que acontece quando o método principal não é declarado como static? Quando o método principal não é declarado como static, o programa pode ser compilado perfeitamente, mas acaba com uma seria ambiguidade e lanca um erro de execução no tempo que diz "NoSuchMethodError". Ao declarar um método principal, não se esqueça de especificar o static keyword. Com isso, terminamos o segmento iniciante de flexiviras. A seguir, vem o segmento intermediário que é o próximo nível de flexiviras. ## 2. Java Development Kit (JDK) * **Flexivira 21: ** Que é JDK e mencione as variações de JDK? JDK é uma sigla para Java Development Kit. Este é um pacote combinado de JRE (Java Runtime Environment) e ferramentas de desenvolvimento usadas para desenvolver aplicações de Java e applets. A Oracle tem as seguintes variações para Java Development Kit: 1. Java Development Kit Standard Edition: Normalmente usado por iniciantes e desenvolvedores intermediários. 2. Java Development Kit Enterprise Edition: Usado por desenvolvedores profissionais de Java para desenvolver aplicações de Java-based e Frameworks. 3. Java Development Kit Micro Edition: É uma versão leve de JDK, destinada à aplicação em dispositivos móveis. ## 3. Specificadores de Acesso e Tipos de Specificadores de Acesso em Java * **Flexivira 23: ** Briefly explain access specifiers and types of access specifiers in Java. PEspecificadores de acesso são palavras-chave pré-definidas usadas para ajudar a um Java virtual machine understands the duration of a particular data member or data-manipulating method within a class or outside the class. In Java, we have four types of access specifiers: 1. Public Access Specifier: When you declare a data member or a data-manipulating method as public, then it can be accessible by any class or object throughout the package. 2. Private Access Specifier: Unlike the public access specifier, when you provide the private access specifier, the accessibility of that particular private data member or the data-manipulating method will be provided only to the same class or package in which it is declared. 3. Protected Access Specifier: Similar to the private access specifier, the protected access specifier is a bit more secure, . The access of this particular protected data member or protected data-manipulating method could be a little more difficult to access unless you're going to implement everything that is present in that particular package. 4. Default Access Specifier: When you declare a variable or a data-manipulating method without using any specific access specifiers, i. e. , public, private, and protected, then the JVM implicitly considers it as the default access specifier. There is no much difference between the public access specifier and the default access specifier. Both have the same functionality and access ability. # Documentação Técnica ## Palavras Chave Construtor em Java Em Java, temos duas palavras-chave especiais: `this` e `super`. ### Palavra Chave `this` O termo `this` é uma palavra-chave especial designada como uma referência de variável. O `this` keyword é usado para se referir às propriedades da classe atual (métodos de manipulação de dados, membros de dados de instância e construtores). ### Palavra Chave `super` O `super` é uma palavra-chave especial também designada como uma referência de variável. O `super` keyword é usado de forma semelhante ao `this` keyword e é usado para se referir ao objeto da classe pai imediatamente superior. ## Sobrecarga de Métodos em Java A sobrecarga de métodos e a superposição são conceitos de polimorfismo em Java. O processo de criar vários tipos de assinatura de métodos usando o mesmo nome de método é chamado de sobrecarga de métodos. Por exemplo, considere que você queria incluir uma operação de soma em seu programa que realiza a soma de um número. O primeiro método terá o nome `add` e dentro do método terá duas variáveis do tipo `int` como parâmetros. Da mesma forma, você queria realizar outra operação de soma com o mesmo nome `add`, então aqui você fornece o nome do método inteiramente igual ao primeiro método, mas dentro dos parâmetros há diferença: você será adicionando três parâmetros. Quando você passa os valores para o método `add`, a confusão se origina: qual método deverá ser sobrecarregado? Isso completamente depende do número de parâmetros que você passa. Se você estiver passando dois parâmetros, então o primeiro método será executado. Se você estiver passando três parâmetros, então o segundo método será executado. Essa é como a sobrecarga de métodos acontece em Java. O processo de sobrecarga de métodos pode ser conquistado por duas formas diferentes: 1. Mudando o número de argumentos 2. Variando o tipo de retorno do método ## Sobrecarga de Métodos Estáticos O valor das variáveis ou métodos de manipulação de dados não será modificado quando tivermos utilizado a palavra-chave `static` diante dele. Portanto, a pergunta é: podemos sobrecarregar um método estático? Vejamos a resposta para isso. Não, Java não dá suporte à sobrecarga de métodos estáticos. O processo gerará um erro: "método estático não pode ser referenciado". ## Ligaçãolate A ligação é um processo de unificação da chamada de método com o segmento de código do método durante o tempo de execução. A ligação ocorre quando o segmento de código do método não é conhecido ainda até que o método seja chamado durante o tempo de execução. ## Enviação Dinâmica de Métodos A enviação dinâmica de métodos é um processo em que a chamada de método é executada durante o tempo de execução. O método sobrescrito é chamado através de uma referência de variável da classe mãe. Este processo é chamado de polimorfismo em tempo de execução. ## Lista de Ligações vs. Array Lista de Ligações e Array são estruturas de dados. A Lista de Ligações emprega membros do heap em lá da memória. Basicamente, o que você faz aqui é você basicamente conecta os nós através de endereços. Então, se você quiser eliminar um número, então o que você faz é apenas manipular os endereços da forma que desejar. A raiz pela qual a função de exclusão ou qualquer outra função de manipulação será mais rápida na Lista de Ligaições do que no Array. ## Ciclo de Vida de um Thread O ciclo de vida de um Thread inclui cinco estados: estado recém nascido, estado executável, estado em execução, estado bloqueado, e estado morto. ## Diferença entre Operadores Embora pareçam semelhantes, há uma diferença substancial entre eles. O primeiro operador, que parece dois símbolos maiores que, realiza a operação de deslocamento para a direita. Quando você fornece um número binário ou valor binário, então os bits serão deslocados para a direita. O segundo símbolo ou segundo operador, que é um símbolo de três maiores que, é usado para deslocar os bits nulos. A função desses operadores é isso. ## Ciclo de Vida de uma Applet O ciclo de vida de uma Applet inclui os seguintes estágios: inicialização, início, parada, destruição, e desenho. ## Uso de Genéricos em Java A segurança de tipo em tempo de compilação é fornecida por meio de genéricos em Java. O aproximo permite aos usuários interceptar entradas innecessárias inadequadas durante a compilação. Os métodos genéricos e classes ajudam os programadores a especificar uma declaração de um único método ou um conjunto relacionado de métodos, ou uma declaração de uma única classe ou um conjunto relacionado de classes. ## Interface Externa em Java A interface `Externalizable` ajuda com o controle do processo de serialização. A interface `Externalizable` integra a `readExternal` e `writeExternal` métodos. ## Serialização A serialização é um processo de envio seu código em Java ou em Java projetos de um sistema de computador para um sistema de computador diferente. Se você quiser executar algum tipo de código Java em outro local, então você serializa esse código particular para um local de onde você deseja executa-lo, e esse processo de transferência de código é chamado de serialização. ## Demônio Thread O demônio thread pode ser definido como um thread com menos responsabilidades. O demônio thread é projetado para executar no fundo durante o processo de coleta de lixo na Java. A `setDemon` método é usada para criar o demônio thread no Java. ## Enumeração em Java A enumeração ou `enum` é uma interface em Java. A enumeração permite o acesso sequencial dos elementos armazenados em uma coleção em Java. ## Java como Linguagem Programação Dinâmica O Java foi projetado para se adaptar a um ambiente em evolução. Os programas em Java incluem uma grande quantidade de informação em tempo de execução que é usada para resolver o acesso aos objetos em tempo de execução. É por isso que o Java é comumente considerado como uma linguagem de programação dinâmica. ## Código que Executa antes de Executar o Método Main Sim, podemos executar qualquer código mesmo antes do método principal. Você vai usar o bloco de código estático da classe quando criar os objetos no momento da carga da classe. Qualquer declaração de código no bloco de código estático da classe será executada uma vez enquanto carrega a classe mesmo antes da criação de objetos no método principal. ##visor de Guias finalizados O `finalized` método é chamado pelo recolhimento. Para cada objeto, o recolhimento chama o `finalized` método apenas uma vez. ## Página JSP JSP é basicamente uma abreviatura de Java Servlet Page. A página Java Servlet Inclui dois tipos de dados: dados estáticos e Elementos de Página Java Servlet. ## JDBC JDBC é basicamente uma abreviatura de conectador Java Database. JDBC é uma camada abstrata usada para estabelecer conectividade entre qualquer banco de dados existente e uma aplicação Java. ## Diretivas JSP As Diretivas são instruções processadas pelo motor JSP após a página JSP ser compilada em um servlet. As diretivas são usadas para definir instruções de nível de página, incluir dados de um arquivo externo e especificar bibliotecas de etiquetas personalizadas. Além disso, as diretivas são definidas entre os seguintes símbolos: `<%@`. Estes são os símbolos que são usados para especificar as diretivas em uma página JSP. A seguir estão os tipos diferentes de diretivas: 1. Diretiva de inclusão 2. Diretiva de página 3. Diretiva de biblioteca de etiquetas A diretiva de inclusão inclui um arquivo e merge o conteúdo do arquivo com o arquivo atual. A diretiva de página é usada para definir atributos específicos em uma página JSP como a página de erro de rede e o buffer. A diretiva de biblioteca de etiquetas é usada para declarar uma biblioteca de etiquetas personalizadas no JSP. ## Observador e Observável Classes As classes que subclassificam a classe Observable mantêm uma lista de observadores. Quando um objeto observável for atualizado, ele invoca o método `update` de cada observador para notificar que os Observadores foram modificados. Os observadores são informados por meio da interface Observer. ## Perguntas de Java Avançado ### O `this` e o `super` palavras-chave podem ser usados em conjunto? Não, `this` e `super` palavras-chaves devem ser usados na primeira declaração na classe Construtor. O código a seguir fornece uma ideia melhor: ```java public MyClass(String name) { super. setName(name); // EstPosso nomear o super. setName(this. name); this. name = name; // Há uma chamada precisa de nível this. setName(name); } ``` Você pode ver que, neste código, usamos as palavras-chaves `super` e `this` na classe Construtor com a essência. É assim que você pode usar `super` palavra-chave e `this` conjuntamente caso tenha essa necessidade. # Tutorial de Cadeias em Java ## O que são cadeias em Java? Uma sessão é basicamente definida como a fase dinâmica de uma conversa aleatória entre o cliente e o servidor. O canal de comunicação principal inclui a cadeia de respostas e solicitações de ambas as partes. Normalmente, o modo mais popular de gerenciar a administração de sessão é a emprego de um ID de sessão no escritório de comunicação do cliente e do servidor. ## Framework do Spring O Spring é basicamente definido como o framewok e o container de controle de inversão para Java. O principal objetivo do framework do Spring é criar aplicações de empresa em Java. É importante se ter em mente que as características centrais do framework do Spring são essencialmente conductivas para qualquer uma aplicações Java. ## Arquitetura do Java (JCA) JCA é basicamente uma abreviatura para Arquitetura de Criptografia de Java. A JCA fornece uma plataforma que fornece arquitetura e APIs para criptografia e descriptografia. A JCA é usada pelo desenvolvedor para combinar aplicação com medidas de segurança, e ela também ajuda a executar regras de segurança terceirizada. Ela usa criptografia de tabela hash, digesto de mensagem, etc, para implementar a segurança. ## API de Persistência em Java (JPA) A JPA é definida como uma abreviatura para API de Persistência em Java. A JPA é usada para criar a camada de persistência em aplicações de desktop e web. A JPA abrange o seguinte: - Java Persistence API Query Language - Java Persistence Criteria API - Metadados de mapeamento de objetos - . . . ## Autenticações em Servlets Java - Autenticação básica: A autenticação básica contém um nome de usuário e senha fornecidos pelo cliente para autenticar como o usuário. - Autenticação de Formulário: Neste tipo especial de autenticação, o formulário de login é criado pelo programador usando HTML. - Autenticação Digest: A autenticação Digest é similar à autenticação básica, mas neste, as senhas são criptografadas usando uma fórmula de hash. Isso torna-se mais seguro. - Autenticação do Certificado do Cliente: A autenticação do Certificado do Cliente requer que cada cliente que acede à recurso possua um certificado que ele envia para se autenticar. Isso requer o protocolo SSL. ## Tutorial de Cadeias em Java | O que são cadeias em Java? | Tutorial de Cadeias em Java | Iniciantes | URL de Simplilearn: https://www.youtube.com/watch?v=R57pDw5cvGA Este tutorial abordará tudo o que você precisar saber para dominar o Java, com ênfase em cadeias. Nós exploraremos o que são cadeias em Java, como criar, definir e declarar cadeias, operações que podem ser feitas em cadeias e métodos incorporados na classe do String. Além disso, vamos fazer dois programas principais para entender o funcionamento de Java cadeias. # Comparação de Strings em Java Aprenda a comparar strings e reverter strings em Java. ## Comparação de Duas Strings - Comparar simplesmente aprender e praticar é falso, pois é definitivamente falso. - Estudar e estudar ambas as strings correspondem, portanto é verdadeiro. - Aprender apenas e estudar não correspondem, o que resulta no resultado sendo falso. ## Reversão de uma String - Agora, vamos para o segundo programa: reverter uma string. - Apague tudo a partir aqui e escreva o código abaixo. - Atribua uma variável `String input` e chame-a "aprenda simples" como a parte principal. - Use `StringBuilder` porque a string é imutável, e, como discutimos anteriormente, `StringBuilder` permite manipulação. - Crie outra variável `input1` e um `new StringBuilder`. - Em `input1`, faça um `append` para realizar operações como reversão, eliminação ou concatenação. - Defina `input1` igual a `input1. reverse()` para reverter a string contida em `input1`. - Para imprimir a string revertida, use `System. out. println("A string invertida é " + input1. toString())`. - Nota-se que é fundamental utilizar `StringBuilder` para manipular operações de string em uma string, pois sem `StringBuilder`, um erro pode ocorrer (por exemplo, "não foi possível manipular a string" ou "não foi possível reverter a string"). ## Exemplos - Com o exemplo "aprenda simples", a string revertida será "retnlé ssap". - Para um palíndromo, como "malayalam", a string revertida também será "malayalam". ## Programador de Java - Esta seção fornece um resumo de como um Programador de Java trabalha. - ### Trabalho de Programador de Java - Aborda onde se pode utilizar Java, quem é um programador de Java, o que eles precisam ser boas em, e como melhorar Java. Referências: - [Programador de Java](https://www.youtube.com/watch?v=Us6g8VrOHls) --- - O texto que se segue é uma breve introduceção para aqueles novos ao idioma ou aqueles em busca de conhecimentos adicionais. - Enfatiza a importância de manter-se atualizado com novas funcionalidades, conhecimento em ferramentas relevantes, habilidades de codificação, e compreensão de design de sistemas complexos em Java. - Menciona várias áreas e conceitos que podem ser focados, incluindo bancos de dados relacionais, SQL, mapeamento de objetos-relacionais, EJB, serviços Java-base web, J2EE framework, XML, Xquery, e XSL. Referências: - [Curso de Java em Aprender Simples](https://www.youtube.com/watch?v=TanJlGUbWNc) --- Olá lá! - Se gostou deste vídeo, inscreva-se no canal YouTube de Aprender Simples. - Clique aqui para assistir mais vídeos similares. - Clique aqui para se tornar certificado. Como recordatorio, também verifique nossos outros vídeos visitando nosso canal e clique no ícone de sino para nunca perder um update. Obrigado por assistir. Acompanhe-nos por mais do Aprender Simples! # Spring Boot: Construindo Web Services RESTfull ## Introdução Nesta sessão, vamos aprender a criar um web service RESTfull simples usando Spring Boot. O Spring Boot é uma opção popular para a construção de microserviços, pois fornece um framework leve e de produção pronto para a construção de web services RESTfull. ## Pré-requisitos Antes de começarmos, garanta que você tenha instalado Java e Maven em seu computador. ## Visão Geral do Projeto Neste projeto, criaremos uma aplicação `RestService` que tem dois componentes principais: a classe principal da aplicação e um controlador REST. O controlador REST será responsável por lidar com solicitações e devolver respostas no formato de uma string. ### Classe de Aplicação Principal A classe de aplicação principal é onde a aplicação Spring é inicializada. Aqui está a classe principal para nosso projeto: ```java package com. example. restservice; import org. springframework. boot. SpringApplication; import org. springframework. boot. autoconfigure. SpringBootApplication; @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication. run(Application. class, args); } } ``` A classe principal está anotada com `@SpringBootApplication`, o que diz a Spring Boot que esta é a entrada do aplicativo. Além disso, temos um método público `static void main` que inicializa a aplicação Spring quando executado. ### Controlador REST O controlador REST lida com solicitações HTTP e devolve respostas HTTP. Aqui está o controlador REST para nosso projeto: ```java package com. example. restservice. controller; import org. springframework. web. bind. annotation. GetMapping; import org. springframework. web. bind. annotation. RestController; @RestController public class RestController { @GetMapping("/**") public String index() { return "Olá do Spring Boot! "; } } ``` O controlador REST está anotado com `@RestController`, o que diz a Spring que esta é uma classe controladora. Temos uma `@GetMapping` anotação no método `index()`, que mapia a solicitação com o `/**` endpoint para este método. O método retorna uma simples string resposta. ##Execução da Aplicação Para executar a aplicação, abra um terminal e navegue até o diretório do projeto. Em seguida, execute o seguinte comando: ``` mvn spring-boot: run ``` A aplicação será iniciada e você poderá acessá-la ao navigar até `http://localhost:8080` no seu navegador web. Você deverá ver a mensagem "Olá do Spring Boot! " no navegador. ## Conclusão Nesta sessão, aprendemos a criar um web service RESTfull simples usando Spring Boot. Criamos uma classe principal de aplicação e um controlador REST, e aprendemos a rodar a aplicação usando Maven. Em futuras sessões, exploraremos a criação de web services RESTfull mais complexos usando Spring Boot, incluindo a manipulação de solicitações com diferentes métodos HTTP e a devolução de tipos de dados mais complexos. [Voltar para a página inicial](https://github.com/seanprashanth/spring-boot-tutorial) | [Voltar](. . /part1/) | [Próximo](. . /part3/) # Objectos Imutáveis e Classe de Entidade em Spring Boot Este documento abordará a importância de objectos imutáveis em aplicações de grande escala, com ênfase na classe `StudentEntity` e o seu repositório numa aplicação Spring Boot. ## Classe StudentEntity A `StudentEntity` classe representa uma tabela na base de dados, com a anotação `@Entity` da API de Persistência Java (JPA) da biblioteca de persistência. ```markdown @Entity public class StudentEntity { @Id @GeneratedValue(strategy = GenerationType. AUTO) private Long id; // Outros elementos da classe e getters/setters } ``` A anotação `@Id` indica a chave primária da tabela, e `@GeneratedValue` é utilizado para gerar automaticamente um valor novo para o campo `id` a cada vez que se cria um novo objeto de aluno. ##Repositório Uma classe de repositório é utilizada para manter a persistência do objeto de aluno na base de dados. ```java public interface StudentRepository extends JpaRepository<StudentEntity, Long> { } ``` Neste exemplo, a interface de repositório estende `JpaRepository`, e os parâmetros do tipo representam o tipo da entidade (`StudentEntity`) e sua chave primária (`Long`). A Spring Boot fornece automaticamente vários métodos para operações CRUD (Criar, Ler, Atualizar, Apagar), graças à implantação da `JpaRepository`. ## Controlador O controlador lida com as requisições HTTP e utiliza injecção de dependência para acessar o `StudentRepository`. ```java @RestController public class StudentController { @Autowired private StudentRepository studentRepository; // Métodos do controlador para criar, ler, atualizar e apagar o objeto de aluno } ``` Usando a anotação `@RestController`, a Spring Boot reconhece esta classe como um controlador de endpoint. O controlador foi injetado com o `StudentRepository` através de injecção de dependência. ### Criar Aluno Para criar um novo aluno, pode-se definir um método POST com a anotação `@PostMapping` e utilizar a anotação `@RequestBody` para mapear o corpo da solicitação para um objeto `StudentEntity`. ```java @PostMapping("/students") public ResponseEntity<Void> createStudent(@Valid @RequestBody StudentEntity student) { studentRepository. save(student); return ResponseEntity. ok(). build(); } ``` ### Ler Aluno Para ler um aluno específico, pode-se utilizar uma solicitação GET com o ID do aluno na caminho da URL. A anotação `@PathVariable` é utilizada para mapear o ID da URL para uma variável no método. ```java @GetMapping("/students/{id}") public ResponseEntity<StudentEntity> getStudent(@PathVariable Long id) { return studentRepository. findById(id). map(student -> ResponseEntity. ok(student)). orElse(ResponseEntity. notFound(). build()); } ``` Neste exemplo, o método `findById` a partir da `JpaRepository` é utilizado para recuperar o objeto de aluno para o ID dado, e um objeto opcional é retornado. Para obter o objeto de aluno real, pode-se chamar o método `. get()` no objeto opcional. ## Executando a Aplicação Para executar a aplicação, navegue até o diretório do projecto no terminal e execute: ```sh mvn spring-boot: run ``` A aplicação iniciará num Tomcat, acessível via URL localhost: 8080. Pode-se utilizar quaisquer clients de REST para interactuar com o endpoint. Por exemplo, o [Advanced REST Client Chrome extension](https://chrome.google.com/webstore/detail/advanced-rest-client/hgmloofddffdnphfgcellkdfbfbjeloo) pode ser utilizado para testar os endpoints. # Tutorial de Cliente REST Avançado: Criação de uma Solicitação POST Este tutorial não se refere a clientes REST avançados, mas fornecerá uma explicação rápida e simples. Você pode escolher o tipo de método para atingir, como uma solicitação POST. Suponha que você queira fazer uma solicitação POST; então, você pode fornecer o URL. Lembre-se de que o URL que você coloca aqui no método de controle deve corresponder exatamente. Por exemplo, `http://localhost/student/create` seria apropriado. Agora que copiei e colei o URL, verifique se está correto. Estamos lidando com um método POST, e vou atingir esse URL específico em seguida. Preciso fornecer o tipo de conteúdo e o corpo da solicitação POST. No tipo de conteúdo, você pode escolher `application/json` porque estou fornecendo um objeto JSON. Aqui está como o objeto JSON se parece: ```json { "page": "Seu valor para página", "address": "Seu valor para endereço" } ``` O cliente REST avançado também fornece uma interface de manipulação gráfica pra criar esse JSON se você pensar que a criação de JSON é complicada. Não é realmente complicado; envolve apenas chaves e colchetes e então você coloca pares de chave-valor, como se segue: ```json { "chave_para_página": "Seu valor para página", "chave_para_endereço": "Seu valor para endereço" } ``` Tenha cuidado para que as chaves tenham que corresponder exatamente às propriedades de estudante, como aquelas em `student. java`, que tem `page` e `address`. Se as chaves não corresponderem, esse pedido falhará. Ao clicar em "Enviar, " ele atingirá minha aplicação Spring Boot que está em execução em `localhost: 8080`. Ele llamará o método `student/create`, converterá automaticamente o JSON que eu estou enviando em um objeto Java e fará o salvamento automaticamente porque eu tenho chamado o método `repository. save()`. Quando você clica em Enviar, você recebe uma resposta de 200 OK, indicando que tudo deu corretamente, e na resposta headers, eu recebo o mesmo objeto de estudante de volta. Como esse método de save retorna o objeto do estudante criado, tudo é armazenado. Agora, vamos recuperar o objeto. Ele já foi salvo no banco de dados H2 em memória, e você pode se conectar a este banco de dados e olhar para ele, mas para simplicidade, eu vou fazer isso aqui. Suponha que o primeiro objeto seja geralmente adicionado como o id um por padrão pelo banco de dados H2, então quando eu enviar solicitação para essa URL, ele atingirá o `studentController` e no `studentController`, ele irá atingir o método `getStudent()`, que é com um objeto de estudante e um URL de id. Ele encontrará o banco de dados com esse id e retornará o objeto de estudante se ele encontrar um objeto de estudante com esse id. Confirmemos isso. Agora, clique no botão "Enviar" para enviar uma solicitação GET dessa URL específica. O Spring encontrará se um estudante com o id 1 existe em seu banco de dados. Se ele encontrar um objeto de estudante com esse id, ele retornará. Agora, tente-lo nos dois. Tente confirmar o que acontece quando tento recuperar um objeto de estudante com o id 2, que ainda não existe porque só insertei um objeto com o id 1. Então quando você enviar solicitação para o GET com um id 2 estudante, você obtém um erro 500 Interno do Servidor porque ainda não existe um objeto armazenado no banco de dados H2 com o id 2. Você pode também fazer ele parecer mais bonito não enviando o erro 500 Interno do Servidor e enviando uma exceção do servidor tranquilo. A partir de aqui, você pode enviar uma exceção tranquila que diga, por exemplo, "Aluno não encontrado". Ou também pode lançar um objeto opcional e fornecer um tipo de exceção específica que você quer lançar ao invés de apenas lançar um erro 500 Interno do Servidor, mas isso é uma coisa adicional, programação defensiva adicional que você pode fazer. Você pode acrescentar mais e mais validações e restrições a este projeto enquanto o constrói. Este é a ideia básica do que eu quero mostrar a você: a criação de uma aplicação Spring Boot, ligar-la a um banco de dados, criar uma interface HTTP com o controlador de estudante, executar a aplicação, usar qualquer cliente REST aleatório, fazer uma solicitação POST, fornecer o URL exato, o corpo que deve corresponder exatamente às propriedades do objeto de estudante, especialmente as convenções de caso devem corresponder exatamente. Se isso for tudo igual, você receberá uma resposta de volta a indicação de que o objeto foi criado. Se você deseja recuperar o valor do objeto, você vai usar o método HTTP GET, e você novamente fornece um URL que tem que corresponder exatamente a algum método em algum controle do Spring Boot que está em execução em `localhost`. Se você fornecer o id correto, você obterá um resultado válido. Se você fornecer um id inválido, obterá um erro 500 Interno do Servidor. A partir de aqui, você pode tornar esse controle mais robusto e mais maduro como desejar, você pode adicionar métodos findAll, métodos de atualização de estudantes, métodos de exclusão de estudantes e ter todo tipo de filtros e por exemplo, para retornar todos os alunos iniciando com o nome "a" ou retornar todos os alunos com o número de função um e aqueles com os números entre um e cem. Você pode escrever quantos endpoints quiser e construir esse aplicativo como complexo e maduro quanto quiser. E tudo isso é o que eu pretendia cobrir nesta aula em particular. Obrigado, e voltemos em outra sessão. --- ## Projetos Java Top 10 de 2024 | Projetos Java para o seu CV | Projetos de Programação Java | URL Simplilearn: [https://www.youtube.com/watch?v=srJcIYSr34c](https://www.youtube.com/watch?v=srJcIYSr34c) O Java é a língua de programação mais usada na indústria da TI e está sendo usada para o desenvolvimento de quase qualquer tipo de software, desde telefones móveis até mainframes. Se você é iniciante ou um aspirante a desenvolvedor de software, fortalecer seu portfólio com projetos Java realísticos e maduros é totalmente recomendado. Este vídeo de projetos de Java Top 10 é baseado totalmente em este plano para ajudar os desenvolvedores a ganhar um passo a mais em seu caminho para o seu sonho. Estes projetos Java não apenas de design, mas representam uma beautã que oferece soluções que redefinem a eficiência, a organização e a experiência do usuário em diferentes domínios. Vamos juntar nossos esforços nesta viagem pela lista de top 10 projetos de Java, onde a inovação encontra a funcionalidade para moldar o futuro da desenvolvimento de software. Antes de avançarmos para os projetos, se você também deseja ser um desenvolvedor de Java alto pagante, consulte a ligação mencionada abaixo para saber mais detalhes. Agora, vamos avançar da nível inicial para projetos Java avançados. Então anexemos o primeiro Java Project: Banco Online. # Top 10 Melhores Projetos em Java em 2022 | Projetos de Código Aberto em Java para iniciantes para serem contratados| Simplilearn Mantendo a formatação Markdown: * Use # para títulos e subtítulos * Use ** para texto em negrito * Use ` para código em linha * Use ``` para blocos de código * Use > para citações * Use - ou * para listas * Preserve todas as URLs intactas Organize em seções claras com subtítulos e mantenha a hierarquia: 1. **Jogo "Tempo do Pássaro"** * Reimplemente o clássico jogo de cobra no celular Nokia * Implemente totalmente em Java, incorporando uma base de dados MySQL e uma interface gráfica de usuário completa * Começa com uma cobra cuja comprimento aumenta com cada alimento consumido * A navegação envolve a cobra girando para a esquerda ou para a direita em ângulos de 90° * Termina com a colisão com uma parede ou qualquer obstáculo 2. **Sistema de Configuração de Exames** * Simplifica a tarefa de organizar a alocação de assentos para todos os alunos sob supervisão * Captura detalhes completos dos alunos, incluindo nome, número de matrícula, seção, curso, ano, e armazena as informações seguramente em bancos de dados * As tarefas administrativas são automatizadas através da aplicação * Utiliza Java, HTML, CSS, JavaScript, MySQL, servidor Tomcat 3. **Projeto de Reconhecimento de Fala** * Amplamente utilizado para fins como Amazon Alexa, Google Translate, e segurança * No Java, o reconhecedor de fala converte áudio em texto usando o pacote java. speech. recognition * O projeto deve ser capaz de criar um reconhecedor de fala, alocar recursos, carregar e ativar gramática, associar o ouvinte de resultados, cometer alterações, e processar resultados 4. **Projeto de Reconhecimento Facial** * Utilizado em diversos domínios como telefones e departamentos de polícia * Funciona com OpenCV com a biblioteca de reconhecimento facial OpenCV, uma biblioteca de visão computacional aberta com módulos como detecção de objetos, reconhecimento facial, e realidade aumentada * O projeto deve ser capaz de gerenciar as faces dos usuários, facilitar a identificação facial, login e logout fáceis, armazenar IDs de face, e identificar suspeitos apenas com imagens 5. **Projeto de Reconhecimento de Veículos** * Utilizado em aplicações em tempo real como reconhecimento de placas de veículo * O reconhecimento de veículos em Java implementa princípios algorítmicos e matemáticos da inteligência artificial, visão da máquina, e CNN para capturar a imagem, ler o valor alfanumérico nele, e recuperar os dados do veículo 6. **Software de Reconhecimento de Placas** * Implementa princípios algorítmicos e matemáticos da inteligência artificial, visão da máquina, e CNN * O projeto deve ser capaz de realizar várias tarefas, incluindo capturar a imagem, pre-processamento da imagem, segmentação do conjunto de caracteres da placa, extração de características, treinamento da rede neural, avaliação, e processamento de resultados 7. **Serviço de Correio Online** * Desenvolvido para atividades diárias como pedidos e envio # Novos aspectos e módulos podem ser facilmente integrados no sistema em futuro ## Sistema de gestão de e-saúde Com o novo normal de online banking, não merece a atenção nem o interesse de uma pessoa normal, mas para um programador entusiasta é tão excitante quanto uma atração em um parque de diversões, porque isso é como as principais bancos de peso e bancários multinacionais implementam seus serviços bancários através de várias opções, de modo que seus clientes possam experimentar a facilidade do banco em seus dedos. Um projeto desse tipo no seu currículo pode ser um destaque para o recrutador, especialmente se o recrutador for de uma empresa de banco ou financeiro. Um aplicativo de banco online é um modelo de site de internet banking que deve permitir que os clientes realizem transações bancárias básicas sentando no canto da casa ou escritório através de um celular ou computador. Os clientes podem acessar o site bancário para visualizar informações de seu saldo conta e realizar transações em sua conta de acordo com os requisitos. Um empregador pode entrar e adicionar informações de cliente e conta para realização de transações com bancos online. Com o banco online, a estrutura tradicional de banco de terra se converte em um modo clique e portal, dando assim aos clientes a oportunidade real de experimentar o conceito de bancos virtuais. Hoje, o banco não é mais limitado a agências. ## Sistema de examinação online Exames online já são famosos para nós hoje em dia, mas isso é totalmente limitado a exames avançados como CE, GRE, CAT etc. A demanda para este projeto aumenta a cada dia em relação ao momento atual pois muitas escolas e faculdades já viraram para o sistema de educação online e estão procurando para aplicar exames online para a segurança de alunos online exam é um projeto simples desenvolvido para proporcionar uma plataforma online para faculdades e alunos para conduzir exames online e suas avaliações. Este projeto particular possui dois componentes: primeiro é a parte do admin que tem o direito de adicionar estudantes, criar um login de um único uso, adicionar questões e posteriormente avaliar. Após a parte do lado do admin, temos o lado dos estudantes, então os estudantes podem entrar, atualizar seu perfil e senha selecionarem respostas em MCQs, escrevem respostas para questões e finalmente fecham a sessão e desconectam. Este projeto particular pode ser um grande sucesso com o uso de simples servlets Java e JavaScript. ## Projeto-guia da cidade inteligente O projeto Smart City é um software web desenvolvido em Java para armazenar os detalhes de uma cidade em particular. O objetivo principal deste projeto é ajudar turistas e outros visitantes da cidade fornecendo informações sobre hotéis, transporte, reserva de passagem aérea, compras, notícias da cidade etc Este projeto Smart City serve os visitantes como um guia da cidade e, por isso, é chamado de projeto City Guide Project. Java. Com este projeto, pode-se acessar os detalhes da cidade de qualquer lugar a qualquer hora. A implementação deste projeto promove eficazmente o turismo e negócios. Os hotéis podem ser encontrados mais facilmente em qualquer lugar com a ajuda desta software online. Estudantes poderão procurar instituições acadêmicas situadas em qualquer lugar com a ajuda deste software online. Você pode ver o mapa completo da cidade com a ajuda deste projeto. ## Sistema de rastreamento de bugs O sistema Bug Tracking é uma aplicação web desenvolvida em Java para empresas de software. O objetivo principal deste projeto é gerenciar erros ou bugs que ocorrem durante o ciclo de desenvolvimento do software. Após a implementação deste projeto, os empregados serão capazes de atualizar os detalhes do problema e solucionar os bugs. Este aplicativo ajuda o gerente do projeto a avaliar os resultados dos trabalhadores. ## Reconhecimento facial com OpenCV Pode-se usar Reconhecimento de Rosto com OpenCV que é uma biblioteca de computação de visão de código aberto, que contém módulos tais como reconhecimento facial, detecção de rosto, *augmented reality. * As principais funções que esta biblioteca software oferece são: gerenciar as faces do utilizador, facilitar o reconhecimento de rosto, login e logout fáceis, salvar id's de rosto, fazer suspensão por imagens e ajudar a identificar supostos criminalmente o sistema de reconhecimento de rosto fornece uma maneira aprimorada de encontrar cyber criminals. ## Reconhecimento de veículo com OpenCV Plate Number recognition ou Java-PR é um software que reconhece a placa de um veículo que utiliza princípios matemáticos e de inteligência artificial. É possível utilizar OpenCV, Java e algumas áreas de processamento de linguagem natural para desenvolver um projeto de reconhecimento de placa de veículo. Este projeto oferece recursos de linguagem de alto nível para cálculos computacionais interativo ambiente para exploração iterativa funções matemáticas ativados gráficos para integrar Matlab e outras funcções. ## Sistema de reconhecimento de voz com Java Speech API Mas reconhecimento de voz é um pacote de Java que define a interface do reunidor de reconhecimento de voz e um conjunto de classes de suporte. As etapas iniciais do projeto são a criação de um reconhecedor de voz, a alocação de recursos, a carga de um gramático, a adição de um ouvinte de resultados e finalmente o fornecimento dos resultados. O reconhecimento de voz está integrado no Open Source Open Source Speech Recognition Engine (AuDF) e pode ser executado tanto em embutido como em PC. Este projeto é utilizado para diversas aplicações comerciais e infomerciais tais como: SpeechSynthesizer para dar à computador o poder de falar de várias línguas VHS para notas de voz e outras inúmeras aplicações comerciais. Esses são apenas alguns exemplos de projetos Java, existem outros projetos tais como: * Calcular árvores com Matlab * Gerenciar contatos e agenda * E-commerce * sistema de mensagens em tempo real * Gerenciamento de livros biblioteca * Análise de dados * Gerenciamento de gerenciamento de projetos * Árvores de decisão * visualização3D * Análise de imagens * Direcionador de GUI * Recursos multimídia com basic libraries * Gerenciamento de eventos * Rest API * Cryptography * Mineradores de dados * Pesquisa Web * Robôs inteligentes * Licença inteligente * conversor de moedas. 