BIZURAL: Programação Orientada a Objetos

· CaioSimioni · Artigos

Neste artigo, reúno um bizu completo de Programação Orientada a Objetos para revisão de prova, cobrindo desde algoritmos e tipos de dados até herança, polimorfismo, encapsulamento e interfaces.

A proposta desse bizu é:

  • revisar os fundamentos de algoritmos e tipos de dados;
  • destacar as principais pegadinhas de prova em cada tópico;
  • organizar os conceitos de POO (classes, herança, polimorfismo, encapsulamento);
  • servir como consulta rápida antes da prova.

1. Algoritmos — concepção e fundamentos

Um algoritmo é um conjunto de passos ordenados, finitos e sem ambiguidade que resolve um único problema. Um problema pode ter vários algoritmos como solução, mas um algoritmo resolve apenas um problema.

Propriedades obrigatórias de um algoritmo:

  • ações simples e bem definidas (sem ambiguidade);
  • sequência ordenada de ações;
  • conjunto finito de passos.

Passos para a solução de um problema (a ordem cai em prova):

  1. entendimento do problema;
  2. criação de uma sequência de passos;
  3. execução dessa sequência;
  4. verificação da adequação da solução.

Formas de representar um algoritmo:

  • descrição narrativa (linguagem natural);
  • fluxograma (símbolos gráficos);
  • pseudocódigo (ex.: ferramenta gratuita VisualG).

Variável é aquela cujo valor pode ser alterado durante a execução, enquanto constante precisa ser inicializada e não pode ter o valor alterado.

declare constante real pi = 3.14

2. Tipos de dados e operadores

Tipo primitivo é o tipo básico, implementado por toda linguagem (int, real, boolean, char). Tipo derivado deriva dos primitivos e tem estrutura mais complexa (String, vetor/array, matriz, classe, enumeração).

Tipos primitivos:

  • Inteiro (int): números inteiros positivos, negativos e nulo. Ex.: 5, -10, 0;
  • Real (float/double): casa decimal com ponto, não vírgula. Ex.: 5.2;
  • Booleano (boolean): só Verdadeiro (V) ou Falso (F);
  • Caractere (char): entre aspas simples. Ex.: 'C', '5', '%'.

String não é primitivo, é derivado: é um conjunto de caracteres. Ex.: "Aluno".

O tipo int vai de -2.147.483.648 até 2.147.483.647. Acima dessa faixa, o número precisa ser declarado como Long.

Três fatores categorizam um tipo de dado: natureza, tamanho (bits) e representação/faixa de valores.

Operadores aritméticos:

+  Adição              -  Subtração
*  Multiplicação       /  Divisão
\  Divisão inteira     ^ ou Exp()  Exponenciação
%  Módulo (resto da divisão)

Essa mesma prioridade da matemática se aplica aqui; parênteses alteram a prioridade.

Operadores relacionais: > < >= <= = <> (diferente). O resultado de uma comparação sempre é um valor lógico (V ou F).

Operadores lógicos — E (multiplicação lógica) só é V se ambas as partes forem V; OU (adição lógica) é V se pelo menos uma parte for V; NÃO (negação) inverte o valor lógico.

V e F = F
V ou F = V
Não V = F

3. Estruturas de controle — seleção e repetição

Quatro tipos de estrutura de seleção (decisão):

  • Simples: Se (condição) Então (bloco);
  • Composta: Se (condição) Então (bloco) Senão (outro bloco);
  • Encadeada: condições uma dentro da outra — para avaliar a mais interna é preciso satisfazer as condições mais externas;
  • Múltipla escolha: Escolha X / Caso V1... / Caso contrário.

While testa a condição antes de executar, então o bloco pode nunca ser executado. Do-While testa a condição depois de executar, então o bloco executa pelo menos uma vez, mesmo que a condição já seja falsa. For é usado quando a repetição é controlada por variável contadora simples (inicialização, condição e atualização cabem numa única linha).

Quando usar cada estrutura (cai como questão de "qual a melhor opção"):

  • While: não precisa inicializar/atualizar contador; o dado da condição vem durante a execução do bloco;
  • Do-While: é preciso executar o bloco ao menos uma vez para obter a informação usada na condição;
  • For: repetição controlada por contador simples e conhecido.

4. Arrays (vetores) e ordenação

Um array é uma Estrutura de Dados, também chamada de Variável Composta Homogênea: composta porque armazena mais de um dado, e homogênea porque todos os dados armazenados são do mesmo tipo.

Um array de uma dimensão é chamado de vetor, e cada elemento é acessado por um único índice. O índice pode começar em 0 ou em 1, conforme a declaração:

vet: vetor [1..10] de real

O Bubble Sort compara elementos adjacentes (vizinhos) e troca se estiverem fora de ordem, repetindo passagens até uma passagem inteira sem nenhuma troca. É simples de implementar, mas lento comparado a outros algoritmos de ordenação — bom só para arrays pequenos.

5. Paradigma orientado a objetos — abstração, classe e objeto

Abstração segue a lógica de "abstrair primeiro, implementar depois": é o processo de identificar só os aspectos relevantes de algo do mundo real, ignorando detalhes desnecessários, para criar um modelo simplificado.

Classe é o modelo/molde genérico e abstrato (a "planta" da entidade). Objeto é a instância concreta da classe, criada por instanciação (aloca memória real).

Exemplo: "Roupa" é a classe; uma camiseta azul, tamanho M, específica é o objeto.

