diff --git a/.github/AI_INSTRUCTIONS.md b/.github/AI_INSTRUCTIONS.md new file mode 100644 index 0000000..0818de7 --- /dev/null +++ b/.github/AI_INSTRUCTIONS.md @@ -0,0 +1,417 @@ +# Instruções para Assistentes de IA + +Este documento contém diretrizes para assistentes de IA que auxiliam na criação de conteúdo para o repositório Java Labs. + +## 🎯 Objetivo do Repositório + +Criar uma base de conhecimento completa e acessível sobre Java para iniciantes em português (pt-BR). + +## 📋 Diretrizes Gerais + +### Público-Alvo + +- **Iniciantes** em programação +- Pessoas com pouco ou nenhum conhecimento de Java +- Estudantes que buscam material em português +- Autodidatas procurando conteúdo estruturado + +### Tom e Linguagem + +- ✅ Use **linguagem clara e acessível** +- ✅ Seja **didático e paciente** +- ✅ Explique **termos técnicos** quando usá-los +- ✅ Use **analogias do cotidiano** +- ✅ Forneça **exemplos práticos e relevantes** +- ❌ Evite jargões sem explicação +- ❌ Não assuma conhecimento prévio avançado +- ❌ Evite linguagem muito técnica ou acadêmica + +## 📚 Estrutura de Conteúdo + +### Arquivos de Conteúdo + +Localização: `docs/XX-nome-do-topico.md` + +Formato de numeração: + +- `01-introducao-java.md` +- `02-variaveis-tipos-dados.md` +- `03-estruturas-controle.md` +- etc. + +### Template Obrigatório + +**SEMPRE** use o template em `.github/TEMPLATE.md` como base. + +### Seções Essenciais + +1. **Cabeçalho com metadados:** + - Última atualização + - Nível (Iniciante/Intermediário/Avançado) + - Tempo estimado de leitura + +2. **Introdução:** + - O que será aprendido + - Por que é importante + - Contexto relevante + +3. **Explicação do Conceito:** + - Definição clara + - Como funciona + - Conceitos relacionados + +4. **Exemplos Práticos:** + - Código funcional e testado + - Comentários explicativos + - Saída esperada + +5. **Exercícios:** + - Práticos e aplicáveis + - Com dicas de resolução + - Progressão de dificuldade + +6. **Navegação:** + - Link para tópico anterior + - Link para próximo tópico + - Link para índice + +## 💻 Código + +### Padrões de Código Java + +```java +// ✅ BOM: Código claro com comentários +public class CalculadoraSimples { + // Método para somar dois números + public int somar(int a, int b) { + return a + b; + } +} +``` + +```java +// ❌ EVITE: Código sem explicação +public class Calc { + public int s(int x, int y) { return x + y; } +} +``` + +### Regras para Código + +1. **Sempre inclua comentários explicativos** +2. **Use nomes descritivos** para variáveis e métodos +3. **Siga convenções Java:** + - Classes: PascalCase + - Métodos/variáveis: camelCase + - Constantes: UPPER_SNAKE_CASE +4. **Teste o código** antes de incluir +5. **Inclua a saída esperada** quando relevante +6. **Mantenha exemplos simples** e focados + +## 📖 Progressão de Conteúdo + +### Ordem Lógica + +Organize tópicos em sequência didática: + +1. **Fundamentos:** + - Introdução ao Java + - Instalação e configuração + - Primeiro programa + - Variáveis e tipos de dados + +2. **Básico:** + - Operadores + - Estruturas de controle (if, switch) + - Loops (for, while) + - Arrays + +3. **Intermediário:** + - Orientação a Objetos + - Classes e Objetos + - Herança + - Polimorfismo + - Encapsulamento + +4. **Avançado:** + - Coleções + - Exceções + - I/O + - Threads + - Generics + +### Dependências + +- Sempre mencione **pré-requisitos** no início +- Link para tópicos necessários +- Recapitule conceitos importantes + +## 🎨 Formatação Markdown + +### Títulos + +```markdown +# Título Principal (H1) - Apenas um por arquivo + +## Seção Principal (H2) + +### Subseção (H3) + +#### Detalhes (H4) +``` + +### Código + +````markdown +```java +// Código Java +public class Exemplo { + public static void main(String[] args) { + System.out.println("Olá, Mundo!"); + } +} +``` +```` + +### Destaques + +```markdown +**Negrito** para ênfase +_Itálico_ para termos técnicos +`código inline` para comandos/código +``` + +### Listas + +```markdown +- Item não ordenado +- Outro item + +1. Item ordenado +2. Segundo item +``` + +### Blocos de Citação + +```markdown +> **Importante:** Informação crucial que o leitor deve saber +``` + +### Details/Summary (FAQ) + +```markdown +
+Pergunta frequente? + +Resposta detalhada aqui. + +
+``` + +## 🔗 Links e Navegação + +### Links Internos + +```markdown +[📖 Tópico Relacionado](../notes/02-variaveis.md) +[💻 Exemplo de Código](../examples/01-HelloWorld/) +``` + +### Links Externos + +```markdown +[Documentação Oficial do Java](https://docs.oracle.com/javase/) +``` + +### Navegação de Rodapé + +Sempre inclua no final: + +```markdown +**[⬅️ Voltar ao Índice](../README.md)** | **[➡️ Próximo Tópico](02-topico.md)** +``` + +## 📊 Organização de Arquivos + +``` +java-labs/ +├── notes/ # Conteúdos numerados +│ ├── README.md # Índice de conteúdos +│ ├── 01-introducao.md +│ ├── 02-variaveis.md +│ └── ... +├── examples/ # Exemplos de código +│ ├── README.md # Índice de códigos +│ ├── 01-HelloWorld/ +│ ├── 02-Variaveis/ +│ └── ... +├── exercicios/ # Exercícios práticos +│ └── README.md +├── projetos/ # Mini projetos +│ └── README.md +├── recursos/ # Livros, cursos, etc. +│ └── README.md +└── .github/ + ├── TEMPLATE.md + ├── CONTRIBUTING.md + └── AI_INSTRUCTIONS.md +``` + +## ✅ Checklist para Novos Conteúdos + +Antes de criar/sugerir novo conteúdo, verifique: + +- [ ] Usei o template oficial +- [ ] Numeração está correta e sequencial +- [ ] Conteúdo está em pt-BR +- [ ] Código foi testado e funciona +- [ ] Incluí exemplos práticos +- [ ] Adicionei exercícios quando aplicável +- [ ] Links estão funcionando +- [ ] Ortografia e gramática revisadas +- [ ] Metadados preenchidos (nível, tempo) +- [ ] Navegação (anterior/próximo) configurada +- [ ] README/índice atualizado + +## 🎯 Princípios de Design Pedagógico + +### 1. Progressão Gradual + +- Do simples ao complexo +- Um conceito por vez +- Revisão de conceitos anteriores + +### 2. Aprendizado Ativo + +- Exercícios práticos +- Desafios aplicáveis +- Projetos incrementais + +### 3. Contexto Relevante + +- Exemplos do mundo real +- Problemas práticos +- Aplicações concretas + +### 4. Feedback Imediato + +- Saídas de código mostradas +- Dicas para exercícios +- Avisos sobre erros comuns + +### 5. Múltiplas Representações + +- Texto explicativo +- Código de exemplo +- Analogias +- Diagramas quando necessário + +## 🚫 O Que Evitar + +### Conteúdo + +- ❌ Assumir conhecimento prévio não mencionado +- ❌ Usar jargões sem explicação +- ❌ Exemplos muito complexos para o nível +- ❌ Pular etapas importantes +- ❌ Código sem comentários + +### Estilo + +- ❌ Parágrafos muito longos +- ❌ Linguagem muito formal/acadêmica +- ❌ Excesso de informação de uma vez +- ❌ Falta de exemplos práticos +- ❌ Links quebrados + +### Organização + +- ❌ Numeração inconsistente +- ❌ Estrutura diferente do template +- ❌ Falta de navegação +- ❌ README não atualizado +- ❌ Arquivos mal organizados + +## 💡 Dicas para Criar Conteúdo de Qualidade + +1. **Comece com o "porquê":** Explique por que o tópico é importante +2. **Use analogias:** Relacione conceitos técnicos com situações do dia a dia +3. **Mostre, não apenas diga:** Exemplos concretos são essenciais +4. **Antecipe dúvidas:** Inclua seção de perguntas frequentes +5. **Teste tudo:** Código deve funcionar e ser executável +6. **Revise sempre:** Ortografia, gramática e clareza são fundamentais +7. **Pense no iniciante:** Se você não entenderia há 6 meses, simplifique +8. **Incremental:** Construa conhecimento passo a passo + +## 📝 Exemplos de Bom Conteúdo + +### Título Descritivo + +✅ "02 - Variáveis e Tipos de Dados em Java" +❌ "Vars" + +### Explicação Clara + +✅ "Uma variável é como uma caixa que armazena informações. Cada caixa tem um nome (identificador) e pode guardar um tipo específico de dado." +❌ "Variável é um identificador que referencia um espaço de memória." + +### Exemplo Prático + +✅ + +```java +// Declarando uma variável para armazenar a idade de uma pessoa +int idade = 25; +System.out.println("A idade é: " + idade); // Saída: A idade é: 25 +``` + +❌ + +```java +int x = 25; +``` + +## 🔄 Processo de Criação + +1. **Planejamento:** + - Defina o escopo do tópico + - Liste conceitos a cobrir + - Identifique pré-requisitos + +2. **Estruturação:** + - Use o template + - Organize seções logicamente + - Planeje exemplos e exercícios + +3. **Desenvolvimento:** + - Escreva com clareza + - Crie/teste código + - Adicione recursos + +4. **Revisão:** + - Verifique clareza + - Teste todos os links e códigos + - Revise ortografia + +5. **Integração:** + - Atualize README/índice + - Configure navegação + - Verifique numeração + +## 🎓 Recursos de Referência + +Ao criar conteúdo, consulte: + +- [Documentação Oficial Java](https://docs.oracle.com/javase/) +- [Java Tutorial da Oracle](https://docs.oracle.com/javase/tutorial/) +- Conteúdos já existentes no repositório para manter consistência + +## 📞 Suporte + +Em caso de dúvidas sobre estas instruções: + +1. Consulte exemplos existentes em `docs/` +2. Revise o template em `.github/TEMPLATE.md` +3. Leia o guia de contribuição em `.github/CONTRIBUTING.md` + +**Lembre-se:** O objetivo é tornar o aprendizado de Java **acessível, prático e agradável** para iniciantes! diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 0000000..9669e53 --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,69 @@ +# Guia de Contribuição + +Obrigado por querer contribuir com o Java Labs! + +## O que pode ser contribuido + +- Melhorias e correções nos conteúdos (`/notes`) +- Novos exemplos de código em `/examples` +- Exercícios adicionais em `/exercicios` +- Projetos práticos em `/projetos` +- Recursos recomendados em `/recursos` + +## Processo + +1. Crie uma branch a partir de `main` seguindo o padrão: + ``` + feature/descricao-curta + fix/descricao-curta + docs/descricao-curta + ``` + +2. Faça commits atômicos com mensagens no padrão de Conventional Commits: + ``` + feat: adicionar exercícios sobre loops + fix: corrigir exemplo de recursão + docs: melhorar conteúdo sobre herança + ``` + + Tipos válidos: `feat`, `fix`, `docs`, `style`, `refactor`, `chore` + +3. Abra um Pull Request usando o template disponível e aguarde revisão. + +4. Após aprovação, o merge será feito por um mantenedor. + +## Padrões de conteúdo + +### Documentação (Markdown) + +- Escreva em português (pt-BR) +- Use títulos hierárquicos (`##`, `###`) +- Prefira exemplos curtos e diretos +- Inclua o "por quê", não apenas o "como" +- Nomeie os arquivos com prefixo numérico sequencial: `03-nome-do-topico.md` +- Atualize o índice em `notes/README.md` ao adicionar um novo tópico + +### Exemplos de código (`/examples`) + +- Um conceito por pasta, nomeada com prefixo sequencial: `02-NomeDoExemplo/` +- Inclua um comentário no topo do arquivo explicando o que o exemplo demonstra +- Adicione um `README.md` na pasta com instruções de execução +- Teste o código antes de submeter: `javac Arquivo.java && java Arquivo` + +### Exercícios (`/exercicios`) + +- Descreva claramente o objetivo +- Indique o nível de dificuldade (iniciante / intermediário / avançado) +- Inclua exemplos de saída esperada +- Use critérios de sucesso em formato de checklist + +### Projetos (`/projetos`) + +- Descreva o objetivo e o contexto +- Liste os requisitos em formato de checklist +- Inclua ao menos um exemplo de uso ou saída esperada +- Adicione dicas para quem está começando + +## Dúvidas? + +Abra uma issue com a tag `question`. diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..7a664ba --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,27 @@ +## O que este PR faz? + + + +## Tipo de mudança + +- [ ] Novo conteúdo (`/docs`) +- [ ] Novo exemplo de código (`/codigos`) +- [ ] Novo exercício (`/exercicios`) +- [ ] Novo projeto (`/projetos`) +- [ ] Recurso recomendado (`/recursos`) +- [ ] Correção de conteúdo existente +- [ ] Outro: + +## Checklist + +- [ ] O conteúdo está em português +- [ ] Os arquivos estão no diretório correto +- [ ] Exemplos de código compilam e executam sem erros +- [ ] Exercícios e projetos têm objetivo e critérios de sucesso descritos +- [ ] O índice (`notes/README.md`) foi atualizado, se necessário +- [ ] Minha branch está atualizada com `main` +- [ ] Não há conflitos de merge + +## Contexto adicional + + diff --git a/.github/TEMPLATE.md b/.github/TEMPLATE.md new file mode 100644 index 0000000..ac44331 --- /dev/null +++ b/.github/TEMPLATE.md @@ -0,0 +1,144 @@ +# [Número] - [Título do Tópico] + +> **Última atualização:** [Data] +> **Nível:** [Iniciante/Intermediário/Avançado] +> **Tempo de leitura:** [X minutos] + +## Introdução + +[Breve introdução ao tópico - 2-3 parágrafos explicando o que será abordado e por que é importante] + +## O que é [Tópico]? + +[Definição clara e objetiva do conceito principal] + +### Conceitos Básicos + +[Explicação dos conceitos fundamentais usando linguagem simples] + +#### Analogia + +[Usar analogias do dia a dia para facilitar o entendimento. Exemplo: "Imagine que..."] + +## Como Funciona + +[Explicação detalhada de como o conceito funciona na prática] + +### Exemplo Prático + +[Incluir exemplos concretos e aplicáveis] + +```java +// Código de exemplo em Java +public class Exemplo { + public static void main(String[] args) { + // Seu código aqui + } +} +``` + +## Principais Características + +- **Característica 1:** [Descrição] +- **Característica 2:** [Descrição] +- **Característica 3:** [Descrição] + +## Aplicações Práticas + +[Lista de aplicações práticas do conceito] + +1. **Aplicação 1:** [Descrição] +2. **Aplicação 2:** [Descrição] +3. **Aplicação 3:** [Descrição] + +## Exemplos de Código + +### Exemplo 1: [Nome do Exemplo] + +```java +// Código do exemplo +``` + +**Explicação:** +[Explicação linha por linha ou conceitual do código] + +## Conceitos Relacionados + +[Links para outros tópicos relacionados no repositório] + +- [📖 Tópico Anterior](../notes/XX-topico-anterior.md) +- [📖 Tópico Relacionado](../notes/XX-topico-relacionado.md) +- [📖 Próximo Tópico](../notes/XX-proximo-topico.md) + +## Recursos Adicionais + +### Para Aprender Mais + +- 📚 **Livros:** + - [Nome do Livro](link) - [Breve descrição] +- 🎓 **Cursos:** + - [Nome do Curso](link) - [Plataforma] - [Nível] +- 📹 **Vídeos:** + - [Título do Vídeo](link) - [Canal/Criador] +- 📰 **Artigos:** + - [Título do Artigo](link) - [Autor/Fonte] + +### Ferramentas Práticas + +- [Nome da Ferramenta](link) - [Descrição breve] + +## Exercícios Práticos + +### Exercício 1: [Nome do Exercício] + +**Objetivo:** [Descrição do objetivo] + +**Instruções:** + +1. [Passo 1] +2. [Passo 2] +3. [Passo 3] + +**Dica:** [Dica para resolução] + +### Exercício 2: [Nome do Exercício] + +**Objetivo:** [Descrição do objetivo] + +**Instruções:** + +1. [Passo 1] +2. [Passo 2] + +## Perguntas Frequentes + +
+Pergunta 1? + +Resposta detalhada para a pergunta 1. + +
+ +
+Pergunta 2? + +Resposta detalhada para a pergunta 2. + +
+ +## Resumo + +[Resumo dos pontos principais abordados neste tópico em bullet points] + +- Ponto 1 +- Ponto 2 +- Ponto 3 + +## Próximos Passos + +[Sugestões do que estudar em seguida] + +1. [Próximo tópico recomendado](link) +2. [Prática recomendada](link) + +**[⬅️ Voltar ao Índice](../README.md)** | **[➡️ Próximo Tópico](link)** diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d7d5fda --- /dev/null +++ b/.gitignore @@ -0,0 +1,98 @@ +# Compiled class files +*.class + +# Log files +*.log + +# BlueJ files +*.ctxt + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files +*.jar +*.war +*.nar +*.ear +*.zip +*.tar.gz +*.rar + +# Virtual machine crash logs +hs_err_pid* +replay_pid* + +# Eclipse +.classpath +.project +.settings/ +bin/ + +# IntelliJ IDEA +.idea/ +*.iml +*.iws +*.ipr +out/ + +# NetBeans +nbproject/ +build/ +nbbuild/ +dist/ +nbdist/ +.nb-gradle/ + +# VS Code +.vscode/ +*.code-workspace + +# Maven +target/ +pom.xml.tag +pom.xml.releaseBackup +pom.xml.versionsBackup +pom.xml.next +release.properties +dependency-reduced-pom.xml +buildNumber.properties +.mvn/timing.properties +.mvn/wrapper/maven-wrapper.jar + +# Gradle +.gradle/ +build/ +!gradle-wrapper.jar + +# macOS +.DS_Store +.AppleDouble +.LSOverride + +# Windows +Thumbs.db +ehthumbs.db +Desktop.ini +$RECYCLE.BIN/ + +# Linux +*~ +.directory + +# Temporary files +*.tmp +*.bak +*.swp +*~.nib +local.properties + +# Node (for any web tools) +node_modules/ +npm-debug.log* + +# Jekyll +_site/ +.sass-cache/ +.jekyll-cache/ +.jekyll-metadata diff --git a/README.md b/README.md index e628055..25dd5e5 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,203 @@ -# java4beginners -Base de conhecimento sobre Java para iniciantes. +# ☕ Java Labs + +> Base de conhecimento completa sobre Java para iniciantes em português + +Bem-vindo ao **Java Labs**! Este é um repositório dedicado a ensinar Java de forma clara, prática e estruturada para quem está começando na programação. + +[![GitHub Pages](https://img.shields.io/badge/GitHub-Pages-blue)](https://caramelotech.github.io/java-labs/) +[![License](https://img.shields.io/github/license/caramelotech/java-labs)](LICENSE) + +## 📚 Sobre o Projeto + +O **Java Labs** é uma iniciativa educacional que visa fornecer: + +- ✅ Conteúdo didático em português (pt-BR) +- ✅ Explicações claras e acessíveis +- ✅ Exemplos práticos e funcionais +- ✅ Exercícios para fixação +- ✅ Trilha de aprendizado estruturada +- ✅ Recursos adicionais curados + +## 🗂️ Estrutura do Repositório + +``` +java-labs/ +├── 📖 notes/ # Conteúdos teóricos numerados +├── 💻 examples/ # Exemplos de código executáveis +├── 🧪 exercicios/ # Exercícios práticos +├── 🚀 projetos/ # Mini projetos +├── 📚 recursos/ # Livros, cursos e materiais extras +└── 🔧 .github/ # Templates e guias de contribuição +``` + +### Navegação Rápida + +| Seção | Descrição | Link | +| ----------------- | ----------------------------- | -------------------------------------------------- | +| 📖 **Conteúdos** | Tópicos teóricos organizados | [notes/](notes/README.md) | +| 💻 **Códigos** | Exemplos práticos em Java | [examples/](examples/README.md) | +| 🧪 **Exercícios** | Exercícios práticos | [exercicios/](exercicios/README.md) | +| 🚀 **Projetos** | Mini projetos | [projetos/](projetos/README.md) | +| 📚 **Recursos** | Livros, cursos, ferramentas | [recursos/](recursos/README.md) | +| 🤝 **Contribuir** | Como contribuir com o projeto | [.github/CONTRIBUTING.md](.github/CONTRIBUTING.md) | + +## 🚀 Começando + +### 1. Por Onde Começar? + +Se você é **totalmente iniciante**: + +1. 📖 Leia [Introdução ao Java](notes/01-introducao-java.md) +2. 🔧 Configure seu ambiente (em breve) +3. 💻 Execute o [Hello World](examples/01-HelloWorld/) +4. 📚 Continue seguindo a [trilha de conteúdos](notes/README.md) + +### 2. Instalação do Java + +Para executar os exemplos, você precisa ter o **JDK (Java Development Kit)** instalado. + +- **Download:** [Oracle JDK](https://www.oracle.com/java/technologies/downloads/) ou [OpenJDK](https://openjdk.org/) +- **Versão recomendada:** Java 17 LTS ou superior + +### 3. Testando a Instalação + +```bash +java --version +javac --version +``` + +## 📖 Índice de Conteúdos + +### 🌱 Fundamentos + +1. [Introdução à Linguagem Java](notes/01-introducao-java.md) ✅ +2. Instalação e Configuração (em breve) +3. Primeiro Programa - Hello World (em breve) +4. Variáveis e Tipos de Dados (em breve) +5. Operadores (em breve) + +### 🔧 Estruturas Básicas + +6. Estruturas de Decisão (if/else) (em breve) +7. Switch Case (em breve) +8. Laços de Repetição (for) (em breve) +9. Laços de Repetição (while/do-while) (em breve) +10. Arrays (em breve) + +### 🎨 Orientação a Objetos + +11. Classes e Objetos (em breve) +12. Encapsulamento (em breve) +13. Herança (em breve) +14. Polimorfismo (em breve) +15. Interfaces (em breve) + +**[Ver índice completo →](notes/README.md)** + +## 💻 Exemplos de Código + +Todos os exemplos estão em [`examples/`](examples/) organizados por tópico: + +- [Hello World](examples/01-HelloWorld/) ✅ +- Variáveis (em breve) +- Estruturas de Controle (em breve) +- POO (em breve) + +## 🎯 Objetivos de Aprendizado + +Ao completar este curso, você será capaz de: + +- ✅ Compreender os fundamentos da programação Java +- ✅ Escrever programas orientados a objetos +- ✅ Utilizar estruturas de dados básicas +- ✅ Tratar exceções e erros +- ✅ Criar aplicações Java simples +- ✅ Ter base sólida para frameworks avançados + +## 🤝 Como Contribuir + +Contribuições são muito bem-vindas! Veja como você pode ajudar: + +1. 🐛 Reportar erros ou typos +2. ✨ Sugerir melhorias de conteúdo +3. 📝 Adicionar novos tópicos +4. 💻 Contribuir com exemplos de código +5. 📚 Recomendar recursos úteis + +**Leia o [Guia de Contribuição](.github/CONTRIBUTING.md)** para mais detalhes. + +### Para Assistentes de IA + +Se você é uma IA auxiliando neste projeto, consulte [AI_INSTRUCTIONS.md](.github/AI_INSTRUCTIONS.md) para diretrizes específicas. + +## 📋 Templates Disponíveis + +- [Template de Conteúdo](.github/TEMPLATE.md) - Para criar novos tópicos +- [Template de PR](.github/PULL_REQUEST_TEMPLATE.md) - Para pull requests +- [Guia de Contribuição](.github/CONTRIBUTING.md) - Diretrizes gerais + +## 📚 Recursos Recomendados + +### Livros + +- "Use a Cabeça! Java" - Kathy Sierra & Bert Bates +- "Java: Como Programar" - Deitel & Deitel + +### Cursos Online + +- [Curso de Java - Curso em Vídeo](https://www.youtube.com/playlist?list=PLHz_AreHm4dkI2ZdjTwZA4mPMxWTfNSpR) (Gratuito, PT-BR) +- [Java Programming - Coursera](https://www.coursera.org/specializations/java-programming) + +**[Ver lista completa de recursos →](recursos/README.md)** + + + +## 🌐 GitHub Pages + +Este repositório está disponível online através do GitHub Pages: + +**🔗 [https://caramelotech.github.io/java-labs/](https://caramelotech.github.io/java-labs/)** + +## 📊 Status do Projeto + +Este projeto está em **desenvolvimento ativo**. Novos conteúdos são adicionados regularmente. + +### Progresso Atual + +- [x] Estrutura do repositório +- [x] Template de conteúdos +- [x] Guias de contribuição +- [x] Introdução ao Java +- [x] Exemplo Hello World +- [ ] Instalação e Configuração +- [ ] Variáveis e Tipos +- [ ] Estruturas de Controle +- [ ] POO Básica +- [ ] Tópicos Avançados + +## 📞 Contato e Suporte + +- 🐛 **Issues:** [GitHub Issues](https://github.com/caramelotech/java-labs/issues) +- 💬 **Discussões:** [GitHub Discussions](https://github.com/caramelotech/java-labs/discussions) +- 🌐 **Website:** [caramelotech.github.io/java-labs](https://caramelotech.github.io/java-labs/) + +## 📄 Licença + +Este projeto está sob a licença especificada no arquivo [LICENSE](LICENSE). + +## 🙏 Agradecimentos + +Agradecemos a todos que contribuem para tornar o aprendizado de Java mais acessível! + +## ⭐ Apoie o Projeto + +Se este repositório está ajudando você, considere: + +- ⭐ Dar uma estrela no repositório +- 🔄 Compartilhar com amigos +- 🤝 Contribuir com conteúdo +- 📢 Divulgar nas redes sociais + +**Feito com ❤️ por [Caramelo Tech](https://github.com/caramelotech)** + +**Bons estudos! 🚀** diff --git a/_config.yml b/_config.yml new file mode 100644 index 0000000..948ca83 --- /dev/null +++ b/_config.yml @@ -0,0 +1,56 @@ +# Configuração do GitHub Pages para Java Labs + +# Tema +theme: jekyll-theme-cayman +title: "Java Labs" +description: "Base de conhecimento sobre Java para iniciantes" + +# URL e baseurl +# url: "https://caramelotech.github.io" +# baseurl: "/java-labs" + +# SEO +lang: pt-BR +author: Caramelo Tech + +# Plugins +plugins: + - jekyll-relative-links + - jekyll-optional-front-matter + - jekyll-readme-index + - jekyll-titles-from-headings + +# Configurações de markdown +markdown: kramdown +kramdown: + input: GFM + hard_wrap: false + +# Links relativos +relative_links: + enabled: true + collections: false + +# Títulos automáticos dos headings +titles_from_headings: + enabled: true + strip_title: true + collections: false + +# Incluir/excluir arquivos +include: + - README.md + - docs + - codigos + - recursos + +exclude: + - .git + - .gitignore + - LICENSE + - node_modules + - vendor + +# Configurações adicionais +show_downloads: false +#google_analytics: diff --git a/examples/01-HelloWorld/HelloWorld.java b/examples/01-HelloWorld/HelloWorld.java new file mode 100644 index 0000000..8c9ac95 --- /dev/null +++ b/examples/01-HelloWorld/HelloWorld.java @@ -0,0 +1,30 @@ +/** + * HelloWorld.java + * + * Este é o programa mais simples em Java - o clássico "Olá, Mundo!" + * É tradição começar aprendendo qualquer linguagem com este exemplo. + * + * O que este programa faz: + * - Imprime a mensagem "Olá, Mundo!" no console + * + * Como executar: + * 1. Compile: javac HelloWorld.java + * 2. Execute: java HelloWorld + */ + +public class HelloWorld { + /** + * Método main - ponto de entrada do programa + * Todo programa Java precisa de um método main para ser executado + * + * @param args argumentos da linha de comando (não usados neste exemplo) + */ + public static void main(String[] args) { + // Imprime a mensagem no console + System.out.println("Olá, Mundo!"); + + // Você pode adicionar mais mensagens + System.out.println("Bem-vindo ao Java!"); + System.out.println("Este é meu primeiro programa."); + } +} diff --git a/examples/01-HelloWorld/README.md b/examples/01-HelloWorld/README.md new file mode 100644 index 0000000..e7a4010 --- /dev/null +++ b/examples/01-HelloWorld/README.md @@ -0,0 +1,145 @@ +# 01 - Hello World + +Este é o programa mais básico em Java - o famoso "Olá, Mundo!" + +## 📝 Sobre + +Todo programador começa sua jornada com um programa Hello World. É uma tradição na computação e serve para: + +- Verificar se o ambiente de desenvolvimento está configurado +- Entender a estrutura básica de um programa +- Fazer seu primeiro código funcionar! + +## 📂 Arquivos + +- `HelloWorld.java` - Código fonte do programa + +## 🚀 Como Executar + +### 1. Compile o programa + +```bash +javac HelloWorld.java +``` + +Isso vai gerar um arquivo `HelloWorld.class` (o bytecode). + +### 2. Execute o programa + +```bash +java HelloWorld +``` + +### 3. Saída Esperada + +``` +Olá, Mundo! +Bem-vindo ao Java! +Este é meu primeiro programa. +``` + +## 🔍 Entendendo o Código + +### Linha por Linha + +```java +public class HelloWorld { +``` + +- `public` - modificador de acesso (classe pode ser acessada de qualquer lugar) +- `class` - palavra-chave para definir uma classe +- `HelloWorld` - nome da classe (deve ser igual ao nome do arquivo) + +```java +public static void main(String[] args) { +``` + +- `public` - método pode ser chamado de qualquer lugar +- `static` - método pertence à classe, não a uma instância +- `void` - método não retorna nenhum valor +- `main` - nome do método (ponto de entrada do programa) +- `String[] args` - parâmetro que recebe argumentos da linha de comando + +```java +System.out.println("Olá, Mundo!"); +``` + +- `System` - classe do sistema Java +- `out` - objeto de saída padrão (console) +- `println` - método que imprime e pula linha +- `"Olá, Mundo!"` - string (texto) a ser impressa + +## 💡 Conceitos Importantes + +### 1. Nome do Arquivo = Nome da Classe + +O arquivo **deve** se chamar `HelloWorld.java` porque a classe se chama `HelloWorld`. + +### 2. Ponto e Vírgula + +Toda instrução em Java termina com `;` + +### 3. Chaves { } + +Delimitam blocos de código (classes, métodos, etc.) + +### 4. Case Sensitive + +Java diferencia maiúsculas de minúsculas: + +- `HelloWorld` ≠ `helloworld` +- `System` ≠ `system` + +## 🎯 Experimente + +Tente modificar o programa: + +1. **Mude a mensagem:** + + ```java + System.out.println("Seu nome aqui!"); + ``` + +2. **Adicione mais linhas:** + + ```java + System.out.println("Linha 1"); + System.out.println("Linha 2"); + System.out.println("Linha 3"); + ``` + +3. **Use `print` em vez de `println`:** + ```java + System.out.print("Não pula linha "); + System.out.print("fica na mesma linha"); + ``` + +## 🔗 Conceitos Relacionados + +- [📖 Introdução ao Java](../../notes/01-introducao-java.md) +- [📖 Estrutura de um Programa Java](../../notes/03-primeiro-programa.md) + +## ❓ Problemas Comuns + +### Erro: "javac não é reconhecido" + +**Solução:** JDK não está instalado ou não está no PATH. +Veja: [Instalação e Configuração](../../notes/02-instalacao-configuracao.md) + +### Erro: "Could not find or load main class HelloWorld" + +**Soluções:** + +1. Certifique-se que compilou: `javac HelloWorld.java` +2. Execute no diretório correto (onde está o .class) +3. Use `java HelloWorld` (sem .class no final) + +### Erro de compilação + +**Verifique:** + +- Nome do arquivo = nome da classe +- Sintaxe correta (chaves, ponto e vírgula) +- Case das palavras + +**[⬅️ Voltar ao Índice de Códigos](../README.md)** diff --git a/examples/README.md b/examples/README.md new file mode 100644 index 0000000..0619f9b --- /dev/null +++ b/examples/README.md @@ -0,0 +1,123 @@ +# 💻 Códigos de Exemplo + +Bem-vindo à seção de códigos! Aqui você encontrará exemplos práticos e funcionais de código Java organizados por tópico. + +## 📂 Estrutura + +Cada tópico possui sua própria pasta com exemplos executáveis: + +``` +examples/ +├── 01-HelloWorld/ +│ ├── HelloWorld.java +│ └── README.md +├── 02-Variaveis/ +│ ├── TiposPrimitivos.java +│ ├── DeclaracaoVariaveis.java +│ └── README.md +└── ... +``` + +## 🗂️ Índice de Códigos + +### 🌱 Fundamentos + +| Pasta | Descrição | Arquivos | +| ---------------- | ----------------------------- | -------------------------------------------------- | +| `01-HelloWorld/` | Primeiro programa em Java | HelloWorld.java | +| `02-Variaveis/` | Exemplos de variáveis e tipos | TiposPrimitivos.java, DeclaracaoVariaveis.java | +| `03-Operadores/` | Operadores em Java | OperadoresAritmeticos.java, OperadoresLogicos.java | + +### 🔧 Estruturas de Controle + +| Pasta | Descrição | Arquivos | +| ------------------ | ---------------------- | ------------------------------------------------ | +| `04-Condicionais/` | If/Else e Switch | IfElse.java, Switch.java | +| `05-Loops/` | For, While, Do-While | LoopFor.java, LoopWhile.java | +| `06-Arrays/` | Trabalhando com arrays | ArraysBasicos.java, ArraysMultidimensionais.java | + +### 🎨 Orientação a Objetos + +| Pasta | Descrição | Arquivos | +| -------------------- | ------------------------- | ---------------------------------------- | +| `07-ClassesObjetos/` | Classes e objetos básicos | Carro.java, Principal.java | +| `08-Encapsulamento/` | Getters e Setters | ContaBancaria.java | +| `09-Heranca/` | Herança em Java | Animal.java, Cachorro.java, Gato.java | +| `10-Polimorfismo/` | Polimorfismo | Forma.java, Circulo.java, Retangulo.java | + +## 🚀 Como Usar os Exemplos + +### 1. Navegue até a pasta do exemplo + +```bash +cd examples/01-HelloWorld +``` + +### 2. Compile o código + +```bash +javac HelloWorld.java +``` + +### 3. Execute o programa + +```bash +java HelloWorld +``` + +## 📝 Convenções de Código + +Todos os exemplos seguem as convenções Java: + +- **Classes:** PascalCase (Ex: `MinhaClasse`) +- **Métodos:** camelCase (Ex: `meuMetodo`) +- **Variáveis:** camelCase (Ex: `minhaVariavel`) +- **Constantes:** UPPER_SNAKE_CASE (Ex: `MINHA_CONSTANTE`) + +## 💡 Dicas + +1. **Leia o README de cada pasta:** Contém explicações específicas +2. **Execute os códigos:** Aprender fazendo é essencial +3. **Modifique e experimente:** Altere os exemplos para testar +4. **Compare com a teoria:** Relacione com os conteúdos em `/notes` + +## 🆘 Problemas ao Executar? + +### JDK não instalado? + +Veja o guia de instalação em [notes/02-instalacao-configuracao.md](../notes/02-instalacao-configuracao.md) + +### Erro de compilação? + +Verifique se: + +- O JDK está instalado corretamente +- Está no diretório correto +- O nome do arquivo corresponde ao nome da classe + +### Dúvidas? + +Abra uma [issue](https://github.com/caramelotech/java-labs/issues) no repositório + +## 🤝 Contribuindo + +Quer adicionar um novo exemplo? + +1. Siga a estrutura de pastas existente +2. Adicione comentários explicativos no código +3. Crie um README.md na pasta do exemplo +4. Teste o código antes de submeter +5. Veja o [Guia de Contribuição](../.github/CONTRIBUTING.md) + +## 📊 Status dos Exemplos + +- [x] 01 - HelloWorld +- [ ] 02 - Variáveis +- [ ] 03 - Operadores +- [ ] 04 - Condicionais +- [ ] 05 - Loops +- [ ] ... (em desenvolvimento) + +**[⬅️ Voltar ao README Principal](../README.md)** + +> **Nota:** Esta seção está em constante expansão. Novos exemplos são adicionados regularmente. diff --git a/exercicios/README.md b/exercicios/README.md new file mode 100644 index 0000000..ba202a3 --- /dev/null +++ b/exercicios/README.md @@ -0,0 +1,68 @@ +# Exercícios + +Pratique o que aprendeu nos conteúdos e exemplos de código. + +## Como usar + +1. Leia o enunciado do exercício +2. Tente resolver por conta própria antes de buscar ajuda +3. Consulte os `notes/` se precisar revisar algum conceito +4. Compare sua solução com a dos colegas + +## Exercício 01 - Hello World + +**Objetivo:** Escrever e executar o primeiro programa Java. + +**Instrução:** +Crie uma classe `OlaMundo` que imprima `"Olá, Caramelo Tech!"` na saída. + +**Critérios de sucesso:** + +- [ ] O arquivo se chama `OlaMundo.java` +- [ ] O programa compila sem erros (`javac OlaMundo.java`) +- [ ] A mensagem aparece corretamente ao executar (`java OlaMundo`) + +## Exercício 02 - Variáveis e Tipos + +**Objetivo:** Declarar e usar variáveis de diferentes tipos. + +**Instrução:** + +1. Declare uma variável `String` com seu nome +2. Declare uma variável `int` com sua idade +3. Declare uma variável `double` com sua altura em metros +4. Imprima uma frase combinando as três + +Saída esperada: + +``` +Meu nome é Ana, tenho 25 anos e medo 1.68m. +``` + +**Critérios de sucesso:** + +- [ ] As três variáveis são declaradas corretamente +- [ ] A mensagem é exibida conforme esperado + +## Exercício 03 - Estrutura de Repetição + +**Objetivo:** Usar loops para repetir ações. + +**Instrução:** +Escreva um programa que imprima os números de 1 a 10, um por linha, usando um loop `for`. + +Saída esperada: + +``` +1 +2 +3 +... +10 +``` + +**Critérios de sucesso:** + +- [ ] Todos os números de 1 a 10 são exibidos +- [ ] Cada número aparece em uma linha separada +- [ ] Um loop `for` é usado (não imprima cada número manualmente) diff --git a/notes/01-introducao-java.md b/notes/01-introducao-java.md new file mode 100644 index 0000000..bca24ce --- /dev/null +++ b/notes/01-introducao-java.md @@ -0,0 +1,339 @@ +# 01 - Introdução à Linguagem Java + +> **Última atualização:** 01/03/2026 +> **Nível:** Iniciante +> **Tempo de leitura:** 15 minutos + +## Introdução + +Java é uma das linguagens de programação mais populares e amplamente utilizadas no mundo. Criada com o objetivo de ser **portável, segura e robusta**, Java permite que você escreva um programa uma vez e execute em praticamente qualquer plataforma, desde computadores desktop até dispositivos móveis e servidores corporativos. + +Neste primeiro tópico, você vai entender o que é Java, suas principais características, como funciona o processo de desenvolvimento e os conceitos fundamentais que tornam esta linguagem tão poderosa e versátil. + +Se você está começando sua jornada em programação, Java é uma excelente escolha por sua sintaxe clara, vasta documentação e enorme comunidade de desenvolvedores. + +## O que é Java? + +Java é uma **linguagem de programação de alto nível, orientada a objetos**, criada na década de 1990 por uma equipe liderada por **James Gosling** na empresa Sun Microsystems (posteriormente adquirida pela Oracle). + +Inicialmente, Java foi desenvolvida para dispositivos eletrônicos embarcados, mas rapidamente ganhou popularidade com o crescimento da internet, tornando-se uma das linguagens mais utilizadas para: + +- Sistemas corporativos +- Aplicações web +- Desenvolvimento mobile (Android) +- Sistemas distribuídos +- Backend de aplicações + +### O Lema WORA + +Um dos lemas mais conhecidos da linguagem é: + +> **WORA — Write Once, Run Anywhere** +> +> (Escreva uma vez, execute em qualquer lugar) + +Isso significa que um programa Java pode ser executado em qualquer sistema operacional que possua uma **JVM (Java Virtual Machine)** instalada, sem necessidade de modificações no código. + +## Principais Características do Java + +### 1. Independente de Plataforma + +Java não é compilado diretamente para código de máquina específico de um sistema operacional. + +**Como funciona:** + +1. O código Java é compilado para **bytecode** +2. O bytecode é executado pela **JVM** + +Isso permite que o mesmo programa funcione em: + +- ✅ Windows +- ✅ Linux +- ✅ macOS +- ✅ Servidores +- ✅ Dispositivos embarcados + +#### Analogia + +Imagine que você escreve uma carta em um idioma universal (bytecode). Cada país (sistema operacional) tem um tradutor especializado (JVM) que consegue ler e executar sua carta. Você escreve apenas uma vez, mas todos conseguem entender! + +### 2. Orientado a Objetos + +Java foi projetado seguindo os conceitos da **Programação Orientada a Objetos (POO)**. + +Isso significa que programas são organizados em: + +- **Classes:** Modelos ou estruturas +- **Objetos:** Instâncias das classes +- **Métodos:** Ações que os objetos podem realizar +- **Atributos:** Características dos objetos + +**Benefícios da POO:** + +- 📦 Reutilização de código +- 🔧 Facilidade de manutenção +- 📈 Escalabilidade +- 🗂️ Organização lógica + +### 3. Garbage Collector (Coletor de Lixo) + +Java possui **gerenciamento automático de memória**. + +O **Garbage Collector (GC)** é responsável por: + +- Liberar memória de objetos que não estão mais sendo utilizados +- Evitar vazamentos de memória (memory leaks) +- Reduzir erros comuns como ponteiros inválidos + +**Vantagem:** O programador não precisa desalocar memória manualmente, diferente de linguagens como C ou C++. + +### 4. Multithreading + +Java possui **suporte nativo para execução concorrente**. + +Isso significa que um programa pode executar múltiplas tarefas ao mesmo tempo, por exemplo: + +- Processar dados enquanto baixa arquivos +- Executar várias requisições simultaneamente +- Criar aplicações responsivas + +### 5. Tratamento de Exceções + +Java possui um sistema robusto de tratamento de erros chamado **Exceptions**. + +**Permite:** + +- Detectar erros em tempo de execução +- Controlar falhas de forma segura +- Evitar que o sistema pare inesperadamente + +**Exemplos de situações tratadas:** + +- Arquivo não encontrado +- Divisão por zero +- Problemas de rede + +## Processo de Desenvolvimento em Java + +O fluxo de desenvolvimento Java segue etapas bem definidas: + +### 1️⃣ Criação do Código Fonte + +Todo código Java é escrito em arquivos de texto com extensão `.java` + +**Exemplo:** + +``` +MeuPrograma.java +``` + +### 2️⃣ Compilação + +O compilador Java (`javac`) transforma o código fonte em **bytecode**. + +**Comando:** + +```bash +javac MeuPrograma.java +``` + +**Isso gera:** + +``` +MeuPrograma.class +``` + +### 3️⃣ Execução + +O arquivo `.class` é executado pela JVM: + +```bash +java MeuPrograma +``` + +**Importante:** O arquivo `.class` **não contém código de máquina nativo**, mas sim **bytecode**, que é interpretado ou compilado dinamicamente pela JVM. + +## JVM — Java Virtual Machine + +A **JVM** é o coração do Java. + +**Ela é responsável por:** + +- ⚙️ Executar bytecode +- 💾 Gerenciar memória +- 🗑️ Executar Garbage Collector +- 🔄 Controlar threads +- 🌍 Garantir portabilidade + +**Importante:** Cada sistema operacional possui sua própria implementação de JVM, mas todas executam o mesmo bytecode Java. + +## JDK — Java Development Kit + +O **JDK** é o **kit completo para desenvolvimento Java**. + +**Ele contém:** + +- Compilador (`javac`) +- JVM +- Bibliotecas padrão +- Ferramentas de desenvolvimento (javadoc, debugger, etc.) + +**Se você quer programar em Java, você precisa do JDK.** + +## JRE — Java Runtime Environment + +O **JRE** é o **ambiente de execução**. + +**Contém:** + +- JVM +- Bibliotecas necessárias para rodar programas + +**Não contém ferramentas de desenvolvimento.** + +**Nota:** Nas versões modernas do Java, o JRE está embutido no JDK. + +## Plataformas Java + +### Java SE (Standard Edition) + +**Base da linguagem Java.** + +**Inclui:** + +- Sintaxe da linguagem +- Bibliotecas fundamentais +- APIs principais + +**Usado para:** + +- Aplicações desktop +- Sistemas backend +- Fundamentos do Java + +### Java EE (Enterprise Edition) — Atualmente Jakarta EE + +**Voltado para sistemas corporativos.** + +**Inclui:** + +- Servlets +- APIs Web +- Persistência +- Segurança +- Microsserviços + +**Muito usado em empresas e sistemas de grande porte.** + +### Java ME (Micro Edition) + +**Versão para dispositivos com recursos limitados:** + +- Dispositivos embarcados +- Sistemas antigos de celulares +- IoT (Internet of Things) + +**Hoje menos comum.** + +### JavaFX + +**Framework para criação de interfaces gráficas modernas em Java.** + +**Permite:** + +- Interfaces desktop +- Animações +- Componentes visuais avançados + +## Resumo Visual do Ecossistema + +``` +JDK (Java Development Kit) + ├── JRE (Java Runtime Environment) + │ ├── JVM (Java Virtual Machine) + │ └── Bibliotecas de Classe + └── Ferramentas de Desenvolvimento + ├── javac (compilador) + ├── javadoc (documentação) + └── debugger, etc. +``` + +## Outras Características Importantes + +### Multiplataforma + +Executa em diversos sistemas operacionais sem alterações. + +### Portável (WORA) + +Write Once, Run Anywhere - Escreva uma vez, rode em qualquer lugar. + +### Robusta + +Java foi projetada para reduzir erros comuns: + +- Verificação de tipos em tempo de compilação +- Gerenciamento automático de memória +- Tratamento de exceções +- Verificação de acesso + +### Segura + +Possui mecanismos de segurança como: + +- Bytecode verification +- ClassLoader +- Security Manager (em contextos específicos) +- Sem ponteiros diretos como em C/C++ + +### Interpretada + Compilada + +Java é considerada híbrida: + +- Compilada para bytecode +- Executada pela JVM (interpretação ou JIT compilation) + +## Resumo + +Neste tópico, você aprendeu: + +- ✅ Java é uma linguagem portável, robusta e orientada a objetos +- ✅ O lema WORA (Write Once, Run Anywhere) é possível graças à JVM +- ✅ Java é compilada para bytecode e executada pela JVM +- ✅ Os pilares da POO são: classes, objetos, encapsulamento, herança, polimorfismo e abstração +- ✅ JDK é para desenvolvimento, JRE é para execução +- ✅ Java possui gerenciamento automático de memória (Garbage Collector) +- ✅ Existem diferentes plataformas Java (SE, EE, ME, JavaFX) + +## Próximos Passos + +Agora que você entende o que é Java e suas características principais, está pronto para: + +1. **[Instalar o JDK e configurar seu ambiente de desenvolvimento](02-instalacao-configuracao.md)** +2. **Escrever seu primeiro programa "Olá, Mundo!"** +3. **Aprender sobre variáveis e tipos de dados** + +## Perguntas Frequentes + +
+Java e JavaScript são a mesma coisa? + +Não! Apesar do nome similar, são linguagens completamente diferentes. Java é uma linguagem de programação completa, enquanto JavaScript foi criada principalmente para navegadores web (embora hoje também rode em servidores). + +
+ +
+Java ainda é relevante em 2026? + +Sim! Java continua sendo uma das linguagens mais utilizadas no mundo, especialmente em sistemas corporativos, Android, sistemas bancários e aplicações de grande escala. + +
+ +
+É difícil aprender Java? + +Java tem uma curva de aprendizado moderada. Com os conceitos básicos de lógica de programação e POO, você consegue criar aplicações funcionais. Este repositório foi criado justamente para facilitar seu aprendizado! + +
+ +**[⬅️ Voltar ao Índice](../README.md)** | **[➡️ Próximo: Instalação e Configuração](02-instalacao-configuracao.md)** diff --git a/notes/02-sintaxe.md b/notes/02-sintaxe.md new file mode 100644 index 0000000..06c2d38 --- /dev/null +++ b/notes/02-sintaxe.md @@ -0,0 +1,495 @@ +# 02 - Sintaxe Java + +## Introdução + +A sintaxe Java é o conjunto de regras que define como um programa Java deve ser escrito. Compreender a sintaxe é fundamental para escrever código que o compilador Java possa entender e executar corretamente. + +Neste guia, você aprenderá os fundamentos da sintaxe Java de forma progressiva, começando pelos conceitos mais básicos até estruturas mais complexas. + +### Sintaxe vs Semântica + +**Sintaxe** refere-se às regras de escrita do código (como escrever comandos). **Semântica** refere-se ao significado (o que o código faz). + +```java +// Sintaxe correta, semântica errada +int numero = "texto"; // Erro: tentando atribuir texto a um inteiro + +// Sintaxe e semântica corretas +int numero = 42; +``` + +### Palavras Reservadas + +Java possui palavras reservadas que não podem ser usadas como nomes de variáveis ou classes: + +`public`, `private`, `class`, `int`, `if`, `else`, `while`, `for`, `return`, `final`, `static`, `void`, `true`, `false`, `null` + +## 1. Estrutura Básica de um Programa Java + +Todo programa Java começa com uma estrutura básica. Vamos entender cada parte: + +```java +public class MeuPrimeiroPrograma { + public static void main(String[] args) { + System.out.println("Olá, Mundo!"); + } +} +``` + +### Componentes da Estrutura: + +- **`public class MeuPrimeiroPrograma`**: Declaração da classe pública +- **`public static void main(String[] args)`**: Método principal (ponto de entrada do programa) +- **`System.out.println()`**: Comando para imprimir texto na tela +- **Chaves `{}`**: Delimitam blocos de código +- **Ponto e vírgula `;`**: Marca o fim de uma instrução + +> **Importante**: O nome do arquivo Java deve ser idêntico ao nome da classe pública, incluindo maiúsculas e minúsculas. Por exemplo, `MeuPrimeiroPrograma.java`. + +## 2. Comentários + +Comentários são textos ignorados pelo compilador, usados para documentar o código e facilitar o entendimento. + +### Tipos de Comentários: + +```java +// Comentário de linha única +// Use para explicações breves + +/* + * Comentário de múltiplas linhas + * Use para explicações mais longas + * ou para desabilitar temporariamente blocos de código + */ + +/** + * Comentário de documentação (JavaDoc) + * Usado para gerar documentação automática + * @author Seu Nome + * @version 1.0 + */ +``` + +### Boas Práticas com Comentários: + +- ✅ Explique o "porquê", não o "o quê" (o código deve ser autoexplicativo) +- ✅ Mantenha os comentários atualizados com o código +- ✅ Use JavaDoc para documentar classes e métodos públicos +- ❌ Evite comentários óbvios que apenas repetem o código + +## 3. Tipos de Dados Primitivos + +Java possui 8 tipos de dados primitivos, divididos em categorias: + +### Números Inteiros: + +| Tipo | Tamanho | Intervalo | Uso Comum | +| ------- | ------- | -------------------------------- | ----------------------------- | +| `byte` | 8 bits | -128 a 127 | Economizar memória | +| `short` | 16 bits | -32.768 a 32.767 | Valores inteiros pequenos | +| `int` | 32 bits | -2.147.483.648 a 2.147.483.647 | **Tipo padrão para inteiros** | +| `long` | 64 bits | -9.223.372.036.854.775.808 a ... | Valores muito grandes | + +### Números de Ponto Flutuante: + +| Tipo | Tamanho | Precisão | Uso Comum | +| -------- | ------- | ----------- | ----------------------------------- | +| `float` | 32 bits | 6-7 dígitos | Valores decimais com menos precisão | +| `double` | 64 bits | 15 dígitos | **Tipo padrão para decimais** | + +### Outros Tipos: + +| Tipo | Tamanho | Valores | Uso | +| --------- | ------- | ----------------- | ----------------------- | +| `boolean` | 1 bit | `true` ou `false` | Lógica e condições | +| `char` | 16 bits | 0 a 65.535 | Caractere Unicode único | + +### Exemplos Práticos: + +```java +// Números inteiros +int idade = 25; +long populacaoMundial = 7800000000L; // Note o 'L' no final + +// Números decimais +double preco = 19.99; +float temperatura = 36.5f; // Note o 'f' no final + +// Booleanos +boolean estaAtivo = true; +boolean temDesconto = false; + +// Caracteres +char inicial = 'A'; +char simbolo = '@'; +``` + +## 4. Variáveis + +Variáveis são contêineres para armazenar valores de dados. Em Java, cada variável deve ter um tipo específico. + +### Declaração e Inicialização: + +```java +// Declaração simples +int numero; + +// Declaração com inicialização +int quantidade = 10; + +// Múltiplas declarações do mesmo tipo +int x = 5, y = 10, z = 15; + +// Constantes (valores que não mudam) +final double PI = 3.14159; +final int DIAS_DA_SEMANA = 7; +``` + +### Convenções de Nomenclatura para Variáveis: + +#### ✅ **Regras Obrigatórias:** + +1. Deve começar com letra, `$` ou `_` (underscore) +2. Não pode começar com número +3. Não pode usar palavras reservadas do Java +4. É case-sensitive (`idade` ≠ `Idade`) + +#### ✅ **Boas Práticas (Convenção camelCase):** + +```java +// ✅ BOM - Use camelCase (primeira palavra minúscula, demais iniciam com maiúscula) +int idadeDoUsuario; +String nomeCompleto; +double salarioMensal; +boolean estaCadastrado; + +// ✅ BOM - Nomes descritivos e significativos +int quantidadeDeAlunos; +double precoComDesconto; + +// ✅ BOM - Constantes em MAIÚSCULAS com underscore +final int IDADE_MINIMA = 18; +final double TAXA_DE_JUROS = 0.05; + +// ❌ RUIM - Nomes muito curtos ou sem significado +int a, b, c; +String s; + +// ❌ RUIM - Não usar underscores em variáveis normais +int nome_do_usuario; // Evite, use camelCase + +// ❌ RUIM - Começar com letra maiúscula (reservado para classes) +int NomeDoUsuario; +``` + +### Escopo de Variáveis: + +```java +public class ExemploEscopo { + // Variável de instância (pertence à classe) + private int valorGlobal = 100; + + public void metodoExemplo() { + // Variável local (existe apenas dentro deste método) + int valorLocal = 50; + + if (valorLocal > 0) { + // Variável de bloco (existe apenas dentro deste bloco if) + int valorTemporario = 10; + System.out.println(valorTemporario); + } + // valorTemporario não existe aqui! + } +} +``` + +## 5. Strings + +String é um tipo de referência (não primitivo) usado para armazenar texto. + +```java +// Declaração de Strings +String nome = "Maria Silva"; +String mensagem = "Bem-vindo ao Java!"; + +// Concatenação +String primeiroNome = "João"; +String sobrenome = "Santos"; +String nomeCompleto = primeiroNome + " " + sobrenome; + +// Métodos úteis de String +int tamanho = nome.length(); // Retorna o tamanho +String maiuscula = nome.toUpperCase(); // Converte para maiúsculas +String minuscula = nome.toLowerCase(); // Converte para minúsculas +boolean contem = nome.contains("Maria"); // Verifica se contém um texto +``` + +### Boas Práticas com Strings: + +```java +// ✅ BOM - Use aspas duplas para Strings +String texto = "Olá, Mundo!"; + +// ✅ BOM - Use StringBuilder para concatenações em loops +StringBuilder sb = new StringBuilder(); +for (int i = 0; i < 1000; i++) { + sb.append(i); +} + +// ❌ RUIM - Concatenação em loops (ineficiente) +String resultado = ""; +for (int i = 0; i < 1000; i++) { + resultado += i; // Cria muitos objetos temporários +} +``` + +## 6. Classes e Objetos + +Classes são modelos (blueprints) para criar objetos. Objetos são instâncias de classes. + +### Estrutura de uma Classe: + +```java +/** + * Classe que representa um Estudante + * @author Seu Nome + */ +public class Estudante { + // Atributos (características) + private String nome; + private int idade; + private double nota; + + // Construtor (cria novos objetos) + public Estudante(String nome, int idade, double nota) { + this.nome = nome; + this.idade = idade; + this.nota = nota; + } + + // Métodos (comportamentos) + public void estudar() { + System.out.println(nome + " está estudando."); + } + + public boolean estaAprovado() { + return nota >= 7.0; + } + + // Getters e Setters + public String getNome() { + return nome; + } + + public void setNome(String nome) { + this.nome = nome; + } +} +``` + +### Criando e Usando Objetos: + +```java +public class TesteEstudante { + public static void main(String[] args) { + // Criando objetos + Estudante aluno1 = new Estudante("Carlos", 20, 8.5); + Estudante aluno2 = new Estudante("Ana", 19, 6.5); + + // Usando métodos + aluno1.estudar(); + + if (aluno1.estaAprovado()) { + System.out.println(aluno1.getNome() + " foi aprovado!"); + } + } +} +``` + +## 7. Convenções de Nomenclatura para Classes + +As convenções de nomenclatura tornam o código mais legível e profissional. + +### ✅ **Regras para Classes:** + +```java +// ✅ BOM - PascalCase (cada palavra começa com maiúscula) +public class ContaBancaria { } +public class UsuarioSistema { } +public class RelatorioVendas { } + +// ✅ BOM - Substantivos descritivos +public class Pessoa { } +public class Produto { } +public class Cliente { } + +// ✅ BOM - Nomes específicos e significativos +public class GerenciadorDeArquivos { } +public class ProcessadorDePagamentos { } + +// ❌ RUIM - Começar com minúscula +public class contaBancaria { } + +// ❌ RUIM - Usar underscores +public class Conta_Bancaria { } + +// ❌ RUIM - Nomes genéricos ou sem significado +public class Classe1 { } +public class Dados { } +public class Teste { } +``` + +### ✅ **Regras para Pacotes:** + +```java +// ✅ BOM - Tudo em minúsculas +package com.empresa.projeto.modulo; +package br.com.meusite.utils; + +// ❌ RUIM - Usar maiúsculas +package Com.Empresa.Projeto; +``` + +### ✅ **Regras para Métodos:** + +```java +// ✅ BOM - camelCase (começa com minúscula) +public void calcularTotal() { } +public void enviarEmail() { } +public boolean verificarDisponibilidade() { } + +// ✅ BOM - Verbos que descrevem a ação +public void salvar() { } +public void atualizar() { } +public String obterNome() { } +public boolean isAtivo() { } // Prefixo 'is' para métodos booleanos + +// ❌ RUIM - Começar com maiúscula +public void CalcularTotal() { } + +// ❌ RUIM - Nomes não descritivos +public void fazer() { } +public void processar() { } // Muito genérico +``` + +## 8. Modificadores de Acesso + +Controlam a visibilidade de classes, atributos e métodos. + +| Modificador | Classe | Pacote | Subclasse | Todos | +| ----------- | ------ | ------ | --------- | ----- | +| `public` | ✅ | ✅ | ✅ | ✅ | +| `protected` | ✅ | ✅ | ✅ | ❌ | +| `default` | ✅ | ✅ | ❌ | ❌ | +| `private` | ✅ | ❌ | ❌ | ❌ | + +### Boas Práticas: + +```java +public class Exemplo { + // ✅ BOM - Atributos privados (encapsulamento) + private String nome; + private int idade; + + // ✅ BOM - Métodos públicos para acesso controlado + public String getNome() { + return nome; + } + + public void setNome(String nome) { + // Validação antes de atribuir + if (nome != null && !nome.isEmpty()) { + this.nome = nome; + } + } + + // ✅ BOM - Métodos auxiliares privados + private void validarDados() { + // Lógica interna da classe + } +} +``` + +## 9. Operadores Básicos + +### Operadores Aritméticos: + +```java +int a = 10, b = 3; + +int soma = a + b; // 13 +int subtracao = a - b; // 7 +int multiplicacao = a * b; // 30 +int divisao = a / b; // 3 (divisão inteira) +int resto = a % b; // 1 (módulo/resto) + +// Incremento e Decremento +int contador = 0; +contador++; // contador = 1 +contador--; // contador = 0 +``` + +### Operadores de Comparação: + +```java +int x = 5, y = 10; + +boolean igual = (x == y); // false +boolean diferente = (x != y); // true +boolean maior = (x > y); // false +boolean menor = (x < y); // true +boolean maiorIgual = (x >= y); // false +boolean menorIgual = (x <= y); // true +``` + +### Operadores Lógicos: + +```java +boolean a = true, b = false; + +boolean e = a && b; // false (E lógico - AND) +boolean ou = a || b; // true (OU lógico - OR) +boolean nao = !a; // false (NÃO lógico - NOT) +``` + +## 10. Resumo das Boas Práticas + +### Nomenclatura: + +| Elemento | Convenção | Exemplo | +| --------- | ---------- | --------------------- | +| Classe | PascalCase | `ContaBancaria` | +| Método | camelCase | `calcularSaldo()` | +| Variável | camelCase | `saldoAtual` | +| Constante | MAIÚSCULAS | `TAXA_JUROS` | +| Pacote | minúsculas | `com.empresa.projeto` | + +### Princípios Gerais: + +1. **Legibilidade**: Escreva código que outros possam entender facilmente +2. **Nomenclatura Clara**: Use nomes descritivos e significativos +3. **Consistência**: Siga as mesmas convenções em todo o projeto +4. **Encapsulamento**: Mantenha atributos privados e forneça métodos públicos +5. **Comentários Úteis**: Documente o "porquê", não o "o quê" +6. **Uma Responsabilidade**: Cada classe/método deve ter uma única responsabilidade bem definida + +## Exercícios Práticos + +Para fixar o aprendizado, tente criar: + +1. Uma classe `Livro` com atributos título, autor e número de páginas +2. Uma classe `Calculadora` com métodos para operações básicas +3. Um programa que declare variáveis de diferentes tipos e imprima seus valores +4. Pratique a nomenclatura correta em todos os seus exercícios + +## Próximos Passos + +Após dominar a sintaxe básica, você estará pronto para: + +- Estruturas de controle (if, else, switch) +- Laços de repetição (for, while, do-while) +- Arrays e Collections +- Orientação a Objetos avançada +- Tratamento de exceções + +Continue praticando! A sintaxe se torna natural com a prática constante. 🚀 diff --git a/notes/03-operadores.md b/notes/03-operadores.md new file mode 100644 index 0000000..d742989 --- /dev/null +++ b/notes/03-operadores.md @@ -0,0 +1,363 @@ +# Operadores em Java e Boas Práticas de Código + +Neste capítulo você aprenderá: + +- Operadores aritméticos e de atribuição +- Operadores relacionais +- Operadores unários +- Operadores ternários e lógicos +- Comentários +- JavaDoc +- JavaBeans + +Esses conceitos são fundamentais para escrever código Java de forma correta e profissional. + +# Operadores de Atribuição e Aritméticos + +## Operador de Atribuição + +O operador de atribuição é usado para armazenar um valor em uma variável. + +```java +int idade = 25; +``` + +O símbolo `=` significa: + +> Receba o valor da direita e armazene na variável da esquerda. + +## Operadores Aritméticos + +São usados para realizar cálculos matemáticos. + +| Operador | Significado | Exemplo | +| -------- | ------------------------- | ------- | +| `+` | Soma | a + b | +| `-` | Subtração | a - b | +| `*` | Multiplicação | a \* b | +| `/` | Divisão | a / b | +| `%` | Resto da divisão (módulo) | a % b | + +### Exemplo + +```java +int a = 10; +int b = 3; + +int soma = a + b; // 13 +int sub = a - b; // 7 +int mult = a * b; // 30 +int div = a / b; // 3 +int resto = a % b; // 1 +``` + +## Operadores de Atribuição Combinados + +Java permite simplificar operações com atribuição. + +| Operador | Equivalente | +| -------- | ----------- | +| `+=` | a = a + b | +| `-=` | a = a - b | +| `*=` | a = a \* b | +| `/=` | a = a / b | +| `%=` | a = a % b | + +### Exemplo + +```java +int x = 10; + +x += 5; // x = 15 +x -= 3; // x = 12 +x *= 2; // x = 24 +``` + +# Operadores Relacionais + +São usados para comparar valores. + +O resultado sempre será um **boolean** (`true` ou `false`). + +| Operador | Significado | +| -------- | -------------- | +| `==` | Igual | +| `!=` | Diferente | +| `>` | Maior | +| `<` | Menor | +| `>=` | Maior ou igual | +| `<=` | Menor ou igual | + +### Exemplo + +```java +int idade = 18; + +System.out.println(idade >= 18); // true +System.out.println(idade < 18); // false +``` + +⚠️ Atenção importante: + +```java +== → comparação += → atribuição +``` + +Erro comum de iniciantes! + +# Operadores Unários + +Operam sobre apenas **um operando**. + +## Principais Operadores Unários + +| Operador | Função | +| -------- | -------------- | +| `+` | Valor positivo | +| `-` | Negativo | +| `++` | Incremento | +| `--` | Decremento | +| `!` | Negação lógica | + +## Incremento e Decremento + +### Pré-incremento + +Incrementa antes de usar. + +```java +int x = 5; +int y = ++x; // x = 6, y = 6 +``` + +### Pós-incremento + +Incrementa depois de usar. + +```java +int x = 5; +int y = x++; // x = 6, y = 5 +``` + +## Negação Lógica + +```java +boolean ativo = true; + +System.out.println(!ativo); // false +``` + +# Operadores Lógicos + +Usados para combinar expressões booleanas. + +| Operador | Nome | Significado | | | +| -------- | ---- | ----------- | --- | --------- | +| `&&` | AND | E lógico | | | +| ` | | ` | OR | OU lógico | +| `!` | NOT | Negação | | | + +## Exemplo + +```java +int idade = 20; +boolean temCarteira = true; + +if (idade >= 18 && temCarteira) { + System.out.println("Pode dirigir"); +} +``` + +# Operador Ternário + +O operador ternário é uma forma reduzida de escrever um `if-else`. + +## Sintaxe + +```java +condicao ? valorSeVerdadeiro : valorSeFalso; +``` + +## Exemplo + +```java +int idade = 18; + +String resultado = (idade >= 18) ? "Maior de idade" : "Menor de idade"; + +System.out.println(resultado); +``` + +Equivalente ao: + +```java +String resultado; + +if (idade >= 18) { + resultado = "Maior de idade"; +} else { + resultado = "Menor de idade"; +} +``` + +# Comentários em Java + +Comentários servem para: + +- Explicar código +- Documentar decisões +- Melhorar manutenção +- Ajudar outros desenvolvedores + +Java possui três tipos de comentários. + +## Comentário de Linha + +```java +// Este é um comentário de linha +int idade = 25; +``` + +## Comentário de Bloco + +```java +/* +Este é um comentário +de múltiplas linhas +*/ +int idade = 25; +``` + +## Comentário de Documentação (JavaDoc) + +```java +/** + * Este é um comentário JavaDoc + */ +``` + +Esse tipo gera documentação automática. + +# JavaDoc + +JavaDoc é uma ferramenta oficial do Java para gerar documentação a partir do código. + +Muito usado em projetos profissionais e bibliotecas. + +## Exemplo de JavaDoc em Método + +```java +/** + * Calcula a soma de dois números. + * + * @param a Primeiro número + * @param b Segundo número + * @return Resultado da soma + */ +public int somar(int a, int b) { + return a + b; +} +``` + +## Principais Tags JavaDoc + +| Tag | Função | +| ---------- | ------------ | +| `@author` | Autor | +| `@version` | Versão | +| `@param` | Parâmetro | +| `@return` | Retorno | +| `@throws` | Exceções | +| `@see` | Referência | +| `@since` | Desde versão | + +## Gerar Documentação + +Comando: + +```bash +javadoc NomeArquivo.java +``` + +# JavaBeans + +JavaBeans é um padrão de classe Java usado principalmente para: + +- Representar entidades +- Transferir dados +- Modelar objetos de domínio +- Frameworks (Spring, Hibernate, etc.) + +## Características de um JavaBean + +Um JavaBean deve: + +1. Possuir construtor vazio +2. Ter atributos privados (`private`) +3. Possuir métodos getters e setters públicos +4. Ser serializável (opcional, mas comum) + +## Exemplo de JavaBean + +```java +import java.io.Serializable; + +public class Pessoa implements Serializable { + + private String nome; + private int idade; + + public Pessoa() { + } + + public String getNome() { + return nome; + } + + public void setNome(String nome) { + this.nome = nome; + } + + public int getIdade() { + return idade; + } + + public void setIdade(int idade) { + this.idade = idade; + } +} +``` + +## Por que JavaBeans são importantes? + +Porque muitos frameworks Java dependem desse padrão: + +- Spring Boot +- Hibernate / JPA +- JSF +- Bibliotecas de serialização +- APIs REST + +# Boas Práticas Importantes + +✅ Use nomes claros para variáveis +✅ Evite comentários óbvios +✅ Prefira JavaDoc em APIs públicas +✅ Use operadores com clareza +✅ Evite ternário complexo + +# Resumo + +Neste capítulo você aprendeu: + +- Operadores aritméticos e de atribuição +- Operadores relacionais +- Operadores unários +- Operadores lógicos +- Operador ternário +- Comentários em Java +- JavaDoc +- JavaBeans + +Esses conceitos são fundamentais para escrever programas Java profissionais. diff --git a/notes/11-orientacao-a-objeto.md b/notes/11-orientacao-a-objeto.md new file mode 100644 index 0000000..176a825 --- /dev/null +++ b/notes/11-orientacao-a-objeto.md @@ -0,0 +1,71 @@ +# 11 - Programação Orientada a Objetos (POO) em Java + +Para desenvolver software de forma consistente em Java, é essencial compreender os pilares da POO. + +## Classe e Objeto + +- **Classe** - Modelo ou estrutura (planta de uma casa) +- **Objeto** - Instância da classe (casa construída) + +**Exemplo conceitual:** + +``` +Classe: Carro +Objeto: MeuCarro (um carro específico, como um "Fusca azul, 1970") +``` + +## Encapsulamento + +Consiste em **proteger os dados internos** de uma classe e permitir acesso controlado. + +**Normalmente feito com:** + +- Atributos privados (`private`) +- Métodos públicos (`get` e `set`) + +**Benefícios:** + +- Segurança +- Organização +- Controle de acesso + +## Abstração + +Abstração significa representar apenas as **características essenciais** de um objeto, escondendo detalhes desnecessários. + +**Exemplo:** + +Um usuário dirige um carro sem precisar saber como o motor funciona internamente. Você apenas usa o volante, acelerador e freio (interface pública). + +## Herança + +Permite que uma classe **herde características** de outra. + +**Exemplo:** + +``` +Animal (classe pai) + ↓ +Cachorro (classe filha - herda características de Animal) +``` + +**Benefícios:** + +- Reutilização de código +- Hierarquia lógica +- Redução de duplicação + +## Polimorfismo + +Significa "**muitas formas**". + +Permite que um mesmo método tenha **comportamentos diferentes** dependendo do contexto. + +**Exemplo:** + +``` +Animal.fazerSom() + +Cachorro → Latir ("Au au!") +Gato → Miar ("Miau!") +``` diff --git a/notes/README.md b/notes/README.md new file mode 100644 index 0000000..b6d412d --- /dev/null +++ b/notes/README.md @@ -0,0 +1,112 @@ +# 📚 Conteúdos - Java Labs + +Bem-vindo à seção de conteúdos do Java Labs! Aqui você encontrará todos os tópicos organizados de forma sequencial para facilitar seu aprendizado. + +## 🎯 Como Usar Este Índice + +Os tópicos estão numerados na ordem recomendada de estudo. Comece pelo **01** e avance progressivamente. Cada tópico possui links de navegação para o anterior e próximo, facilitando sua jornada. + +## 📖 Índice de Conteúdos + +### 🌱 Fundamentos + +| # | Tópico | Nível | Descrição | +| --- | ---------------------------------------------------- | --------- | -------------------------------------------------- | +| 01 | [Introdução à Linguagem Java](01-introducao-java.md) | Iniciante | Conheça Java, suas características e o ecossistema | +| 02 | Instalação e Configuração | Iniciante | Configure seu ambiente de desenvolvimento | +| 03 | Primeiro Programa - Hello World | Iniciante | Escreva e execute seu primeiro programa | +| 04 | Variáveis e Tipos de Dados | Iniciante | Aprenda sobre tipos primitivos e variáveis | +| 05 | Operadores | Iniciante | Operadores aritméticos, lógicos e relacionais | + +### 🔧 Estruturas Básicas + +| # | Tópico | Nível | Descrição | +| --- | ----------------------------------- | --------- | ---------------------------------- | +| 06 | Estruturas de Decisão (if/else) | Iniciante | Controle de fluxo com condicionais | +| 07 | Switch Case | Iniciante | Estrutura de seleção múltipla | +| 08 | Laços de Repetição (for) | Iniciante | Loops com for | +| 09 | Laços de Repetição (while/do-while) | Iniciante | Loops com while | +| 10 | Arrays | Iniciante | Trabalhando com arrays | + +### 🎨 Orientação a Objetos + +| # | Tópico | Nível | Descrição | +| --- | ----------------- | ------------- | ---------------------------------- | +| 11 | Classes e Objetos | Intermediário | Fundamentos da POO | +| 12 | Construtores | Intermediário | Inicialização de objetos | +| 13 | Métodos | Intermediário | Criação e uso de métodos | +| 14 | Encapsulamento | Intermediário | Proteção de dados | +| 15 | Herança | Intermediário | Reutilização de código via herança | +| 16 | Polimorfismo | Intermediário | Múltiplas formas de um método | +| 17 | Classes Abstratas | Intermediário | Abstração em Java | +| 18 | Interfaces | Intermediário | Contratos de implementação | + +### 🚀 Tópicos Avançados + +| # | Tópico | Nível | Descrição | +| --- | ---------------------- | -------- | ----------------------------- | +| 19 | Coleções (Collections) | Avançado | List, Set, Map | +| 20 | Exceções | Avançado | Tratamento de erros | +| 21 | Entrada e Saída (I/O) | Avançado | Leitura e escrita de arquivos | +| 22 | Generics | Avançado | Tipos genéricos | +| 23 | Threads | Avançado | Programação concorrente | + +## 🗺️ Trilha de Aprendizado Recomendada + +``` +Fundamentos (01-05) + ↓ +Estruturas Básicas (06-10) + ↓ +Orientação a Objetos (11-18) + ↓ +Tópicos Avançados (19-23) +``` + +## 📝 Legenda de Níveis + +- 🌱 **Iniciante:** Sem necessidade de conhecimento prévio +- 🔧 **Intermediário:** Requer conhecimento dos fundamentos +- 🚀 **Avançado:** Requer sólido entendimento de Java + +## 💡 Dicas de Estudo + +1. **Siga a ordem:** Os tópicos foram organizados pedagogicamente +2. **Pratique:** Cada tópico tem exercícios - faça todos! +3. **Consulte os códigos:** Veja exemplos práticos em `/codigos` +4. **Não pule conceitos:** Cada tópico é base para o próximo +5. **Tire dúvidas:** Use a seção de issues do repositório + +## 🔗 Recursos Relacionados + +- [💻 Códigos de Exemplo](../examples/README.md) +- [📚 Recursos Adicionais](../recursos/README.md) +- [🤝 Guia de Contribuição](../.github/CONTRIBUTING.md) + +## 📊 Progresso Sugerido + +Marque seu progresso: + +- [ ] Fundamentos (01-05) +- [ ] Estruturas Básicas (06-10) +- [ ] Orientação a Objetos (11-18) +- [ ] Tópicos Avançados (19-23) + +## ⏱️ Tempo Estimado Total + +- **Fundamentos:** ~2 horas +- **Estruturas Básicas:** ~3 horas +- **Orientação a Objetos:** ~5 horas +- **Tópicos Avançados:** ~4 horas + +**Total:** Aproximadamente 14 horas de estudo + tempo de prática + +## 🆘 Precisa de Ajuda? + +- 📖 Consulte o [Guia de Contribuição](../.github/CONTRIBUTING.md) +- 💬 Abra uma [Issue](https://github.com/caramelotech/java-labs/issues) +- 🤝 Contribua com novos conteúdos + +**[⬅️ Voltar ao README Principal](../README.md)** + +> **Nota:** Este índice é atualizado constantemente. Nem todos os tópicos listados podem estar disponíveis ainda. Contribuições são bem-vindas! diff --git a/notes/recursos.md b/notes/recursos.md new file mode 100644 index 0000000..7e571ee --- /dev/null +++ b/notes/recursos.md @@ -0,0 +1,176 @@ +# 📚 Recursos Adicionais + +Esta seção contém uma curadoria de **livros, cursos, vídeos, artigos e ferramentas** para complementar seu aprendizado de Java. + +## 📖 Livros Recomendados + +### Para Iniciantes + +| Livro | Autor(es) | Descrição | Link | +| ------------------------------------- | --------------------------- | ----------------------------------------------------- | ----------------------------------------------------------------------------------- | +| **Use a Cabeça! Java** | Kathy Sierra & Bert Bates | Abordagem visual e didática, perfeito para iniciantes | [Amazon](https://www.amazon.com.br/Use-Cabe%C3%A7a-Java-Kathy-Sierra/dp/8576081733) | +| **Java: Como Programar** | Paul Deitel & Harvey Deitel | Livro completo com muitos exemplos práticos | [Amazon](https://www.amazon.com.br/Java-Como-Programar-Paul-Deitel/dp/8543004799) | +| **Introdução à Programação com Java** | Y. Daniel Liang | Excelente para quem está começando | [Amazon](https://www.amazon.com.br/) | + +### Para Nível Intermediário + +| Livro | Autor(es) | Descrição | Link | +| ------------------ | ---------------- | ------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- | +| **Effective Java** | Joshua Bloch | Melhores práticas e padrões em Java | [Amazon](https://www.amazon.com.br/Effective-Java-Joshua-Bloch/dp/0134685997) | +| **Clean Code** | Robert C. Martin | Princípios de código limpo (não específico de Java, mas essencial) | [Amazon](https://www.amazon.com.br/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) | + +### Para Nível Avançado + +| Livro | Autor(es) | Descrição | Link | +| ----------------------------------------- | ---------------- | ----------------------------------------------------- | ------------------------------------ | +| **Java Concurrency in Practice** | Brian Goetz | Programação concorrente e threads | [Amazon](https://www.amazon.com.br/) | +| **Designing Data-Intensive Applications** | Martin Kleppmann | Arquitetura de sistemas (conceitos aplicáveis a Java) | [Amazon](https://www.amazon.com.br/) | + +## 🎓 Cursos Online + +### Gratuitos + +| Curso | Plataforma | Nível | Idioma | Link | +| -------------------------------------------- | ---------------------------------- | ------------- | ------ | ----------------------------------------------------------------------------------- | +| **Curso de Java** | Curso em Vídeo (Gustavo Guanabara) | Iniciante | PT-BR | [YouTube](https://www.youtube.com/playlist?list=PLHz_AreHm4dkI2ZdjTwZA4mPMxWTfNSpR) | +| **Java Programming** | Coursera (Duke University) | Iniciante | EN | [Coursera](https://www.coursera.org/specializations/java-programming) | +| **Java Tutorial for Beginners** | Programming with Mosh | Iniciante | EN | [YouTube](https://www.youtube.com/watch?v=eIrMbAQSU34) | +| **Programação Orientada a Objetos com Java** | USP (Coursera) | Intermediário | PT-BR | [Coursera](https://www.coursera.org/) | + +### Pagos + +| Curso | Plataforma | Nível | Preço Aprox. | Link | +| -------------------------------- | -------------------- | ---------------------- | ------------ | ------------------------------------------------------------------------------ | +| **Java Programming Masterclass** | Udemy (Tim Buchalka) | Todos | ~R$30-50 | [Udemy](https://www.udemy.com/course/java-the-complete-java-developer-course/) | +| **Formação Java** | Alura | Todos | Assinatura | [Alura](https://www.alura.com.br/formacao-java) | +| **Java Web Full-Stack** | DevSuperior | Intermediário/Avançado | Variável | [DevSuperior](https://devsuperior.com.br/) | + +## 📹 Canais no YouTube + +| Canal | Descrição | Nível | Idioma | +| ------------------------- | -------------------------------------- | ----------------------- | ------ | +| **Curso em Vídeo** | Gustavo Guanabara - Excelente didática | Iniciante | PT-BR | +| **DevDojo** | Conteúdo aprofundado de Java | Intermediário/Avançado | PT-BR | +| **Loiane Groner** | Tutoriais completos de Java | Todos | PT-BR | +| **Java Brains** | Conceitos avançados e frameworks | Intermediário/Avançado | EN | +| **Programming with Mosh** | Tutoriais claros e diretos | Iniciante/Intermediário | EN | + +## 📰 Blogs e Sites + +| Site | Descrição | Link | +| ----------------------------- | --------------------------------------- | ----------------------------------------------------------------------------- | +| **Baeldung** | Tutoriais e artigos sobre Java e Spring | [baeldung.com](https://www.baeldung.com/) | +| **DZone Java** | Artigos e notícias sobre Java | [dzone.com/java](https://dzone.com/java-jdk-development-tutorials-tools-news) | +| **Oracle Java Documentation** | Documentação oficial | [docs.oracle.com/javase](https://docs.oracle.com/javase/) | +| **Java Code Geeks** | Tutoriais e exemplos | [javacodegeeks.com](https://www.javacodegeeks.com/) | +| **Dev.to #java** | Comunidade com artigos diversos | [dev.to/t/java](https://dev.to/t/java) | + +## 🛠️ Ferramentas e IDEs + +### IDEs Recomendadas + +| Ferramenta | Descrição | Licença | Link | +| ----------------- | ------------------------------ | ------------------------------------ | ------------------------------------------------------- | +| **IntelliJ IDEA** | IDE poderosa e inteligente | Community (grátis) / Ultimate (paga) | [jetbrains.com/idea](https://www.jetbrains.com/idea/) | +| **Eclipse** | IDE tradicional e popular | Grátis | [eclipse.org](https://www.eclipse.org/) | +| **VS Code** | Editor leve com extensões Java | Grátis | [code.visualstudio.com](https://code.visualstudio.com/) | +| **NetBeans** | IDE completa da Apache | Grátis | [netbeans.apache.org](https://netbeans.apache.org/) | + +### Ferramentas de Build + +| Ferramenta | Descrição | Link | +| ---------- | --------------------------- | --------------------------------------------- | +| **Maven** | Gerenciador de dependências | [maven.apache.org](https://maven.apache.org/) | +| **Gradle** | Build tool moderno | [gradle.org](https://gradle.org/) | + +### Ferramentas Online + +| Ferramenta | Descrição | Link | +| ------------- | ---------------------------- | ------------------------------------------------------------------------------------ | +| **JDoodle** | Compilador Java online | [jdoodle.com/online-java-compiler](https://www.jdoodle.com/online-java-compiler/) | +| **Replit** | IDE online colaborativa | [replit.com](https://replit.com/) | +| **OnlineGDB** | Compilador e debugger online | [onlinegdb.com/online_java_compiler](https://www.onlinegdb.com/online_java_compiler) | + +## 📱 Aplicativos Mobile + +| App | Plataforma | Descrição | +| --------------- | ----------- | ----------------------------------------- | +| **SoloLearn** | Android/iOS | Aprenda programação no celular | +| **Grasshopper** | Android/iOS | Jogos para aprender lógica de programação | +| **Enki** | Android/iOS | Desafios diários de programação | + +## 🎮 Plataformas de Prática + +| Plataforma | Descrição | Link | +| -------------------- | ----------------------- | ----------------------------------------------------------- | +| **HackerRank** | Desafios de programação | [hackerrank.com](https://www.hackerrank.com/domains/java) | +| **LeetCode** | Problemas de algoritmos | [leetcode.com](https://leetcode.com/) | +| **Codewars** | Katas de programação | [codewars.com](https://www.codewars.com/) | +| **Exercism** | Exercícios com mentoria | [exercism.io/tracks/java](https://exercism.io/tracks/java) | +| **URI Online Judge** | Problemas de competição | [urionlinejudge.com.br](https://www.urionlinejudge.com.br/) | + +## 🌐 Comunidades + +| Comunidade | Descrição | Link | +| ---------------------- | -------------------------- | ------------------------------------------------------------------------------------------ | +| **Stack Overflow** | Perguntas e respostas | [stackoverflow.com/questions/tagged/java](https://stackoverflow.com/questions/tagged/java) | +| **Reddit r/learnjava** | Comunidade para iniciantes | [reddit.com/r/learnjava](https://www.reddit.com/r/learnjava/) | +| **Discord - Java** | Servidores de discussão | Vários disponíveis | +| **GitHub Discussions** | Discussões sobre Java | Diversos repositórios | + +## 📄 Documentação Oficial + +| Recurso | Descrição | Link | +| -------------------------- | ----------------------------- | ------------------------------------------------------------------------------- | +| **Java SE Documentation** | Documentação completa do Java | [docs.oracle.com/javase](https://docs.oracle.com/javase/) | +| **Java Tutorial** | Tutorial oficial da Oracle | [docs.oracle.com/javase/tutorial](https://docs.oracle.com/javase/tutorial/) | +| **Java API Specification** | Referência da API Java | [docs.oracle.com/javase/8/docs/api](https://docs.oracle.com/javase/8/docs/api/) | + +## 🎯 Trilhas de Aprendizado Complementares + +### Frontend com Java + +- **JavaFX:** Interfaces gráficas desktop +- **Swing:** Framework UI (legado mas ainda usado) + +### Backend com Java + +- **Spring Boot:** Framework web mais popular +- **Jakarta EE:** Plataforma enterprise +- **Quarkus:** Framework nativo para cloud + +### Mobile + +- **Android Development:** Desenvolvimento Android com Java/Kotlin + +## 💡 Dicas de Uso + +1. **Escolha recursos adequados ao seu nível** - Não pule etapas +2. **Combine teoria e prática** - Livros + plataformas de código +3. **Participe de comunidades** - Tire dúvidas e ajude outros +4. **Pratique regularmente** - Consistência é mais importante que intensidade +5. **Construa projetos** - Aplique o que aprendeu em projetos reais + +## 🤝 Contribuindo + +Conhece um recurso excelente que não está aqui? + +1. Verifique se é relevante para iniciantes/intermediários +2. Teste o recurso antes de recomendar +3. Adicione seguindo o formato existente +4. Envie um Pull Request + +Veja o [Guia de Contribuição](../.github/CONTRIBUTING.md) para mais detalhes. + +## ⭐ Recursos em Destaque + +### 🏆 Top 3 para Iniciantes + +1. **Curso de Java - Curso em Vídeo** (Gratuito, PT-BR, Excelente didática) +2. **Use a Cabeça! Java** (Livro visual e prático) +3. **HackerRank** (Prática com feedback imediato) + +**[⬅️ Voltar para o início](../README.md)** + +> **Última atualização:** 01/03/2026 +> **Nota:** Links e preços podem mudar. Verifique diretamente nas plataformas. diff --git a/projetos/README.md b/projetos/README.md new file mode 100644 index 0000000..3143c6f --- /dev/null +++ b/projetos/README.md @@ -0,0 +1,70 @@ +# Projetos + +Mini projetos para aplicar o que foi aprendido de forma integrada. + +## Como usar + +1. Leia o enunciado do projeto +2. Planeje antes de codificar - defina classes, métodos e fluxo +3. Implemente incrementalmente +4. Teste cada parte antes de avançar + +## Projeto 01 - Calculadora de Linha de Comando + +**Objetivo:** Construir uma calculadora interativa via terminal. + +**Descrição:** +Crie um programa que receba dois números e uma operação do usuário e exiba o resultado. + +**Operações suportadas:** + +- Adição (`+`) +- Subtração (`-`) +- Multiplicação (`*`) +- Divisão (`/`) + +**Exemplo de uso:** + +``` +Informe o primeiro número: 10 +Informe o operador (+, -, *, /): * +Informe o segundo número: 5 +Resultado: 50 +``` + +**Requisitos:** + +- [ ] Receber os dois números e o operador via `Scanner` +- [ ] Exibir o resultado correto para cada operação +- [ ] Tratar divisão por zero com uma mensagem de erro +- [ ] Organizar a lógica em métodos separados por operação + +**Desafio extra:** + +- Permitir múltiplos cálculos sem reiniciar o programa +- Adicionar suporte a números decimais (`double`) + +**Dica:** +Comece pela adição. Quando funcionar, adicione as demais operações com `if/else` ou `switch`. + +## Projeto 02 - Cadastro de Estudantes + +**Objetivo:** Praticar orientação a objetos com uma pequena aplicação de cadastro. + +**Descrição:** +Crie um sistema simples que armazene estudantes e calcule médias. + +**Requisitos:** + +- [ ] Classe `Estudante` com nome, matrícula e lista de notas +- [ ] Método para calcular a média do estudante +- [ ] Método para verificar se está aprovado (média >= 7.0) +- [ ] Programa principal que cadastra ao menos 3 estudantes e exibe o resultado de cada um + +**Exemplo de saída:** + +``` +Ana Silva - Média: 8.5 - Aprovada +Carlos Souza - Média: 6.0 - Reprovado +Maria Lima - Média: 7.0 - Aprovada +```