Orientação a Objetos em Java (ARQINOO)

Roteiro da Aula

• Bloco 1: Membros Estáticos (static)
• Bloco 2: Constantes (final) e static final
• Bloco 3: Associação e Agregação de Objetos
• Bloco 4: Composição de Objetos + Exercício Integrador

Bloco 1 — Membros Estáticos

• Ideia: pertencem à classe, não à instância.
• Atributos estáticos: único valor compartilhado entre todos os objetos.
• Métodos estáticos: chamados via Classe.metodo(); não acessam estado de instância.
• Exemplos: Math.sqrt, contadores globais, fábricas simples.

Exemplo: contador de instâncias

public class Contador {
    private static int totalObjetos = 0; // compartilhado

    public Contador(){
        totalObjetos++; // incrementa a cada novo objeto
    }

    public static int getTotalObjetos(){
        return totalObjetos; // acesso estático
    }
}

public class Main {
    public static void main(String[] args) {
        new Contador();
        new Contador();
        System.out.println("Objetos criados: " + Contador.getTotalObjetos());
    }
}

Exemplo: utilitários estáticos

public class Matematica {
    public static int soma(int a, int b) { return a + b; }
    public static double media(double... valores) {
        double s = 0; for(double v: valores) s += v; return s/valores.length;
    }
}

int r1 = Matematica.soma(3,4);          // Classe.metodo
double m = Matematica.media(7.0, 8.5);   // sem instanciar

Prática (10–15 min)

1. Crie a classe Aluno com nome e um campo static totalAlunos.
2. Incremente o total no construtor.
3. No main, crie 3 alunos e imprima Aluno.getTotalAlunos().

Bloco 2 — Constantes e final

• final em variável ⇒ valor imutável após a atribuição.
• final em método ⇒ não pode ser sobrescrito.
• final em classe ⇒ não pode ser herdada.
• static final ⇒ constante de classe (nome em MAIÚSCULAS_COM_UNDERSCORE).

final em variável (primitivo)

Em tipos primitivos, final torna o valor imutável após a primeira atribuição.

    //Final.java//
    public class Final {
        final int porta = 8080;
        
        public void tentaAlterarFinal(){
            //this.porta++;
        }
    }

    ///////////////////////
    //App.java//
    public class App {
        public static void main(String[] args) throws Exception {
            Final f = new Final();
            System.out.println(f.porta);
            //f.porta++;
        }
    }

Exemplo: constante de classe

public class Circulo {
    public static final double PI = 3.141592653589793;
    private double raio;

    public Circulo(double raio) { this.raio = raio; }
    public double area() { return PI * raio * raio; }
}

Prática (10–15 min)

1. Crie ConversorMoeda com public static final double TAXA_DOLAR = 5.25.
2. Método realParaDolar(double) e um main de teste.
3. Altere para receber a taxa no construtor e discuta prós/contras.

Bloco 3 — Associação × Agregação

Exemplo: Associação

class Carro {
    private final String modelo;
    public Carro(String modelo) { this.modelo = modelo; }
    public String getModelo() { return modelo; }
}

class Motorista {
    private final String nome;
    public Motorista(String nome) { this.nome = nome; }

    // associação simples: o motorista usa um Carro passado por parâmetro (não o "possui")
    public void dirigir(Carro c) {
        System.out.println(nome + " está dirigindo o " + c.getModelo());
    }
}

Exemplo: Associação

public class Ex1Associacao {
    public static void main(String[] args) {
        Carro carro = new Carro("Sedan X");
        Motorista motorista = new Motorista("Alice");
        motorista.dirigir(carro); // vínculo momentâneo/uso
    }
}

Exemplo: Agregação

        
            import java.util.ArrayList;
            import java.util.List;
            
            class Livro {
                private final String titulo;
                public Livro(String titulo) { this.titulo = titulo; }
                public String getTitulo() { return titulo; }
            }
            
            class Biblioteca {
                private final String nome;
                private final List acervo; // agregação: "todo/parte" fraca
            
                public Biblioteca(String nome) {
                    this.nome = nome;
                    this.acervo = new ArrayList<>(); // inicializa a lista concreta
                }
            
                // recebe livros criados fora (ciclo de vida independente)
                public void adicionarLivro(Livro livro) { acervo.add(livro); }
            
                public void listar() {
                    System.out.println("Acervo da biblioteca " + nome + ":");
                    for (Livro l : acervo) System.out.println("- " + l.getTitulo());
                }
            }

        
    

Exemplo: Agregação

        
            

    public class Ex2Agregacao {
        public static void main(String[] args) {
            // livros existem independentemente
            Livro l1 = new Livro("POO em Java");
            Livro l2 = new Livro("Estruturas de Dados");
    
            Biblioteca b = new Biblioteca("Central");
            b.adicionarLivro(l1);
            b.adicionarLivro(l2);
    
            b.listar();
            // Mesmo se a biblioteca 'sumir', l1 e l2 ainda fazem sentido (agregação).
        }
    }

        
    

Prática (10–15 min)

1. Implemente Professor que pertence a um Departamento (associação).
2. Implemente Turma que agrega vários Alunos (agregação).
3. No main, componha os objetos e imprima um resumo.

Bloco 4 — Composição

• Relação “tem-um” forte: parte não existe sem o todo.
• O todo é responsável pelo ciclo de vida das partes.
• Ex.: Carro e seu Motor.

Exemplo: Composição (Carro-Motor)

public class Motor {
    private int potencia;
    public Motor(int potencia){ this.potencia = potencia; }
    public void ligar(){ System.out.println("Motor " + potencia + "cv ligado"); }
}

public class Carro {
    private final Motor motor; // parte essencial
    public Carro(){ this.motor = new Motor(100); } // cria e gerencia
    public void ligar(){ motor.ligar(); System.out.println("Carro ligado!"); }
}

Exemplo: Composição (Computador)

public class Processador { public void iniciar(){ System.out.println("CPU pronta"); } }
public class Memoria { public void carregar(){ System.out.println("Memória ok"); } }

public class Computador {
    private final Processador cpu; // composição
    private final Memoria ram;     // composição
    public Computador(){ this.cpu = new Processador(); this.ram = new Memoria(); }
    public void ligar(){ cpu.iniciar(); ram.carregar(); System.out.println("Computador ligado!"); }
}

Associação × Agregação × Composição

• Associação: uso geral (pode ser temporário).
• Agregação: todo–parte fraco (vida independente).
• Composição: todo–parte forte (vida dependente).

Exercício Integrador (20–25 min)

1. Sistema Biblioteca:
   • Livro com titulo e Autor (associação).
   • Biblioteca compõe várias Estantes (composição).
   • Campo static em Livro para contar total cadastrados.
   • Constantes static final para limites (ex.: MAX_ESTANTES).
2. Imprima um relatório simples (totais e vínculos).

Mini-quiz

1. Método static acessa diretamente atributos de instância? (a) sim (b) não
2. static final define… (a) constante (b) variável mutável
3. Na agregação, as partes… (a) dependem do todo (b) não dependem
4. Na composição, destruir o todo… (a) não afeta partes (b) elimina partes

Mini-quiz — Gabarito

1. (b) não
2. (a) constante
3. (b) não dependem
4. (b) elimina partes

Referências rápidas

• Documentação Java SE
• Guia de convenções de código Java
• Extension Pack for Java (VS Code)

Fechamento

• static para dados/métodos de classe; use com parcimônia.
• final para imutabilidade e contratos (constantes, APIs).
• Escolha entre associação, agregação e composição pelo ciclo de vida.
• Próxima aula: herança, polimorfismo e interfaces.