Um objeto possui:

  • estado: valores dos seus atributos;
  • comportamento: métodos que pode executar;
  • interação com outros objetos por troca de mensagens (chamadas de método).

Entidade é um termo genérico: pode ser uma classe, um objeto específico ou um conceito abstrato do domínio do problema.

6. Classe abstrata x classe concreta x interface

Classe abstrata não pode ser instanciada — serve de modelo/base para subclasses; pode ter método abstrato (sem corpo) e método concreto (com corpo); pode ter atributos e construtores. Classe concreta pode ser instanciada diretamente e fornece a implementação completa de todos os métodos herdados.

A comparação mais cobrada em prova é classe abstrata x interface:

  • classe abstrata tem métodos abstratos e métodos concretos; interface só tem métodos abstratos (implicitamente public + abstract) e constantes (implicitamente public static final);
  • classe abstrata tem atributos e construtores; interface não tem atributos comuns nem construtores;
  • classe abstrata usa extends — uma classe só herda de uma classe (herança simples); interface usa implements — uma classe pode implementar várias interfaces;
  • a interface funciona como um contrato: quem implementa é obrigado a implementar todos os métodos declarados.
public interface Vestivel {
    void vestir();
}

7. Pilares da POO — polimorfismo e encapsulamento

Polimorfismo é a capacidade de um objeto assumir múltiplos comportamentos ou ser tratado de formas diferentes. É implementado por herança e sobrescrita de métodos (@Override): um objeto da classe filha pode ser referenciado por uma variável do tipo da classe pai.

Em POO, a decisão de qual implementação de método será chamada acontece em tempo de execução (runtime), com base no tipo real do objeto — e não no tipo declarado da variável:

Roupa r = new Camiseta();
r.exibirDetalhes();
// executa o método de Camiseta, mesmo "r" sendo do tipo Roupa

Encapsulamento protege e oculta os detalhes internos da classe, fornecendo acesso controlado aos membros: os atributos ficam declarados como private, e o acesso acontece via métodos getters (obter valor) e setters (alterar/validar valor). Isso garante a integridade dos dados e permite validação antes de mudar um atributo.

8. Modificadores de acesso e palavras reservadas

Os quatro modificadores de acesso, do mais restritivo ao menos restritivo:

  • private: acesso só dentro da própria classe;
  • default (sem modificador): acesso só dentro do mesmo pacote;
  • protected: mesmo pacote + subclasses (mesmo em pacotes diferentes);
  • public: acessível de qualquer lugar do programa.

Outras palavras reservadas (Java):

  • class — declara uma classe;
  • extends — estabelece herança entre classes (a filha herda da pai);
  • super — acessa elementos da classe pai (ex.: chamar o construtor da classe pai);
  • this — referencia o próprio objeto/instância atual;
  • abstract — declara classe ou método abstrato (sem implementação);
  • @Override — anotação que confirma a sobrescrita de um método herdado da classe pai;
  • final — classe/método que não pode ser estendido/sobrescrito.

static indica que o membro pertence à classe em si, não a uma instância, podendo ser chamado sem criar objeto:

public static void main(String[] args)
// public -> acessível de qualquer lugar
// static -> chamado direto pela JVM, sem precisar instanciar a classe
// void   -> não retorna nenhum valor

9. Herança — especialização x generalização / classe final

Especialização (herança) parte de uma classe genérica e cria classes mais específicas (subclasses), adicionando características próprias. Ex.: Roupa → Camiseta, Calça, Vestido.

Generalização é o processo inverso: abstrai características comuns de várias classes numa única classe base, evitando duplicação de código e promovendo reutilização.

Uma classe final, declarada com a palavra-chave final, não pode ser estendida (não pode ter subclasses) — útil para travar uma lógica/comportamento que não deve ser modificado por outras classes.

10. Classificação de linguagens de programação

Linguagem fortemente tipada exige compatibilidade entre tipos, sem conversão automática, sendo mais segura e evitando erros de tipo. Linguagem fracamente tipada permite conversão/coerção automática entre tipos diferentes, sendo mais flexível, porém mais propensa a erros ocultos.

Linguagem compilada tem o código-fonte traduzido inteiro para código de máquina antes da execução (ex.: C, C++, Go, Rust, Java compila para bytecode). Linguagem interpretada é executada linha por linha, em tempo real, por um interpretador (ex.: Python, JavaScript, Ruby, PHP, Perl).

Java é híbrido: compila para bytecode e a JVM interpreta/executa esse bytecode.

Principais pegadinhas para revisar antes da prova

  • variável muda de valor, constante não;
  • tipo primitivo x derivado — String é derivado, não primitivo;
  • While testa antes (pode não executar), Do-While testa depois (executa ao menos 1 vez);
  • classe abstrata tem atributos, construtores e métodos concretos; interface só tem métodos abstratos e constantes;
  • polimorfismo é resolvido em tempo de execução, pelo tipo real do objeto;
  • ordem dos modificadores de acesso: private < default < protected < public;
  • especialização cria subclasses a partir do geral; generalização faz o caminho inverso.

Conclusão

Esse bizu reúne os pontos que mais caem em prova sobre algoritmos, tipos de dados e Programação Orientada a Objetos, com foco nas comparações que costumam confundir na hora da prova.

Se você está estudando para uma prova de POO, vale revisar principalmente as seções de classe abstrata x interface e polimorfismo, que são as mais cobradas.

<< voltar para Artigos