DEV Community: Emanoel Carvalho

Transações em Banco de Dados - Entendendo o Funcionamento

Emanoel Carvalho — Sun, 29 Mar 2026 00:28:52 +0000

Voltando ao Básico: O que é Atomicidade?

Antes de falar de transaction, precisamos entender o conceito que a sustenta: atomicidade.

O átomo, na física clássica, era considerado a menor unidade indivisível da matéria. Na computação, pegamos emprestado esse conceito para dizer:

"Esse conjunto de operações é indivisível, acontece tudo, ou não acontece nada."

É exatamente isso que uma transaction garante.

A Analogia do PIX

Imagine que você vai fazer um PIX de R$100 para um amigo. Por baixo dos panos, o banco precisa executar duas operações:

1. Debitar R$100 da sua conta
2. Creditar R$100 na conta do seu amigo

Agora imagine que a operação 1 acontece, mas o sistema cai antes da operação 2. O que acontece?

❌ Você perdeu R$100
❌ Seu amigo não recebeu nada
❌ O dinheiro simplesmente sumiu do sistema

Isso é uma inconsistência. E é exatamente o tipo de problema que uma transaction resolve.

Com uma transaction, o banco de dados entende que essas duas operações são uma coisa só. Se a segunda falhar, a primeira é desfeita automaticamente, como se nunca tivesse acontecido, claro, isso não resolve outros problemas como disponibilidade e escalabilidade, mas aqui estou tentando explicar o funcionamento de um conceito, em um sistema real, as coisas são sempre mais complexas.

O Ciclo de Vida de uma Transaction

INÍCIO DA TRANSACTION
        │
        ▼
  [Operação 1] ──── falhou? ──→ ROLLBACK (desfaz tudo)
        │
        ▼
  [Operação 2] ──── falhou? ──→ ROLLBACK (desfaz tudo)
        │
        ▼
  [Operação N] ──── falhou? ──→ ROLLBACK (desfaz tudo)
        │
        ▼
  Tudo certo?
        │
        ▼
     COMMIT ✅ (persiste tudo)

Só existe um de dois desfechos possíveis: commit ou rollback. Nunca um estado no meio.

As 4 Propriedades ACID

Transactions seguem um conjunto de propriedades chamado ACID. Entender cada uma delas é entender por que transactions funcionam:

Propriedade	Nome	O que garante
A	Atomicidade	Tudo ou nada
C	Consistência	O banco sempre vai de um estado válido para outro estado válido
I	Isolamento	Transactions paralelas não se interferem
D	Durabilidade	Após o commit, os dados sobrevivem a falhas

💡 Quando um banco de dados diz que é ACID-compliant, ele está dizendo que respeita todas essas propriedades. PostgreSQL, MySQL e SQL Server são exemplos clássicos.

Isolamento — A Propriedade Mais Traiçoeira

O Isolamento merece atenção especial, porque é onde a maioria dos bugs sutis aparecem.

Imagine dois usuários comprando o último item do estoque ao mesmo tempo:

Transaction A                    Transaction B
─────────────────────────────────────────────────
Lê estoque: 1 unidade
                                 Lê estoque: 1 unidade
Decrementa: 0 unidades
                                 Decrementa: 0 unidades ← PROBLEMA
Commit ✅
                                 Commit ✅ ← vendeu algo que não existe

Isso se chama Race Condition, e é um dos problemas que o nível de isolamento da transaction controla. Bancos de dados oferecem diferentes níveis:

Nível	Proteção
`READ UNCOMMITTED`	Nenhuma — lê dados ainda não commitados
`READ COMMITTED`	Lê apenas dados já commitados
`REPEATABLE READ`	Garante que releituras retornam o mesmo valor
`SERIALIZABLE`	Máxima proteção — transactions executam como se fossem sequenciais

Na Prática: E-commerce com Sequelize

Agora que o conceito está claro, veja como isso se traduz em código:

const { sequelize, Pedido, Estoque, Sale } = require('./models');

async function finalizarCompra(usuarioId, produtoId, quantidade) {
  // 1. Abre a transaction — a partir daqui, tudo é atômico
  const transaction = await sequelize.transaction();

  try {
    // 2. Lê o estoque dentro da transaction
    const produto = await Estoque.findOne(
      { where: { produtoId } },
      { transaction } // ← vincula essa query à transaction
    );

    if (!produto || produto.quantidade < quantidade) {
      throw new Error('Estoque insuficiente');
    }

    // 3. Decrementa o estoque
    await produto.update(
      { quantidade: produto.quantidade - quantidade },
      { transaction }
    );

    // 4. Cria o pedido
    const pedido = await Pedido.create(
      { usuarioId, produtoId, quantidade, status: 'confirmado' },
      { transaction }
    );

    // 5. Registra a venda
    await Sale.create(
      { pedidoId: pedido.id, valor: produto.preco * quantidade },
      { transaction }
    );

    // 6. Tudo certo — persiste as alterações
    await transaction.commit();

  } catch (error) {
    // 7. Algo falhou — desfaz TUDO
    await transaction.rollback();
    throw error;
  }
}

O que acontece se Sale.create falhar?

O estoque volta ao valor original ✅
O pedido é removido ✅
Nenhuma inconsistência no banco ✅

O Erro Clássico: O Hook Invisível

Aqui está o cenário que quebra sistemas de desenvolvedores experientes. Você escreve uma transaction perfeita, testa, e o sistema entra em deadlock. Você olha para todo o código e não acha o problema.

O culpado? Um hook no model que ninguém lembrou de vincular à transaction.

// ⚠️ Hook disparando FORA da transaction
Pedido.afterCreate(async (pedido) => {
  await LogAuditoria.create({
    entidade: 'Pedido',
    entidadeId: pedido.id,
    acao: 'criado',
  });
  // Essa query não sabe que existe uma transaction aberta
  // Ela tenta acessar o registro do pedido, que ainda está "preso"
  // no lock da transaction — e aí o deadlock acontece
});

Por que o deadlock acontece?

Transaction principal          Hook (conexão separada)
──────────────────────────────────────────────────────
Cria Pedido (lock no registro)
                               Tenta ler o Pedido ← bloqueado pelo lock
Aguarda o hook terminar ←──── Aguarda a transaction liberar o lock
        │                              │
        └──────── DEADLOCK ────────────┘
                  (espera infinita)

✅ A Correção

Pedido.afterCreate(async (pedido, options) => {
  await LogAuditoria.create(
    {
      entidade: 'Pedido',
      entidadeId: pedido.id,
      acao: 'criado',
    },
    { transaction: options.transaction } // ← participa da mesma transaction
  );
});

Agora o hook faz parte da transaction. Se houver rollback, o log também é desfeito. Se houver commit, tudo é salvo junto.

Resumo Mental

Pense em uma transaction como uma caixa de vidro. Tudo que acontece dentro dela é visível apenas para ela mesma, até que você decida abrir a caixa (commit) ou jogar tudo fora (rollback). Qualquer coisa que aconteça fora da caixa, enquanto ela ainda está fechada, não enxerga o que está dentro, e é aí que os problemas aparecem.

No próximo nível: quando um único banco não é suficiente e você precisa de transactions distribuídas entre microsserviços, aí entram patterns como Saga e Outbox. Mas isso é história para outro artigo.

GitHub Stats Quebrados? Resolva de Vez com GitHub Actions!

Emanoel Carvalho — Tue, 17 Feb 2026 19:25:08 +0000

Se você chegou até aqui, provavelmente já se deparou com aquele frustrante ícone de imagem quebrada no seu perfil do GitHub onde deveria estar aparecendo suas estatísticas lindamente renderizadas. Eu sei, é irritante!

Mas calma, tenho uma boa notícia: existe uma solução permanente, gratuita e muito mais poderosa do que simplesmente esperar o serviço voltar. Neste artigo, vou te mostrar como implementar um sistema automatizado que gera suas métricas do GitHub usando GitHub Actions, garantindo que seu perfil esteja sempre atualizado e funcionando perfeitamente.

📉 O Problema: Por Que o GitHub Readme Stats Caiu?

Antes de partirmos para a solução, é importante entender o que realmente aconteceu com o github-readme-stats, aquele serviço querido que todos usávamos.

A História Por Trás do Erro 503

O GitHub Readme Stats é um projeto open-source extremamente popular que gerava cards dinâmicos de estatísticas do GitHub. Durante muito tempo, ele funcionou perfeitamente hospedado na Vercel com um plano enterprise gratuito fornecido como patrocínio para projetos open-source.

Mas o que deu errado?

Em abril de 2024, a Vercel descontinuou esse patrocínio. O projeto foi rebaixado para o plano "Hobby" gratuito, que possui limites de uso bem mais restritos. Com milhões de desenvolvedores usando o serviço público, esses limites são ultrapassados rapidamente, resultando no temido erro:

503 SERVICE_UNAVAILABLE
DEPLOYMENT_PAUSED
"This Deployment is paused by the owner."

Por Que Isso Não Vai Se Resolver Sozinho?

Muita gente pensa que é apenas uma "queda temporária", mas a verdade é mais complexa:

Limites de recursos: O plano gratuito da Vercel não suporta o tráfego massivo gerado pelo uso global
Custos insustentáveis: Manter o serviço funcionando exigiria que o mantenedor arcasse com custos significativos
Problema estrutural: Não é um bug, mas sim uma incompatibilidade entre demanda e recursos disponíveis

O Impacto na Comunidade

Milhares de perfis do GitHub exibindo imagens quebradas
Perda da funcionalidade de showcasing de habilidades
Frustração generalizada entre desenvolvedores
Dezenas de issues duplicadas reportando o mesmo problema

A Solução Proposta: GitHub Actions + lowlighter/metrics

Depois de analisar as alternativas disponíveis, a solução mais robusta e confiável é migrar para o lowlighter/metrics executando via GitHub Actions. Vamos entender por quê.

Por Que Esta Solução é Superior?

1. Totalmente Gratuita e Independente

Roda na infraestrutura do próprio GitHub
Sem depender de serviços externos que podem cair
Zero custos de hospedagem

2. Extremamente Personalizável

Mais de 40 plugins disponíveis
Mais de 300 opções de configuração
Templates variados: classic, terminal, markdown, etc.

3. Mais Poderosa

Enquanto o GitHub Readme Stats oferece apenas cards básicos, o lowlighter/metrics fornece:

