AULA 01 MÓDULO 1 fundamentos java ⏱ 50 min

Do Procedural ao OO

Entenda por que o paradigma OO nasceu, o que a JVM faz por você e como a mesma funcionalidade fica mais segura e manutenível em uma classe Java.

paradigma OOJVMJDKIntelliJencapsulamentoprocedural

O problema do código procedural

Você já sabe programar — funções, arrays, laços. Mas quando o sistema cresce, o código procedural começa a mostrar rachaduras. Funções com 200 linhas, variáveis globais que ninguém sabe quem modificou, copiar e colar para "reutilizar".

💥
cenário real
Um sistema de cadastro de alunos em C: 500 linhas no main. Adicionar um novo campo em Aluno quebra 12 funções diferentes. O paradigma OO existe para resolver exatamente isso.
1
Lógica espalhada — funções sem dono, qualquer parte do código acessa qualquer dado
2
Acoplamento máximo — mudar uma função quebra outras — sem fronteiras claras
3
Reuso por cópia — precisa de algo parecido? Copia e cola e reza
4
Nenhum contrato — quem garante que aluno.nota nunca seja -50?

Histórico e contexto

O paradigma orientado a objetos nasceu na década de 60 com Simula 67, popularizou-se com Smalltalk nos anos 70 e chegou ao mainstream com C++ e Java.

por que Java?
Java foi criada em 1995 pela Sun Microsystems com o lema 'Write Once, Run Anywhere'. A JVM (Java Virtual Machine) interpreta o bytecode em qualquer plataforma. Hoje é a linguagem base de sistemas bancários, Android e grandes enterprises.

JVM, JRE, JDK — o que instalar

JDK (Java Development Kit) — Tudo que você precisa para DESENVOLVER. Inclui compilador (javac), JRE e ferramentas de debug.
JRE (Java Runtime Environment) — Para RODAR programas Java. Inclui a JVM. Usuário final instala o JRE.
JVM (Java Virtual Machine) — Executa o bytecode .class. HotSpot + JIT compilation: Java compila em código nativo na primeira execução — não é lento.
💡
IntelliJ IDEA
IDE mais usada para Java profissional. Community Edition é gratuita. Atalhos essenciais: Ctrl+Shift+F10 (rodar), Ctrl+/ (comentar), Alt+Insert (gerar getters), Shift+F6 (renomear).
java
// Do procedural ao OO — a mesma funcionalidade, dois paradigmas

// ANTES: Procedural — tudo no main, sem fronteiras
// String[] nomes = new String[100];
// double[] notas = new double[100];
// notas[0] = -50; // Java aceita. Problema silencioso.

// DEPOIS: Orientado a Objetos — classe como unidade coesa
public class Aluno {
    // Estado encapsulado — ninguém acessa diretamente
    private String nome;
    private double nota;

    // Construtor — objeto nasce em estado válido
    public Aluno(String nome, double nota) {
        this.nome = nome;
        setNota(nota); // usa setter com validação
    }

    public void setNota(double nota) {
        if (nota < 0 || nota > 10)
            throw new IllegalArgumentException("Nota deve ser entre 0 e 10");
        this.nota = nota;
    }

    public String toString() {
        return "Aluno{" + nome + ", nota=" + nota + "}";
    }
}

// Main — limpo, sem detalhes de implementação
public class Main {
    public static void main(String[] args) {
        Aluno a = new Aluno("Ana", 8.5);
        System.out.println(a); // Aluno{Ana, nota=8.5}
        // a.setNota(-50); → lança exceção imediatamente
    }
}
quiz · aula 01
Teste seus conhecimentos em Java
0/3 respondidas
QUESTÃO 01
No paradigma procedural, qual é o principal problema quando o sistema cresce?
QUESTÃO 02
O que é a JVM?
QUESTÃO 03
Por que usar setter com validação em vez de atribuição direta?
0/3