Linguagens Orientadas a Objetos (Parte I)

Caio Argolo
Luiz Daud
Jorge Roberto
•
•
•
•
O que é abstração?
Empresa x Academia
Vamos abstrair?
Quais atributos importantes em cada contexto?
• Quais são os processos?
• Quando vieram os dados?
•
•
•
•
•
Como facilitar a vida de um programador?
A modularização (processos, containers, módulos
E quando a coisa é muito grande?
As unidades de compilação!
O grande trunfo do escalonamento!!!
• É um encapsulamento que inclui somente a representação dos
dados de um tipo específico de dado e os subprogramas
relacionados a ele.
• Cuma?
• Classes e objetos!
• E assim surgiu a orientação a objetos!
•
•
•
•
E ele é um dado abstrato?
E quem aceita ele?
O que fazemos com ele?
A revelação!
• As unidades sintáticas.
• Iteradores – Permissão de acesso a todos os dados do objeto
de forma segura (Get e Set);
• Construtores – Permissão de criação de uma instância do objeto
respeitando normas internas do tipo de dado abstrato.
• Destrutores – Indicadores de descarte de instâncias.
•
•
•
•
Abstração de dados!
Encapsulamento!
Garbage collection!
Ocultação da informação.
•
•
•
•
•
•
Abstração de dados!
Encapsulamento!
Garbage collection!
Ocultação da informação.
Tipos de dados (private, limited private)
Acesso e modificação!
•
•
•
•
•
•
Simula
Smalltalk
O que define se o paradigma é orientação a objetos?
Tipos de dados abstratos
Herança
Vinculação dinâmica
•
•
•
•
•
•
•
•
•
Aumentando a produtividade
Estabelecimento de um padrão
A coexistência de tipos de dados semelhantes
Vamos criar então as subclassses!
Classe pai = Superclasse
Classe filho = Subclasse
E esses tais métodos?
E essas tais mensagens?
Que história é essa de sobrecarga?
• Classe FrenchGothic que tem um método com o estilo de
fachada.
• Suas subclasses terão particularidades nesse método de estilo,
cada uma com seus toques especiais.
• Então as subclasses Reims, Amien e Chartres terão métodos
diferentes da classe pai.
• Jamais limite a liberdade oferecida pela utilização de dados
abstratos.
• Fique atento a hierarquização para não causar dependência!
• Herança simples - Há somente uma classe pai
• Herança múltipla - Há várias classes pai C++ & Python
• O curioso caso do Java!
• Mas desde quando interfaces são classes?
• São pseudo-classes, definem um tipo, métodos e propriedades.
As classes que
implementarem essa interface deverão
adquirir também seus métodos. Não podemos
restringir
acesso aos membros da interface, isso só é possível nas classes
nas quais elas
forem implementadas.
• São classes que podem possuir métodos ou propriedades não
implementados quanto alguns já implementados. É o meio
termo entre interfaces e classes. Não podem ser instanciadas,
apenas utilizadas como superclasses. Durante gerações de
herança os métodos podem ou não ser implementados, mas a
classe só deixará de ser abstrata quando estiver com todos os
métodos implementados.
•
•
•
•
•
•
Classes diferentes
Métodos de mesmo nome
Reutilizando os métodos!
E as classes abstratas?
A economia de tempo!
Pode-se comparar a orientação a objetos a uma sinulação
onde a computação é separada entre diferentes
computadores. Cada objeto seria um computador que
representa um
elemento do mundo real, com suas
características, métodos e afins.
• public class OperacaoMatematica {
•
calculaCoisa(float a, float b) {
•
}
•
}
•
•
public class Multiplica extends OperacaoMatematica{
•
calculaCoisa(float a, float b){
•
return a*b;
•
}
•
}
•
•
public class Soma extends OperacaoMatematica{
•
calculaCoisa(float a, float b){
•
return a+b;
•
}
•
}
• Quando nos referimos a vinculação dos métodos aos objetos
através das mensagens, a vinculação será dinâmica. Caso o
programador opte por vincular estaticamente, estará ganhando
tempo de execução em troca de tempo de produção.
3.1 – Suporte em C++
• 3.1 – Suporte em C++
• 3.1.1 – Características Gerais:
• Compatibilidade quase completa com C original.
• Linguagem Híbrida:
• Estrutura de Classes da orientação a objetos.
• Tipos das linguagens imperativas tradicionais.
•
•
•
•
Objetos alocados no mesmo lugar que as variáveis.
Toda classe tem um método construtor.
A maioria das definições de classe incluem um método destrutor.
Fornece controle de acesso sobre variáveis e métodos, diferentemente
do SmallTalk.
• 3.1 – Suporte em C++
• 3.1.2 – Herança.
• Um classe pode ser derivada de outra.
• Diferente do SmallTalk um classe do C++ pode ser independente de
um Superclasse
• Alguns ou todos os dados e funções da Superclasse podem ser
herdados pelas subclasses.
• A acessibilidade aos membros da subclasses podem ser diferentes da
classe “Pai”.
• Assim que as classes do C++ podem ser impedidas de serem subtipos.
• O modo de acesso a uma classe pode ser public ou private.
• 3.1 – Suporte em C++
• 3.1.2 – Herança.
• Se uma classe Pai é pública e uma classe filha é pública.
• Os métodos públicos e protegidos da Pai serão públicos e protegidos na
filha.
• Em uma classe derivada privada.
• Os membros públicos e protegidos da classe básica são privados.
• A classe privada derivada interrompe o acesso a todos os membros de todas as
classes ancestrais e suas sucessoras e os protegidos podem ou não ser acessíveis
às classes subsequentes.
• 3.1 – Suporte em C++
• 3.1.3 – Vinculação Dinâmica.
• Numa vinculação estática, uma chamada de função é vinculada
estaticamente a uma definição de função.
• No C++ uma variável ponteiro ou referência que tenha como tipo
uma classe pai pode apontar para objetos de qualquer classe filha.
• Para chamar uma função da classe filha a partir de uma dessas
variáveis utiliza-se a palavra virtual na declaração da função.
3.1 – Suporte em C++
3.1.3 – Vinculação
Dinâmica.
• 3.1 – Suporte em C++
• 3.1.3 – Vinculação Dinâmica.
• A função da classe pai não deve ter corpo pois será uma função
virtual pura.
• Apenas as funções das derivadas terão corpo pois serão chamadas
dinamicamente a partir da referencia feita pela classe pai
• Uma classe que inclui uma função virtual pura é uma classe abstrata e
não pode ser instanciada.
• Esse recurso permite alterações ou adições na função desenhar das
classes filhas sem grandes alterações de código.
• 3.1 – Suporte em C++
• 3.1.4 – Avaliação.
• A herança do C++ é mais confusa que a do SmallTalk
• No C++ o programador deve especificar a vinculação estática ou
dinâmica
• A verificação estática de tipos do C++ é muito mais eficiente que
dinâmica do SmallTalk
• SmallTalk preza pela elegância enquanto C++ pela
retrocomptibilidade com o C e desempenho.
• C++ chegou a ser 10 vezes mais rápida que o SmallTalk em
benchmarks.
3.2 – Suporte em Java
• 3.2 – Suporte em Java
• 3.2.1 – Características gerais.
• Não utiliza apenas objetos
• Tipos primitivos não são objetos
•
•
•
•
•
•
Não possui tipos enumeração ou registro.
Arrays são objetos.
As classes sempre tem um pai ao contrario do C++
Todas as classes derivam da classe object ou de alguma filha dela.
Todos os objetos em java são heap-dinâmicos explícitos.
Utiliza coletor de lixo.
• 3.2 – Suporte em Java
• 3.2.2 – Herança.
• Diretamente Java suporta apenas herança simples.
• Existe uma um tipo de classe virtual, a interface, que implementa uma espécie de
herança múltipla.
• Interfaces definem apenas a especificação de uma classe.
• Um classe pode herdar de uma classe pai e implementar um interface.
• Um exemplo de herança são os Applets.
• Quando um applet implementa uma animação é normalmente definida para rodar em
seu próprio Thread.
• Porém uma classe não pode herdar de Applet e Thread ao mesmo tempo
• Por isso utiliza-se a interface predefinida Runnable.
• Public class Clock extends Applet implementes Runnable.
• No java um método pode ser declarado como final, assim ele não pode ser
sobrescrito em nenhuma classe descendente.
• Quando um classe é declarada final em sua definição ela não pode ser pai de
nenhuma classe.
• 3.2 – Suporte em Java
• 3.2.3 – Vinculação Dinâmica.
• Todas as chamadas de métodos são Vinculadas dinamicamente.
• Métodos declarados como final não podem ser sobrescritos por isso
possuem vinculação estática.
• Diferente do C++ que é preciso declarar um método como virtual
para utilizar vinculação dinâmica.
• Aqui a vinculação estática precisa de declaração.
• 3.2 – Suporte em Java
• 3.2.4 – Encapsulamento.
• Dois tipos Classes e Pacotes
• Pacotes são um Encapsulamento lógico.
• Um pacote cria um novo nome de espaço.
• Variáveis sem modificador de acesso tem um escopo de pocte.
• Todos os métodos e variáveis privados não declarados são visíveis em
todo o pacote no qual são declarados
• Ampliação do conceito de protegido do C++
• Alternativa aos amigos no C++
• 3.2 – Suporte em Java
• 3.2.5 – Avaliação.
• Projeto similar ao C++
• Mas tem diferenças
•
•
•
•
Ausência de funções.
Não permite classes sem pais.
Vinculação dinâmica é normal
Controles de acesso simplificados, Variando de controles de derivação a
funções amigas.
3.3 – Suporte em ADA 95
• 3.3 – Suporte em ADA 95
• 3.3.1 – Características gerais.
• Derivada do ADA 83, mas com extensões significativas.
• Projetada para suportar orientação o objetos.
• ADA 83 já possuía suporte a tipos abstratos.
• Implementaram apenas suporte a vinculação dinâmica e herança.
• Tinha o objetivo de mudar o mínimo no ADA 83
• E manter a verificação de tipos estática.
• Classes como uma nova categoria, tipos marcados.
• Esses tipos podem ser registros ou tipos privados.
• São encapsulados em pacotes que permitem compilação separada.
• OS tipos são chamados marcados porque incluem implicitamente uma tag.
• O subprograma que define as operações em um tipo-marcado aparece
na mesma lista da declaração que a do tipo.
3.3 – Suporte em ADA 95
3.3.1 – Características
gerais.
• 3.3 – Suporte em ADA 95
• 3.3.2 – Herança.
• Os tipos derivados baseiam-se em tipos marcados.
• Novas entidades são adicionadas às herdadas incluindo uma
definição de registro.
• Essa nova classe é definida em um pacote separado, para não exigir
a recompilarão do tipo-pai.
• Por esse mecanismo de herança não existe nenhuma maneira de
impedir que as entidades da classe-pai sejam incluídas na derivada.
• Classes derivadas podem somente estender classes-pai, e portanto
são subtipos.
• 3.3 – Suporte em ADA 95
• 3.3.3 – Vinculação Dinâmica.
• Oferece tanto vinculação dinâmica quanto estática.
• A vinculação dinâmica é forçada utilizando tipos de classe ampla.
• Três tipos básicos puramente abstratos podem ser definidos no ADA
95.
• Basta declarar como abstract nas definições de tipos
• As definições de subprogramas não podem ter corpos.
• 3.3 – Suporte em ADA 95
• 3.3.4 – Avaliação.
• Não é possível comparar ADA 95 com C++, baseando apenas no que foi
apresentado.
• Elas são muito diferentes.
• Porém as classes C++ tem seu próprio sistemas de tipos usual herdado do
C
• C++ oferece melhor suporte a herança múltipla.
• ADA não inclui suporte a construtores e destrutores.
• ADA não restringe a vinculação dinâmica apenas a ponteiros e
referências. E sim aos próprios objetos.
3.4 – Considerações Finais
• 3.4 – Considerações Finais
• A programação Orientada a a objetos inclui três conceitos fundamentais:
• Tipos de dados abstratos.
• Herança.
• Vinculação Dinâmica.
• Paradigma suportado com:
• Classes
• Métodos
• Objetos
• Passagem de mensagens
• Alguma linguagens são Puramente OO (SmallTalk)
• Outras Híbridas (C++)
• E outras controversas (Java)