Análise de linguagens com detalhes avançados
Gráficos de linhas de código
Calendários isométricos de commits
Análise de hábitos de codificação
Integração com WakaTime, LeetCode e outras plataformas

4. Confiável e Estável

Execução controlada por você
Sem rate limits externos
SVG gerado e commitado no seu repositório
Sempre disponível, mesmo offline

🛠️ Tutorial Passo a Passo Completo

Agora vamos colocar a mão na massa! Siga este guia detalhado para implementar suas métricas automatizadas.

Pré-requisitos

Antes de começar, certifique-se de que você tem:

✅ Uma conta no GitHub (Sim, eu sei, pode parecer besta essa confirmação rsrs)
✅ Um repositório para seu perfil (geralmente seu-usuario/seu-usuario)
✅ Conhecimento básico de Git e GitHub

Passo 1: Criar o Personal Access Token (PAT)

O token é necessário para que o GitHub Actions possa acessar seus dados de forma segura.

Acesse as configurações de desenvolvedor:
- Vá para github.com/settings/tokens
- Ou navegue: Settings → Developer settings → Personal access tokens → Tokens (classic)
Gere um novo token:
- Clique em "Generate new token" → "Generate new token (classic)"
- Dê um nome descritivo, como METRICS_TOKEN
Configure os escopos necessários:

Para funcionalidades básicas, selecione:

✅ public_repo - para acessar repositórios públicos
✅ read:user - para dados do usuário

Se você quiser métricas mais avançadas, adicione:

✅ read:org - para métricas de organizações (se aplicável)
✅ repo - para incluir repositórios privados

Gere e copie o token:
- Clique em "Generate token"
- IMPORTANTE: Copie o token AGORA! Você não poderá vê-lo novamente
- O formato será algo como: ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Passo 2: Adicionar o Token como Secret no Repositório

Agora vamos armazenar o token de forma segura no seu repositório.

Navegue até o repositório do seu perfil:
- Geralmente é https://github.com/seu-usuario/seu-usuario
Acesse as configurações de Secrets:
- Clique em "Settings" (No menu superior)
- No menu lateral: "Secrets and variables" → "Actions"
Crie um novo secret:
- Clique em "New repository secret"
- Name: METRICS_TOKEN
- Value: Cole o token que você copiou no Passo 1
- Clique em "Add secret"

Pronto! Seu token está seguro e pronto para ser usado.

Passo 3: Criar o Arquivo de Workflow

Agora vamos criar a automação que vai gerar suas métricas.

No seu repositório, crie a estrutura de pastas:
- Crie a pasta .github/workflows/ na raiz do repositório
- Se estiver usando a interface web, você pode fazer isso ao criar o arquivo
Crie o arquivo metrics.yml:
- Caminho completo: .github/workflows/metrics.yml
Adicione o seguinte conteúdo:

name: GitHub Metrics

on:
  # Permite execução manual do workflow
  workflow_dispatch:

  # Executa automaticamente todo dia às 6h da manhã (UTC)
  schedule:
    - cron: "0 6 * * *"

jobs:
  metrics:
    runs-on: ubuntu-latest
    permissions:
      contents: write

    steps:
      - uses: lowlighter/metrics@latest
        with:
          # Token de autenticação (obrigatório)
          token: ${{ secrets.METRICS_TOKEN }}

          # Seu usuário do GitHub
          user: seu-usuario-aqui

          # Nome do arquivo que será gerado
          filename: assets/metrics.svg

          # Seções base a serem incluídas
          base: header, activity, community, repositories, metadata

          # Plugin de linguagens de programação
          plugin_languages: yes
          plugin_languages_sections: most-used, recently-used
          plugin_languages_details: bytes-size, percentage
          plugin_languages_limit: 8

          # Plugin de linhas de código
          plugin_lines: yes

** IMPORTANTE: Substitua seu-usuario-aqui** pelo seu username do GitHub!
Commit o arquivo:
- Se estiver na interface web, clique em "Commit changes"
- Se estiver localmente: git add .github/workflows/metrics.yml && git commit -m "feat: adiciona GitHub Metrics workflow" && git push

Passo 4: Entender a Configuração do Workflow

Vamos destrinchar cada parte do workflow para você entender exatamente o que está acontecendo.

Trigger Events (Eventos de Disparo)

on:
  workflow_dispatch:
  schedule:
    - cron: "0 6 * * *"

workflow_dispatch: Permite executar o workflow manualmente através da interface do GitHub
schedule: Agenda execuções automáticas
cron: "0 6 * * *": Sintaxe cron que significa:
- 0 = minuto 0
- 6 = hora 6 (UTC)
- * * * = todos os dias, todos os meses, todos os dias da semana

Dica: Para converter para seu fuso horário local, use crontab.guru

Permissões

permissions:
  contents: write

Esta linha é crítica! Ela concede ao workflow permissão para fazer commit dos arquivos gerados de volta ao repositório. Sem isso, o workflow falhará.

Configurações Básicas

token: ${{ secrets.METRICS_TOKEN }}
user: seu-usuario-aqui
filename: assets/metrics.svg

token: Referência ao secret que criamos (nunca exponha o token diretamente!)
user: Seu username do GitHub
filename: Onde o SVG será salvo (cria a pasta automaticamente)

Base Sections (Seções Base)

base: header, activity, community, repositories, metadata

Define quais informações básicas serão exibidas:

header: Cabeçalho com seu nome e avatar
activity: Nível de atividade e contribuições
community: Pull requests, issues, reviews
repositories: Estatísticas dos seus repositórios
metadata: Informações sobre quando foi gerado

Plugin: Languages (Linguagens)

plugin_languages: yes
plugin_languages_sections: most-used, recently-used
plugin_languages_details: bytes-size, percentage
plugin_languages_limit: 8

most-used: Mostra suas linguagens mais utilizadas historicamente
recently-used: Linguagens usadas recentemente
bytes-size, percentage: Exibe o tamanho em bytes e percentual
limit: 8: Mostra no máximo 8 linguagens

Plugin: Lines (Linhas de Código)

plugin_lines: yes

Gera estatísticas sobre linhas de código adicionadas e removidas. Simples e direto!

Passo 5: Executar e Testar

Agora vamos rodar o workflow pela primeira vez!

Navegue até a aba Actions do seu repositório:
- URL: https://github.com/seu-usuario/seu-usuario/actions
Encontre o workflow "GitHub Metrics":
- Ele deve aparecer na lista de workflows disponíveis
Execute manualmente:
- Clique no workflow "GitHub Metrics"
- Clique no botão "Run workflow" (à direita)
- Mantenha a branch padrão selecionada
- Clique em "Run workflow" (verde)
Acompanhe a execução:
- Aguarde alguns segundos e recarregue a página
- Clique na execução que apareceu
- Clique em "metrics" para ver os detalhes
- Acompanhe o log em tempo real
Verificar o resultado:
- Se tudo correr bem, você verá um ✅ verde
- O arquivo assets/metrics.svg será criado no seu repositório
- Verifique acessando: https://media2.dev.to/dynamic/image/width=1000,height=420,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fs8yjffjm1uwfulw9il5g.png

Passo 6: Adicionar o SVG ao README

Última etapa: vamos exibir suas métricas no README!

Abra o arquivo README.md do seu repositório
Adicione a imagem usando Markdown:

## 📊 Minhas Estatísticas do GitHub

![Metrics](./assets/metrics.svg)

Ou, para garantir que sempre mostre a versão mais recente:

## 📊 Minhas Estatísticas do GitHub

