☕🦠 Java: Parasita do Conhecimento <Fundações que Evoluem seu Cérebro de Dev>

#Java

🧪 1) A invocação: `main()` é o pacto

Pequeno ritual que desperta a JVM dentro de você:

public class Despertar {
  public static void main(String[] args) {
      System.out.println("A simbiose começou.");
  }
}

Por que importa:

Ponto de entrada único.
A JVM olha pra tua main e executa o domínio inicial do programa.

[IDE] -> compila -> [.class bytecode] -> [JVM]
                   ^ JIT/HotSpot otimiza

🧬 2) POO: moldando o parasita (Encapsular → Herdar → Polimorfizar)

🔒 Encapsulamento (controle da mutaçã)

public class Maldicao {
  private int nivel = 1;


  public int getNivel() { return nivel; }
  public void evoluir() { nivel++; } // controla COMO evolui
}

Ideia: esconder estado, expor comportamento.

Você decide como a mutação ocorre.

🧠 Herança & Polimorfismo (formas do parasita)

abstract class Feitico { abstract int custo(); }


class Dominio extends Feitico { @Override int custo() { return 5; } }
class Cortina extends Feitico { @Override int custo() { return 2; } }


public class Batalha {
  static int pagar(Feitico f) { return f.custo(); } // polimorfismo
}

Regra de ouro: prefira interfaces/composição a herança pesada.

Herança é lâmina afiada: útil, mas perigosa.

Feitico (interface/abstrata)
 |------ Dominio
 |------ Cortina

⚔️ 3) Controle de fluxo: instinto de sobrevivência

int energia = 3;
while (energia > 0) {
  System.out.println("Lutando... energia: " + energia--);
}

Boas práticas para sua vida dev :

Use for (var x : lista) para iterar coleções.
Saídas antecipadas clarificam intenção

if (!tokenValido) return; // reduz nesting e ruído visual

🐍 4) Coleções: enxames de dados

List<String> tecnicas = new ArrayList<>();
tecnicas.add("Domínio");
tecnicas.add("Amplificação");


Map<String, Integer> poder = Map.of("Domínio", 9000, "Amplificação", 7000);

Regras que evitam dor:

Prefira interfaces na referência (List, Map).
Use imutabilidade sempre que possível (List.of, Map.of).

List -> ordem, index  
Set  -> unicidade  
Map  -> chave -> valor

💀 5) Exceções: exorcizando maldições

public int lerNivel(String s) {
  try {
      return Integer.parseInt(s);
  } catch (NumberFormatException e) {
      return 1; // fallback sensato
  }
}

Dicas de sobrevivência:

Capture exceções específicas, não Exception.
Logue contexto, não desespero.
Use Optional para ausências válidas, não para exceções.

public Optional<String> buscarTecnica(UUID id) {
  return Optional.ofNullable(repo.findById(id));
}

⚡ 6) Stream API: quando o poder desperta

🔹 6.1O básico — map/filter/reduce

List<Integer> niveis = List.of(1,2,3,4,5);


int somatorio = niveis.stream()
  .filter(n -> n >= 3)
  .map(n -> n * 100)
  .reduce(0, Integer::sum);

🔹 Coleções de entidades

record Feitico(String nome, int custo) {}


List<Feitico> grimorio = List.of(
  new Feitico("Domínio", 5),
  new Feitico("Cortina", 2),
  new Feitico("Amplificação", 4)
);


List<String> caros = grimorio.stream()
  .filter(f -> f.custo() >= 4)
  .sorted(Comparator.comparingInt(Feitico::custo).reversed())
  .map(Feitico::nome)
  .toList();

Evite:

❌ forEach mutando listas externas.
✅ Prefira map e collect.
❌ Streams infinitos sem controle.
✅ Use limit, findFirst, anyMatch.

☠️ 7) Nulos: a maldição favorita da JVM

String tecnica = getTecnicaPossivelmenteNula();
String segura = Objects.requireNonNullElse(tecnica, "Básica");

Disciplina de dev:

Evite null em APIs públicas — use Optional.
Valide entradas na borda (DTOs/controllers).
Habilite ferramentas como SpotBugs ou NullAway.

🚫 8) Erros clássicos de iniciantes (com cura imediata)

Erro	Cura
Misturar lógica e I/O	Separe domínio de infra
Criar getters/setters a rodo	Encapsule comportamento
Coleção errada	Use HashMap p/ busca rápida, TreeMap p/ ordenação
Engolir exceção	Sempre logue causa e contexto

☕ Conclusão: poder em troca de responsabilidade

Java não brilha sozinho.

Ele recompensa disciplina: encapsular, modelar, colecionar, tratar exceções e dominar Streams.

Isso te puxa do caos para o design .

como um bom contrato de simbiose: poder em troca de responsabilidade.

“Domine o básico até ficar entediante. Depois, tudo parecerá avançado.”

🧠 Desafio Final — A simbiose perfeita

Implemente uma estrutura que modele o contrato simbiótico entre o Hospedeiro e o Parasita, onde:

O Parasita evolui com base nas ações do Hospedeiro.
Ambos compartilham energia, mas nunca diretamente (encapsulamento e imutabilidade).
O Hospedeiro pode invocar poderes (métodos) que o Parasita amplifica (polimorfismo + composição).
Nenhuma classe pode expor estado diretamente — apenas comportamento.

interface Poder {
  int amplificar(int energiaBase);
}


final class Parasita implements Poder {
  private final int fator;


  Parasita(int fator) { this.fator = fator; }


  @Override
  public int amplificar(int energiaBase) {
      return energiaBase * fator;
  }
}


final class Hospedeiro {
  private int energia;
  private final Poder simbionte;


  Hospedeiro(int energiaInicial, Poder simbionte) {
      this.energia = energiaInicial;
      this.simbionte = simbionte;
  }


  public void lutar() {
      energia = simbionte.amplificar(energia);
      System.out.println("Energia após fusão: " + energia);
  }
}


public class Simbiose {
  public static void main(String[] args) {
      var hospedeiro = new Hospedeiro(10, new Parasita(3));
      hospedeiro.lutar();
  }
}

Questão para o leitor: