diff --git a/.github/AI_INSTRUCTIONS.md b/.github/AI_INSTRUCTIONS.md new file mode 100644 index 0000000..055abe1 --- /dev/null +++ b/.github/AI_INSTRUCTIONS.md @@ -0,0 +1,433 @@ +# 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 Java4Beginners. + +--- + +## 🎯 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](../docs/02-variaveis.md) +[💻 Exemplo de Código](../codigos/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 + +``` +java4beginners/ +├── docs/ # Conteúdos numerados +│ ├── README.md # Índice de conteúdos +│ ├── 01-introducao.md +│ ├── 02-variaveis.md +│ └── ... +├── codigos/ # Exemplos de código +│ ├── README.md # Índice de códigos +│ ├── 01-HelloWorld/ +│ ├── 02-Variaveis/ +│ └── ... +├── 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..ccae54a --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,194 @@ +# Guia de Contribuição + +Obrigado por considerar contribuir para o Java4Beginners! 🎉 + +Este documento fornece diretrizes para contribuir com o projeto. + +--- + +## 🤝 Como Contribuir + +### Reportar Bugs ou Sugerir Melhorias + +1. Verifique se já não existe uma issue sobre o assunto +2. Abra uma [nova issue](https://github.com/caramelotech/java4beginners/issues/new) +3. Descreva claramente o problema ou sugestão +4. Adicione exemplos quando possível + +### Adicionar Conteúdo + +1. **Fork** o repositório +2. **Clone** seu fork localmente +3. Crie uma **branch** para sua contribuição: + + ```bash + git checkout -b feature/meu-novo-conteudo + ``` + +4. **Use o template** disponível em `.github/TEMPLATE.md` + +5. **Adicione seu conteúdo** seguindo as diretrizes abaixo + +6. **Commit** suas mudanças: + + ```bash + git add . + git commit -m "Adiciona conteúdo sobre [tópico]" + ``` + +7. **Push** para seu fork: + + ```bash + git push origin feature/meu-novo-conteudo + ``` + +8. Abra um **Pull Request** descrevendo suas mudanças + +--- + +## 📝 Diretrizes de Conteúdo + +### Estrutura dos Arquivos + +- **Conteúdos educacionais:** `docs/XX-nome-do-topico.md` + - Onde XX é o número sequencial (01, 02, 03...) + - Use kebab-case para nomes de arquivo + +- **Códigos de exemplo:** `codigos/XX-NomeDoExemplo/` + - Organize em pastas por tópico + - Inclua comentários explicativos + +- **Recursos:** `recursos/README.md` + - Adicione livros, cursos, artigos relevantes + - Mantenha organizado por categoria + +### Estilo de Escrita + +- ✅ Use linguagem clara e acessível +- ✅ Explique conceitos complexos com analogias +- ✅ Inclua exemplos práticos +- ✅ Adicione código quando relevante +- ✅ Use formatação Markdown corretamente +- ❌ Evite jargões sem explicação +- ❌ Não assuma conhecimento prévio avançado +- ❌ Evite parágrafos muito longos + +### Código + +- ✅ Siga as convenções de código Java +- ✅ Adicione comentários explicativos +- ✅ Use nomes descritivos para variáveis/métodos +- ✅ Teste o código antes de submeter +- ✅ Inclua saída esperada quando aplicável + +### Numeração + +Ao adicionar novo conteúdo: + +1. Verifique o último número usado em `docs/` +2. Use o próximo número sequencial +3. Atualize o índice em `docs/README.md` +4. Adicione links de navegação (anterior/próximo) + +--- + +## 🎨 Template + +Use sempre o template oficial em `.github/TEMPLATE.md` para criar novos conteúdos. + +### Seções Obrigatórias + +- Introdução +- Explicação do conceito +- Exemplos práticos +- Exercícios (quando aplicável) + +### Seções Opcionais + +- Recursos adicionais +- Perguntas frequentes +- Conceitos relacionados + +--- + +## 🔍 Revisão + +Antes de submeter seu PR: + +- [ ] Revisei ortografia e gramática +- [ ] Testei todos os links +- [ ] Executei e testei códigos de exemplo +- [ ] Segui o template oficial +- [ ] Atualizei o índice/README quando necessário +- [ ] Adicionei metadados (nível, tempo de leitura) + +--- + +## 📋 Tipos de Contribuição + +### Conteúdo Educacional + +- Novos tópicos sobre Java +- Tutoriais práticos +- Guias de conceitos + +### Código + +- Exemplos práticos +- Exercícios resolvidos +- Projetos de referência + +### Recursos + +- Livros recomendados +- Cursos online +- Artigos e vídeos +- Ferramentas úteis + +### Melhorias + +- Correções de erros +- Melhorias de texto +- Atualização de links +- Otimização de exemplos + +--- + +## 🌟 Boas Práticas + +1. **Seja consistente** com o estilo existente +2. **Teste tudo** antes de submeter +3. **Documente bem** seu código +4. **Seja didático** - lembre-se do público iniciante +5. **Mantenha simples** - prefira clareza à complexidade +6. **Cite fontes** quando usar conteúdo de terceiros + +--- + +## ❓ Dúvidas + +Se tiver dúvidas sobre como contribuir: + +1. Consulte os [exemplos existentes](../docs/) +2. Leia outros PRs aprovados +3. Abra uma issue para discussão +4. Entre em contato com os mantenedores + +--- + +## 📜 Código de Conduta + +- Seja respeitoso e profissional +- Aceite críticas construtivas +- Foque no melhor para o projeto +- Ajude outros contribuidores + +--- + +## 🙏 Agradecimentos + +Toda contribuição é valiosa! Obrigado por ajudar a tornar o aprendizado de Java mais acessível. + +--- + +**[⬅️ Voltar ao README](../README.md)** diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..b67ecd2 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,62 @@ +## Descrição + + + +--- + +## Tipo de Mudança + + + +- [ ] 📝 Novo conteúdo educacional +- [ ] 🐛 Correção de erro (typo, link quebrado, etc.) +- [ ] ✨ Melhoria de conteúdo existente +- [ ] 💻 Novo código de exemplo +- [ ] 📚 Adição de recursos (livros, cursos, etc.) +- [ ] 🔧 Configuração ou estrutura do repositório +- [ ] 📖 Atualização de documentação + +--- + +## Checklist + + + +- [ ] Segui as [diretrizes de contribuição](../CONTRIBUTING.md) +- [ ] Usei o [template adequado](TEMPLATE.md) (se aplicável) +- [ ] Revisei ortografia e gramática +- [ ] Verifiquei que os links estão funcionando +- [ ] Testei os códigos de exemplo (se aplicável) +- [ ] Adicionei/atualizei o índice (README.md) se necessário +- [ ] O conteúdo está numerado corretamente (se novo tópico) + +--- + +## Conteúdo Adicionado/Modificado + + + +- [ ] `docs/XX-nome-do-topico.md` +- [ ] `codigos/exemplo.java` +- [ ] `recursos/README.md` +- [ ] Outro: + +--- + +## Screenshots + + + +--- + +## Informações Adicionais + + + +--- + +## Revisores + + + +cc: @caramelotech diff --git a/.github/TEMPLATE.md b/.github/TEMPLATE.md new file mode 100644 index 0000000..5bb0c24 --- /dev/null +++ b/.github/TEMPLATE.md @@ -0,0 +1,171 @@ +# [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](../docs/XX-topico-anterior.md) +- [📖 Tópico Relacionado](../docs/XX-topico-relacionado.md) +- [📖 Próximo Tópico](../docs/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..7ff6d31 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,227 @@ -# java4beginners -Base de conhecimento sobre Java para iniciantes. +# ☕ Java4Beginners + +> Base de conhecimento completa sobre Java para iniciantes em português + +Bem-vindo ao **Java4Beginners**! 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/java4beginners/) +[![License](https://img.shields.io/github/license/caramelotech/java4beginners)](LICENSE) + +--- + +## 📚 Sobre o Projeto + +O **Java4Beginners** é 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 + +``` +java4beginners/ +├── 📖 docs/ # Conteúdos teóricos numerados +├── 💻 codigos/ # Exemplos de código executáveis +├── 📚 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 | [docs/](docs/README.md) | +| 💻 **Códigos** | Exemplos práticos em Java | [codigos/](codigos/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](docs/01-introducao-java.md) +2. 🔧 Configure seu ambiente (em breve) +3. 💻 Execute o [Hello World](codigos/01-HelloWorld/) +4. 📚 Continue seguindo a [trilha de conteúdos](docs/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](docs/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 →](docs/README.md)** + +--- + +## 💻 Exemplos de Código + +Todos os exemplos estão em [`codigos/`](codigos/) organizados por tópico: + +- [Hello World](codigos/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/java4beginners/](https://caramelotech.github.io/java4beginners/)** + +--- + +## 📊 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/java4beginners/issues) +- 💬 **Discussões:** [GitHub Discussions](https://github.com/caramelotech/java4beginners/discussions) +- 🌐 **Website:** [caramelotech.github.io/java4beginners](https://caramelotech.github.io/java4beginners/) + +--- + +## 📄 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..e9d38c6 --- /dev/null +++ b/_config.yml @@ -0,0 +1,56 @@ +# Configuração do GitHub Pages para Java4Beginners + +# Tema +theme: jekyll-theme-cayman +title: "Java4Beginners" +description: "Base de conhecimento sobre Java para iniciantes" + +# URL e baseurl +# url: "https://caramelotech.github.io" +# baseurl: "/java4beginners" + +# 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/codigos/01-HelloWorld/HelloWorld.java b/codigos/01-HelloWorld/HelloWorld.java new file mode 100644 index 0000000..8c9ac95 --- /dev/null +++ b/codigos/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/codigos/01-HelloWorld/README.md b/codigos/01-HelloWorld/README.md new file mode 100644 index 0000000..90cde3e --- /dev/null +++ b/codigos/01-HelloWorld/README.md @@ -0,0 +1,155 @@ +# 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](../../docs/01-introducao-java.md) +- [📖 Estrutura de um Programa Java](../../docs/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](../../docs/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/codigos/README.md b/codigos/README.md new file mode 100644 index 0000000..6b0a245 --- /dev/null +++ b/codigos/README.md @@ -0,0 +1,147 @@ +# 💻 Códigos de Exemplo - Java4Beginners + +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: + +``` +codigos/ +├── 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 codigos/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 `/docs` + +--- + +## 🔗 Recursos Relacionados + +- [📖 Conteúdos Teóricos](../docs/README.md) +- [📚 Recursos Adicionais](../recursos/README.md) +- [🤝 Como Contribuir](../.github/CONTRIBUTING.md) + +--- + +## 🆘 Problemas ao Executar? + +### JDK não instalado? +Veja o guia de instalação em [docs/02-instalacao-configuracao.md](../docs/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/java4beginners/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/docs/01-introducao-java.md b/docs/01-introducao-java.md new file mode 100644 index 0000000..bb5a9d7 --- /dev/null +++ b/docs/01-introducao-java.md @@ -0,0 +1,477 @@ +# 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. + +--- + +## 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!") +``` + +--- + +## 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** + +--- + +## Recursos Adicionais + +### Para Aprender Mais + +- 📚 **Livros:** + - "Java: Como Programar" - Deitel & Deitel + - "Use a Cabeça! Java" - Kathy Sierra & Bert Bates + +- 🎓 **Cursos:** + - [Java Programming - Coursera](https://www.coursera.org/learn/java-programming) + - [Curso de Java - Curso em Vídeo](https://www.cursoemvideo.com/curso/java/) + +- 📰 **Documentação:** + - [Documentação Oficial do Java](https://docs.oracle.com/javase/) + - [Java Tutorial da Oracle](https://docs.oracle.com/javase/tutorial/) + +--- + +## Perguntas Frequentes + +
+Preciso pagar para usar Java? + +Não! Java é gratuito para desenvolvimento e uso. Você pode baixar o JDK gratuitamente e criar aplicações sem custos. + +
+ +
+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/docs/02-sintaxe.md b/docs/02-sintaxe.md new file mode 100644 index 0000000..aa8aa72 --- /dev/null +++ b/docs/02-sintaxe.md @@ -0,0 +1,501 @@ +# 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. + +--- + +## 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/docs/README.md b/docs/README.md new file mode 100644 index 0000000..e924ef1 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,134 @@ +# 📚 Conteúdos - Java4Beginners + +Bem-vindo à seção de conteúdos do Java4Beginners! 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](../codigos/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/java4beginners/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/recursos/README.md b/recursos/README.md new file mode 100644 index 0000000..09641fd --- /dev/null +++ b/recursos/README.md @@ -0,0 +1,207 @@ +# 📚 Recursos Adicionais - Java4Beginners + +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) | +| **Java 8 in Action** | Raoul-Gabriel Urma et al. | Recursos modernos do Java 8+ | [Amazon](https://www.amazon.com.br/) | + +### 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 ao README Principal](../README.md)** + +--- + +> **Última atualização:** 01/03/2026 +> **Nota:** Links e preços podem mudar. Verifique diretamente nas plataformas.