{"id":26716817,"url":"https://github.com/isaacalves7/java","last_synced_at":"2026-04-07T16:32:21.190Z","repository":{"id":41235409,"uuid":"290644773","full_name":"IsaacAlves7/java","owner":"IsaacAlves7","description":"☕ It's a repository of Java programming language and his content.","archived":false,"fork":false,"pushed_at":"2025-03-22T19:02:14.000Z","size":1222,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-03-22T20:18:32.113Z","etag":null,"topics":["android","gradle","java","java-programming","javaee","javafx","jboss","jpa","jsf","jsp","junit5","kotlin","maven","oci","oracle-database","oracle-db","primefaces","spring","spring-boot"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/IsaacAlves7.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2020-08-27T01:34:11.000Z","updated_at":"2025-03-22T19:02:17.000Z","dependencies_parsed_at":"2024-06-17T19:30:41.648Z","dependency_job_id":null,"html_url":"https://github.com/IsaacAlves7/java","commit_stats":null,"previous_names":["isaacalves7/java-studies","isaacalves7/java"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/IsaacAlves7%2Fjava","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/IsaacAlves7%2Fjava/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/IsaacAlves7%2Fjava/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/IsaacAlves7%2Fjava/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/IsaacAlves7","download_url":"https://codeload.github.com/IsaacAlves7/java/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":245873785,"owners_count":20686652,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["android","gradle","java","java-programming","javaee","javafx","jboss","jpa","jsf","jsp","junit5","kotlin","maven","oci","oracle-database","oracle-db","primefaces","spring","spring-boot"],"created_at":"2025-03-27T15:43:25.509Z","updated_at":"2026-04-07T16:32:21.157Z","avatar_url":"https://github.com/IsaacAlves7.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003ca href=\"https://github.com/IsaacAlves7/java-programming\"\u003e\u003cimg src=\"https://training.infnet.edu.br/wp-content/uploads/sites/18/2019/02/desenvolvedor-java.jpg\"/\u003e\u003c/a\u003e\n\n\u003e Versículo chave: \"Consagre ao Senhor tudo o que você faz, e os seus planos serão bem-sucedidos.\" - Provérbios 16:3\n\n# It's a repository of Java language ☕\n\u003e ☕ **Preparação**: Para este conteúdo, o aluno deverá dispor de um computador com acesso à internet, um web browser com suporte a HTML 5 (Google Chrome, Mozilla Firefox, Microsoft Edge, Safari, Opera etc.), um editor de texto ou IDE (VSCode etc.) e o software JDK, com a versão mais recente, instalado na sua máquina local.\n\n\u003ca href=\"https://github.com/IsaacAlves7/java-programming\"\u003e\u003cdiv align=\"center\"\u003e\u003cimg src=\"https://github.com/IsaacAlves7/java/assets/61624336/4879f8a9-f7e2-4025-9f35-5b5997b49f7f\" height=\"177\"/\u003e\u003c/div\u003e\u003c/a\u003e\n\n\u003cimg src=\"https://user-images.githubusercontent.com/61624336/183478203-20b992ae-b018-448a-bd56-e2fae9c5f7ae.svg\" align=\"right\" height=\"77\"\u003e\n\nSou um especialista em desenvolvimento de software com foco no ecossistema Java/Kotlin, atuando com frameworks robustos como Spring Boot, Jakarta EE e Quarkus. \n\nTenho sólida experiência na aplicação de boas práticas de engenharia de software, como os princípios SOLID, DRY, KISS, TDA e SoC, com domínio na aplicação de design patterns (criacionais, estruturais e comportamentais), além da adoção dos princípios de Clean Code e Clean Architecture para garantir legibilidade, manutenibilidade e escalabilidade do código.\n\nNo front-end, colaboro em projetos com SPAs desenvolvidas em React, Angular e Vue, integradas com back-ends Java via APIs REST ou GraphQL. Também participo de aplicações SSR com frameworks como Next.js ou Thymeleaf em projetos fullstack Java. Tenho domínio de HTML/CSS, Flexbox e CSS Grid, com foco em design responsivo baseado em protótipos UI/UX elaborados no Figma.\n\nNo back-end, desenvolvo APIs RESTful e GraphQL utilizando Spring Boot (com Spring Web, Spring Data, Spring Security e graphql-java). Tenho experiência com Git e colaboração em times ágeis com pipelines CI/CD (Jenkins, GitLab CI, GitHub Actions), análise estática e linting com ferramentas como Checkstyle, PMD e SonarQube, além da escrita de testes unitários e de integração com JUnit, Mockito, Testcontainers e REST-assured. Trabalho em arquiteturas distribuídas e baseadas em microsserviços com comunicação via REST e mensageria (RabbitMQ, Apache Kafka), com observabilidade garantida por Prometheus, Grafana e logs estruturados com Logback, Logstash ou Elastic Stack.\n\nTambém aplico ferramentas de analytics como Google Analytics 4 e Segment, monitorando a usabilidade de componentes e o comportamento dos usuários em ambientes de produção. Tenho experiência com deploy e escalabilidade de aplicações em ambientes PaaS (Heroku, Azure App Service) e uso de recursos em nuvens públicas como AWS (EC2, ECS, RDS, S3), Azure e Google Cloud (App Engine, GKE).\n\n\u003cdiv align=\"left\"\u003e\u003ca href=\"https://github.com/IsaacAlves7/java-programming\"\u003e\u003cimg src=\"https://cdn.icon-icons.com/icons2/2530/PNG/512/java_button_icon_151928.png\" height=\"47\"\u003e\u003c/a\u003e\u003c/div\u003e\n\n# ☕ The History of Java language\n\u003cimg src=\"https://cdn.worldvectorlogo.com/logos/java.svg\" height=\"77\" align=\"right\"\u003e\n\nO **Java** é o ambiente computacional, ou plataforma, criada pela empresa estadunidense Sun Microsystems, e vendida para a Oracle depois de alguns anos. A plataforma permite desenvolver programas utilizando a linguagem de programação Java. A tecnologia \u003ca href=\"https://user-images.githubusercontent.com/61624336/155857899-572ed5c4-cdb1-4171-9865-b8a8de7f8377.jpg\"\u003eJava\u003c/a\u003e foi desenvolvida na década de 1990, a partir de um projeto pessoal de um funcionário da Sun Microsystems. A ideia inicial estava ligada à criação de uma linguagem de programação que pudesse ser utilizada em diferentes sistemas, alterando o paradigma de que uma aplicação só poderia ser desenvolvida para uso em um único ambiente de hardware e sistema operacional, como era bastante comum na época. \n\nAs grandes empresas desenvolviam suas aplicações voltadas para seu ambiente de hardware e software (sistema operacional - SO), e estas aplicações não eram capazes de serem executadas em diferentes plataformas, principalmente de outros fabricantes. Se analisarmos a linguagem C, criada junto com o sistema operacional UNIX, temos uma biblioteca muito vasta de funções, mas poucas são consideradas padrão para atender a diferentes sistemas; e, mesmo assim, uma aplicação compilada em um sistema operacional (ambiente) não pode ser executada em outro.\n\nA linguagem Java rompeu este paradigma e passou a permitir que uma aplicação desenvolvida em um ambiente - hardware + software (SO) - possa ser executada em outro sem necessidade de qualquer outro procedimento. A Sun Microsystems, ao tomar conhecimento desta ideia, deu total apoio ao seu desenvolvimento e criou um grupo com 13 membros, liderado por James Gosling, que passaram a trabalhar exclusivamente neste projeto. A equipe foi batizada de “Green Team” e o grupo passou a trabalhar em um conjunto de escritórios fora das dependências físicas da Sun, e sem qualquer tipo de comunicação com a matriz, durante 18 meses para a concretização desta ideia.\n\nCom a tecnologia Java, as aplicações passaram a ser portáveis de um sistema para o outro, sem nenhuma necessidade de alteração. Por isso, afirmamos que a portabilidade é uma das mais importantes características da linguagem Java.\n\nAinda naquela época, o grupo já havia antecipado uma nova onda na computação, na convergência entre dispositivos controlados digitalmente e computadores. Hoje em dia, percebemos bem isso quando analisamos um smartphone, um dispositivo digital que possui inúmeras funções de computadores; entre elas, podemos destacar a execução de aplicativos. Inicialmente, a linguagem foi batizada de **Oak**, pois o grupo tinha como vista da janela do escritório *um carvalho*. Posteriormente, a linguagem foi rebatizada como **Java**, em função do *gosto do grupo pelo tipo de café*. Por isso, temos como ícone da linguagem uma xícara de café com sua fumaça característica.\n\nA linguagem é muito poderosa para o desenvolvimento de aplicações, seja para o desenvolvimento de aplicações menos sofisticadas ou para uso em dispositivos menos complexos que computadores, conhecidos como dispositivos inteligentes, tais como cafeteiras, micro-ondas, geladeiras e uma gama de outros dispositivos que possam ser controlados por software. A linguagem ainda é muito eficiente no desenvolvimento de sistemas de entretenimento doméstico, dando suporte a streaming de vídeo e televisão digital, que ainda não era tão desenvolvida na época.\n\n\u003cimg src=\"https://cdn.worldvectorlogo.com/logos/java-duke.svg\" height=\"77\" title=\"Duke, the Java Mascot\" align=\"right\"\u003e\n\nA tecnologia Java permite ainda o desenvolvimento de todos os tipos de aplicações, indo do mais simples controle de um eletrodoméstico, passando por aplicações domésticas, comerciais, de automação, até o desenvolvimento de aplicações mais complexas, com comunicação de dados e aplicações para supercomputadores.\n\nA linguagem Java teve início ao incorporar a tecnologia Java ao navegador de internet *Netscape navigator*, em sua versão de 1995. A tecnologia ganhou a aceitação do mercado e dos desenvolvedores, sendo uma das mais importantes linguagens de programação para o desenvolvimento de sistemas. São dezenas de milhões de desenvolvedores Java no mundo e, atualmente, esta tecnologia é encontrada em supercomputadores, servidores, desktops, notebooks, máquinas de cartões de crédito e débito, robôs, automóveis, jogos eletrônicos, bem como uma gama de dispositivos digitais, redes e demais tecnologias de programação. A linguagem Java ainda é a linguagem nativa para o desenvolvimento de aplicações para o Android (sistema operacional para smartphones).\n\nA tecnologia Java foi totalmente gratuita por muito tempo, mas recentemente a Oracle, que passou a deter os direitos da linguagem após adquirir a Sun Microsystems, está licenciando o uso para empresas com custos. A empresa deve permitir o licenciamento gratuito somente para desenvolvedores avulsos que criam aplicações pessoais sem custo ou para simples aprendizado.\n\nPrincipais características e vantagens da tecnologia Java:\n\n\u003cimg src=\"https://cdn.worldvectorlogo.com/logos/java-1.svg\" height=\"77\" align=\"right\"\u003e\n\n- \u003ca href=\"https://manoelcampos.gitbooks.io/poo-java/content/\"\u003eOrientada a objetos\u003c/a\u003e, com uma grande diversidade de bibliotecas de classes disponível;\n- Independe de plataforma: write once, run everywhere ;\n- Segurança - Mecanismos para sistemas livres de vírus, pacotes para criptografia;\n- Simplicidade;\n- Sintaxe dos comandos básicos segue o padrão do C;\n- Sintaxe da parte OO bem mais simples que o C++;\n- Internacionalização;\n- Unicode: padrão que permite manipular textos de qualquer sistema de escrita;\n- Robustez;\n- Tratamento de exceções;\n- JVM (Java Virtual Machine) impede que uma aplicação mal comportada paralise o sistema;\n- Distribuída e multitarefa;\n- Os programas podem utilizar recursos da rede com a mesma facilidade que acessam arquivos locais;\n- Trabalha com diversos protocolos (TCP/IP, HTTP, FTP);\n- Execução simultânea de múltiplas threads;\n- Gerenciamento de memória;\n- Memória virtual gerenciada pela JVM (Java Virtual Machine);\n- Garbage collection (limpeza de memória);\n- Desempenho;\n- Mais rápida que linguagens de script, porém mais lenta que as linguagens compiladas puras;\n- Hoje, os problemas de desempenho são resolvidos com compilação just-in-time.\n\n![623784202_1546511484145091_5190546318736151751_n](https://github.com/user-attachments/assets/494faef1-075c-4d00-aa33-dd494874d850)\n\n\u003cimg src=\"https://luizgustavoss.files.wordpress.com/2009/02/api_jse.png\" height=\"277\" align=\"right\"\u003e\n\nA **plataforma Java** é uma plataforma de software desenvolvida pela Sun Microsystems (agora parte da Oracle), projetada para fornecer um ambiente para o desenvolvimento e execução de aplicações independentes de sistema operacional e hardware, mais especificamente ela é o sistema de implementação do Java. Isso é possível graças ao conceito de *Write Once, Run Anywhere (WORA)*, onde um programa Java pode ser escrito uma vez e executado em qualquer dispositivo que tenha a **Java Virtual Machine (JVM)** instalada. De forma geral, entendemos que plataforma (ambiente de execução) é composta por hardware + software básico (sistema operacional). A plataforma Java é puramente baseada em software, e sua estrutura modular (JVM, API, JRE e JDK) permite que aplicações Java sejam portáveis, seguras e eficientes. Essa arquitetura fez do Java uma das linguagens mais utilizadas no mundo, especialmente em sistemas empresariais, aplicações web e desenvolvimento para dispositivos embarcados.\n\nA plataforma Java é definida apenas em software e possui dois componentes:\n\n- Máquina Virtual Java (JVM - Java Virtual Machine);\n- Conjunto de bibliotecas que disponibilizam classes comuns.\n\nDetalhando mais sobre a estrutura da Plataforma Java, ela é composta por quatro camadas principais, cada uma com um papel fundamental:\n\nMáquina Virtual Java (JVM - Java Virtual Machine):\n\nA **JVM** é o coração da plataforma Java e atua como um **interpretador** para o código Java compilado (bytecode). Ela é responsável por:\n- Executar programas Java de forma independente do sistema operacional.\n- Gerenciar memória automaticamente via **Garbage Collector (GC)**.\n- Otimizar o desempenho através da **compilação Just-In-Time (JIT)**.\n- Fornecer segurança ao isolar o código executado.\n\nA JVM traduz o **bytecode Java** para instruções específicas da máquina onde está rodando.\n\nBiblioteca de Classes (Java API - Application Programming Interface):\n\nA **API do Java** é um conjunto de bibliotecas padrão que oferece funcionalidades essenciais para o desenvolvimento de aplicações. Ela contém:\n- **Pacotes básicos** (`java.lang`, `java.util`, `java.io`) → Manipulação de strings, coleções, entrada/saída, etc.\n- **Bibliotecas de rede** (`java.net`) → Comunicação via HTTP, sockets e WebSockets.\n- **Bibliotecas de concorrência** (`java.util.concurrent`) → Threads, sincronização, paralelismo.\n- **Acesso a bancos de dados** (`java.sql`, `javax.persistence`) → JDBC, JPA.\n- **Interface gráfica** (`javax.swing`, `javafx`) → Desenvolvimento de GUIs.\n\nAmbiente de Execução (JRE - Java Runtime Environment):\n\nO **JRE** é o ambiente necessário para executar aplicações Java e contém:\n- A **JVM**.\n- As **bibliotecas de classes da API Java**.\n- Ferramentas básicas para rodar aplicações Java.\n\nSe um usuário final quiser rodar um programa Java, basta ter o **JRE** instalado. No entanto, para desenvolvimento, o JRE sozinho não é suficiente.\n\nKit de Desenvolvimento Java (JDK - Java Development Kit):\n\n\u003cimg src=\"https://user-images.githubusercontent.com/61624336/113073382-5e214b80-919f-11eb-8141-93ea67a402dc.png\" height=\"277\" align=\"right\"\u003e\n\nO **JDK** é um **superconjunto do JRE** e inclui ferramentas para **desenvolver** aplicações Java. Ele contém:\n- **Compilador (javac)** → Transforma código-fonte Java em **bytecode**.\n- **Depuradores e ferramentas de monitoramento** (`jdb`, `jconsole`, `jvisualvm`).\n- **Bibliotecas adicionais** para desenvolvimento avançado.\n- **Ferramentas para modularização** (desde o Java 9 com `jlink` e `jmod`).\n\nSe um desenvolvedor deseja programar em Java, ele precisa do **JDK**.\n\nExemplo de Fluxo de Execução na Plataforma Java:\n\n1. Um desenvolvedor escreve um programa em **Java** (`.java`).\n2. O código-fonte é compilado pelo **`javac`** e transformado em **bytecode** (`.class`).\n3. A **JVM** lê o bytecode e o executa na máquina usando o **JRE**.  \n\nAPI Java:\n\n\u003cimg src=\"https://user-images.githubusercontent.com/61624336/112760358-0b903580-8fcd-11eb-9e08-46f78186e835.png\" height=\"77\" align=\"left\"\u003e\n\n\"Diferentemente das linguagens convencionais, que são compiladas para código nativo, a linguagem Java é compilada para \"bytecode\" (gerando o \u003ccode\u003e.class\u003c/code\u003e ou \u003ccode\u003e.jar\u003c/code\u003e), que é executado por uma máquina virtual Java (JVM - Java Virtual Machine).\"\n\nO modelo inicial era interpretado. Já o atual trocou a etapa do interpretador por uma 2ª compilação (compilador JIT, isto é, just-in-time).\n\nA tecnologia Java é composta por três plataformas:\n\n\u003cimg src=\"https://cdn.worldvectorlogo.com/logos/jee-2.svg\" height=\"77\" align=\"right\"\u003e\n\n- **J2SE** ou **Java SE (Java Standard Edition)**: base da plataforma, inclui o ambiente de execução e as bibliotecas comuns;\n  \n- **J2EE** ou **Java EE (Java Enterprise Edition)**: versão voltada para o desenvolvimento de aplicações corporativas e aplicações web;\n  \n- **J2ME** ou **Java ME (Java Micro Edition)**: versão voltada para o desenvolvimento de aplicações móveis ou embarcadas.\n\nA sigla JSE pode referir-se a diferentes tecnologias dependendo do contexto, mas comumente tem dois significados principais:\n\n1. **Java Standard Edition (Java SE)**: Este é um conjunto de especificações e tecnologias fornecidas pela Oracle para o desenvolvimento de aplicativos Java. O Java SE inclui a linguagem de programação Java, a Máquina Virtual Java (JVM) e bibliotecas padrão para criar aplicações de desktop e servidor.\n\n2. **JavaScript Engine**: Este é um motor que executa o código JavaScript, comumente usado em navegadores web para executar scripts em páginas web. Exemplos de motores JavaScript incluem o V8 do Google Chrome, o SpiderMonkey do Mozilla Firefox e o Chakra do Microsoft Edge.\n\nPortanto, a sigla JSE pode se referir tanto ao Java Standard Edition, relacionado à linguagem de programação Java, quanto a um motor JavaScript, relacionado ao JavaScript. O significado exato depende do contexto em que a sigla é utilizada.\n\n![1752755951665](https://github.com/user-attachments/assets/677e64be-31d6-4a07-a535-a3e412f39aae)\n\n## [Java] Ambiente de desenvolvimento\n\u003cimg src=\"https://user-images.githubusercontent.com/61624336/171005805-d123b7c1-89e6-492c-9d03-3dcafb40142e.png\" align=\"right\" height=\"77\"\u003e\n\nExistem os ambientes JDK e JRE para construir e executar uma aplicação Java. \n\nO **Java Development Kit (JDK)** é uma coleção de programas para, dentre outras tarefas, compilar e executar aplicações Java. Este é o kit necessário para o desenvolvedor, pois contém todo o suporte para a criação de aplicações em Java.\n\nExemplo:\n- Javac (compilador Java);\n- Javadoc (utilitário para documentação);\n- Java;\n- Outros.\n\nKit com todos os programas necessários para executar aplicações Java. Faz parte do JDK, mas pode ser instalado separadamente para execução em máquinas clientes, uma vez que o JDK é voltado para os desenvolvedores. O JRE pode ser instalado separadamente e dá suporte somente a execução de aplicações ou jogos como o Minecraft, por isso é a versão mais indicada para instalação nas máquinas clientes que apenas executarão aplicações, não sendo responsáveis pelo seu desenvolvimento.\n\n![img01](https://user-images.githubusercontent.com/61624336/112771689-6c3a6500-9003-11eb-8436-1bda07a25ea3.jpg)\n\nO código de um programa Java é compilado apenas uma vez, gerando um código intermediário, o **bytecode**, que pode ser executado quantas vezes forem necessárias em qualquer ambiente que possua uma máquina virtual Java (JVM) disponível.\n\nInicialmente a tecnologia Java realizava uma interpretação completa do bytecode, mas atualmente o interpretador realiza uma compilação **just-in-time** (compila o bytecode para o ambiente onde ocorrerá a execução), permitindo aumentar o desempenho da aplicação.\n\nPara o desenvolvimento de aplicações em Java é comum o uso de ferramentas IDEs (Integrated Development Environment), que facilitam a codificação e a realização de testes, sendo as mais conhecidas:\n  \n- Eclipse;\n- NetBeans;\n- IntelliJ;\n- BlueJ.\n\nVocê pode usar qualquer tipo de ambiente, se preferir um editor de texto como um bloco de notas ou um VSCode você precisa usar a extensão `.java`.\n\n# ☕ [Java] Ambiente de programação\n\u003ca href=\"https://netbeans.apache.org/download/index.html\"\u003e\u003cimg src=\"https://upload.wikimedia.org/wikipedia/commons/9/98/Apache_NetBeans_Logo.svg\" height=\"77\" align=\"right\"\u003e\u003c/a\u003e\n\nExistem várias ferramentas para o desenvolvimento de sistemas utilizando a linguagem Java, mas os desenvolvedores têm preferência pelos IDEs **Netbeans** e **Eclipse**. Ambos são gratuitos e podem ser adquiridos pela internet através de download.\n\nÉ importante que você já tenha instalado o JDK antes de instalar o seu IDE escolhido (Netbeans ou Eclipse). Assista o vídeo: \n\nExistem dois arquivos diferentes: o primeiro, com o source, contém os códigos fonte no Netbeans e não é o ideal para trabalharmos o desenvolvimento. A versão adequada para nós é a versão bin, que contém todos os códigos já compilados e prontos para a execução e desenvolvimento de projetos e aplicações Java.\n\n\u003ca href=\"https://www.eclipse.org/downloads/\"\u003e\u003cimg src=\"https://cdn.worldvectorlogo.com/logos/eclipse-11.svg\" height=\"77\" align=\"right\"\u003e\u003c/a\u003e\n\nVocê não precisa instalar as duas, pois ambas são concorrentes e desempenham as mesmas funcionalidades. A preferência é a critério do programador.\n\nA linguagem Java possui uma base de construção semelhante à linguagem C e, por isso, boa parte de sua estrutura e sintaxe se assemelha a ela. Desta forma, programadores com conhecimento nesta linguagem tem grande facilidade com a sintaxe da linguagem Java. Outra importante semelhança está nas estruturas de controle de fluxo, que são construídas da mesma forma em ambas as linguagens.\n\n\u003e Cuidado com as diferenças de versões no sistema operacional: se instalar o Java para 64 bits, você deverá usar um IDE (Netbeans ou Eclipse) de 64 bits. O mesmo para a versão de 32 bits: tanto o Java quanto o IDE deverão ser para 32 bits.\n\n## [Java] `Hello, World!`\nVeja abaixo o passo a passo para criar sua primeira aplicação em Java, imprimindo na tela o `Hello, World!`, você pode usar qualquer editor de texto e salvar a extensão do arquivo `.java`, mas nesse exemplo, eu estarei utilizando a IDE Netbeans:\n\n\u003ctable\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003cimg src=\"https://user-images.githubusercontent.com/61624336/112783450-bc2a2380-9025-11eb-9ad8-b3425b12416e.jpg\"\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cimg src=\"https://user-images.githubusercontent.com/61624336/112783457-bd5b5080-9025-11eb-9ed8-7834c9429c27.jpg\"\u003e\u003c/td\u003e\n  \u003c/tr\u003e\n   \u003ctr\u003e\n     \u003ctd\u003e\u003cimg src=\"https://user-images.githubusercontent.com/61624336/112783460-be8c7d80-9025-11eb-9d0e-38d8ce22f537.jpg\"\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cimg src=\"https://user-images.githubusercontent.com/61624336/112783560-f7c4ed80-9025-11eb-9aa5-db63dc209059.jpg\"\u003e\u003c/td\u003e\n  \u003c/tr\u003e\n\u003c/table\u003e\n\nO projeto `Exemplo` foi criado e automaticamente teremos uma **classe inicial** para execução da aplicação.\n\n![img07](https://user-images.githubusercontent.com/61624336/112783806-89ccf600-9026-11eb-9a35-7d2d9b04774e.jpg)\n\nO ambiente está pronto para digitarmos o código da aplicação: preencha o código conforme o exemplo a seguir.\n\n![img08](https://user-images.githubusercontent.com/61624336/112783867-ac5f0f00-9026-11eb-824b-76e8d7f981c5.jpg)\n\n[![.JAVA](https://img.shields.io/badge/-Exemplo.java-000000?style=social\u0026logo=OpenJdk\u0026logoColor=chocolate)](#)\n\n```java\nimport java.util.Scanner;\n\npublic class Exemplo {\n\n // identação do bloco da classe Exemplo (a classe sempre possui o nome do arquivo, os dois andam bem alinhados!)\n public static void main(String[] args) {\n\n   // identação do bloco do método main\n\n   // TODO Auto-generated method stub\n   Scanner sc = new Scanner(System.in);\n   double media, nota1, nota2;\n\n   System.out.println(\"Digite a nota 1:\");\n   nota1 = Double.parseDouble(sc.nextLine());\n\n   System.out.println(\"Digite a nota 2:\");\n   nota2 = Double.parseDouble(sc.nextLine());\n\n   media = (nota1 + nota2) /2.0;\n\n   System.out.println(\"A sua média é:\" + media);\n   sc.close();\n\n  } // encerramento da identação do bloco do método main\n} // encerramento da identação da classe Exemplo\n```\n\nApós o código estar pronto e sem erros, podemos executar a aplicação clicando sobre o “arquivo da classe” com o botão direito, e em seguida clicar sobre a opção `Run file`.\n\n![img10](https://user-images.githubusercontent.com/61624336/112784797-e7624200-9028-11eb-8739-7c214e90e4f0.jpg)\n\nA aplicação executará na parte inferior do Netbeans:\n\n![img11](https://user-images.githubusercontent.com/61624336/112784856-03fe7a00-9029-11eb-93f7-7da23c1e5735.jpg)\n\nCrie um programa em java e execute os seguintes comandos para abri-lo como saída pelo terminal:\n\n[![.JAVA](https://img.shields.io/badge/-HelloWorld.java-000000?style=social\u0026logo=OpenJdk\u0026logoColor=chocolate)](#)\n\n```java\npublic class HelloWorld {\n    public static void main(String[] args)\n    {\n        System.out.println(\"Hello, World!\");\n    }\n}\n```\n\nConfigurando a saída do programa pela interface de linha de comando (CLI) do terminal:\n\n```sh\n# Compilar o App na JVM\njavac app.java\njava app\n\n# Compilar o arquivo .JAR na JVM\njava -jar app.jar\n\n# Compilar o arquivo .JAR na JVM pelo Powershell usando versão específica\n\u0026 \"C:\\Program Files\\Java\\jre1.8.0_471\\bin\\java.exe\" -jar app.jar --installServer\n```\n\nA linguagem **Java** tem boa parte de suas características herdadas da linguagem **C**. Muitos dos seus operadores, formação de identificadores, comandos de controle de fluxo e várias outras características são compartilhados entre estas duas linguagens.\n\nTodas as instruções da linguagem Java devem terminar por um símbolo de ponto e vírgula “\u003ccode\u003e;\u003c/code\u003e”. Você não usará o ponto e vírgula quando a instrução for uma codificação que irá continuar com um bloco de comandos.\n\nVejamos um exemplo:\n\n```java\nSystem.out.println(“Mensagem do sistema”);\n```\n\nOs blocos de comandos em Java são delimitados por \u003ccode\u003e{\u003c/code\u003e (abrir) e \u003ccode\u003e}\u003c/code\u003e (fechar) chaves, em que a instrução anterior define que todos os comandos do bloco farão parte desta. Isso irá ocorrer em classes, métodos e instruções de controle de fluxo. \n\nExemplo:\n\n```java\nif(nota\u003e10.0) {\n\nSystem.out.println(“Nota inválida”);\n\n}\n```\n\nComo usar a endentação? Quando desenvolvemos um programa em qualquer linguagem, é comum que utilizemos um conjunto de espaços na frente das instruções de forma a facilitar a visualização de blocos. Sempre que iniciamos um bloco, devemos começar na próxima linha com um deslocamento de pelo menos quatro espaços em brando ou uma tabulação (normalmente quatro espaços). Isso permite que identifiquemos rapidamente que certo conjunto de instruções faz parte de um conjunto que será executado em bloco. \n\nExemplo:\n\n```java\nimport java.util.Scanner;\n\npublic class Exemplo {\n // identação do bloco da classe Exemplo (a classe sempre possui o nome do arquivo, os dois andam bem alinhados!)\n public static void main(String[] args) {\n// identação do bloco do método main\n// TODO Auto-generated method stub\n   Scanner sc = new Scanner(System.in);\n   double media, nota1, nota2;\n\n   System.out.println(\"Digite a nota 1:\");\n   nota1 = Double.parseDouble(sc.nextLine());\n\n   System.out.println(\"Digite a nota 2:\");\n   nota2 = Double.parseDouble(sc.nextLine());\n\n   media = (nota1 + nota2) /2.0;\n\n   System.out.println(\"A sua média é:\" + media);\n   sc.close();\n\n  } // encerramento da identação do bloco do método main\n} // encerramento da identação da classe Exemplo\n```\n\nEm todas as linguagens de programação, devemos identificar variáveis, programas, funções, métodos, parâmetros etc. O ato de nomear algo em uma linguagem de programação é uma forma de identificação da linguagem. Em Java são permitidos identificadores que comecem com letras (maiúsculas ou minúsculas), ou um símbolo de “\u003ccode\u003e$\u003c/code\u003e” (dólar) ou “\u003ccode\u003e_\u003c/code\u003e” (underscore \u003ccode\u003e/\u003c/code\u003eunderline). Números podem ser usados, mas não para iniciar um identificador.\n\n**Java** é uma linguagem de programação sensível à caixa (alta ou baixa ou **case sensitive**). Desta forma, a linguagem faz distinção entre letras maiúsculas e minúsculas. Mas isso não quer dizer que podemos utilizar qualquer nome como um identificador, pois existem algumas palavras reservadas que não podem ser utilizadas para tal. \n\nExemplos de identificadores válidos em Java:\n\n\u003cimg height=\"177\" align=\"right\" src=\"https://github.com/user-attachments/assets/d561bc7f-fa2c-4bfd-9ca1-34ad677e8101\" /\u003e\n\n- `identificador`\n- `nomeCompleto`\n- `NomeCompleto`\n- `nota1`\n- `_sys_path`\n- `$user`\n\nObserve que os exemplos 2 e 3 possuem a mesma grafia, mas, como existe mudança entre caixa alta e baixa, para a linguagem Java são dois diferentes identificadores. \n\n\u003ctable class=\"custom-table\"\u003e\n  \u003ctbody\u003e\n     \u003ctr\u003e\u003ctd colspan=\"4\"\u003ePalavras reservadas da linguagem Java (não podem ser usadas como identificadores), dentre elas podemos destacar:\u003c/td\u003e\u003c/tr\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003eabstract\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003earguments\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eawait\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eboolean\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003ebreak\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003ebyte\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003ecase\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003ecatch\u003c/code\u003e\u003c/td\u003e\n      \u003c/tr\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003echar\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eclass\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003econst\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003econtinue\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003edebugger\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003edefault\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003edelete\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003edo\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003edouble\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eelse\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eenum\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eeval\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003eexport\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eextends\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003efalse\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003efinal\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003efinally\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003efloat\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003efor\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003efunction\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003egoto\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eimplements\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eif\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eimport\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003ein\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003einstanceof\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eint\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003einterface\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003elet\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003elong\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003enative\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003enew\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003enull\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003epackage\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eprivate\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eprotected\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003epublic\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003ereturn\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eshort\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003estatic\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003esuper\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eswitch\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003esynchronized\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003ethis\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003ethrow\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003ethrows\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003etdrow\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003etransient\u003c/code\u003e - \u003ccode\u003etrue\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003etry\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003etypeof\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003evar\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003evoid\u003c/code\u003e\u003c/td\u003e\n      \u003ctr\u003e\n\t  \u003ctd\u003e\u003ccode\u003evolatile\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003ewhile\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003ewith\u003c/code\u003e\u003c/td\u003e\n\t  \u003ctd\u003e\u003ccode\u003eyield\u003c/code\u003e\u003c/td\u003e\n      \u003c/tr\u003e\n   \u003c/tbody\u003e\n\u003c/table\u003e\n\n\u003e \u003cb\u003eOBS:\u003c/b\u003e Todas as palavras reservadas começam por letras minúsculas e são palavras do idioma inglês.\n\n## [Java] Comentários\nO uso de comentários em Java é semelhante ao usado na linguagem C, mas apenas dois destes tipos são iguais nas duas linguagens, sendo o terceiro tipo somente disponibilizado na linguagem Java.\n\nVejamos:\n\n\u003ccode\u003e//\u003c/code\u003e comentário de uma linha  \n\nQuando usamos duas barras em uma linha de código, todo o seu conteúdo, após as duas barras, é desconsiderado pelo compilador, o que quer dizer que podemos escrever qualquer conteúdo que o mesmo não será compilado. É muito usado para deixar informações e avisos do programador no código.\n\n```java\n// TODO Auto-generated method stub\u003c/pre\u003e\n```\n\n\u003ccode\u003e/**/\u003c/code\u003e comentário de duas ou mais linhas (bloco)\n\nAo usarmos o comentário de bloco, podemos comentar não apenas um trecho de uma linha, mas todo um conjunto de linhas. É utilizado quando temos longos trechos de textos com avisos e informações, ou para a depuração do código. Para a depuração do código, podemos comentar um conjunto de linhas para realizar um conjunto de testes. Neste caso, podemos comentar um conjunto de instruções ou porque estas instruções estão com problemas e queremos verificar as demais. Ou, ao contrário, onde temos um conjunto de instruções já testadas e corretas e queremos apenas testar as demais. Seja como for, o uso do comentário de bloco é muito usual e comum entre os programadores.\n\n\u003ccode\u003e/***/\u003c/code\u003e comentário de documentação\n\nO comentário de documentação se difere do comentário de bloco por possuir um asterisco a mais no início, mas ambos encerram da mesma forma. Existe uma ferramenta na linguagem Java responsável por extrair de um projeto (com várias classes) todos os comentários de documentação e montar um documento com todo este conteúdo.  \n\nNeste caso, usamos este tipo de comentário apenas para descrever avisos e informações das classes, de forma a realizar a documentação do sistema ainda durante sua fase de criação. Isto permite que o desenvolvedor descreva todo a documentação no próprio projeto, facilitando a descrição e a manutenção do sistema. Assim, ao terminar um projeto ou realizar algum tipo de modificação, basta gerar novamente a documentação do sistema que tudo estará atualizado.\n\n# ☕ [Java] Tipos de dados \nA linguagem Java possui nove tipos de dados básicos, sendo oito deles primitivos e um tipo especial. Os **tipos primitivos** (armazenam apenas valores) são os tipos básicos de variáveis que armazenam valores simples, sem a necessidade de objetos ou referências. São fundamentais para armazenar valores simples e são divididos em oito categorias:\n\n**Tipo lógico** (`boolean`), o tipo lógico só permite dois estados, verdadeiro (\u003ccode\u003etrue\u003c/code\u003e) ou falso (\u003ccode\u003efalse\u003c/code\u003e); em Java ainda é permitido o uso de \u003ccode\u003eon\u003c/code\u003e e \u003ccode\u003eoff\u003c/code\u003e, ou \u003ccode\u003eyes\u003c/code\u003e e \u003ccode\u003eno\u003c/code\u003e. \n\nExemplo:\n\n```java\nboolean status = true;\n```\n\n**Tipo caractere** (`char`), o tipo `char` permite que seja armazenado na memória apenas um caractere e se difere do texto (`String`) por ser definido entre `‘e’`. Quando usamos aspas simples ou dupla determinamos apenas um caractere.\n\nExemplo:\n\n```java\nchar letra = ‘A’;\n```\n\nTambém é possível armazenar caracteres de controle:\n\n\u003ctable\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003cb\u003eCaractere Especial\u003c/b\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cb\u003eRepresentação\u003c/b\u003e\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n     \u003ctd\u003e\u003ccode\u003e’\\n’\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003enova linha.\u003c/td\u003e\n  \u003c/tr\u003e\n   \u003ctr\u003e\n     \u003ctd\u003e\u003ccode\u003e’\\r’\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eenter.\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n     \u003ctd\u003e\u003ccode\u003e’\\u????’\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eespecifica um caractere Unicode o qual é representado na forma Hexadecimal.\u003c/td\u003e\n  \u003c/tr\u003e\n    \u003ctr\u003e\n     \u003ctd\u003e\u003ccode\u003e’\\t’\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003etabulação.\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e’\\\\’\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003erepresenta um caractere \u003ccode\u003e\\\u003c/code\u003e (barra invertida).\u003c/td\u003e\n  \u003c/tr\u003e\n    \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e’\\” ’\u003c/code\u003e\u003c/td\u003e\n      \u003ctd\u003erepresenta um caractere \u003ccode\u003e“\u003c/code\u003e (aspas)\u003c/td\u003e\n  \u003c/tr\u003e\n\u003c/table\u003e\n\n\u003e \u003cb\u003eOBS:\u003c/b\u003e A barra invertida na frente indica que é um caractere especial.\n\n**Tipos inteiros** (`byte`, `short`, `int` e `long`), são quatro diferentes tipos de inteiros, que se diferenciam pela quantidade de bits que cada um ocupa em memória para armazenar um valor. Isto faz com que, quanto menor a quantidade de bits, maior seja a limitação do valor a ser armazenado. Entretanto, em ocasiões onde a memória é pouca, devemos trabalhar muito bem com estas diferenças para reduzir o espaço de memória necessário. O uso mais comum é do \u003ccode\u003eint\u003c/code\u003e, mas, para números muito grandes ou muito pequenos, devemos usar o \u003ccode\u003elong\u003c/code\u003e. Já para economizar memória podemos usar \u003ccode\u003ebyte\u003c/code\u003e ou \u003ccode\u003eshort\u003c/code\u003e, de acordo com o valor que será armazenado.\n\n\u003ctable\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003cb\u003eTipo de dado\u003c/b\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cb\u003eQuantidade de bits\u003c/b\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cb\u003eQuantidade de Bytes\u003c/b\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cb\u003eEscopo (valores que podem ser armazenados)\u003c/b\u003e\u003c/td\u003e\n  \u003c/tr\u003e\n   \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003ebyte\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003e8\u003c/td\u003e\n    \u003ctd\u003e1\u003c/td\u003e\n    \u003ctd\u003e-2⁷ . . . . 2⁷ - 1\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003eshort\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003e16\u003c/td\u003e\n    \u003ctd\u003e4\u003c/td\u003e\n    \u003ctd\u003e-2³¹ . . . . 2³¹ - 1\u003c/td\u003e\n  \u003ctr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003elong\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003e64\u003c/td\u003e\n    \u003ctd\u003e8\u003c/td\u003e\n    \u003ctd\u003e-2⁶³ . . . . 2⁶³ - 1\u003c/td\u003e\n\u003c/table\u003e    \n\n**Tipos reais** (`float` e `double`) são dois diferentes tipos de valores reais, sendo um de precisão simples (\u003ccode\u003efloat\u003c/code\u003e), que ocupa menos espaço de memória, e o de dupla precisão, que ocupa mais memória. Quanto maior o número de bits para armazenar um valor real, maior será a precisão deste número dentro do sistema. O uso do \u003ccode\u003efloat\u003c/code\u003e é comum quando necessitamos economizar espaço de memória. Em Java, todo tipo de dado numérico é convertido para \u003ccode\u003edouble\u003c/code\u003e automaticamente por coerção (força a conversão de tipo). Por isso, é mais indicado, quando não houver falta de espaço de memória, a utilização de \u003ccode\u003edouble\u003c/code\u003e para armazenamento de valores reais.\n\n\u003ctable\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003cb\u003eTipo de dado\u003c/b\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cb\u003eQuantidade de bits\u003c/b\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cb\u003eQuantidade de Bytes\u003c/b\u003e\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003efloat\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003e32\u003c/td\u003e\n    \u003ctd\u003e4\u003c/td\u003e\n  \u003c/tr\u003e\n   \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003edouble\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003e64\u003c/td\u003e\n    \u003ctd\u003e8\u003c/td\u003e\n  \u003c/tr\u003e\n\u003c/table\u003e    \n\n**Tipo especial** pode se referir a estruturas que vão além dos tipos primitivos e de referência comuns. Alguns exemplos incluem, `Enum` (enumeração) que define um conjunto fixo de constantes nomeadas:\n\n```java\nenum DiaDaSemana { SEGUNDA, TERÇA, QUARTA, QUINTA, SEXTA, SÁBADO, DOMINGO }\n```\n\n**Tipo texto** (\u003ccode\u003eString\u003c/code\u003e) não é um tipo primitivo, mas um tipo especial. Na verdade, o tipo String é uma classe e por isso começa com letra maiúscula, ao contrário dos tipos primitivos, que sempre começam por minúsculas. Este tipo de dado armazena um conjunto de caracteres, formando palavras ou frases de tamanhos variados. Como classe, veremos mais tarde que elementos do tipo String possuem métodos que podem realizar ações específicas sobre o seu conteúdo. \n\nExemplo:\n\n```java\nString nome = “João da Silva”;\n```\n\n# ☕ [Java] Constantes e variáveis\n**Variáveis** e **constantes** em Java devem obrigatoriamente possuir um tipo. Isso ocorre porque Java é uma linguagem de programação fortemente tipada. Linguagens de programação fortemente tipadas Obrigam que todas as variáveis e constantes sejam definidas por um tipo de dado.\n\nLinguagens de programação fracamente tipadas permitem que variáveis sejam usadas a qualquer momento, sem a necessidade de terem um tipo predefinido. Isso quer dizer que o tipo de dado pode variar em diferentes partes do programa.\n\n**Variáveis** são declaradas por meio de um tipo e um identificador, sem que sejam necessárias outras informações. A boa prática em programação Java determina que todas as variáveis comecem por letras minúsculas e, somente se tiver mais de uma palavra, o inicial da segunda palavra em diante deverá começar por letras maiúsculas. \n\nExemplos:\n\n```java\nint c;\ndouble nota1 = 0; // indica que a variável será inicializada com 0 (zero)\nString nomeCompleto;\n```\n\nA definição de constantes precisam do modificador final, que indica que, uma vez que ocorreu uma atribuição a variável, seu conteúdo não poderá ser mudado. Em Java, constantes podem ser criadas em nomes em minúsculas ou maiúsculas, mas a boa prática de programação determina que sua identificação deve ser toda em maiúsculas. \n\nExemplos:\n\n```java\nfinal int IDADEMINIMA = 15;\nfinal double VALORDOLAR = 3.96;\nfinal NOMEEMPRESA = “Super Empreendimentos”;\n```\n\n# ☕ [Java] Operadores e expressões\n\n\u003ctable align=\"right\"\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003cb\u003eOperador\u003c/b\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cb\u003eDescrição\u003c/b\u003e\u003c/td\u003e\n  \u003c/tr\u003e\n    \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e=\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eAtribuição\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e+\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eSoma\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e-\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eSubtração\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e*\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eMultiplicação\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e/\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eDivisão\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e%\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eResto da divisão\u003c/td\u003e\n  \u003c/tr\u003e\n\u003c/table\u003e\n\n**Operadores aritméticos** em Java são usados para realizar operações matemáticas básicas entre valores numéricos. Eles incluem:\n\n\u003e \u003cb\u003eOBS:\u003c/b\u003e Java sempre realizará a operação inteira quando os operandos forem inteiros, e a operação real ocorrerá caso um ou mais operando seja real.\n\nExemplos:\n\n```java\n// o valor atribuído será 3 e não 3.5, porque ambos os operandos são inteiros\nint v = 7 / 2;\n\n// o valor atribuído será 3.5, porque o primeiro operando é real.\ndouble v = 7.0 / 2;\n```\n\t\nA mesma lógica serve para variáveis:\n\n```java\nint a, b=7, c=2;\n\na = b / c; // será armazenado 3 em a.\n\ndouble a, b=7.0, c=2.0;\n\na = b / c; // será armazenado 3.5 em a.\n```\n\nPodemos alterar o tipo de um operando em uma expressão utilizando o **cast**, que nada mais é do que informar que o valor armazenado na variável terá o seu valor em função do tipo alterado. \n\nExemplo:\n\n```java\nint b=7, c=2;\n\ndouble a=0;\n\na = (double) b / c; // o valor de b será convertido para double antes da operação\n\n// e isso fará com que o primeiro operando seja real e desta\n\n// forma a operação será real, armazenado 3.5 em a.\n```\n\n```java\n+=   -=   *=   /=   %=\n```\n\nExemplo:\n\n```java\nint alturaParede = 2.85; // declaração da variável alturaParede\n\nalturaParede += 0.15; // a variável alturaParede terá o valor\n\n// acrescido (somado) em 0.15, sendo\n\n// equivalente a:\n\n// alturaParede = alturaParede + 0.15;\n```\n\nDesta forma, não precisamos colocar o nome da variável duas vezes.\n\nEm Java temos os operadores de incremento \u003ccode\u003e++\u003c/code\u003e e de decremento \u003ccode\u003e--\u003c/code\u003e, que sempre adicionam uma unidade (\u003ccode\u003e++\u003c/code\u003e) ou subtraem uma unidade (\u003ccode\u003e--\u003c/code\u003e). Eles podem ser ainda divididos em **pré-incremento** e **pós-incremento**, e **pré-decremento** e **pós-decremento**. \n\nO **pré-incremento** determina que primeiro seja realizada a operação de incremento e depois é realizada a operação de atribuição. \n\nExemplo:\n\n```java\nint a = 20, b=0;\n\nb = ++a; // primeiro a variável a será incrementada de uma unidade, valendo 21,\n\n// depois b receberá o valor de a e assim, também valerá 21.\n```\n\nO **pós-incremento** determina que antes seja realizada a atribuição para só então ser realizada a operação de incremento. \n\nExemplo:\n\n```java\nint a = 20, b=0;\n\nb = a++; // primeiro b receberá o valor de a, que é 20 (antes do incremento),\n\n// depois a será incrementado e assim, o valor de a será 21 e o de b será 20.\n```\n\nO **pré-decremento** determina que primeiro seja realizada a operação de decremento e depois é realizada a operação de atribuição.\n\nExemplo:\n\n```java\nint a = 20, b=0;\n\nb = --a; // primeiro a variável a será decrementada de uma unidade, valendo 19,\n\n// depois b receberá o valor de a e assim, também valerá 19.\n```\n\nO **pós-decremento** determina que antes seja realizada a atribuição para só então ser realizada a operação de decremento. \n\nExemplo:\n\n```java\nint a = 20, b=0;\n\nb = a--; // primeiro b receberá o valor de a, que é 20 (antes do incremento),\n\n// depois a será decrementado e, assim, o valor de a será 19 e o de b será 20.\n```\n\n**Operadores de Relacionais** são usados para definir condições.\n\n\u003ctable\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003cb\u003eOperador\u003c/b\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cb\u003eDescrição\u003c/b\u003e\u003c/td\u003e\n  \u003c/tr\u003e\n    \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e==\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eIgualdade/ Comparação\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e!=\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eNegação/ Diferente\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e\u0026gt;\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eMaior que\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e\u0026lt;\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eMenor que\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e\u0026gt;=\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eMaior ou igual a\u003c/td\u003e\n  \u003c/tr\u003e\n    \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e\u0026lt;=\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eMenor ou igual a\u003c/td\u003e\n  \u003c/tr\u003e\n\u003c/table\u003e\n\nExemplos:\n\n```java\n/*1)*/ if(a \u003e b) { ... }\n\n/*2)*/ while (a \u003c=100) { ... }\n\n/*3)*/ for (int c =0; c\u003c50; c++) { ... }\n```\n\nOperadores de em Expressões Lógicas\n\n\u003ctable\u003e\n   \u003ctr\u003e\n    \u003ctd\u003e\u003cb\u003eOperador\u003c/b\u003e\u003c/td\u003e\n     \u003ctd\u003e\u003cb\u003eDescrição\u003c/b\u003e\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e!\u003c/code\u003e\u003c/td\u003e\n     \u003ctd\u003eNÃO lógico\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e\u0026\u0026\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eE lógico\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e||\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eOU lógico\u003c/td\u003e\n  \u003c/tr\u003e\n\u003c/table\u003e\n\nSão os determinantes das tabelas-verdade. \n\nOrdem de precedência: `!, \u0026\u0026, ||`\n\nExemplos:\n\n```java\nif(a \u003e b \u0026\u0026 c \u003c d) { ... }\n\nwhile (a \u003c=100 || b == 10) { ... }\n\nif( !a == 15 \u0026\u0026 b \u003e= 10) { ... }\n\nif( !a == 15 || c \u003e d \u0026\u0026 b \u003e= 10) { ... }\n```\n\nPela ordem de precedência: `if( (!a == 15) || (c \u003e d \u0026\u0026 b \u003e= 10))` \n\nPrimeiro será executada a negação (`!`); depois o e lógico (`\u0026\u0026`) e por último o ou lógico (`||`).\n\nOperadores de bits\n\n\u003ctable\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003cb\u003eOperador\u003c/b\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cb\u003eDescrição\u003c/b\u003e\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e\u0026\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eE entre bits\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e^\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eOU EXCLUSIVO entre bits\u003c/td\u003e\n  \u003c/tr\u003e\n   \u003ctr\u003e\n    \u003ctd\u003e\u003ccode\u003e|\u003c/code\u003e\u003c/td\u003e\n    \u003ctd\u003eOU entre bits\u003c/td\u003e\n  \u003c/tr\u003e\n\u003c/table\u003e\n\nOrdem de precedência: \n\u003col\u003e\n  \u003cli\u003e\u003ccode\u003e\u0026\u003c/code\u003e\u003c/li\u003e\n  \u003cli\u003e\u003ccode\u003e^\u003c/code\u003e\u003c/li\u003e\n  \u003cli\u003e\u003ccode\u003e|\u003c/code\u003e\u003c/li\u003e\n\u003c/ol\u003e\n\n# ☕ [Java] Estruturas de programação\nComandos de controle de fluxo Servem para determinar se as condições são verdadeiras ou controlar uma determinada ordem lógica de eventos para o código.\n\n## [Java] Estrutura condicional\n\nSe (`if`):\n\n```java\nif (condição) {\n\n// instruções;\n\n}\n\n// A cláusula else é opcional.\n```\n\n`if ... else`:\n\n```java\nif (condição) {\n\n// instruções;\n\n}\n\nelse {\n\n// instruções;\n\n}\n```\n\n`if ... else if ... else`\n\n```java\nif (condição1) {\n\ninstruções;\n\n}\n\nelse if (condição2) {\n\ninstruções;\n\n}\n\nelse if (condição3) {\n\ninstruções;\n\n}\n\nelse {\n\ninstruções;\n\n}\n```\n\n\u003e A cláusula `if` deve ocorrer apenas uma vez; As cláusulas `else if` podem ocorrer: nenhuma, uma ou várias vezes; A cláusula `else` só pode ocorrer uma única vez.\n\n\u003ccode\u003eswitch … case\u003c/code\u003e\n\nEstruturas de decisão caracterizadas pela possibilidade de uma variável possuir vários valores diferentes em uma determinada situação.  \n\nUma única estrutura \u003ccode\u003eswitch\u003c/code\u003e pode analisar vários diferentes valores para a variável de controle. A variável de controle em Java pode ser do tipo: \u003ccode\u003einteiro\u003c/code\u003e, \u003ccode\u003ecaractere\u003c/code\u003e, ou \u003ccode\u003eString\u003c/code\u003e. \n\nA cláusula \u003ccode\u003ecase\u003c/code\u003e pode ocorrer de uma a várias vezes, e a cláusula \u003ccode\u003edefault\u003c/code\u003e é opcional.\n\nhttps://medium.com/javarevisited/re-write-this-java-if-else-code-block-or-ill-reject-your-pull-request-953f20c0f544\n\n## [Java] Estrutura de Laços de Repetição (Loops)\n`for` é uma estrutura de repetição (Laços de repetição ou Loop) controlada por uma ou mais variáveis contadoras e caracterizada pela existência de três parâmetros, sendo todos eles opcionais:\n\n**1** - Inicialização da(s) variável(is) de controle\n\n**2** - Condição sobre a(s) variável(is) de controle para parada das iterações\n\n**3** - Passo da(s) variável(is) de controle a cada iteração\n\n```java\nfor((1)inicialização; (2)condição de controle; (3)passo) {\n\n// instruções\n\n}\n```\n\nExemplo:\n\n1) Repetição controlada por uma variável:\n\n```java\nfor (int c=1; c\u003c=limite; i++) {\n\ninstruções;\n\n}\n```\n\n2) Repetição controlada por duas variáveis:\n\n```java\nfor (a=1, b=2; a*b\u0026lt;limite; a++, b+=2) {\n\ninstruções;\n\n}\n```\n\n3) Repetição sem fim\n\n```java\nfor ( ; ; ) {\n\ninstruções;\n\n}\n```\n\n`while`, esta estrutura realiza a repetição de um conjunto de instruções enquanto a condição determinada for verdadeira; caso a condição seja falsa no primeiro teste, nenhuma instrução será executada.\n\n```java\n// realiza o teste da condição no início da estrutura\n\nwhile (condição) {\n\ninstruções;\n\n}\n```\n\n`do...while` esta estrutura de repetição é semelhante à anterior, mas com o diferencial de que as condições devem ser verificadas apenas no final da estrutura, obrigando que as instruções sejam sempre executadas pelo menos uma vez.\n\n```java\n// Teste de condição no final\n\ndo\n\n{\n\ninstruções;\n\n} while (condição);\n```\n\n# ☕ [Java] Entrada e Saída de dados\nEm Java temos muitas formas de **entrada de dados** (input), inclusive de forma gráfica. Inicialmente trabalharemos com a *classe* \u003ccode\u003eScanner\u003c/code\u003e, responsável pela entrada de dados em formato texto, com perguntas diretas ao usuário e a inclusão da resposta em variáveis do programa. \n\nPara realizarmos esta tarefa, é necessário que seja criado um objeto da classe `Scanner`. \n\nPara isso, devemos **importar** a *classe* \u003ccode\u003eScanner\u003c/code\u003e antes do início da programação da classe:\n\n```java\nimport java.util.Scanner;\n```\n\nDepois é necessário criar o **objeto** para realizar as entradas de dados:\n\n```java\npublic class EntradaDados {\n  public static void main (String[] args) {\n    Scanner entrada = new Scanner(System.in);\n  }\n}\n```\n\nExistem vários métodos associados a classe `Scanner` para a entrada de dados, mas para evitarmos problemas futuros podemos usar sempre a entrada de dados de texto \u003ccode\u003e(nextLine())\u003c/code\u003e e converter o texto para o tipo desejado.\n\nExemplo:\n\n1) Para entrada de texto (String):\n\n```java\nString nome;\n\nNome = entrada.nextLine(); // não precisa de conversão, apenas da entrada.\n```\n\n2) Para entrada de valor real:\n\n```java\ndouble nota1;\n\nnota1=Double.parseDouble(entrada.nextLine());\n\n// a entrada de dados em texto precisa de conversão para double.\n```\n\n3) Para entrada de valor inteiro:\n\n```java\nint idade;\n\nidade = Integer.\u003cb\u003eparseInt\u003c/b\u003e(entrada.nextLine());\n\n// a entrada de dados em texto precisa de conversão para int\n```\n\nÉ aconselhável evitar o uso de métodos como:\n\n- `entrada.nextDouble();`\n- `entrada.nextFloat();`\n- `entrada.nextInt();`\n\nEstes métodos, quando usados em conjunto, podem fazer com que a aplicação pule alguma entrada de dados, sendo necessário que seja realizada uma “limpeza de buffer”. Este tipo de problema pode ser contornado ao usar sempre o método “`nextLine()`” e a conversão de tipos.\n\nA **saída de dados** (output) em modo texto pode ser realizada pela *classe* \u003ccode\u003eSystem\u003c/code\u003e, e o método \u003ccode\u003eout.print\u003c/code\u003e (não pula linha), \u003ccode\u003eout.println\u003c/code\u003e (pula linha) ou outros métodos:\n\n1) Apenas uma mensagem:\n\n```java\nSystem.out.println(\"Entre com a Nota A1.........: \");\n```\n\n2) Mensagem e conteúdo de variáveis:\n\n```java\nSystem.out.println(\" Nome: \" + nome + \" Idade: \" + idade + \" Nota 1: \" + nota1);\n```\n\nA seguir temos o exemplo completo de um programa que recebe duas notas e apresenta a média.\n\n```java\npublic class Exemplo {\n\npublic static void main(String[] args) {\n\n// TODO Auto-generated method stub\n\nScanner sc = new Scanner(System.in);\n\ndouble media, nota1, nota2;\n\nSystem.out.println(\"Digite a nota 1:\");\n\nnota1 = Double.parseDouble(sc.nextLine());\n\nSystem.out.println(\"Digite a nota 2:\");\n\nnota2 = Double.parseDouble(sc.nextLine());\n\nmedia = (nota1 + nota2) /2.0;\n\nSystem.out.println(\"A sua média é:\" + media);\n\nsc.close();\n\n}\n\n}\n```\n\n## [Java] Conversão de tipos\nA conversão de tipos em Java pode ser feita por cast ou com o uso de conversão por classes. Ambos já foram vistos em exemplos anteriores:\n\n1) Por cast: Usado para converter valores de um tipo para outro; com cast basta indicar o tipo que você quer que a variável, ou valor, seja convertida, colocando o tipo desejado entre parênteses:\n\n2) Por uso de classes para conversão de textos em valores:\n\n```java\ndouble nota1 = Double.parseDouble(“7.8”);\n\nint idade = Integer.parseInt(“34”);\n\nfloat valor = Float.parseFloat(“2.15”);\n\nlong valor2 = Long.parseLong(“3456789”);\n\nPode-se usar ainda:\n\nByte.parseByte() / Short.parseShort()\n```\n\n# ♨️ [Java] A boa prática em programação Java \n\u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e\n\nA boa prática em programação Java leva em conta um conjunto de regras que facilitam o desenvolvimento de aplicações e melhoram bastante o trabalho em conjunto realizado por equipes. Ao seguir estas regras, projetos podem ser desenvolvidos em paralelo por diferentes programadores, sem que seja necessário que cada componente precise esperar que outros terminem suas tarefas. Estas regras foram utilizadas na construção da linguagem permitindo que não seja necessário decorar as sintaxes de instruções Java. Não são obrigatórias, mas permitem a codificação melhor de nossas aplicações. Vamos ver algumas dessas regras na prática:\n\n1 - Variáveis auxiliares, atributos, métodos e objetos devem ser identificados iniciando por letras minúsculas. Quando houver mais de uma palavra, deve-se começar cada nova palavra com uma letra maiúscula. \n\nExemplos:\n\n```java\nint idade;\n\nint maiorIdade;\n\nString nome;\n\nString nomeCompleto;\n```\n\n2 - Constantes devem ser identificadas por letras maiúsculas em todo o seu nome; mesmo quando temos mais de uma palavra, todo o identificador deve ficar em maiúsculas. \n\nExemplos:\n\n```java\nfinal int idade;\n\nfinal int maiorIdade;\n\nfinal String nome;\n\nfinal String nomeCompleto;\n```\n\n3 - Classes e interfaces (tipo especial de classe) devem iniciar por letras maiúsculas. Quando houver mais de uma palavra, deve-se começar cada nova palavra com uma letra maiúscula. \n\nExemplos:\n\n```java\npublic class Carro { ... }\n\npublic class Carro Hibrido { ... }\n\npublic interface Basico { ... }\n\npublic interface MetodosBasicos { ... }\n```\n\n4 - Técnicas Básicas de Economia de Memória para Programação em Java: Melhores Práticas para Otimizar Código Java e Reduzir o Uso de Memória. Java é uma linguagem de programação popular amplamente utilizada para desenvolver aplicações complexas. No entanto, um dos problemas comuns dos programas Java é o alto uso de memória, que pode levar a problemas de desempenho e até mesmo travamentos. Portanto, é importante usar técnicas de economia de memória para otimizar o código Java e reduzir o uso de memória.\n\nUso de tipos de dados primitivos: Ao usar tipos de dados primitivos em vez de seus wrappers de objetos, podemos economizar memória evitando a sobrecarga da criação de objetos.\n\n```java\nint x = 42;      // use int instead of Integer\ndouble d = 3.14; // use double instead of Double\nboolean b = true; // use boolean instead of Boolean\n```\n\nEvite a criação desnecessária de objetos: \n\n```java\nString s = \"Hello\" + \" World\"; // use StringBuilder instead\n```\n\nEssa linha de código cria um objeto de `new string` para a `string` concatenada `\"Hello World\"`. Em vez disso, podemos usar um `StringBuilder` para anexar as strings e evitar criar um novo objeto para cada concatenação:\n\n```java\nStringBuilder sb = new StringBuilder();\nsb.append(\"Hello\");\nsb.append(\" World\");\n```\n\n# ☕ [Java] Classes e objetos\n\u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e\n\nA **programação orientada a objetos (OOP)** tem como principal conceito representar, em um sistema computacional, um objeto da vida real. Esta representação deve descrever o objeto quanto às suas características e ações que poderá realizar dentro do sistema. Não devemos nos preocupar com todas as características presentes no objeto, mas com aquelas que serão necessárias ao sistema (requisitos).\n\nExemplo: A placa de um automóvel é importante para um sistema de estacionamento, assim como a hora de chegada e saída.\n\nEm alguns casos, o `fabricante`, `modelo` e a `cor` do automóvel poderão ser importantes, mas dificilmente iremos cadastrar o número do `chassi` do mesmo. Como o número do `chassi` não é facilmente visto e seu cadastramento dependeria da documentação do automóvel ou de uma análise para a identificação, que seria difícil, uma vez que é um identificador com muitas letras e números, acabaria por gerar filas e insatisfação dos clientes.\n\nEntretanto, para o sistema de cadastramento do `DETRAN`, por exemplo, o número do `chassi` é uma das informações mais importantes. Dessa forma, identificarmos a `placa` é importante como descritor do automóvel para o sistema de estacionamento, já o `chassi` não.\n\nPor isso, devemos analisar cada objeto separadamente e quais são as características importantes para o sistema em que o objeto será utilizado. Como outro exemplo, podemos notar que a `matrícula`, `nome` e `CR` de um `aluno` são importantes para o sistema acadêmico, mas o time para o qual o `aluno` torce ou sua religião não são. Por isso, os descritores time e religião não são importantes para o objeto `Aluno` em um sistema acadêmico.\n\nAs **classes** Java são responsáveis pelo **conjunto de códigos para a criação de objetos e aplicações**. Uma classe Java deve descrever as *características e ações* que o objeto possui ao ser representado em um sistema computacional, levando em consideração as caracteristicas (atributos) e as ações (métodos) juntamente ou não com seus argumentos (parâmetros).\n\n**Atributo** é conceitualmente um descritor do objeto e deve representar uma **característica**,  dele. O **conjunto de atributos** do objeto deve representar todas as *características importantes* do objeto para o sistema.\n\nExemplo:\n\n```java\nString matricula; // atributo para armazenamento da matrícula\n\nString nome; // atributo para armazenamento do nome\n\ndouble cr; // atributo para armazenamento do cr\n```\n\n**Método** é uma **ação**, um conjunto de instruções a serem executadas por um objeto para realizar uma determinada tarefa.\n\nO **conjunto de métodos** de um objeto deve descrever **todas as ações (tarefas ou funções)** que o objeto poderá realizar dentro do sistema.\n\nExemplo:\n\n```java\npublic int soma(int n1, int n2){\n\nint soma;\nsoma = n1 + n2;\n\nreturn soma;\n\n}\n\npublic void imprimeAumento(double salario, int percentual){\n\ndouble aumento;\naumento = salario + salario * percentual / 100.0;\nSystem.out.println(\"O salário com aumento é: \" + aumento);\n\n}\n```\n\nA classe modela o **objeto** de acordo com as necessidades do sistema para a sua descrição e suas ações. A partir de uma mesma classe, vários objetos diferentes, mas com características semelhantes, podem ser criados em um mesmo sistema ou em diferentes sistemas.\n\nSe consideramos a classe Aluno, podemos criar a partir desta classe dezenas, centenas ou mesmo milhares de objetos Alunos com características semelhantes, tais como matrícula, nome e CR, mas com propriedades (valores próprios nos atributos de cada objeto) diferentes.\n\nOs *objetos* só existem durante a execução do sistema, pois estes só existirão como referência na memória do computador neste momento. Dizemos também que os objetos só existem “em tempo de execução”, uma vez que o sistema ao ser encerrado terá toda a sua memória apagada. Consequentemente, todas as suas variáveis e objetos não existirão mais.\n\nExemplo: `Aluno.java` (objeto com o nome da classe)\n\n```java\n// Classe Aluno\npublic class Aluno { // declaração e início da classe\n\n   // Atributos devem ser identificados começando por letras minúsculas\n   String matricula, nome;\n   double cr;\n\n   // Métodos devem ser identificados começando por letras minúsculas\n   public void imprimir() {\n     System.out.println(\"Matrícula: \" + matricula);\n     System.out.println(\"Nome: \" + nome);\n     System.out.println(\"CR: \" + cr);\n   }\n} // termino da classe\n```\n\n# ☕ [Java] Aplicações Java\n\u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e\n\n**Aplicações em Java** são classes especiais que possuem um método \u003ccode\u003emain()\u003c/code\u003e. O método `main` é responsável por criar os objetos e realizar a combinação de diferentes classes para atender às necessidades de um sistema.\n\nEm cada sistema, temos apenas uma aplicação, que será responsável pela lógica de criação e uso das classes. A comunicação entre os objetos ocorre por meio de trocas de mensagens, que são expressas com o uso de métodos. Uma aplicação, então, cria objetos a partir de uma ou mais classes e usa os métodos dos objetos para realizar as ações que atenderão às necessidades dos usuários.\n\nExemplo: `AppAluno.java` (aplicação)\n\n```java\n// Aplicação para uso da Classe Aluno\npublic class AppAluno { // Declaração e início da classe\n   public static void main(String[] args){ // Método inicial da App\n      Aluno aluno1 = new Aluno();\n      Aluno aluno2 = new Aluno();\n      Aluno aluno3 = new Aluno();\n\n     // Definindo valores para os atributos do aluno1\n     aluno1.matricula = \"1001\";\n     aluno1.nome = \"André\";\n     aluno1.cr = 6.7;\n\n     // Definindo valores para os atributos do aluno2\n     aluno2.matricula = \"1002\";\n     aluno2.nome = \"Maria\";\n     aluno2.cr = 7.5;\n\n     // Definindo valores para os atributos do aluno3\n     aluno3.matricula = \"1003\";\n     aluno3.nome = \"João\";\n     aluno3.cr = 7.0;\n\n     // Exibindo os valores dos atributos de cada aluno\n     aluno1.imprimir();\n     aluno2.imprimir();\n     aluno3.imprimir();\n   }\n}\n```\n\n\u003e [!Note]\n\u003e 1. Cada classe pública (`public`) deve ser criada em um arquivo próprio e o nome da classe deve ser o mesmo do arquivo. Ou seja, a classe Aluno deve ser criada no **arquivo** \u003ccode\u003eAluno.java\u003c/code\u003e e a **classe da aplicação** \"`AppAluno`\" deve ser criada no arquivo \u003ccode\u003eAppAluno.java\u003c/code\u003e. No projeto, seja no Eclipse ou no Netbeans, deverão ser criadas duas classes, uma para o `Aluno` e outra para a aplicação;\n\u003e\n\u003e 2. Foi criada apenas uma classe `Aluno`, mas a partir dela poderemos criar quantos objetos quisermos;\n\u003e\n\u003e 3. Na aplicação foram criados três diferentes objetos do tipo `Aluno`. Isso faz com que cada **objeto** `Aluno` (`aluno1`, `aluno2` e `aluno3`) seja criado na memória em locais diferentes (endereços) e possuam espaço de alocação de memória diferentes para cada atributo de cada objeto;\n\n4. Cada *objeto* criado é independente do outro e possui valores próprios para os seus atributos (propriedades). Como a ação é realizada pelo objeto, cada método fará a ação sobre os atributos do objeto indicado, evitando que haja qualquer tipo de alteração indevida nos valores de cada um.\n\n![img02](https://user-images.githubusercontent.com/61624336/119909388-16166f00-bf2b-11eb-88c1-15bbf2b15e8e.jpg)\n\n5. Operador \u003ccode\u003enew\u003c/code\u003e serve para criar um novo objeto e instancia-lo com \u003ccode\u003e()\u003c/code\u003e, portanto, é um método construtor.\n\n```java\nnome_da_classe nome_do_objeto = new método_construtor();\n```\n\nA classe `Aluno` passou a ser uma **biblioteca de classes**, e esta classe pode ser reutilizada em diversas outras aplicações. Esse conceito é um dos mais importantes na programação orientada a objetos, pois reduz o trabalho. Qualquer classe criada poderá ser reaproveitada inúmeras vezes por diversas aplicações, poupando esforço de desenvolvimento e facilitando a manutenção.\n\nCada classe criada se torna uma parte da sua biblioteca de classes e, conforme você vai criando novas classes, a sua biblioteca tende a aumentar. Dessa forma, quando você for criar novas aplicações, terá à sua disposição uma séria de classes já prontas e disponíveis para reaproveitar, sem precisar de novas.\n\nSe você precisar realizar qualquer melhoria em uma classe da sua biblioteca, você poderá realizar sem problemas, pois qualquer inclusão não afetará o uso desta classe nas aplicações antigas, mantendo a compatibilidade entre todas as aplicações.\n\nCom base no reaproveitamento de código da programação orientada a objetos, podemos realizar alterações de melhoria, atualização ou qualquer manutenção em uma classe. Isso fará com que todas as aplicações sejam atualizadas quando forem recompiladas.\n\n# ☕ [Java] Métodos Getters e Setters\n\u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e\n\nPor questões de segurança e falta de controle, não é comum realizar acessos diretos aos atributos de um objeto, por isso são criados métodos específicos para receber o valor e realizar a **atribuição (Setters)**, ou para a **recuperação (Getters)** de um valor armazenado nos atributos de um objeto. Este processo pode evitar que valores incorretos sejam atribuídos sem qualquer chance de análise.\n\n**Métodos Setters** são métodos especiais que recebem o valor do atributo e, por serem métodos, podem analisar se são válidos, sendo responsáveis pela atribuição. Quando o atributo é protegido (privado), é necessário um método para realizar a atribuição.\n\nCaracterísticas dos métodos Setters:\n\n- São sempre do tipo \u003ccode\u003evoid\u003c/code\u003e, pois métodos Setters não devem retornar nada;\n\n- Devem ser públicos para que a aplicação tenha acesso ao método;\n\n- Devem começar pela palavra \u003ccode\u003eset\u003c/code\u003e e o nome do atributo: como tem mais de uma palavra, cada nova palavra no nome deve começar por letra maiúscula;\n\n- Possui sempre um parâmetro do mesmo tipo do atributo que receberá o valor, pois ambos (parâmetro e atributo) devem ser do mesmo tipo.\n\nA verificação do valor a ser atribuído não pode ser realizada quando efetuamos uma atribuição direta:\n\n```java\nAluno a = new Aluno();\n\na.cr = -5.0;\n```\n\nO uso de um método Setter neste caso evitará que seja atribuído um valor inválido para o CR, no caso `-5.0`;\n\nExemplo: `Aluno.java` Setter = `Aluno.class`\n\n```java\n// Classe Aluno\npublic class Aluno { // Declaração e início da classe\n  // Atributos devem ser identificados começando por letras minúsculas\n  String matricula, nome;\n  double cr;\n\n  // Métodos devem ser identificados começando por letras minúsculas\n  public void imprimir() { // Método imprimir(os dados do Aluno)\n    System.out.println(\"Matrícula: \" + matricula);\n    System.out.println(\"Nome: \" + nome);\n    System.out.println(\"CR: \" + cr);\n  }\n\n  // Setter\n  public void setCr(double c){\n    if(c \u003e= 0.0 \u0026\u0026 c \u003c= 10.0){\n         cr = c;\n    }\n  }\n}\n```\n\nExemplo: `AppAluno.java` (aplicação chamando o Setter) - `AppAluno.class`\n\n```java\n// Aplicação para uso da Classe Aluno\npublic class AppAluno { // Declaração e início da classe\n\n  public static void main(String[] args){ // Método inicial da App\n    Aluno aluno1 = new Aluno();\n    Aluno aluno2 = new Aluno();\n    Aluno aluno3 = new Aluno();\n    Aluno a = new Aluno();\n\n    // Definindo valores para os atributos do aluno1\n    aluno1.matricula = \"1001\";\n    aluno1.nome = \"André\";\n    aluno1.cr = 6.7;\n\n    // Definindo valores para os atributos do aluno2\n    aluno2.matricula = \"1002\";\n    aluno2.nome = \"Maria\";\n    aluno2.cr = 7.5;\n\n    // Definindo valores para os atributos do aluno3\n    aluno3.matricula = \"1003\";\n    aluno3.nome = \"João\";\n    aluno3.cr = 7.0;\n    a.cr = -5.0;\n\n    // Exibindo os valores dos atributos de cada aluno\n    aluno1.imprimir();\n    aluno2.imprimir();\n    aluno3.imprimir();\n    a.setCr(-5.0); // setter\n  }\n}\n```\n\n- Note que o parâmetro c recebe o valor a ser atribuído ao CR (`-5.0`), mas antes de atribuir é realizada uma verificação do valor para averiguar se o mesmo é válido. No caso, o valor do parâmetro é menor do que zero.\n\n- Como sabemos que um CR não pode ser negativo, a atribuição não será realizada, assim como a tentativa de realizar a atribuição de um CR maior do que `10` (dez) também não permitirá que a atribuição ocorra.\n\nApenas atribuições com valores válidos poderão ser realizadas neste caso.\n\nO **Métodos Getters** são métodos especiais que retornam o valor armazenado no atributo, evitando acesso direto a ele pela aplicação. Assim como visto no método Setter, a proteção do atributo (`private`) fará com que a aplicação não tenha acesso direto a ele, fazendo com que seja necessário um método público para recuperar o valor atribuído ao mesmo.\n\nCaracterísticas dos métodos Getters:\n\n- São sempre do mesmo tipo do atributo que será retornado, nunca do tipo \u003ccode\u003evoid\u003c/code\u003e;\n\n- Devem ser públicos para que a aplicação tenha acesso ao método;\n\n- Devem começar pela palavra \u003ccode\u003eget\u003c/code\u003e e o nome do atributo: como tem mais de uma palavra, cada nova palavra no nome deve começar por letra maiúscula;\n\n- Não possui parâmetro: esses métodos nunca receberão parâmetros, uma vez que não farão atribuições ou ações com parâmetros, realizando apenas o retorno do valor armazenado no atributo.\n\nExemplo: `Aluno.java` Getter\n\n```java\n// Classe Aluno\npublic class Aluno { // Declaração e início da classe\n  // Atributos devem ser identificados começando por letras minúsculas\n  String matricula, nome;\n  double cr;\n\n  // Métodos devem ser identificados começando por letras minúsculas\n  public void imprimir() { // Método imprimir(os dados do Aluno)\n    System.out.println(\"Matrícula: \" + matricula);\n    System.out.println(\"Nome: \" + nome);\n    System.out.println(\"CR: \" + cr);\n  }\n\n  // Setter\n  public void setCr(double c){\n    if(c \u003e= 0.0 \u0026\u0026 c \u003c= 10.0){\n         cr = c;\n    }\n  }\n\n  // Getter\n  public double getCr() {\n    return cr;\n  }\n  \n}\n```\n\nNote que não existe parâmetro, o método apenas deve retornar o valor armazenado e por isso não pode ser \u003ccode\u003evoid\u003c/code\u003e, sendo o tipo de retorno do mesmo tipo do atributo que será retornado, e a ação é a de retorno (`return`).\n\nNo futuro, os atributos das nossas classes serão protegidos contra acesso direto (privado), impedindo que a aplicação possa acessar diretamente um atributo. Dessa forma, é necessário que usemos os métodos *Setters* e *Getters* para atribuir e recuperar os valores do atributo.\n\nExemplo: `Aluno.java` (versão com métodos Setters e Getters.)\n\n```java\npublic class Aluno {\n  // Atributos devem ser identificados começando por letras minúsculas\n  String matricula, nome;\n  double cr;\n\n  // Métodos também\n  public void setMatricula(String m){\n    if(!m.isEmpty()) { // se o parâmetro m NÃO (!) estiver vazio\n        matricula = m; // será feita a atribuição\n    } \n  }\n\n  public String getMatricula() {\n     return matricula; // retorna a matricula\n  }\n\n  public void setNome(String n){\n    if(!n.isEmpty()){ // se o parâmetro n NÃO (!) estiver vazio\n       nome = n; // será feita a atribuição\n    }\n  }\n\n  public String getNome(){\n    return nome; // retorna o nome\n  }\n\n  public void setCr(double c){\n    if(c \u003e= 0 \u0026\u0026 c \u003c= 10) {\n       cr = c;\n    }\n  }\n\n  public double getCr() {\n    return cr; // retorna o CR\n  }\n\n  public void imprimir() { // Método imprimir(os dados do Aluno)\n    // Os Getters usados aqui!\n    System.out.println(\"Matrícula: \" + getMatricula());\n    System.out.println(\"Nome: \" + getNome());\n    System.out.println(\"CR: \" + getCr());\n  }\n}\n```\n\nExemplo: `AppAluno.java` (nova versão)\n\n```java\n// Aplicação para o uso da Classe Aluno\npublic class Aluno {\n   public static void main(String[] args) {\n      Aluno aluno1 = new Aluno(); // Criação da nova instância do objeto aluno1 (instanciação)\n      Aluno aluno2 = new Aluno(); // Criação da nova instância do objeto aluno2 (instanciação)\n      Aluno aluno3 = new Aluno(); // Criação da nova instância do objeto aluno3 (instanciação)\n\n     // Definindo valores para os atributos do aluno1\n      aluno1.setMatricula(\"1001\");\n      aluno1.setNome(\"André\");\n      aluno1.setCr(6.7);\n\n     // Definindo valores para os atributos do aluno2\n      aluno2.setMatricula(\"1002\");\n      aluno2.setNome(\"Isaac\");\n      aluno2.setCr(7.7);\n\n     // Definindo valores para os atributos do aluno3\n// Valores vazios e inválidos, não serão atribuídos\n      aluno3.setMatricula(\"\");\n      aluno3.setNome(\"\");\n      aluno3.setCr(12);\n\n     // Exibição dos valores dos atributos de cada aluno\n      aluno1.imprimir();\n      aluno2.imprimir();\n      aluno3.imprimir();\n   }\n}\n```\n\n\u003e [!Note]\n\u003e \n\u003e 1. Os valores dos atributos dos alunos `1` e `2` serão atribuídos normalmente, mas os valores do `aluno3` não, porque a `matrícula` e o `nome` estão vazios e o `CR` não é válido;\n\u003e \n\u003e 2. Os valores foram atribuídos utilizando os métodos Setters, que verificaram se os valores eram válidos para só então realizar as atribuições;\n\u003e \n\u003e 3. Os métodos Getters foram usados na própria classe `Aluno` para buscar os valores armazenados nos atributos do objeto no método `imprimir`.\n\nExemplo: A classe `Carro` possui os atributos e métodos a seguir, crie a classe `Carro` e a aplicação `AppCarro`, realize a entrada de dados na aplicação através do teclado, e ao final imprima os dados dos respectivos carros (através do método \u003ccode\u003eimprimir()\u003c/code\u003e).\n\nClasse `Carro`:\n\n\u003ctable\u003e\n\n\u003ctr\u003e\n  \u003ctd\u003e\u003cb\u003eAtributos\u003c/b\u003e\u003c/td\u003e\n  \u003ctd\u003e\u003cb\u003eMétodos\u003c/b\u003e\u003c/td\u003e\n\u003c/tr\u003e\n\n\u003ctr\u003e\n  \u003ctd\u003eFabricante: texto\u003c/td\u003e\n  \u003ctd\u003e- \u003ci\u003eSetters\u003c/i\u003e para todos os atributos\u003c/td\u003e\n\u003c/tr\u003e\n\n\u003ctr\u003e\n  \u003ctd\u003eModelo: texto\u003c/td\u003e\n  \u003ctd\u003e- \u003ci\u003eGetters\u003c/i\u003e para todos os atributos\u003c/td\u003e\n\u003c/tr\u003e\n\n\u003ctr\u003e\n  \u003ctd\u003eCor: texto\u003c/td\u003e\n  \u003ctd\u003e- \u003cb\u003eImprimir()\u003c/b\u003e // imprime todos os atributos\u003c/td\u003e\n\u003c/tr\u003e\n\n\u003ctr\u003e\n  \u003ctd\u003ePlaca: texto\u003c/td\u003e\n\u003c/tr\u003e\n\n\u003ctr\u003e\n  \u003ctd\u003eValor: real\u003c/td\u003e\n\u003c/tr\u003e\n\n\u003ctr\u003e\n  \u003ctd\u003eNúmero de Portas: inteiro\u003c/td\u003e\n\u003c/tr\u003e\n\n\u003ctr\u003e\n  \u003ctd\u003eAno de fabricação: inteiro\u003c/td\u003e\n\u003c/tr\u003e\n\n\u003ctr\u003e\n  \u003ctd\u003eAno do Modelo: inteiro\u003c/td\u003e\n\u003c/tr\u003e\n\n\u003c/table\u003e\u003cbr \\\u003e\n\n`Carro.java`\n\n```java\npublic class Carro {\n  // Attributes\n  String fabricante, modelo, cor, placa;\n  double valor;\n  int numeroPortas, anoFabricacao, anoModelo;\n\n  // Setter methods\n  public void setFabricante (String fab){\n    if(!fab.isEmpty()) {\n       fabricante = fab;\n    }\n  }\n  public void setModelo (String mad){\n    if(!mod.isEmpty()) {\n       modelo = mod;\n    }\n  }\n  public void setCor (String c){\n    if(!c.isEmpty()) {\n       cor = c;\n    }\n  }\n  public void setPlaca (String p){\n    if(!p.isEmpty()) {\n       placa = p;\n    }\n  }\n  public void setValor (String val){\n    if(!val.isEmpty()) {\n       valor = val;\n    }\n  }\n}\n```\n\n`AppCarro.java`\n\n```java\nimport java.util.Scanner;\n// Scanner para imprimir os dados\n\npublic class AppCarro {\n    public static void main (String[] args){\n        Scanner entrada = new Scanner(System.in);\n        Carro car1 = new Carro();\n\n        // Entrada de Dados\n        System.out.println(\"---------- Entrada de Dados - Carro ----------\");\n\n        // Fabricante\n        System.out.println(\"Digite o Fabricante do Carro: \");\n        car1.setFabricante(entrada.nextLine());\n\n        // Modelo\n        System.out.println(\"Digite o Modelo do Carro: \");\n        car1.setModelo(entrada.nextLine());\n\n        // Placa\n        System.out.println(\"Digite a Placa do Carro: \");\n        car1.setPlaca(entrada.nextLine());\n\n        // Cor\n        System.out.println(\"Digite a Cor do Carro: \");\n        car1.setCor(entrada.nextLine());\n\n        // Valor\n        System.out.println(\"Digite o Valor do Carro: \");\n        car1.setValor(Double.parseDouble(entrada.nextLine()));\n\n        // Número de Portas\n        System.out.println(\"Digite o Nº de Portas do Carro: \");\n        car1.setNumeroPortas(Integer.parseInt(entrada.nextLine()));\n\n        // Ano de Fabricação\n        System.out.println(\"Digite o Ano de Fabricação do Carro: \");\n        car1.setAnoFabricacao(Integer.parseInt(entrada.nextLine()));\n\n        // Ano do Modelo\n        System.out.println(\"Digite o Ano do Modelo do Carro: \");\n        car1.setAnoModelo(Integer.parseInt(entrada.nextLine()));\n\n        // Saída de Dados\n        System.out.println(\"--------------- Saída de Dados - Carro ---------------\");\n        car1.imprimir();\n    }\n}\n```\n\n\u003e [!Note]\n\u003e Você pode ver que temos algumas repetições de código para realizar a entrada de dados de cada objeto. Se aumentarmos o número de objetos, aumentaremos consideravelmente o tamanho do código. Para resolver este problema e evitarmos a redundância de códigos, vamos incluir um novo método na classe `Carro`, um método para a entrada de dados. Desta forma, evitamos a redundância dos códigos de entrada de dados.\n\nClasse `Carro`\n\n\u003ctable\u003e\n  \u003ctr\u003e\n    \u003ctd\u003e\u003cb\u003eAtributos\u003c/b\u003e\u003c/td\u003e\n    \u003ctd\u003e\u003cb\u003eMétodos\u003c/b\u003e\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003eFabricante: texto\u003c/td\u003e\n    \u003ctd\u003e- Setters para todos os atributos\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003eModelo: texto\u003c/td\u003e\n    \u003ctd\u003e- Getters para todos os atributos\u003c/td\u003e\n  \u003c/tr\u003e\n   \u003ctr\u003e\n    \u003ctd\u003eCor: texto\u003c/td\u003e\n    \u003ctd\u003eImprimir() // imprime todos os dados do carro\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003ePlaca: texto\u003c/td\u003e\n    \u003ctd\u003e- EntradaDados () // realiza a entrada de dados do carro\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003eValor: real\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003eValor: real\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003eNumeroPortas: inteiro\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003eAnoFabricacao: inteiro\u003c/td\u003e\n  \u003c/tr\u003e\n  \u003ctr\u003e\n    \u003ctd\u003eAnoModelo: inteiro\u003c/td\u003e\n  \u003c/tr\u003e\n\u003c/table\u003e\n\nNova solução do exercício prático, com a inclusão do método `entradaDados` na classe `Carro`:\n\n`Carro.java`\n\n```java\nimport java.util.Scanner;\n\npublic class Carro {\n  // Usando regras de boas práticas em Java\n  // Para identificadores da classe, dos atributos e dos métodos\n\n  String fabricante, modelo, cor, placa;\n  double valor;\n  int numeroPortas, anoFabricacao, anoModelo;\n\n  // Getters e Setters Fabricante\n  public String getFabricante(){\n    return fabricante;\n  }\n}\n```\n\n`AppCarro.java`\n\n```java\npublic class AppCarro {\n   public static void main (String[] args){\n      // TODO Auto-generated method stub\n      Carro car1 = new Carro();\n      car1.entradaDados();\n      car1.imprimir();\n\n      Carro car2 = new Carro();\n      car2.entradaDados();\n      car2.imprimir();\n\n      Carro car3 = new Carro();\n      car3.entradaDados();\n      car3.imprimir();\n   }\n}\n```\n\n\u003e [!Note]\n\u003e Você pode perceber agora que existe um método para a entrada de dados na classe `Carro`, e que ele está sendo usado por cada carro para realizar a entrada de dados pelo teclado, evitando que os códigos das entradas de dados fiquem redundantes.\n\u003e Além disso, a aplicação ficou muito mais simples. Caso você tenha vários objetos carros, você não terá redundância, portanto sua aplicação ficará mais simples.\n\u003e Faça um teste executando a nova aplicação e analise o resultado. Inclua mais dois objetos carros e teste novamente: você verá que a aplicação terá uma pequena mudança, mas a classe Carro ficará inalterada.\n\u003e A partir deste momento, todas as classes deverão sempre conter o \u003ccode\u003emétodo entradaDados()\u003c/code\u003e.\n\n## [Java] Métodos construtores\n\u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e\n\nA programação orientada a objetos permite que possamos controlar a criação de um objeto através dos chamados **métodos construtores**. Tal característica permite que um método especial, o método construtor, seja executado no momento em que ocorre a criação do objeto (objeto é instanciado) e um conjunto de ações (instruções) podem ser programadas para serem realizadas neste momento.\n\nEntre essas ações, pode-se destacar o recebimento de dados iniciais para serem atribuídos e/ou preparar o objeto para que este esteja apto a atender às necessidades para qual foi criado.\n\nUm método construtor pode ainda ser usado para determinar o tamanho de um vetor que será usado pelo objeto, assim como *pré-configurar estruturas de dados de suporte* ao objeto que está sendo criado.\n\nSão métodos especiais executados apenas uma vez por cada *objeto* criado, pois somente são executados no momento da **instanciação / criação do objeto**, sendo responsáveis por realizar as ações necessárias para a sua criação (controlar a criação do objeto).\n\nCaracterísticas dos métodos construtores:\n\n1. São sempre públicos (`public`, característica de encapsulamento – veremos mais adiante), não podendo ter nenhum tipo de restrição;\n\n2. Não existe definição de tipo de retorno, pois métodos construtores não podem retornar valores com a instrução “`return`”, são sem tipo;\n\n3. Devem ser identificados sempre com o mesmo nome da classe;\n\n4. São executados exclusivamente durante o processo de criação / instanciação do objeto, não podendo ser usados pelo objeto após a sua criação.\n\n`Pessoa.java`\n\n```java\npublic class Pessoa {\n  // Attributes\n  String nome, identidade;\n  int idade;\n\n  // Constructor method\n  public Pessoa(String nome, String identidade, int idade) {\n    // Setters e Attributes\n    setNome(nome);\n    setIdentidade(identidade);\n    setIdade(idade);\n  }\n\n  // Getters and Setters - Nome\n  public String getNome(){\n    return nome;\n  }\n\n  public void setNome(String no) {\n    if(!no.isEmpty()) {\n      nome = no;\n    }\n  }\n\n  // Getters and Setters - Identidade\n  public String getIdentidade(){\n    return identidade;\n  }\n\n  public void setIdentidade(String iden) {\n    if(!iden.isEmpty()) {\n      identidade = iden;\n    }\n  }\n\n  // Getters and Setters - Idade\n  public String getIdade(){\n    return identidade;\n  }\n\n  public void setIdade(String ida) {\n    if(ida \u003e 0) {\n      idade = ida;\n    }\n  }\n\n  // Método imprimir()\n  public void imprimir() {\n    System.out.println(\"Pessoa: \" + nome);\n    System.out.println(\"RG: \" + identidade);\n    System.out.println(\"Idade: \" + idade);\n  }\n}\n```\n\n`AppPessoa.java`\n\n```java\npublic class AppPessoa {\n  public static void main(String[] args) {\n     Pessoa p1 = new Pessoa(\"Isaac\", \"7\", 24);\n\n     p1.imprimir();\n  }\n}\n```\n\n1. Na classe `Pessoa`, o método construtor:\n\n```java\npublic Pessoa(String nome, String identidade, int idade)\n```\n\nO método é público, não possui tipo de retorno antes no nome identificador do método, seu identificador é igual ao nome da classe, por isso começou por letra maiúscula e só será usado para criar o objeto (instanciar);\n\n2. A partir do momento em que um método construtor é criado, a classe só poderá ser instanciada se usarmos um método construtor existente. Por isso, o objeto Pessoa p1 não pode ser criado e sua criação foi comentada na aplicação, pois este método tenta utilizar um método construtor que não existe na classe;\n\n3. O objeto `p2` usa um método construtor existente e por isso pode ser criado;\n\n4. Com o uso do método construtor, os dados recebidos como parâmetros puderam ser utilizados para realizar as atribuições nos atributos do objeto, determinando os valores de suas propriedades no momento da criação do objeto;\n\n5. Os métodos `setIdentidade` (`String id`) e `setIdade` (`int id`) podem ter o mesmo identificador para o parâmetro porque o parâmetro `id` é declarado em diferentes métodos e, sendo assim, ele é válido internamente em cada um dos métodos separadamente.\n\nO processo de compilação de uma classe cria um método construtor vazio quando não for encontrado nenhum método construtor. Desta forma, nos exemplos anteriores, as classes `Aluno` e `Carro` não tinham métodos construtores, então o compilador criou respectivamente os métodos a seguir para as classes `Aluno` e `Carro`:\n\n```java\npublic Aluno ( ) { }\n\n// e\n\npublic Carro ( ) { }\n```\n\nQuando não temos um construtor em uma classe, um construtor VAZIO é criado no processo de compilação.\n\n# ☕ [Java] Polimorfismo\n\u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e\n\n**Polimorfismo** quer dizer muitas formas. O **polimorfismo de sobrecarga** permite o emprego de operadores e identificadores de várias formas, sendo então necessária uma contextualização para que seja realizada a operação adequada. Este contexto está ligado ao emprego do operador, método etc., de acordo com uma situação.\n\nPolimorfismo de sobrecarga de operadores:\n\n```java\nint b=5, c=3;\n\nint a = b + c;\n// o símbolo de + neste contexto está realizando uma operação\n\n// de soma entre valores inteiros, no caso b + c (inteiros)\n\ndouble x=3.5, y=2.2;\n\n// temos um novo contexto, pois a operação será realizada entre dois valores reais, no caso x+y\ndouble z = x + y;\n```\n\nA mudança de contexto faz com que as operações a serem realizadas sejam diferentes, pois toda linguagem de programação possui diferentes formas de realizar as operações de soma inteira e real. Desta forma, a expressão aritmética a seguir utiliza as duas operações conjuntamente:\n\n```java\ndouble z = ( 2 + 5) / (3.5 + 1.5);\n```\n\nNa primeira operação de soma, os operandos são inteiros, então a operação a ser realizada será de uma soma inteira, para somente depois ser realizada a operação de soma real. Desta forma, teremos em um instante a seguinte situação:\n\n```java\ndouble z = ( 7) / (5.0);\n```\n\nAssim, a operação de divisão será real e não inteira porque existe um operando real.\n\nEm Java, todas as operações aritméticas serão realizadas em função dos tipos dos operandos, e a operação será inteira apenas se ambos os operandos foram inteiros. Caso contrário (um operando inteiro e outro real ou dois operandos reais), a operação será real.\n\nO operador \u003ccode\u003e+\u003c/code\u003e é um dos mais usados, sendo um bom exemplo de **sobrecarga de operadores**, pois pode ser utilizado de várias e diferentes formas em função do contexto:\n\n1. Concatenação: \u003ccode\u003eString nome = \"João\" + \" da \" + \"Silva\";\u003c/code\u003e\n2. Soma inteira: \u003ccode\u003eint a = 3 + 4;\u003c/code\u003e\n3. Soma real: \u003ccode\u003edouble b = 1.3 + 2.7;\u003c/code\u003e\n4. Incremento: \u003ccode\u003ex++; ou ++x;\u003c/code\u003e\n5. Concatenação entre textos e valores: \u003ccode\u003eSystem.out.println(\"Idade\" + p2.getIdade());\u003c/code\u003e\n\nAgora imagine a seguinte instrução:\n\n```java\nSystem.out.println(\"Valor =\" + (( 3 + 4) + (1.3 + 2.7) + (++x)));\n```\n\nA *sobrecarga de operadores* está sendo usada de diferentes formas em uma mesma instrução. Cada contexto será avaliado para que seja executada a operação adequada em cada caso.\n\nToda expressão é avaliada sintaticamente, assim como cada contexto será avaliado individualmente no momento da execução.\n\nO **Polimorfismo de sobrecarga de métodos** permite que possamos ter mais de um método com o mesmo identificador em uma mesma classe. Isso só é possível em razão da avaliação do contexto no momento da execução. Vamos levar em consideração que eu desejo realizar o cálculo da área de um quadrado e de um retângulo em uma mesma classe.\n\nPara realizar o cálculo da área do quadrado, eu preciso apenas do valor da base do quadrado. Assim, o método área ficaria da seguinte forma:\n\n```java\npublic int area (int base){\n  return ((int) Math.pow(base,2)); // Math.Pow calcula a base elevada a 2\n}\n```\n\nJá para realizar o cálculo da área do retângulo, eu preciso do valor da base e da altura do quadrado. Assim, o método área ficaria da seguinte forma:\n\n```java\npublic int area(int base, int altura){\n  return(base * altura);\n}\n```\n\n## [Java] Assinaturas\n\u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e\n\nEsses dois métodos podem conviver na mesma classe, uma vez que eles possuem diferentes *assinaturas*. A **assinatura de um método** é determinada pelo tipo de parâmetros e pela ordem em que estes foram declarados. Desta forma, a assinatura do primeiro método é:\n\n```java\narea ( int );\n```\n\ne do segundo:\n\n```java\narea ( int , int );\n```\n\nDiante da diferença de assinaturas, podemos ter dois diferentes contextos para o uso do método de cálculo da área:\n\n```java\nSystem.out.println(\"Área = \" + area( 5 ));\n```\n\n1. No primeiro contexto, é chamado para executar o método área com um único parâmetro e neste caso a avaliação em tempo de execução irá determinar que deve ser usado o cálculo da área do quadrado. Ou seja, aquele que recebe um valor inteiro como parâmetro, e a resposta será: \u003ccode\u003e25\u003c/code\u003e.\n\n```java\nSystem.out.println(\"Área = \" + area( 5, 6 ));\n```\n\n2. No segundo contexto, é chamado para executar o método área com um dos parâmetros e, neste caso, a avaliação em tempo de execução irá determinar que deve ser usado o cálculo da área do retângulo. Ou seja, aquele que recebe dois valores inteiros como parâmetro, e a resposta será: \u003ccode\u003e30\u003c/code\u003e.\n\n\u003e [!Warning]\n\u003e Com o uso da sobrecarga de métodos você poderá criar quantos métodos com o mesmo identificador (nome) quiser em uma mesma classe, desde que eles **não possuam a mesma assinatura de método**.\n\n## [Java] Métodos\n\u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e\n\nSe quisesse incluir um método para calcular a área de uma circunferência, você não poderia incluir nesta classe, pois ele teria a mesma assinatura do método do cálculo da área do quadrado:\n\n```java\npublic static int area(int raio) {\n  return ((int) Math.PI * Math.pow(raio,2));\n  // Math.Pow calcula o raio elevado a 2\n}\n```\n\nO método teria a mesma assinatura do método área do quadrado e, no momento da execução, não haveria como saber qual dos dois deveria seria executado, pois ambos teriam o mesmo contexto:\n\n```java\nSystem.out.println(\"Área Quadrado = \" + area( 5 ));\nSystem.out.println(\"Área Circunferência = \" + area( 4 ));\n```\n\nA linguagem Java não teria como definir qual método executar, já que ambos têm a mesma assinatura e a linguagem não é suficientemente inteligente para tentar buscar isso em algum outro lugar que não o contexto da chamada do método:\n\n```java\narea( 5 )\n\n// e\n\narea( 4 )\n```\n\nComo ambos possuem o mesmo contexto, os métodos com a mesma assinatura não podem compartilhar a mesma classe.\n\nExemplos de polimorfismo de sobrecarga válidos para uma mesma classe:\n\n```java\nmeuMetodo(int a, double b, String c){\n  return 1;\n}\n\nmeuMetodo(double b, String c, int a){\n  return 2;\n}\n\nmeuMetodo(String c, int a, double b){\n  return 3;\n}\n\nmeuMetodo(String c, double b, int a){\n  return 4;\n}\n```\n\nAs assinaturas são respectivamente:\n\n```java\nmeuMetodo(int, double, String)\n\nmeuMetodo(double, String, int)\n\nmeuMetodo(String, int, double)\n\nmeuMetodo(String, double, int)\n```\n\nTodos os métodos acima, apesar de possuírem a mesma quantidade de parâmetros, têm assinaturas diferentes que serão executadas em função de contexto diferentes, respectivamente:\n\n```java\nint g = meuMetodo(2, 2.25, \"Casa\");\n\nint h = meuMetodo(2.25, \"Casa\", 2);\n\nint i = meuMetodo(\"Casa\", 2, 2.25);\n\nint j = meuMetodo(\"Casa\", 2.25, 2);\n```\n\nOs valores armazenados em `g`, `h`, `i` e `j` serão respectivamente: `1, 2, 3 e 4`.\n\n## [Java] A sobrecarga de métodos construtores\n\u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=diagramsdotnet\u0026logoColor=white\"\u003e\n\n**Métodos construtores** são métodos e também podem ser sobrecarregados. Uma classe que possui mais de um método construtor é uma classe que oferece diferentes formas de criação para os seus objetos.\n\nOutra forma de uso de *mais de um construtor* é para manter a compatibilidade de uma classe com suas aplicações antigas.\n\nSe analisarmos a classe \u003ccode\u003eCarro\u003c/code\u003e, vista como exemplo anteriormente, podemos notar que ela não possui nenhum método construtor. Podemos então criar alguns métodos construtores para esta classe e preservar a aplicação antiga, criando e analisando uma classe nova (evoluída) e as duas aplicações, a antiga e a nova:\n\nClasse: `Carro` (atualizada com cinco métodos construtores)\n\n```java\nimport java.util.Scanner;\n\npublic class Carro{\n// Use as regras da boa prática em programação Java\n// para os identificadores da classes, dos atributos e dos métodos\n\n// Atributos\n\nString fabricante, modelo, cor, placa;\ndouble valor;\nint numeroPortas, anoFabricacao, anoModelo;\n\n// Construtor Methods\n\npublic Carro() { }\n\npublic Carro(String placa, double valor){\n    this.placa = placa;\n    this.valor = valor;\n}\n\npublic Carro(String madelo, String cor, String placa, double valor){\n    this.modelo = modelo;\n    this.cor = cor;\n    this.placa = placa;\n    this.valor = valor;\n}\n\npublic Carro(String fabricante, String madelo, String cor, String placa, double valor){\n    this.fabricante = fabricante;\n    this.modelo = modelo;\n    this.cor = cor;\n    this.placa = placa;\n    this.valor = valor;\n}\n\npublic Carro(String fabricante, String madelo, String cor, String placa, double valor,\n             int numeroPortas, int anoFabricacao, int anoModelo){\n    this.fabricante = fabricante;\n    this.modelo = modelo;\n    this.cor = cor;\n    this.placa = placa;\n    this.valor = valor;\n    this.numeroPortas = numeroPortas;\n    this.anoFabricacao = anoFabricacao;\n    this.anoModelo = anoModelo;\n}\n\n// Getters and Setters Methods\n\n// Fabricante - Getters and Setters\n\npublic String getFabricante() {\n    return fabricante;\n}\n\npublic void setFabricante (String fab){\n    if(!fab.isEmpty()) {\n        fabricante = fab;\n    }\n}\n\n// Modelo - Getters and Setters\n\npublic String getModelo() {\n    return modelo;\n}\n\npublic void setModelo (String mad) {\n    if(!mod.isEmpty()) {\n        modelo = mod;\n    }\n}\n\n// Cor - Getters and Setters\n\npublic String getCor() {\n    return cor;\n}\n\npublic void setCor (String co) {\n    if(!co.isEmpty()) {\n        cor = co;\n    }\n}\n\n// Placa - Getters and Setters\n\npublic String getPlaca() {\n    return placa;\n}\n\npublic void setPlaca (String pla){\n    if(!pla.isEmpty()){\n        placa = pla;\n    }\n}\n\n// Valor - Getters and Setters\n\npublic double getValor(){\n    return valor;\n}\n\npublic void setValor(double val){\n    if(val \u003e 0){\n        valor = val;\n    }\n}\n\n// Número de Portas - Getters and Setters\n\npublic int getNumeroPortas(){\n    return numeroPortas;\n}\n\npublic void setNumeroPortas (int nportas){\n    if(nportas \u003e 0){\n        numeroPortas = nportas;\n    }\n}\n\n// Ano de Fabricação - Getters and Setters\n\npublic int getAnoFabricacao(){\n    return anoFabricacao;\n}\n\npublic void setAnoFabricacao(int anofab){\n    if(anofab \u003e 0){\n        anoFabricacao = anofab;\n    }\n}\n\n// Ano de Modelo - Getters and Setters\n\npublic int getAnoModelo(){\n    return anoModelo;\n}\n\npublic void setAnoModelo(int anomod){\n    anoModelo = anomod;\n}\n\npublic void imprimir(){\n    System.out.println(\"Fabricante : \" + getFabricante() );\n    System.out.println(\"Modelo : \" + getModelo() );\n    System.out.println(\"Cor : \" + getCor() );\n    System.out.println(\"Placa : \" + getPlaca() );\n    System.out.println(\"Valor : \" + getValor() );\n    System.out.println(\"Número de Portas : \" + getNumeroPortas() );\n    System.out.println(\"Ano de Fabricação : \" + getAnoFabricacao() );\n    System.out.println(\"Ano do Modelo : \" + getAnoModelo() );\n}\n\npublic void entradaDados(){\n    Scanner entrada = new Scanner(System.in);\n    // o objeto Scanner deve ficar local aos métodos\n    // o objetivo do Scanner para entrada de dados em um atributo do carro\n    // vamos utilizar o objeto para entrada de dados\n\n    System.out.println(\"Digite o Fabricante do carro :\");\n    setFabricante( entrada.nextLine() );\n\n    System.out.println(\"Digite o Modelo do carro :\");\n    setModelo( entrada.nextLine() );\n\n    System.out.println(\"Digite a Cor do carro :\");\n    setCor( entrada.nextLine() );\n\n    System.out.println(\"Digite a Placa do carro :\");\n    setPlaca( entrada.nextLine() );\n\n    System.out.println(\"Digite o Valor do carro :\");\n    setValor( Double.parseDouble( entrada.nextLine() ));\n\n    System.out.println(\"Digite o Número de Portas do carro :\");\n    setNumeroPortas( Integer.parseInt( entrada.nextLine() ));\n\n    System.out.println(\"Digite o Ano de fabricação do carro :\");\n    setAnoFabricacao( Integer.parseInt( entrada.nextLine() ));\n\n    System.out.println(\"Digite o Ano do Modelo do carro :\");\n    setAnoModelo( Integer.parseInt( entrada.nextLine() ));\n}\n}\n```\n\nAplicação antiga `AppCarro`\n\n```java\npublic class AppCarro {\n  public static void main(String[] args) {\n    Carro car1 = new Carro();\n    car1.entradadeDados();\n    car1.imprimir();\n\n    Carro car2 = new Carro();\n    car2.entradadeDados();\n    car2.imprimir();\n\n    Carro car3 = new Carro();\n    car3.entradadeDados();\n    car3.imprimir();\n  } \n}\n```\n\nA execução da aplicação não foi afetada pelas mudanças na classe porque foi criado o construtor vazio \u003ccode\u003epublic Carro ( ) { }\u003c/code\u003e que garantiu a compatibilidade:\n\nAplicação usando diferentes construtores para criar os objetos: `AppCarro`\n\n```java\npublic class AppCarroNovo{\n  public static void main(String[] args){\n    Carro car1 = new Carro();\n    car1.entradaDados();\n    car1.imprimir();\n\n    Carro car2 = new Carro(\"AAA1A00\", 25000);\n    car2.imprimir();\n\n    Carro car3 = new Carro(\"Logan\", \"Azul\", \"ABC1E00\", 32000);\n    car3.imprimir();\n\n    Carro car4 = new Carro(\"Audi\", \"A5\", \"Prata\", \"AUD0I00\", 123000);\n    car4.imprimir();\n\n    Carro car5 = new Carro(\"Fiat\", \"Argo\", \"Verde\", \"ABB1I00\", 42000, 5, 2018, 2019);\n    car5.imprimir();\n  }\n}\n```\n\n\u003e [!Note]\n\u003e\n\u003e 1. O primeiro método construtor criado foi o vazio, para garantir a compatibilidade com a aplicação antiga;\n\u003e 2. Foram incluídos mais quatro métodos construtores seguindo o conceito da sobrecarga de métodos;\n\u003e 3. Na nova aplicação, foram criados cinco diferentes objetos, cada um usando um construtor diferente;\n\u003e 4. Ambas as aplicações funcionaram apesar da alteração;\n\n## [Java] Polimorfismo de sobrecarga e a evolução das classes\n\u003cimg src=\"https://img.shields.io/badge/Java-class_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-Use_Case_diagram-chocolate?style=flat\u0026logo=UML\u0026logoColor=white\"\u003e \u003cimg src=\"https://img.shields.io/badge/Java-class_diagram","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fisaacalves7%2Fjava","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fisaacalves7%2Fjava","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fisaacalves7%2Fjava/lists"}