![Metrics](https://raw.githubusercontent.com/gist/Ev357/17d9fc0cbccd58aea20b392de2d88eba/raw/aa5379c97b7f1bf89105f0960fafdb389cdbd70e/github-metrics.svg)

Commit e push das alterações:

git add README.md
git commit -m "docs: adiciona métricas do GitHub ao README"
git push

Admire o resultado!

Acesse seu perfil e veja suas métricas lindamente renderizadas!

Customizações e Plugins Avançados

Agora que você tem o básico funcionando, que tal turbinar suas métricas? O lowlighter/metrics oferece uma infinidade de opções!

Plugins Populares para Experimentar

1. Calendário Isométrico de Commits

plugin_isocalendar: yes
plugin_isocalendar_duration: half-year

Cria um calendário 3D mostrando sua atividade de commits.

2. Hábitos de Codificação

plugin_habits: yes
plugin_habits_charts: yes
plugin_habits_days: 14
plugin_habits_facts: yes
plugin_habits_from: 200

Analisa seus padrões: horários preferidos, dias mais produtivos, etc.

3. Contribuições Notáveis

plugin_notable: yes
plugin_notable_filter: stars:>50

Destaca repositórios onde você contribuiu que têm mais de 50 stars.

4. Gráfico de Stargazers

plugin_stargazers: yes
plugin_stargazers_charts: yes
plugin_stargazers_charts_type: chartist

Mostra a evolução de stars nos seus repositórios.

5. Integração com WakaTime

plugin_wakatime: yes
plugin_wakatime_token: ${{ secrets.WAKATIME_TOKEN }}
plugin_wakatime_days: 7
plugin_wakatime_sections: time, projects, languages

Exibe estatísticas detalhadas de tempo de codificação do WakaTime.

Templates Visuais Diferentes

Você pode mudar completamente a aparência usando templates:

Terminal Style

template: terminal

Classic (padrão)

template: classic

Repository Style

template: repository

Temas Pré-definidos

config_theme: dark
# Opções: default, dark, auto

Ou use temas personalizados:

config_theme: github-dark
# Outras opções: github, monokai, solarized, etc.

Exemplo de Configuração Avançada

Aqui está um exemplo completo com vários plugins:

name: GitHub Metrics Advanced

on:
  workflow_dispatch:
  schedule:
    - cron: "0 0 * * *"

jobs:
  metrics:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - uses: lowlighter/metrics@latest
        with:
          token: ${{ secrets.METRICS_TOKEN }}
          user: seu-usuario
          filename: assets/metrics-advanced.svg

          # Configurações gerais
          base: header, activity, community, repositories, metadata
          config_timezone: America/Sao_Paulo
          config_theme: dark

          # Plugin de linguagens
          plugin_languages: yes
          plugin_languages_sections: most-used, recently-used
          plugin_languages_details: bytes-size, percentage
          plugin_languages_limit: 8
          plugin_languages_indepth: yes

          # Plugin de linhas de código
          plugin_lines: yes

          # Calendário isométrico
          plugin_isocalendar: yes
          plugin_isocalendar_duration: half-year

          # Hábitos
          plugin_habits: yes
          plugin_habits_charts: yes
          plugin_habits_days: 14
          plugin_habits_facts: yes

          # Contribuições notáveis
          plugin_notable: yes
          plugin_notable_filter: stars:>100

          # Stargazers
          plugin_stargazers: yes
          plugin_stargazers_charts: yes

🔧 Troubleshooting: Problemas Comuns e Soluções

Encontrou algum problema? Vamos resolver! Aqui estão os erros mais comuns e como corrigi-los.

❌ Erro: "Resource not accessible by integration"

Causa: O workflow não tem permissão para fazer commit.

Solução:

Adicione permissions: contents: write ao job
Verifique se as Actions têm permissão de escrita:
- Settings → Actions → General
- Em "Workflow permissions", selecione "Read and write permissions"

❌ Erro: "Bad credentials" ou "401 Unauthorized"

Causa: Problema com o token de acesso.

Soluções:

Verifique se o secret METRICS_TOKEN está configurado corretamente
Certifique-se de que o token não expirou
Confirme que o token tem os escopos necessários
Gere um novo token se necessário

❌ Erro: Plugin não funciona ou exibe "Skipped"

Causa: O token não tem as permissões (scopes) necessárias para aquele plugin.

Solução:

Verifique a documentação do plugin para ver quais scopes são necessários
Crie um novo token com os scopes corretos
Atualize o secret METRICS_TOKEN

❌ O SVG não aparece no README

Causas possíveis:

Caminho incorreto no Markdown
O arquivo ainda não foi gerado

Soluções:

Verifique se o caminho está correto: ./assets/metrics.svg
Ou use o caminho completo: https://upload.wikimedia.org/wikipedia/commons/1/14/Cryogenic_electron_microscopy_workflow.svg
Certifique-se de que o workflow rodou com sucesso
Aguarde alguns minutos para o cache do GitHub atualizar

❌ Workflow executou mas não gerou o arquivo

Causa: Permissões ou configuração incorreta.

Soluções:

Verifique os logs do workflow para mensagens de erro específicas
Confirme que permissions: contents: write está presente
Verifique se o filename está correto
Certifique-se de que a pasta de destino não está em .gitignore

Dica Profissional: Como Debugar

Para facilitar o debugging, adicione esta configuração ao workflow:

config_output: svg
debug: yes

Isso gerará logs mais detalhados mostrando exatamente o que está acontecendo em cada etapa.

Ainda com Problemas?

Consulte a documentação oficial: github.com/lowlighter/metrics
Use o playground interativo: metrics.lecoq.io para testar configurações
Verifique as issues: Procure por problemas similares nas issues do projeto
Peça ajuda: Crie uma issue detalhando seu problema com logs e configurações

🎯 Conclusão e Próximos Passos

Parabéns! Você acabou de implementar uma solução profissional, confiável e totalmente automatizada para exibir suas estatísticas do GitHub.

Vantagens que Você Conquistou

✅ Independência total - Não depende mais de serviços externos

✅ Confiabilidade garantida - Suas métricas sempre estarão disponíveis

✅ Personalização infinita - Mais de 40 plugins ao seu dispor

✅ Gratuito para sempre - Sem custos de hospedagem

✅ Controle total - Você decide quando e como atualizar

✅ Profissionalismo - Um perfil que impressiona recrutadores

Sugestões de Próximos Passos

Experimente diferentes plugins
- Teste o plugin_habits para mostrar seus padrões de codificação
- Adicione plugin_isocalendar para um visual impactante
- Se usa WakaTime, integre com plugin_wakatime
Crie múltiplas versões
- Gere um SVG para modo claro e outro para modo escuro
- Crie versões especializadas (só linguagens, só atividade, etc.)
Otimize o agendamento
- Ajuste o cron para atualizar em horários estratégicos
- Considere executar semanalmente se diário for excessivo
Compartilhe e inspire
- Mostre seu perfil renovado nas redes sociais
- Ajude outros devs compartilhando este artigo
Explore a documentação
- Visite metrics.lecoq.io para descobrir todas as possibilidades
- Leia os exemplos oficiais para inspiração

Uma Nota Final sobre Open Source ❤️

Tanto o github-readme-stats quanto o lowlighter/metrics são projetos open-source mantidos pela comunidade. Se você achar essas ferramentas úteis, considere:

⭐ Dar uma estrela no repositório
💬 Reportar bugs ou sugerir melhorias
🤝 Contribuir com código ou documentação
☕ Apoiar os mantenedores se possível

O open source só funciona porque pessoas dedicam seu tempo para criar ferramentas incríveis gratuitamente. Vamos retribuir sempre que possível!

📚 Recursos Adicionais

Documentação oficial: github.com/lowlighter/metrics
Playground interativo: metrics.lecoq.io
Exemplos de uso: github.com/lowlighter/metrics/tree/examples
GitHub Actions Docs: docs.github.com/actions
Sintaxe Cron: crontab.guru

Gostou do artigo? Deixe um ❤️ e compartilhe com outros desenvolvedores que possam estar com o mesmo problema! Tem alguma dúvida ou sugestão? Comenta aqui embaixo!

Bancos de Dados Chave-Valor: Conceitos, Funcionamento e Laboratório com Redis

Emanoel Carvalho — Thu, 12 Feb 2026 16:00:35 +0000

Introdução

Bancos de dados chave-valor são amplamente utilizados em aplicações modernas por resolverem, de forma simples e eficiente, problemas comuns relacionados a latência, escalabilidade e flexibilidade de dados. Este artigo apresenta uma visão conceitual e prática sobre esse modelo, explicando desde seus fundamentos até um laboratório prático utilizando Redis e Docker.

O que é um banco de dados chave-valor?

Um banco de dados chave-valor é um tipo de banco NoSQL que armazena dados na forma de pares simples:

chave → valor

A chave é um identificador único, e o valor é um bloco de dados associado a essa chave. O banco não precisa interpretar o conteúdo do valor — ele apenas o armazena e o recupera.

Esse modelo é classificado como NoSQL porque abandona conceitos tradicionais dos bancos relacionais, como:

Tabelas
Relacionamentos
Joins
Esquemas rígidos

O objetivo principal é alcançar alto desempenho, flexibilidade de dados e escalabilidade horizontal.

Diferença para outros bancos NoSQL

Embora bancos como Redis e MongoDB pertençam à família NoSQL, eles resolvem problemas diferentes.

Redis: foco em alta performance, com dados armazenados primariamente em memória.
MongoDB: foco em persistência de documentos complexos, armazenados em disco.

A principal diferença está na forma de armazenamento e no tipo de carga de trabalho que cada um atende melhor.

Como funciona o armazenamento em bancos chave-valor?

O armazenamento ocorre por meio de pares simples:

Chave: identificador único
Valor: qualquer tipo de dado (strings, números, JSONs ou objetos serializados)

Essa estrutura é semelhante a um dicionário ou mapa.

Por não existir esquema ou validação estrutural, operações de leitura e escrita são extremamente rápidas.

Exemplos de uso comuns

Carrinhos de compra
Sessões de usuários
Promoções temporárias
Cache de dados frequentemente acessados

Um exemplo bastante conhecido no desenvolvimento front-end é o localStorage, uma API do HTML5 que permite armazenar dados no navegador do usuário no formato chave-valor.

Principais características

Estrutura simples

A chave localiza diretamente o valor. O banco não precisa entender o conteúdo armazenado.

Flexibilidade (schema-less)

Cada valor pode ter uma estrutura diferente, facilitando o armazenamento de dados não estruturados ou semipreenchidos.

Performance e escalabilidade

Acesso direto pela chave
Leitura e escrita em tempo constante (O(1))
Fácil particionamento e escalabilidade horizontal

Acesso direto

Não existem índices complexos nem varredura de dados. A busca é feita diretamente pela chave.

Casos de uso mais comuns

Cache de aplicações: Redis, Memcached
Gerenciamento de sessão: dados de usuários em tempo real
Filas e contadores: métricas, processamento assíncrono

Funcionamento em baixo nível

Em baixo nível, um banco chave-valor é essencialmente um sistema que mapeia um conjunto de bytes (chave) para outro conjunto de bytes (valor).

Internamente:

Não existe conceito de tipo, tabela ou esquema
Tudo é tratado como dados binários

Estrutura em memória

A implementação mais comum utiliza uma tabela hash:

A chave (array de bytes) é passada por uma função hash
O hash gera um índice na tabela
Esse índice aponta para um bucket
O bucket pode conter uma ou mais entradas
Em caso de colisão, a comparação final é feita byte a byte

Se a chave for encontrada, o valor associado é retornado.

Persistência de dados

Embora muitos bancos chave-valor utilizem memória para alcançar alta performance, isso torna os dados voláteis.

Para resolver esse problema, mecanismos de persistência são utilizados.

Write-Ahead Log (WAL)

Toda escrita é registrada primeiro em um log sequencial em disco
Garante que os dados não sejam perdidos em caso de falha

MemTable

Estrutura de dados mantida em memória (como Skip List ou Árvore balanceada)
Escritas são feitas simultaneamente no log e na memória
A resposta de sucesso é enviada após essas operações

Esse modelo realiza apenas operações de append, evitando sobrescritas em disco e aumentando a eficiência.

Por que esse modelo é tão utilizado?

Resolve problemas de latência
Reduz custo de acesso a bancos relacionais
Evita múltiplas consultas repetidas
Simplifica o modelo mental do desenvolvedor

A aplicação sabe exatamente qual chave buscar e recebe o valor diretamente, sem surpresas de performance.

Laboratório prático com Redis

Pré-requisitos

Você precisa ter instalado:

Docker
Docker Compose

Verifique:

docker --version
docker compose version

Estrutura do laboratório

redis-lab/
 ├── docker-compose.yml
 └── README.md (opcional)

Criando o Redis com Docker

docker-compose.yml

version: "3.9"

services:
  redis:
    image: redis:7.2
    container_name: redis-lab
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes

Conceitos envolvidos

redis:7.2: SGBD Redis
Porta 6379: porta padrão do Redis
volumes: persistência de dados
appendonly yes: grava operações em disco (AOF)

Mesmo bancos em memória podem oferecer persistência.

Subindo o banco

docker compose up -d

Verifique:

docker ps

Acessando o Redis

docker exec -it redis-lab redis-cli

Operações básicas

Inserindo dados

SET nome "Carlos"
SET idade 30

Buscando dados

GET nome
GET idade

Busca em tempo constante (O(1)).

Atualizando dados

SET idade 31

Atualizar significa sobrescrever o valor da chave.

Removendo dados

DEL nome

Tipos de dados no Redis

Strings

SET status "ativo"

Listas

LPUSH fila_emails "email1"
LPUSH fila_emails "email2"
LRANGE fila_emails 0 -1

Muito usadas como filas.

Contadores

SET visitas 0
INCR visitas
INCR visitas
GET visitas

Operações atômicas, ideais para métricas.

Hashes

HSET usuario:1 nome "Ana" idade 28 email "ana@email.com"
HGETALL usuario:1

Simulam registros estruturados.

TTL – dados temporários

SET codigo_verificacao "123456" EX 10

Após 10 segundos:

GET codigo_verificacao

Muito usado para sessões, tokens e cache.

Visualizando o estado do banco

KEYS *

⚠️ Em produção, esse comando é perigoso. Aqui é usado apenas para aprendizado.

Resumo mental

Conceito	Redis
Modelo	Chave → Valor
Schema	Não existe
Join	Não
Velocidade	Muito alta
Persistência	Opcional
Uso comum	Cache, sessões, filas

Encerrando o laboratório

docker compose down

Referências

Redis Documentation – https://redis.io/docs
Designing Data-Intensive Applications – Martin Kleppmann
NoSQL Databases – https://www.mongodb.com/nosql-explained
Log-Structured Storage – https://en.wikipedia.org/wiki/Log-structured_file_system

📘Guia Prático: Introdução ao Git + Como Subir Seu Código no GitHub

Emanoel Carvalho — Fri, 12 Dec 2025 01:18:38 +0000

📝 Introdução

No cenário atual do desenvolvimento de software, usamos dezenas de linguagens, frameworks e ferramentas. Mas, independentemente da stack, existe algo que todo desenvolvedor precisa dominar desde cedo: controle de versão.

Nesse contexto, entram em cena duas ferramentas fundamentais:

Git — o sistema de controle de versão mais usado do mundo
GitHub — uma plataforma de hospedagem e colaboração baseada em Git

Antes de mostrar como integrar Git e GitHub, é fundamental entender por que essas ferramentas existem e como funcionam por dentro. Essa base torna qualquer profissional mais confiante e evita erros comuns do dia a dia.

🧩 1. O que é Git?

O Git é um software open source de controle de versão, criado por Linus Torvalds, o mesmo criador do Linux.

A motivação original era simples: ele precisava de um sistema rápido, eficiente e confiável para controlar versões do kernel, algo que ferramentas da época não conseguiam oferecer.

O Git se tornou um padrão global porque é:

rápido
distribuído (cada máquina tem o repositório completo)
seguro (baseado em hashing)
simples de sincronizar com servidores remotos

🛠️ 2. Como o Git funciona?

Ao contrário de sistemas antigos que salvavam apenas diferenças entre arquivos (diffs), o Git trabalha com snapshots completos do estado dos arquivos a cada commit.

Em resumo:

Ele tira uma “foto” do projeto.
Mas salva novamente apenas o que mudou, graças ao hashing e deduplicação.
Cada snapshot é um commit, formando uma linha do tempo.

Isso permite histórico rápido, seguro e fácil de navegar.

📦 3. Os objetos internos do Git

O Git é basicamente um banco de dados de objetos imutáveis, armazenados em .git/objects/.

Os tipos principais são:

1. Blob

Conteúdo de um arquivo.

2. Tree

Representa diretórios, apontando para blobs e outras trees.

3. Commit

Aponta para uma tree e para seus commits pais.

4. Tag

Marcadores para commits, usados geralmente para versões.

Isso garante uma estrutura poderosa e verificável.

🔐 4. Imutabilidade e hashes

Cada objeto é nomeado pelo hash do conteúdo.

Isso garante:

integridade criptográfica
histórico imutável
detecção de corrupção
deduplicação automática

Modificou o conteúdo? O hash muda.

Assim o Git sabe exatamente o que mudou e quando.

🌿 5. Branches: ponteiros leves

Um branch não é uma cópia do projeto.

É apenas um ponteiro para um commit.

main → aponta para o commit mais recente da linha principal
Criar branch → criar novo ponteiro
Commit em um branch → ponteiro avança

Por isso criar branches é barato e incentivado.

🔗 6. Histórico como um DAG

Os commits formam um grafo acíclico dirigido:

Cada commit aponta para seus pais
Merges têm dois pais
O histórico avança sempre para frente

É por isso que o Git é tão eficiente em representar múltiplas linhas de desenvolvimento.

📥 7. Staging Area (Index)

O Git tem uma área intermediária chamada index, onde escolhemos o que vai entrar no commit.

Isso permite:

commits mais limpos
controle granular
combinar partes de arquivos

📡 8. O que são repositórios remotos?

Servidores como GitHub, GitLab ou Bitbucket são apenas repositórios Git adicionais hospedados na nuvem.

Quando usamos:

git push → mandamos commits e atualizamos referências remotas
git pull → trazemos commits remotos e atualizamos nossa branch local

Nada de mágico: é só sincronização.

🔀 9. Merge vs Rebase

Merge

Cria um commit com 2 pais
Mantém histórico paralelo

Rebase

Reescreve commits, mudando seus pais
Produz histórico linear
Gera novos hashes

Ambos fazem parte do arsenal de um desenvolvedor moderno.

🧹 10. Reescrita de histórico

O Git nunca altera commits antigos — cria commits novos.

Os antigos ficam “órfãos” e podem ser removidos pelo git gc.

🎯 Resumo teórico

Git é um banco de dados imutável baseado em hashes.
Commits são snapshots.
Branches são ponteiros.
O histórico é um DAG.
Repositórios remotos são só referência extra.

Agora que entendemos Git… vamos ao GitHub.

🐙 11. O que é GitHub?

O GitHub é a maior plataforma de hospedagem de código do mundo, com milhões de repositórios.

Ele pertence à Microsoft e oferece:

hospedagem de repositórios
issues
pull requests
workflows de CI/CD (GitHub Actions)
colaboração em equipe
interface web rica
apps desktop e mobile

Em resumo:

Git controla seu código localmente; GitHub permite compartilhar, colaborar e publicar.

🚀 12. Como integrar Git + GitHub (tutorial simples e completo)

A seguir, um passo a passo direto e funcional.

1. Instale o Git

Verifique se já está instalado:

git --version

Se não estiver, baixe em:

https://git-scm.com

2. Configure seu nome e email

git config --global user.name "Seu Nome"
git config --global user.email "seuemail@example.com"

3. Crie um repositório local

No diretório do seu projeto:

git init
git add .
git commit -m "primeiro commit"

4. Crie um repositório no GitHub

Acesse https://github.com
Clique em New repository
Dê um nome
Não marque nenhum arquivo (para evitar conflitos no push inicial)

5. Conecte o repositório local ao GitHub

Copie a URL HTTPS fornecida no GitHub e execute:

git remote add origin https://github.com/usuario/repositorio.git

6. Defina a branch principal como `main`

git branch -M main

7. Envie o projeto para o GitHub

git push -u origin main

Pronto! 🎉

Seu projeto está online.

💬 13. Ciclo básico de trabalho no dia a dia

As operações principais:

git add .
git commit -m "mensagem"
git pull
git push

⚠️ 14. Problemas comuns e soluções rápidas

1. Push rejeitado

git pull --rebase origin main

2. Conflicts

Abra os arquivos, resolva, depois:

git add .
git commit

3. Autenticação falha

Configure chave SSH
Ou faça login no GitHub CLI

📚 15. Cheatsheet (comandos principais do Git)

📌 Configuração

git config --global user.name
git config --global user.email

📌 Inicialização

git init

📌 Status e logs

git status
git log --oneline

📌 Staging e commit

git add arquivo
git add .
git commit -m "mensagem"

📌 Branches

git branch
git checkout -b nova-branch
git switch main

📌 Merge & Rebase

git merge nome-branch
git rebase main

📌 Sincronização com o remoto

git remote -v
git push
git pull

📌 Clonar repositório

git clone url

recursion

Emanoel Carvalho — Sun, 16 Mar 2025 19:42:54 +0000

Comunicação Assíncrona e Síncrona

Emanoel Carvalho — Fri, 06 Dec 2024 00:24:58 +0000

A comunicação entre sistemas ou componentes de software pode ser classificada em dois tipos principais: comunicação síncrona e comunicação assíncrona. A escolha entre uma ou outra depende das necessidades do sistema, como desempenho, complexidade e tolerância a falhas. Vamos entender cada tipo de comunicação com mais detalhes.

Comunicação Síncrona

Na comunicação síncrona, as partes envolvidas (geralmente um cliente e um servidor, ou dois processos) devem esperar a resposta uma da outra para continuar. Ou seja, a comunicação acontece de maneira "bloqueante", onde uma parte deve esperar que a outra conclua sua tarefa antes de seguir adiante.

Características da Comunicação Síncrona

Bloqueio: O processo que faz uma requisição deve aguardar até que o processo receptor retorne uma resposta antes de continuar sua execução.
Exemplo de Comunicação: Em uma aplicação cliente-servidor, quando o cliente faz uma solicitação de dados ao servidor, ele aguarda a resposta antes de seguir com o restante do processo.
Fluxo de Execução: O processo solicitante envia uma requisição e bloqueia sua execução até que a resposta seja recebida.

Vantagens

Simples de Implementar: A lógica de implementação é direta, já que o processo solicitante simplesmente espera a resposta do processo receptor.
Determinismo: A ordem das operações é mais previsível, o que pode ser benéfico em certos cenários, como em transações financeiras ou sistemas críticos.

Desvantagens

Ineficiente para Tarefas Lentas: Se a comunicação depende de um processo demorado, como uma requisição a um banco de dados ou a um serviço externo, o sistema pode ficar inativo enquanto aguarda a resposta.
Escalabilidade Limitada: Em sistemas de alta carga, o bloqueio pode afetar negativamente a performance, já que muitos processos podem estar esperando por respostas.

Exemplos de Comunicação Síncrona

Chamada de Funções/Procedimentos: Em programação, quando um método A chama um método B e aguarda o retorno de B antes de continuar a execução.
Protocolos HTTP/HTTPS: Quando um cliente (navegador, por exemplo) faz uma requisição ao servidor e aguarda uma resposta antes de renderizar a página.

Comunicação Assíncrona

A comunicação assíncrona é caracterizada pela independência entre os processos que se comunicam. Nessa abordagem, o processo solicitante envia uma requisição, mas não aguarda a resposta imediatamente. Ele pode continuar a execução enquanto espera que o processo receptor finalize a tarefa e envie a resposta.

Características da Comunicação Assíncrona

Não-Bloqueante: O processo solicitante não é bloqueado enquanto aguarda a resposta. Ele pode continuar com outras operações e, eventualmente, receber a resposta quando ela estiver pronta.
Exemplo de Comunicação: Em um sistema de filas de mensagens, um processo coloca uma mensagem em uma fila e outro processo a consome mais tarde. O primeiro processo não precisa esperar a conclusão do segundo.
Desacoplamento: Os processos envolvidos na comunicação assíncrona não precisam estar diretamente sincronizados no tempo, o que permite maior flexibilidade e robustez.

Vantagens

Desempenho: Como os processos não ficam esperando uns aos outros, a comunicação assíncrona pode ser muito mais eficiente, especialmente em sistemas distribuídos ou de alta concorrência.
Escalabilidade: A comunicação assíncrona tende a ser mais escalável, pois permite que múltiplos processos ou threads sejam gerenciados simultaneamente sem bloqueios.
Resiliência: Em sistemas assíncronos, as falhas em um componente não afetam diretamente o fluxo do sistema, já que as tarefas podem ser reprocessadas ou tratadas de maneira independente.

Desvantagens

Complexidade: A implementação de comunicação assíncrona geralmente envolve o uso de filas de mensagens, callbacks ou eventos, o que pode tornar o sistema mais complexo e difícil de debugar.
Latência de Resposta: Como não há garantia de que a resposta será imediata, o sistema pode não ser adequado para casos em que é necessária uma resposta rápida.
Gerenciamento de Estado: A comunicação assíncrona pode envolver o gerenciamento de estados entre os diferentes processos, o que pode ser desafiador, especialmente quando há falhas ou tentativas de reprocessamento.

Exemplos de Comunicação Assíncrona

Mensageria: Sistemas que utilizam filas de mensagens, como o RabbitMQ ou o Kafka, onde os produtores enviam mensagens para a fila e os consumidores processam essas mensagens de forma assíncrona.
Webhooks: Um serviço pode enviar uma notificação a outro serviço sem esperar uma resposta imediata, permitindo que o receptor trate a solicitação quando estiver pronto.
Eventos e Callbacks: Em JavaScript, a programação assíncrona é frequentemente usada com funções de callback ou Promises, onde as operações assíncronas são feitas, mas o código continua a ser executado sem esperar pela conclusão dessas operações.

Comparação entre Comunicação Síncrona e Assíncrona

Aspecto	Comunicação Síncrona	Comunicação Assíncrona
Bloqueio	Bloqueante, aguarda a resposta antes de continuar	Não-bloqueante, pode continuar a execução
Complexidade	Simples de implementar e entender	Mais complexa, envolve callbacks ou filas de mensagens
Escalabilidade	Pode ser limitada, especialmente em sistemas de alta carga	Mais escalável, pois permite maior concorrência
Desempenho	Pode ser ineficiente em processos lentos	Melhor desempenho em sistemas distribuídos
Exemplos	Chamada de métodos, protocolos HTTP	Fila de mensagens, webhooks, eventos assíncronos

Conclusão

A escolha entre comunicação síncrona e assíncrona depende dos requisitos do sistema. A comunicação síncrona é adequada quando se precisa de respostas imediatas e a ordem das operações é importante, mas pode ser ineficiente em sistemas altamente concorrentes. Já a comunicação assíncrona é ideal para sistemas escaláveis e resilientes, especialmente quando as operações podem ocorrer em paralelo ou quando não há necessidade de uma resposta imediata.

🛠️ Processos na Engenharia de Software

Emanoel Carvalho — Sun, 01 Dec 2024 20:54:45 +0000

Na minha faculdade estamos tendo uma cadeira de engenharia de Software nesse período, e o assunto desta semana, foi processos, algo que achei interessante de se expor aqui para vocês, é um resumo simples, mas explica de uma maneira rápida e superficial o que seria um processo na nossa área de desenvolvimento e sim, programação não é só código rsrs <3.

📖 O que é um Processo de Software?

Um processo de software é um conjunto estruturado de atividades necessárias para o desenvolvimento de um software. Ele define como o trabalho será conduzido e os produtos gerados em cada etapa.

🔑 Principais objetivos:

Organização e controle das atividades.
Qualidade do produto final.
Redução de riscos no desenvolvimento.

📂 Fases de um Processo de Software

Especificação: Definição dos requisitos e funcionalidades.
Projeto: Criação da arquitetura e design do software.
Implementação: Codificação e desenvolvimento.
Validação: Testes e garantia de qualidade.
Manutenção: Correções e atualizações após a entrega.

🚀 Modelos de Processos de Software

1. Modelo Cascata 🌊

Linear e sequencial.
As fases acontecem em ordem, sem voltar atrás.
Exemplo de fases: Requisitos → Design → Codificação → Testes → Manutenção.

Vantagens: Simples e fácil de entender.

Desvantagens: Pouca flexibilidade.

2. Modelo Incremental 📈

O software é desenvolvido em partes (ou incrementos).
Cada incremento adiciona funcionalidades ao sistema.

Vantagens: Entregas parciais e contínuas.

Desvantagens: Requer bom planejamento.

3. Modelo Espiral 🔄

Iterativo, com foco em análise de riscos.
Cada ciclo aborda riscos e aprimora o produto.

Vantagens: Bom para projetos complexos.

Desvantagens: Custo elevado.

4. Modelo Ágil ⚡

Focado em entregas rápidas e adaptação contínua.
Exemplo: Scrum, Kanban.

Vantagens: Flexível e colaborativo.

Desvantagens: Pode ser difícil de gerenciar para projetos grandes.

📊 Práticas Ágeis Comuns

Daily Standup: Reuniões diárias curtas para alinhamento.
Sprint Planning: Planejamento de tarefas para um período curto (sprint).
Retrospectiva: Revisão do que funcionou e o que pode melhorar.

🧩 Ferramentas para Gerenciar Processos

JIRA: Gestão de projetos ágeis.
Trello: Quadro de tarefas baseado em Kanban.
Git: Controle de versão.

🔍 Importância de um Processo Bem Definido

Melhora a previsibilidade do projeto.
Aumenta a qualidade do produto.
Reduz riscos e atrasos.

Associação entre Classes ou Objetos em Java

Emanoel Carvalho — Thu, 14 Nov 2024 01:31:45 +0000

Na programação orientada a objetos (POO), a associação entre classes ou objetos é um relacionamento onde um objeto de uma classe se refere a outro objeto de outra classe. Essa associação pode ser simples ou complexa e pode ser representada de diversas maneiras. Três tipos principais de associação são usados para modelar o relacionamento entre objetos:

Composição
Agregação
Multiplicidade

1. Composição (Composição Forte)

A composição é um tipo de associação mais forte, onde um objeto "parte" de outro objeto. Se o objeto "pai" for destruído, seus objetos "filhos" também serão destruídos. Em outras palavras, o ciclo de vida dos objetos componentes depende do ciclo de vida do objeto que os contém.

Características da Composição:

Relacionamento forte: O objeto "pai" contém o objeto "filho" e controla seu ciclo de vida.
Destruição: Quando o objeto "pai" é destruído, o objeto "filho" também é destruído.
Exemplo: Uma casa e seus cômodos. Se a casa for destruída, os cômodos também serão destruídos, pois não existem independentemente.

Exemplo de Composição:

class Cômodo {
    private String nome;

    Cômodo(String nome) {
        this.nome = nome;
    }

    public String getNome() {
        return nome;
    }
}

class Casa {
    private Cômodo cozinha;
    private Cômodo sala;
    private Cômodo quarto;

    // Construtor que cria os cômodos como parte da casa
    Casa() {
        this.cozinha = new Cômodo("Cozinha");
        this.sala = new Cômodo("Sala");
        this.quarto = new Cômodo("Quarto");
    }

    public void mostrarCômodos() {
        System.out.println("Cômodos da casa: ");
        System.out.println(cozinha.getNome());
        System.out.println(sala.getNome());
        System.out.println(quarto.getNome());
    }

    // A Casa destrói automaticamente seus Cômodos quando a Casa é destruída.
}

public class TesteComposicao {
    public static void main(String[] args) {
        Casa casa = new Casa();
        casa.mostrarCômodos();
        // Se a casa for destruída, os cômodos também seriam.
    }
}

Explicação:

A Casa tem instâncias de Cômodo. No exemplo acima, quando a instância de Casa for destruída, os Cômodos (cozinha, sala, quarto) também seriam destruídos, pois são componentes da Casa e não existem independentemente.
A relação entre Casa e Cômodo é uma composição forte.

2. Agregação (Composição Fraca)

A agregação é uma forma de associação mais fraca em que o objeto "pai" pode conter objetos "filhos", mas esses objetos podem existir independentemente do "pai". Ou seja, se o objeto "pai" for destruído, os objetos "filhos" podem continuar existindo.

Características da Agregação:

Relacionamento mais fraco: O objeto "pai" contém o objeto "filho", mas não é responsável por seu ciclo de vida.
Existência independente: Os objetos "filhos" podem existir sem o objeto "pai".
Exemplo: Um departamento e seus funcionários. O departamento pode existir sem os funcionários, e os funcionários podem existir sem o departamento.

Exemplo de Agregação:

class Funcionario {
    private String nome;

    Funcionario(String nome) {
        this.nome = nome;
    }

    public String getNome() {
        return nome;
    }
}

class Departamento {
    private String nome;
    private Funcionario funcionario;

    Departamento(String nome, Funcionario funcionario) {
        this.nome = nome;
        this.funcionario = funcionario;
    }

    public void exibirInformacoes() {
        System.out.println("Departamento: " + nome);
        System.out.println("Funcionario: " + funcionario.getNome());
    }

    // Mesmo que o Departamento seja destruído, o Funcionário pode continuar existindo.
}

public class TesteAgregacao {
    public static void main(String[] args) {
        Funcionario funcionario = new Funcionario("Maria");
        Departamento departamento = new Departamento("RH", funcionario);
        departamento.exibirInformacoes();
        // O Departamento pode ser destruído, mas o Funcionário ainda existe.
    }
}

Explicação:

A agregação é uma associação mais fraca entre Departamento e Funcionario. Mesmo que o Departamento seja destruído, o Funcionario pode continuar existindo, já que ele é uma entidade independente.
A relação entre Departamento e Funcionario é uma agregação.

3. Multiplicidade

A multiplicidade descreve quantas instâncias de uma classe podem estar associadas a uma instância de outra classe. Ela indica o número de objetos que podem estar relacionados entre si.

Tipos de Multiplicidade:

1:1: Um objeto de uma classe está relacionado a exatamente um objeto de outra classe.
1:N: Um objeto de uma classe pode estar relacionado a vários objetos de outra classe (um para muitos).
N:M: Vários objetos de uma classe podem estar relacionados a vários objetos de outra classe (muitos para muitos).

Exemplo de Multiplicidade 1:N:

class Autor {
    private String nome;

    Autor(String nome) {
        this.nome = nome;
    }

    public String getNome() {
        return nome;
    }
}

class Livro {
    private String titulo;
    private Autor autor; // Um autor para muitos livros

    Livro(String titulo, Autor autor) {
        this.titulo = titulo;
        this.autor = autor;
    }

    public void exibirInformacoes() {
        System.out.println("Livro: " + titulo);
        System.out.println("Autor: " + autor.getNome());
    }
}

public class TesteMultiplicidade {
    public static void main(String[] args) {
        Autor autor = new Autor("J.K. Rowling");
        Livro livro1 = new Livro("Harry Potter e a Pedra Filosofal", autor);
        Livro livro2 = new Livro("Harry Potter e a Câmara Secreta", autor);

        livro1.exibirInformacoes();
        livro2.exibirInformacoes();
        // Um autor pode escrever vários livros, mas cada livro tem exatamente um autor.
    }
}

Explicação:

A relação entre Autor e Livro é de 1:N. Um Autor pode escrever vários Livros, mas cada Livro tem exatamente um Autor.
Este tipo de associação é um exemplo de multiplicidade 1:N.

Exemplo de Multiplicidade N:M:

class Estudante {
    private String nome;

    Estudante(String nome) {
        this.nome = nome;
    }

    public String getNome() {
        return nome;
    }
}

class Curso {
    private String nome;
    private List<Estudante> estudantes = new ArrayList<>();

    Curso(String nome) {
        this.nome = nome;
    }

    public void adicionarEstudante(Estudante estudante) {
        estudantes.add(estudante);
    }

    public void exibirInformacoes() {
        System.out.println("Curso: " + nome);
        for (Estudante estudante : estudantes) {
            System.out.println("Estudante: " + estudante.getNome());
        }
    }
}

public class TesteMultiplicidadeNM {
    public static void main(String[] args) {
        Estudante estudante1 = new Estudante("Ana");
        Estudante estudante2 = new Estudante("Carlos");

        Curso curso = new Curso("Matemática");
        curso.adicionarEstudante(estudante1);
        curso.adicionarEstudante(estudante2);

        curso.exibirInformacoes();
        // Muitos estudantes podem estar matriculados em muitos cursos.
    }
}

Explicação:

A relação entre Estudante e Curso é de N:M. Muitos Estudantes podem estar matriculados em muitos Cursos, e um Curso pode ter muitos Estudantes.
A multiplicidade N:M implica que o relacionamento é mais complexo, e frequentemente exigirá uma classe intermediária (como uma tabela de relacionamento em banco de dados).

Conclusão

Composição: Relacionamento forte, onde o ciclo de vida do objeto "filho" depende do objeto "pai". Se o objeto "pai" for destruído, o objeto "filho" também será.
Agregação: Relacionamento mais fraco, onde o objeto "pai" pode conter objetos "filhos", mas esses objetos podem existir independentemente.
Multiplicidade: Refere-se à quantidade de objetos de uma classe que podem ser associados a objetos de outra classe. Pode ser 1:1, 1:N, ou N:M.

Classe e Instância de Objetos em Java

Emanoel Carvalho — Thu, 14 Nov 2024 01:31:22 +0000

Em Java, uma classe é um modelo ou um template para a criação de objetos. Ela define as propriedades (atributos) e comportamentos (métodos) de um objeto. Já uma instância de objeto é a criação de um objeto a partir de uma classe. Em termos simples, a classe é o "plano de construção", e a instância é o "objeto construído".

Exemplo de Classe e Instância

class Carro {
    String modelo;
    String cor;

    // Método (Comportamento)
    void ligar() {
        System.out.println("O carro " + modelo + " está ligado.");
    }
}

public class TesteCarro {
    public static void main(String[] args) {
        // Criando instâncias de objetos da classe Carro
        Carro carro1 = new Carro();
        carro1.modelo = "Fusca";
        carro1.cor = "Azul";

        Carro carro2 = new Carro();
        carro2.modelo = "Civic";
        carro2.cor = "Preto";

        // Chamando o método
        carro1.ligar();
        carro2.ligar();
    }
}

No exemplo acima, Carro é a classe e carro1 e carro2 são instâncias de objetos criadas a partir dessa classe.

A Importância do Construtor em Java

O construtor é um tipo especial de método usado para inicializar objetos quando eles são criados. Ele tem o mesmo nome da classe e não retorna nada (nem mesmo void). O construtor é chamado automaticamente quando um objeto é instanciado.

Tipos de Construtores em Java

Construtor Implícito (ou Padrão):
- Quando não definimos explicitamente um construtor, o Java cria um construtor padrão para a classe, que não possui parâmetros e simplesmente inicializa os atributos com valores padrão (como null, 0, false).

#### Exemplo de Construtor Implícito:

   class Carro {
       String modelo;
       String cor;

       // Construtor implícito gerado automaticamente pelo Java
       // Inicializa modelo e cor com os valores padrão (null)
   }

   public class TesteCarro {
       public static void main(String[] args) {
           Carro carro = new Carro(); // Construtor implícito chamado
           System.out.println("Modelo: " + carro.modelo); // null
           System.out.println("Cor: " + carro.cor); // null
       }
   }

Construtor Explícito (ou Parametrizado):
- O construtor explícito é definido pelo programador e pode ter parâmetros. Ele permite a inicialização dos atributos do objeto no momento da criação de sua instância.

#### Exemplo de Construtor Explícito:

   class Carro {
       String modelo;
       String cor;

       // Construtor explícito com parâmetros
       Carro(String modelo, String cor) {
           this.modelo = modelo;
           this.cor = cor;
       }
   }

   public class TesteCarro {
       public static void main(String[] args) {
           // Utilizando o construtor explícito para inicializar o objeto
           Carro carro = new Carro("Fusca", "Azul");
           System.out.println("Modelo: " + carro.modelo); // Fusca
           System.out.println("Cor: " + carro.cor); // Azul
       }
   }

Por que o Construtor é Importante?

Inicialização de Objetos: O construtor é essencial para inicializar corretamente os atributos de um objeto assim que ele é criado. Sem um construtor, o objeto seria criado com valores padrões que, muitas vezes, não são adequados ao contexto da aplicação.
Definição de Dependências: Se uma classe depende de outras classes (relacionamentos entre objetos), o construtor é o local ideal para configurar essas dependências. O construtor garante que todos os objetos necessários para o funcionamento correto do objeto principal sejam fornecidos no momento da criação.

Importância do Construtor no Setup de Objetos e Definição de Dependências

Setup de Objetos

O setup de objetos refere-se ao processo de configurar corretamente um objeto no momento em que ele é criado. Isso pode envolver a inicialização de variáveis, a configuração de estados internos ou a execução de outras operações essenciais.

Quando temos um construtor explícito, podemos garantir que a instância de um objeto será configurada corretamente desde o início, sem a necessidade de configurá-lo manualmente após a criação.

Exemplo de Setup de Objeto:

class ContaBancaria {
    String titular;
    double saldo;

    // Construtor para definir o titular e saldo inicial
    ContaBancaria(String titular, double saldoInicial) {
        this.titular = titular;
        this.saldo = saldoInicial;
    }

    void exibirSaldo() {
        System.out.println("Titular: " + titular);
        System.out.println("Saldo: R$ " + saldo);
    }
}

public class TesteContaBancaria {
    public static void main(String[] args) {
        // Criando uma conta bancária com setup imediato
        ContaBancaria conta = new ContaBancaria("Maria", 1500.0);
        conta.exibirSaldo(); // Exibe as informações configuradas pelo construtor
    }
}

Nesse exemplo, o construtor configura o titular e o saldo da conta bancária assim que o objeto é criado, sem a necessidade de chamadas adicionais de métodos após a criação.

Definição de Dependências

Em sistemas mais complexos, um objeto pode depender de outros objetos para funcionar corretamente. O construtor é o local ideal para injetar essas dependências.

Exemplo de Definição de Dependências:

Imagine um sistema de gerenciamento de pedidos onde um objeto Pedido depende de um objeto Produto. Podemos definir essa dependência através do construtor.

class Produto {
    String nome;
    double preco;

    Produto(String nome, double preco) {
        this.nome = nome;
        this.preco = preco;
    }
}

class Pedido {
    Produto produto;
    int quantidade;

    // Construtor do Pedido recebe um Produto como dependência
    Pedido(Produto produto, int quantidade) {
        this.produto = produto;
        this.quantidade = quantidade;
    }

    void exibirPedido() {
        System.out.println("Produto: " + produto.nome);
        System.out.println("Quantidade: " + quantidade);
        System.out.println("Preço Total: R$ " + (produto.preco * quantidade));
    }
}

public class TestePedido {
    public static void main(String[] args) {
        // Criando um produto
        Produto produto = new Produto("Smartphone", 1200.00);

        // Criando um pedido, injetando o produto como dependência
        Pedido pedido = new Pedido(produto, 2);
        pedido.exibirPedido();
    }
}

No exemplo acima, a classe Pedido tem uma dependência da classe Produto. O construtor de Pedido recebe o Produto como parâmetro, garantindo que o pedido seja sempre criado com um produto válido.

Conclusão

O construtor é uma parte fundamental da criação e configuração de objetos em Java. Ele permite:

A inicialização de atributos de maneira adequada.
O setup correto de objetos, evitando erros de configuração.
A definição de dependências entre objetos, o que é especialmente importante em sistemas mais complexos.

A distinção entre construtores implícitos e explícitos também é importante, pois permite o controle total sobre o processo de criação e configuração dos objetos, fornecendo mais flexibilidade e controle sobre como as instâncias são geradas.

Propriedades e Comportamento de Objetos em Java

Emanoel Carvalho — Thu, 14 Nov 2024 01:30:26 +0000

Em programação orientada a objetos (POO), o conceito de propriedades e comportamentos é essencial para entender como objetos são modelados e manipulados. As propriedades de um objeto definem seu estado, enquanto os comportamentos são as ações que ele pode realizar.

1. Propriedades (Estado do Objeto)

As propriedades de um objeto, ou atributos (também chamados de campos ou variáveis de instância), são características que representam o estado do objeto. O estado é a combinação dos valores atribuídos aos atributos, e esse estado pode variar ao longo da execução do programa.

Exemplo de Propriedades (Estado de um Objeto):

public class Carro {
    // Atributos (propriedades) do objeto
    String modelo;
    String cor;
    int ano;
    double velocidadeAtual;

    // Método para acelerar
    void acelerar() {
        velocidadeAtual += 10;
        System.out.println("Acelerando... Velocidade atual: " + velocidadeAtual + " km/h");
    }

    // Método para parar
    void parar() {
        velocidadeAtual = 0;
        System.out.println("O carro parou.");
    }
}

Explicação:

Propriedades/Estado: O estado do objeto carro é definido pelos atributos modelo, cor, ano e velocidadeAtual. Esses atributos mantêm informações sobre o objeto, como o modelo do carro, sua cor, o ano de fabricação e a velocidade atual.
Métodos/Comportamento: Os métodos acelerar e parar são comportamentos que alteram o estado do objeto, modificando o valor de velocidadeAtual.

2. Comportamento de Objetos (Métodos)

Em Java, os métodos são funções associadas a uma classe ou objeto e são responsáveis por definir o comportamento de um objeto. Eles permitem que o objeto interaja com seu estado ou com outros objetos, realizando ações ou retornando valores.

Métodos de Instância e Estáticos

Existem dois tipos de métodos em Java:

Métodos de Instância: São métodos que operam sobre os atributos de uma instância específica da classe (ou seja, de um objeto). Eles precisam de uma instância do objeto para serem chamados.
```
public class Calculadora {
    // Método de instância
    int somar(int a, int b) {
        return a + b;
    }
}
```
Métodos Estáticos: São métodos que pertencem à classe e não a uma instância específica. Eles podem ser chamados sem a necessidade de criar um objeto da classe. Métodos estáticos operam apenas em variáveis estáticas da classe, ou seja, variáveis que são compartilhadas por todas as instâncias da classe.
```
public class Calculadora {
    // Método estático
    static int somarEstatica(int a, int b) {
        return a + b;
    }
}
```

Exemplo de Métodos e Comportamento:

public class ContaBancaria {
    // Propriedades (estado)
    String titular;
    double saldo;

    // Construtor
    ContaBancaria(String titular, double saldoInicial) {
        this.titular = titular;
        this.saldo = saldoInicial;
    }

    // Método para depositar dinheiro
    void depositar(double valor) {
        if (valor > 0) {
            saldo += valor;
            System.out.println("Depósito de R$ " + valor + " realizado. Saldo atual: R$ " + saldo);
        } else {
            System.out.println("Valor de depósito inválido.");
        }
    }

    // Método para sacar dinheiro
    void sacar(double valor) {
        if (valor <= saldo) {
            saldo -= valor;
            System.out.println("Saque de R$ " + valor + " realizado. Saldo atual: R$ " + saldo);
        } else {
            System.out.println("Saldo insuficiente.");
        }
    }

    // Método para exibir saldo
    void exibirSaldo() {
        System.out.println("Saldo da conta de " + titular + ": R$ " + saldo);
    }
}

Explicação:

Métodos de Instância: depositar, sacar e exibirSaldo são métodos de instância, que alteram ou acessam os atributos específicos de cada objeto da classe ContaBancaria.
Método Estático: O método somarEstatica poderia ser chamado sem a criação de um objeto Calculadora, utilizando apenas a classe, por exemplo, Calculadora.somarEstatica(2, 3).

3. A Relação entre Estado e Comportamento

O estado de um objeto é alterado pelos comportamentos definidos por seus métodos. Esses métodos podem modificar diretamente os atributos do objeto, ou seja, o comportamento de um objeto influencia diretamente seu estado.

4. JavaScript também é Orientado a Objetos

Embora JavaScript seja uma linguagem multiparadigma, ela também suporta o paradigma orientado a objetos. Isso significa que, assim como em Java, podemos definir objetos com propriedades e comportamentos. No entanto, em JavaScript, a criação de objetos e a definição de métodos podem ser feitas de maneira mais flexível.

Em JavaScript, a orientação a objetos é implementada de maneira baseada em protótipos, ao invés de classes, como em Java. No entanto, desde a introdução das classes em ES6, JavaScript permite uma sintaxe mais similar à de linguagens orientadas a objetos clássicas.

Exemplo em JavaScript:

class Carro {
    constructor(modelo, cor, ano) {
        this.modelo = modelo;
        this.cor = cor;
        this.ano = ano;
        this.velocidadeAtual = 0;
    }

    acelerar() {
        this.velocidadeAtual += 10;
        console.log(`Acelerando... Velocidade atual: ${this.velocidadeAtual} km/h`);
    }

    parar() {
        this.velocidadeAtual = 0;
        console.log("O carro parou.");
    }
}

let carro = new Carro('Fusca', 'Azul', 1980);
carro.acelerar();
carro.parar();

Neste exemplo, o comportamento de um objeto Carro é definido pelos métodos acelerar e parar, que alteram o estado do objeto (velocidadeAtual).

5. Encapsulamento

Em Java, o conceito de encapsulamento envolve esconder os detalhes internos de implementação de um objeto, permitindo acesso aos seus atributos apenas por meio de métodos públicos. Isso é feito com o uso de modificadores de acesso, como private, protected e public, que controlam a visibilidade e a modificação dos atributos.

Exemplo de Encapsulamento:

public class Carro {
    private String modelo;
    private String cor;
    private int ano;

    public String getModelo() {
        return modelo;
    }

    public void setModelo(String modelo) {
        this.modelo = modelo;
    }

    void acelerar() {
        System.out.println("Acelerando o " + modelo);
    }
}

Aqui, os atributos modelo, cor e ano estão encapsulados com o modificador private, o que significa que não podem ser acessados diretamente fora da classe Carro. A modificação do atributo modelo deve ser feita através do método setModelo.

Para mais detalhes sobre modificadores de acesso e encapsulamento, consulte este artigo sobre modificadores de acesso explicará de uma maneira mais elaborada sobre este pilar da orientação a objetos.

Conclusão

Propriedades (Estado): São os atributos de um objeto, que definem as características e condições do objeto.
Comportamento (Métodos): São as ações que um objeto pode realizar. Métodos de instância operam sobre o estado do objeto, enquanto métodos estáticos pertencem à classe e não a uma instância específica.
Encapsulamento: É a prática de restringir o acesso aos atributos de um objeto, permitindo que a manipulação de seu estado seja feita de forma controlada.

Objetos Mutáveis e Imutáveis em Java

Emanoel Carvalho — Thu, 14 Nov 2024 01:29:36 +0000

Em Java, a mutabilidade de um objeto está relacionada à capacidade de alterar o seu estado (valores dos atributos) após a sua criação. Objetos mutáveis podem ter seus estados alterados ao longo do tempo, enquanto objetos imutáveis têm um estado fixo que não pode ser alterado depois que o objeto é criado.

1. Objetos Mutáveis

Objetos mutáveis são aqueles cujo estado (valores dos atributos) pode ser modificado após sua criação. Isso significa que, depois de criar um objeto mutável, você pode modificar seus atributos diretamente, ou por meio de métodos, se a classe permitir.

Exemplo de Objeto Mutável:

class Carro {
    // Atributos mutáveis
    String modelo;
    String cor;
    int ano;
    double velocidadeAtual;

    // Construtor para inicializar o objeto
    Carro(String modelo, String cor, int ano) {
        this.modelo = modelo;
        this.cor = cor;
        this.ano = ano;
        this.velocidadeAtual = 0; // Inicializando a velocidade
    }

    // Método para acelerar
    void acelerar() {
        velocidadeAtual += 10;
        System.out.println("Acelerando... Velocidade atual: " + velocidadeAtual + " km/h");
    }

    // Método para mudar a cor
    void mudarCor(String novaCor) {
        cor = novaCor;
        System.out.println("A nova cor do carro é: " + cor);
    }
}

public class TesteCarroMutavel {
    public static void main(String[] args) {
        // Criando um objeto mutável
        Carro carro = new Carro("Fusca", "Azul", 1980);

        // Exibindo estado inicial
        System.out.println("Cor inicial do carro: " + carro.cor);

        // Alterando o estado do objeto
        carro.acelerar();
        carro.mudarCor("Vermelho");  // Mudando o estado (atributo) do objeto
    }
}

Explicação:

Objeto Mutável: O objeto carro é mutável porque seus atributos, como cor e velocidadeAtual, podem ser alterados depois de sua criação. O método mudarCor permite alterar o valor do atributo cor, e o método acelerar modifica o atributo velocidadeAtual.
Alterações no Estado: O estado do objeto pode ser modificado diretamente após a criação, refletindo o comportamento mutável.

2. Objetos Imutáveis

Objetos imutáveis são aqueles cujo estado não pode ser alterado depois de sua criação. Uma vez que os valores dos atributos são definidos, não é possível modificá-los diretamente ou por meio de métodos. Objetos imutáveis são frequentemente usados para garantir a segurança e a integridade dos dados, já que o estado do objeto não pode ser alterado de forma inesperada.

Exemplo de Objeto Imutável:

final class CarroImutavel {
    // Atributos imutáveis
    private final String modelo;
    private final String cor;
    private final int ano;

    // Construtor para inicializar o objeto
    CarroImutavel(String modelo, String cor, int ano) {
        this.modelo = modelo;
        this.cor = cor;
        this.ano = ano;
    }

    // Métodos getters para acessar os valores (sem setters)
    public String getModelo() {
        return modelo;
    }

    public String getCor() {
        return cor;
    }

    public int getAno() {
        return ano;
    }
}

public class TesteCarroImutavel {
    public static void main(String[] args) {
        // Criando um objeto imutável
        CarroImutavel carro = new CarroImutavel("Fusca", "Azul", 1980);

        // Exibindo os valores dos atributos
        System.out.println("Modelo do carro: " + carro.getModelo());
        System.out.println("Cor do carro: " + carro.getCor());
        System.out.println("Ano do carro: " + carro.getAno());

        // Não podemos alterar os atributos diretamente
        // carro.cor = "Vermelho";  // Erro: atributo final
    }
}

Explicação:

Objeto Imutável: O objeto carro é imutável porque seus atributos são declarados como final e não há métodos que permitem modificá-los após a criação do objeto. Uma vez que o objeto é construído, seus valores são fixos.
Segurança e Integridade: O uso de atributos final e a ausência de métodos modificadores (setters) garantem que o estado do objeto não seja alterado. Isso é especialmente útil quando você precisa de segurança em relação ao estado de objetos compartilhados em sistemas concorrentes ou quando deseja garantir que certos dados não sejam modificados.

3. Diferenças Entre Objetos Mutáveis e Imutáveis

Objetos Mutáveis

Estado: O estado do objeto pode ser alterado após a criação.
Uso: Útil quando você precisa modificar o estado de um objeto ao longo do tempo, como em uma conta bancária ou em um jogo, onde o estado de um objeto (como a posição de um jogador ou o saldo de uma conta) muda frequentemente.
Exemplo: A classe Carro do exemplo acima é mutável, já que podemos mudar a cor e a velocidade do carro após a criação.

Objetos Imutáveis

Estado: O estado do objeto não pode ser alterado depois de sua criação.
Uso: Útil quando você deseja garantir que o estado do objeto seja seguro, consistente e não seja alterado acidentalmente. Isso é importante, por exemplo, em sistemas financeiros ou em dados compartilhados entre múltiplas threads.
Exemplo: A classe CarroImutavel no exemplo acima é imutável, já que não podemos modificar o modelo, a cor ou o ano do carro após sua criação.

4. Vantagens de Usar Objetos Imutáveis

Segurança: Objetos imutáveis são naturalmente mais seguros, pois seu estado não pode ser alterado por outras partes do programa.
Concorrência: Eles são mais seguros em sistemas multithreaded, já que não há risco de mudanças inesperadas no estado do objeto por diferentes threads ao mesmo tempo.
Previsibilidade: Como o estado do objeto não muda, você pode ter uma maior certeza sobre os valores que o objeto possui, o que torna o comportamento mais previsível.

Exemplo de Classe Imutável Usando a Classe `String`:

A classe String em Java é um exemplo clássico de objeto imutável. Depois de uma String ser criada, seu valor não pode ser alterado.

public class ExemploString {
    public static void main(String[] args) {
        String texto = "Olá";
        System.out.println("Texto original: " + texto);

        // Tentando modificar o texto (não é possível)
        texto = texto.concat(", Mundo!"); // Cria um novo objeto String
        System.out.println("Texto modificado: " + texto); // A string original "Olá" não foi modificada
    }
}

Explicação:

A classe String é imutável em Java. No exemplo acima, quando tentamos adicionar ", Mundo!" ao texto original, o método concat cria uma nova string com o valor concatenado, mas o objeto original texto não é alterado.

Conclusão

Objetos Mutáveis: São objetos cujo estado pode ser alterado após sua criação. Eles são úteis em situações em que o estado de um objeto precisa mudar ao longo do tempo, mas podem ser propensos a erros em sistemas complexos, especialmente quando o estado pode ser alterado de forma inesperada.
Objetos Imutáveis: São objetos cujo estado é definido uma vez no momento da criação e não pode ser alterado. Eles são úteis para garantir segurança, consistência e previsibilidade, especialmente em ambientes concorrentes ou quando a integridade dos dados precisa ser protegida.
O uso de objetos imutáveis pode aumentar a segurança e reduzir a complexidade do código, enquanto objetos mutáveis oferecem maior flexibilidade quando as mudanças de estado são necessárias.

Compreender quando usar objetos mutáveis ou imutáveis é uma habilidade importante para criar sistemas mais seguros e eficientes.

Entendendo Variáveis por Valor e por Referência em Java

Emanoel Carvalho — Fri, 08 Nov 2024 23:49:50 +0000

Em Java, entender como as variáveis são passadas para os métodos é crucial para escrever código eficiente e evitar bugs. A linguagem utiliza dois conceitos principais para manipulação de variáveis: passagem por valor e passagem por referência. Além disso, a forma como objetos são comparados, instanciados e manipulados também desempenha um papel importante na compreensão dos comportamentos de variáveis e objetos. Neste artigo, vamos abordar esses conceitos de forma detalhada e explorar aspectos adicionais, como comparação de objetos, implementação de equals e hashCode, além de diferenças no comportamento de tipos imutáveis como String e Integer.

Passagem por Valor

Em Java, passagem por valor significa que o valor da variável é copiado para o parâmetro do método. Esse comportamento ocorre com tipos primitivos (como int, float, boolean, etc.), onde qualquer modificação do parâmetro dentro do método não afeta a variável original.

Exemplo de Passagem por Valor

public class PassagemPorValor {
    public static void main(String[] args) {
        int x = 10;
        System.out.println("Antes: " + x);
        modificarValor(x);
        System.out.println("Depois: " + x);
    }

    public static void modificarValor(int a) {
        a = 20;
    }
}

Saída:

Antes: 10
Depois: 10

Neste exemplo, x é passado para o método modificarValor(), mas, como x é um tipo primitivo, a modificação de a dentro do método não altera o valor de x fora dele.

Passagem por Referência

Ao contrário da passagem por valor, a passagem por referência ocorre com objetos. Quando você passa uma variável de objeto para um método, o que é realmente passado é a referência para o objeto, não o objeto em si. Isso significa que, se o objeto for modificado dentro do método, a alteração será refletida fora dele, pois ambos os locais (o original e o parâmetro) estão apontando para o mesmo objeto na memória.

Em Java, a passagem por referência ocorre com tipos não primitivos, como instâncias de classes, arrays e outros objetos.

Exemplo de Passagem por Referência

import java.util.ArrayList;

public class PassagemPorReferencia {
    public static void main(String[] args) {
        ArrayList<Integer> lista = new ArrayList<>();
        lista.add(10);
        System.out.println("Antes: " + lista);
        modificarLista(lista);
        System.out.println("Depois: " + lista);
    }

    public static void modificarLista(ArrayList<Integer> list) {
        list.add(20);
    }
}

Saída:

Antes: [10]
Depois: [10, 20]

Neste exemplo, a variável lista é passada para o método modificarLista(). Como lista é um objeto, a modificação do conteúdo do objeto dentro do método afeta a lista original.

Comparação de Objetos: `==` vs `equals()`

Quando comparamos objetos em Java, é importante entender como a comparação é realizada. A comparação de objetos pode ser feita de duas maneiras:

Usando o operador ==: Este operador compara se duas variáveis de objetos referenciam o mesmo local de memória, ou seja, se são o mesmo objeto.
Usando o método equals(): O método equals() compara o conteúdo de dois objetos, ou seja, se os dois objetos são equivalentes em termos de estado (não necessariamente o mesmo objeto na memória).

Exemplo de Comparação de Objetos com `==` e `equals()`

public class ComparacaoObjetos {
    public static void main(String[] args) {
        String a = new String("Hello");
        String b = new String("Hello");

        System.out.println(a == b); // false - compara se são o mesmo objeto
        System.out.println(a.equals(b)); // true - compara o conteúdo dos objetos
    }
}

Saída:

false
true

Neste exemplo, a == b retorna false porque os objetos a e b não são o mesmo objeto na memória, embora seus conteúdos sejam iguais. Por outro lado, a.equals(b) retorna true, porque o método equals() verifica a equivalência do conteúdo das strings.

A Implementação de `equals()` e `hashCode()`

Quando se trabalha com objetos em Java, especialmente em coleções como HashMap ou HashSet, é fundamental que as classes implementem corretamente os métodos equals() e hashCode(). O contrato entre esses métodos estipula que:

Se dois objetos são considerados iguais pelo método equals(), eles devem ter o mesmo valor de hashCode().
Se dois objetos têm o mesmo hashCode(), isso não implica que sejam iguais, mas se forem iguais, terão o mesmo hashCode().

Exemplo de Implementação de `equals()` e `hashCode()`

import java.util.Objects;

public class Pessoa {
    private String nome;
    private int idade;

    public Pessoa(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Pessoa pessoa = (Pessoa) obj;
        return idade == pessoa.idade && Objects.equals(nome, pessoa.nome);
    }

    @Override
    public int hashCode() {
        return Objects.hash(nome, idade);
    }
}

Comparação de Strings e Tipos Imutáveis

Em Java, tipos como String e Integer são imutáveis. Isso significa que, uma vez que um objeto desse tipo é criado, seu estado não pode ser alterado. Isso tem um impacto direto na forma como esses objetos são manipulados e comparados.

String Pool: Quando você cria uma string em Java, usando uma atribuição simples como String a = "Hello";, ela é armazenada em uma área especial da memória chamada String Pool. Isso significa que se outra string "Hello" for criada, a variável irá referenciar o mesmo objeto de string, economizando memória.
Instanciação de String e Integer sem Construtor: Em Java, as classes String e Integer não utilizam construtores diretamente para instanciar objetos. A razão disso é que o Java tem mecanismos especiais (como o String Pool para String e o cache de valores para Integer) que ajudam a otimizar a criação e a comparação de objetos dessas classes.

Exemplo de String Pool

public class StringPool {
    public static void main(String[] args) {
        String a = "Hello";
        String b = "Hello";
        System.out.println(a == b); // true - ambos apontam para o mesmo objeto no String Pool
    }
}

Considerações Finais sobre Passagem de Variáveis

Em Java, a diferença entre passagem por valor e passagem por referência pode ter um impacto significativo no comportamento do seu código, especialmente ao lidar com objetos mutáveis e imutáveis. Compreender como a referência de objetos funciona e como comparar objetos corretamente usando == e equals() ajudará você a evitar erros sutis e a escrever código mais eficiente e previsível.

Além disso, a compreensão das classes imutáveis, como String, e o funcionamento do String Pool são essenciais para otimizar o uso de memória e melhorar a performance de seu código.