MODULARIDADE 2021 1 02 tiposAbstratosDados p2

MODULARIDADE
TADs
Roberto da Silva Bigonha

Mariza A. S. Bigonha
Maio de 2021
Todos os direitos reservados

Proibida a cópia sem autorização dos autores
Tipos Abstratos de Dados

q  Uma fase do projeto de um sistema de software compreende a
atividade de identificar as entidades do mundo real da aplicação e
definir seu mapeamento em elementos que vão compor o programa
q  O projeto, portanto é um exercício intelectual que tem por objetivo

transpor a lacuna semântica existente entre os objetos do mundo real,
identificados pela fase análise, e os objetos implementados pelo
computador. Projeto baseado no mapeamento dos dados de entrada
para os de saída.
Aplicação Lacuna Semântico Computador
análise projeto implementação
@Roberto Bigonha, Mariza Bigonha 2021 Tipos Abstratos de Dados 2

Problema de Comunicação
@Roberto S. Bigonha, Mariza Bigonha 2021 Tipos Abstratos de Dados 3
Abstração
q Abstração é um modo de pensar no qual concentra-se
na ideia e não nas manifestações específicas desta
ideia.
q Abstrair-se significa concentrar-se no que o programa

faz e não em como ele faz.
q Abstração é o elemento básico de construção de

módulos.
q Abstração depende dos objetivos de quem se abstrai.
q Por exemplo, a abstração da entidade pessoa depende

de seu uso no sistema.
@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de Dados 4
... Conceito de Abstração
q Abstração depende dos objetivos de quem se abstrai. Por
exemplo, a abstração da entidade pessoa depende de
seu uso no sistema.
§  Uma pessoa sob a perspectiva de um médico:
Pessoa
Cérebro Pressão Coração Rim Pulmão
§  Uma pessoa sob a perspectiva do emprego:
Pessoa
nome cpf estado civil endereço dependentes
@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de 5

Dados
Tipos de Abstração
1. FUNÇÃO:
q  Conjunto encapsulado de declarações e comandos que calcula um valor e
possivelmente causa um efeito colateral no ambiente.
2. PROCEDIMENTO
q  Conjunto encapsulado de declarações e comandos que deve causar um
efeito colateral no ambiente.
3. ABSTRAÇÃO DE DADOS
q  Estrutura de dados definida pelas suas operações
q  Representação encapsulada.
4. TIPO ABSTRATO DE DADOS
q  Tipo definido pelas suas operações.
q  Representação encapsulada.
5. TIPO ABSTRATO DE DADOS PARAMETRIZADO
q  Tipo definido pelas suas operações.
q  Representação parametrizada e encapsulada.
@Roberto S. Bigonha e Mariza 2021 Tipos Abstrato de Dados 6

Gap Semântico
q  Para reduzir a Lacuna Semântica, extensibilidade
de dados é mais efetiva que a de estrutura de
controle
q  Gap semântico é a distância entre os conceitos

que seres humanos conhecem e entendem e os
conceitos que os computadores manipulam
q  Essa nova visão levou a invenção do conceito

Tipo Abstrato de Dados, que valoriza a criação de
tipos apropriados para cada aplicação
@Roberto S. Bigonha e Mariza A. S. Bigonha 2021 Tipos Abstratos de Dados 7
...Lacuna Semântica
q  Problema:
Implementar um programa para ler, somar dois valores
inteiros no intervalo [-32.768, 32.767] e imprimir resultado.
q  Análise:
q  Os valores a serem operados podem ser representados
por 16 bits em forma de complemento de 2.
q  Objetos que devem ser modelados pelo software são
três valores inteiros.
q  Na solução I supõe-se que sua linguagem de
programação possua somente o tipo de dados Boolean,
com as operações and, or e not.
q  Na solução II supõe-se disponível o tipo integer
Gap Semântico: Exemplo
SOLUÇÃO I: Linguagem com apenas booleanos e sem arranjos
program LacunaGrande;
var
x0,x1,x2,x3,x4,x5,x6,x7,x8,x9 ,x10,x11,x12,x13,x14,x15:Boolean;
y0,y1,y2,y3,y4,y5,y6,y7,y8,y9,y10, y11, y12, y13, y14, y15:Boolean;
t0,t1,t2,t3,t4,t5,t6,t7,t8,t9 ,t10, t11, t12, t13, t14, t15 : Boolean;
c : Boolean;
begin
read(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15);
read(y0,y1,y2,y3,y4,y5,y6,y7,y8,y9,y10, y11,y12,y13,y14,y15);
c := false;
… Gap Semântico: Exemplo

SOLUÇÃO I (continuação):
t15 := (not x15) and (not y15) and (c) or (not x15) and (y15) and (not c) or
(x15) and (not y15) and (not c) or (x15) and (y15) and (c);
c := (x15 and y15) or (x15 and c) or (y15 and c);
t14 := (not x14) and (not y14) and (c) or (not x14) and (y14) and (not c)
or (x14) and (not y14) and (not c) or (x14) and (y14) and (c);
t13 := (not x13) and (not y13) and (c) or (not x13) and (y13) and (not c)
c := (x13 and y13) or (x13 and c) or (y13 and c); ..........................

… Gap Semântico: Exemplo
SOLUÇÃO I (continuação):
t1 := (not x1) and (not y1) and (c) or not x1) and (y1) and (not c)
or
(x1) and (not y1) and (not c) or (x1) and (y1) and (c);
t0 :=(not x0) and (not y0) and (c) or (not x0) and (y0) and (not c)
println(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15);
end.
…Gap Semântico: Exemplo

SOLUÇÃO II: Suponha que exista em sua linguagem o tipo integer
com a operação +:
program LacunaPequena;
var x : integer;
y : integer;
t : integer;
begin
read(x);
read(y);
t := x + y;
println(t)
end.
Por que a Solução II é melhor que Solução I?

Tipo Abstrato de Dados
q  Um tipo abstrato de dados é uma classe de estruturas de dados
descritas por uma visão externa:
1. lista de serviços disponíveis

2. propriedades destes serviços
q  A representação das estruturas de dados do ADT ficam

completamente encapsulada
q  A representação das estruturas de dados do ADT não faz parte

de sua definição.
q  O adjetivo abstrato de um tipo abstrato de dados enfatiza o fato

de as estruturas de dados que representam o tipo NÃO fazem
parte da definição, isto é, da interface, do tipo.
EXEMPLOS DE
IMPLEMENTAÇÃO DE
CLASSES TAD

q  Um tipo abstrato de dados compreende a declaração de uma ou
mais estruturas de dados e operações que contribuem para
implementá-lo, e deve ser caracterizado por um único e relevante
contrato público, definido por uma interface clara e explícita
q  Em POO a estrutura mais importante para para implementar um novo

tipo é a classe, que pode usar ou encapsular outras classes, mas deve
implementar apenas um tipo
q  Os métodos de um TAD devem operar sobre seus campos de forma

relevante e significativa, e somente os métodos do seu contrato podem
ser públicos, sendo todos os demais métodos e os campos declarados
privados

q  TADs são um recurso eficiente para reduzir a Lacuna
Semântica. Quanto maior for essa lacuna, mais difícil é a fase
de projeto e implementação de um programa
q  Quanto mais rica em recursos para expressar as necessidades

de uma aplicação for a linguagem de programação usada,
mais facilmente realizam-se as abstrações necessárias
q  Simula 67, Modula 2, C++, Eiffel, Java e Phyton são exemplos

de linguagens projetadas para reduzir o gap semântico
q  Conclui-se que uma notação recomendada para modelar os

objetos que um sistema manipula é fornecida pela teoria de
tipos abstratos de dados
Especificação Algébrica
q  A definição algébrica PilhaDeInt do tipo de pilhas de objetos do tipo Integer:
1. type PilhaDeInt
2. sorts:
3. Integer, Boolean
4. operations:
5. vazia : PilhaDeInt Boolean
6. crie : Integer PilhaDeInt
7. empilhe : ( Integer, PilhaDeInt ) PilhaDeInt
8. desempilhe : PilhaDeInt PilhaDeInt
9. topo : PilhaDeInt Integer
10. preconditions:
11. pre crie( n : Integer ) : ( n > 0)
12. pre desempilhe( s : PilhaDeInt) : ( not vazia( s) )
13. pre topo( s : PilhaDeInt ) : ( not vazia (s ) )
14. axioms:
15. for all n : Integer, x : Integer, s : PilhaDeInt :

17. not vazia( empilhe( x, s ) )

19. desempilhe( empilhe( x, s ) ) = s
20. end
TAD Pilha de Inteiros

Implementação
q Exemplo
1. public interface PilhaDeInt {

2. boolean vazia( );
3. void empilha ( int x ) throws FaltaEspaço;
4. int desempilha ( ) throws FaltaElemento;
5. }
6. public class FaltaEspaço extends Exception { }
7. public class FaltaElemento extends Exception { }
… Implementação
q O mecanismo presente em quase todas as LPs para criar
estruturas de dados mais elaboradas é o de composição
de estruturas menores, formando, recursivamente,
coleções de dados homogêneos ou tuplas de elementos
heterogêneos, conhecidos como fichas de dados.
q Exemplo:
q  1. public class Aluno {

q  2. public String nome;
q  3. public String matrícula;
q  4. public int nota;
q  5. public int frequência;
q  6. }
Uso das classes fichas-de-dados 
Essas classes geralmente são usadas apenas como estruturas de
dados fortemente vinculadas ao TAD do qual fazem parte,
devendo ser declaradas como estáticas e aninhadas nas classes
que implementam o TAD.
Exemplo:
public class Lista {
public static class Info { public String nome, cpf;}
private static class Nodo {
public Info valor;
public Nodo proximo;
public Nodo( Info valor ) { this.valor = valor;}
}
private Nodo cabeça;
public Lista( ) { cabeça = null; }
public void insira( Info valor ) { ... New Nodo( valor ); ... }
public Info retire( ) { Nodo x; ... ; return x.valor; }
}
Outro Exemplo: PilhaSóDeInteiros

1.  public class PilhaSóDeInteiros implements PilhaDeInt {
2.  private int[ ] s;
3.  private int max, topo = -1;
4.  public PilhaSóDeInteiros ( int size ) {
5.  max = ( size < 1 ? 1 : size – 1 );
6.  s = new int[ max + 1 ];
7.  }
8.  public boolean vazia ( ) { topo == -1; }
9.  public void empilhe (int x) throws FaltaEspaço {
10.  if (topo = max) throws new FaltaEspaço ( );
11.  s [++topo] = x;
12.  }
13.  public int desempilhe ( ) throws FaltaElemento {
14.  if ( topo = -1 ) throws new FaltaElemento ( );
15.  return s [ topo-- ];
16.  } }
Um Exemplo Completo
TAD PilhadeInteiros
class PilhaDeInteiros {
private static final int FUNDO = -1;
private int ultimo; private int[ ] item;
private int top = FUNDO;
public static class CS { ... }
public static class ExMax extends Exception { ... }
public static class ExMin extends Exception { ... }
public PilhadeInteiros( int tamanho ) { ... }
public void push( int v ) throws ExMax { ... }
public int pop( ) throws ExMin { ... }
public boolean vazia ( ) { ... }
public static void main( String[ ] args ) { ... }
}
@Roberto S. Bigonha e Mariza 2021 Tipos Abstratos de Dados 23
Constantes Simbólicas de Módulo
public static class CS {

public static final byte ESTOURO=1;
public static final byte EMFALTA=2;
}

Classe de Exceções
public static class ExMax extends Exception {
private byte id;
public ExMax(byte id) { this.id = id; }
public byte tipo( ) { return id; }
}
public static class ExMin extends Exception {

private byte id;
public ExMin(byte id) { this.id = id; }
public byte tipo( ) { return id; }
}
Operações de PilhadeInteiros
public PilhadeInteiros( int tamanho ) {

if ( tamanho < 0 ) tamanho = 0;
ultimo = tamanho -1 ;
item = new int[ tamanho ];
}

Operações de PilhadeInteiros...
public void push( int v ) throws ExMax {
if ( top==ultimo ) throw new ExMax( CS.ESTOURO );
item[++top]= v;
}
public int pop( ) throws ExMin {

if(vazia ( )) throw new ExMin( CS.EMFALTA );
return item[ top-- ];
}
public boolean vazia( ) { return (top == FUNDO)

}
Teste Interno da PilhaDeInteiros

public static void main( String[ ] args ) {
PilhadeInteiros p1 = new PilhaDeInteiros(10),
PilhaDeInteiros p2 = new PilhadeInteiros(50);
PilhaDeInteiros p3 = new PilhaDeInteiros(5);
PrintStream o = o;
o.println( Pilhas de int, + tamanhos 10, 50 e 5 ); o.println( );
try{ o.println( Insere 10 elems em pi: );
for ( int i = 0;i < 10; i++ ) { p1.push(i); o.println( topo de p1 = +p1.top) } }
o.println( );
o.println( Transfere de p1 para p2: );
o.println( topo de p1 = + p1.top + , topo de p2 = + p2.top );
while ( ! p1.vazio( ) ) {
p2.push( p1.pop( ) );
o.println( topo de p1 = + p1.top + , topo de p2 = + p2.top );
}
Teste Interno da PilhaDeInteiros...
o.println( );
o.println( Transfere de p2 para out: );
while (! p2.vazio( )) o.print(p2.pop( ) + );
o.println( ); o.println( );
o.println( Empilha 10 em p3: );
try{ for ( int i = 0;i < 10; i++ ) { p1.push( i ); p3.push( i ); }
catch( ExMax e )
{ o.println( p3:Exceção de pilha + cheia, id = + e.tipo( ) ); }
o.println( ); o.println( Desempilha 10 de p3: );
try { for (int i = 0;i < 10; i++) p3.pop( ); o.println( ); }
catch ( ExMin e )
{o.println( p3: Exceção de pilha + vazia, id = + e.tipo( ) );}
catch (Exception e) { } o.println( Acabou bem );
}
ADT PilhaDeInteiros ...

Pilhas de int, tamanhos 10, 50 e 5
Insere 10 elems em p1: Transfere tudo de p1 para p2:
Topo de p1 = 9, top de p2 = -1
Topo de p1 = 0
Topo de p1 = 8, top de p2 = 0
Topo de p1 = 1
Topo de p1 = 2
Topo de p1 = 3
Topo de p1 = 4
Topo de p1 = 5
Topo de p1 = 6
Topo de p1 = 7
Topo de p1 = 8
Topo de p1 = 9
Topo de p1 = -1, top de p2 = 9
ADT PilhaDeInteiros
Transfere de p2 para out: 0 1 2 3 4 5 6 7 8 9
Empilha 10 em p3:
p3: Exceção de pilha cheia, id = 1
Desempilha 10 de p3:
p3:Exceção de pilha vazia, id = 2
Acabou bem
ADT PilhaDeObjetos
class PilhaDeObjetos1 {
private static final int FUNDO = -1;
private int Ultimo, top = Fundo; private Object[ ] item;
public PilhaDeObjetos1(int MaxTam) {
this.Ultimo = MaxTam -1 ; item = new Object[MaxTam];
}
public void push(Object v) throws Ex_Max {
if (top == Ultimo) throw new Ex_Max(CS.ESTOURO);
item[++top]= v;
}
public Object pop( ) throws Ex_Min {
if(vazio( )) throw new Ex_Min(CS.EMFALTA);
return item[top--];
}
public boolean vazio( ) { return (top == FUNDO) }
}
ADT PilhaDeObjetos
class PilhaDeObjetos2 {
private static class Elemento {
Elemento link; Object info;
Elemento( Object info ) { this.info = info; }
}
private Elemento item; private Elemento topo;
public void push( Object v ) throws ExMax {
try{ Elemento novo = new Elemento( v ); }
catch( Exception e ) { throw new ExMax( Estouro ); }
novo.link = topo; topo = novo;
}
public Object pop( ) throws ExMin {
Object info;
if( vazio( ) ) throw new ExMin(EmFalta);
info = top.info; top = top.link; return info;
}
public boolean vazio( ) { return ( topo == null ); }
}
Tipos Parametrizados
q Em Java, no lugar de se definir a interface PilhaDeInt

específica, pode-se ter a declaração de uma interface
genérica ou parametrizada Pilha<T> com a seguinte
assinatura:
1. public interface Pilha<T> {

2. void empilhe(T v) throws FaltaEspaco;
3. T desempilhe( ) throws FaltaElemento;
4. boolean vazia( );
5. }

... Tipo Parametrizado
q  A especificação algébrica da interface Pilha<T> pode ter a seguinte forma:
1. type Pilha[T]
2. sorts:
3. Integer, Boolean
4. operations:
5. vazia : Pilha[T] Boolean
6. crie : Integer Pilha[T]
7. empilhe : ( T,Pilha[ T ] ) Pilha[T]
8. desempilhe : Pilha[ T ] Pilha[T]
9. topo : Pilha[ T ] T
10. preconditions:
11. pre crie( n : Integer ) : ( n > 0 )
12. pre desempilhe( s : Pilha[ T ] ) : ( not vazia( s ) )
13. pre topo( s : Pilha[ T ] ) : ( not vazia( s ) )
14. axioms:
15. for all n : Integer, x : T, s : Pilha[ T ]:

17. not vazia (empilhe( x, s ) )

19. desempilhe( empilhe( x, s ) ) = s
20. end
Tipos Parametrizados
q  A classe genérica PilhaSequencial<T> implementa o tipo abstrato
Pilha<T> via arranjo, cujo tamanho é definido pelo usuário por meio
de sua função construtora.
public class PilhaSequencial<T> implements Pilha<T> {
private int ultimo, topo = -1;
private T[ ] itens;
public PilhaSequencial( int max ) {
if ( max < 1 ) max = 1;
itens = ( T[ ] ) new Object[ max ];
ultimo = max – 1; }
public void empilhe( T v ) throws FaltaEspaço {
if ( topo == ultimo ) throw FaltaEspaço( );
itens[ ++topo ] = v; }
public T desempilhe() throws FaltaElemento {
if ( vazia( ) ) throw new FaltaElemento();
return itens[topo--]; }
public boolean vazia( ) {
return ( topo == -1 ) ; } }

…Tipos Parametrizados
Qualquer aplicação pode usar o tipo Pilha<T> e sua implementação, a
classe genérica PilhaSequencial<T> para criar uma ou mais pilhas
independentes. Exemplo: cria uma pilha de Integer e outra de Double
1 public class TesteDePilhaSequencial {
2 public static void main(String[ ] args) {
3 Pilha <Integer> p = new PilhaSequencial <Integer> (20);
4 Pilha <Double> q = new PilhaSequencial <Double> (10);
5 int a, x[ ] = { 1, 2, 3, 4, 5, 6 };
6 double b, y[ ] = { 1.0, 2.0, 3.0, 4.0, 5.0 };
7 for( int i : x ) p.empilhe( i );
8 for( double i : y ) q.empilhe( i );
9 System.out.println( “Topo de q =“ + q.desempilhe( ) );
10 System.out.print( “Pilha p:” );
11  while ( !p.vazia( ) ) {
12  a = p.desempilhe( ); System.out.print(“ “ + a );
14 }
15 }
16 }
A separação da interface da implementação facilita a criação
de outra implementação de abstrato Pilha<T> por meio da
classe genérica PilhaEncadeada<T>
1 public class PilhaEncadeada <T> implements Pilha <T> {

2 private static class Elemento <T> {
3 Elemento <T> prox;
4 T info;
5 Elemento( T info ) {
6 this.info = info;
7 }
8 }
9 private Elemento <T> topo;
10 public PilhaEncadeada( ) { ... }

A separação da interface da implementação facilita a criação
de outra implementação de abstrato Pilha<T> por meio da
classe genérica PilhaEncadeada<T>
11 public void empilhe( T v ) throws FaltaEspaco {
12 Elemento <T> novo;
13 try { novo = new Elemento <T> (v); }
14 catch( Exception e ) { throw new FaltaEspaco( ); }
15 novo.prox = topo; topo = novo;
16 }
17 public T desempilhe( ) throws FaltaElemento {
18 T info;
19 if( vazia( ) ) throw new FaltaElemento( );
20 info = topo.info; topo = topo.prox; return info;
21 }
22 public boolean vazia( ) { return ( topo == null ); }
23 }
TesteDePilhas produz o mesmo resultado que
TesteDePilhaSequencial usa o tipo PilhaEncadeada para
implementar a pilha de elementos do tipo Double
1 public class TesteDePilhas {
2 public static void main( String[ ] args ) {
3 Pilha <Integer > p = new PilhaSequencial < Integer > ( 20 );
4 Pilha < Double > q = new PilhaEncadeada < Double > ( 10 );
5 int a, x[ ] = { 1, 2, 3, 4, 5, 6 };
6 double b, y[ ] = { 1.0, 2.0, 3.0, 4.0, 5.0 };
7 for( int i : x ) p.empilhe( i );
8 for( double i : y ) q.empilhe( i );
9 System.out.println( "Topo de q = " + q.desempilhe( ) );
10  System.out.print( "Pilha p:” );
11  while( !p.vazia( ) ) { a = p.desempilhe( ); System.out.print(" " + a); }
12  }
13 }

Conclusão
q A orientação por objetos tem foco na identificação

e implementação dos objetos que compõem um
sistema, e, nesse contexto, os tipos abstratos de
dados são uma ferramenta extremamente
indispensáveis, eles permitem implementação dos
seguintes clássicos conceitos da Engenharia de
Software:
§  Abstração, Modularidade, Encapsulação e controle de

visibilidade e Separação de interesses
@Roberto Bigonha,Mariza Bigonha 2021 Tipos Abstratos de Dados 41
…Conclusão
q Abstração
§  foco no relevante enquanto ignoram-se detalhes de
implementação
q  Modularidade
§  divisão de um problema em subproblemas
independentes
q Encapsulação e controle de visibilidade

§  boas cercas fazem bons vizinhos
q Separação de interesses
§  conceitos relacionados devem ser agrupados em
módulos, evitando seu espalhamento ao longo do
código
@Roberto Bigonha,Mariza Bigonha 2021 Tipos Abstratos de Dados 42
FIM
@Roberto Bigonha, Mariza Bigonha Tipos Abstratos de Dados 43

MODULARIDADE 2021 1 02 tiposAbstratosDados p2

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

MODULARIDADE 2021 1 02 tiposAbstratosDados p2

Enviado por

Direitos autorais:

Formatos disponíveis

MODULARIDADE

Roberto da Silva Bigonha

Todos os direitos reservados

Tipos Abstratos de Dados

q O projeto, portanto é um exercício intelectual que tem por objetivo

Aplicação Lacuna Semântico Computador

análise projeto implementação

@Roberto Bigonha, Mariza Bigonha 2021 Tipos Abstratos de Dados 2

@Roberto S. Bigonha, Mariza Bigonha 2021 Tipos Abstratos de Dados 3

q Abstrair-se significa concentrar-se no que o programa

q Abstração é o elemento básico de construção de

q Por exemplo, a abstração da entidade pessoa depende

Cérebro Pressão Coração Rim Pulmão

§ Uma pessoa sob a perspectiva do emprego:

nome cpf estado civil endereço dependentes

@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de 5

@Roberto S. Bigonha e Mariza 2021 Tipos Abstrato de Dados 6

q Gap semântico é a distância entre os conceitos

q Essa nova visão levou a invenção do conceito

@Roberto S. Bigonha e Mariza A. S. Bigonha 2021 Tipos Abstratos de Dados 7

y0,y1,y2,y3,y4,y5,y6,y7,y8,y9,y10, y11, y12, y13, y14, y15:Boolean;

t0,t1,t2,t3,t4,t5,t6,t7,t8,t9 ,t10, t11, t12, t13, t14, t15 : Boolean;

… Gap Semântico: Exemplo

c := (x15 and y15) or (x15 and c) or (y15 and c);

c := (x14 and y14) or (x14 and c) or (y14 and c);

c := (x13 and y13) or (x13 and c) or (y13 and c); ..........................

c := (x1 and y1) or (x1 and c) or (y1 and c);

…Gap Semântico: Exemplo

Por que a Solução II é melhor que Solução I?

1. lista de serviços disponíveis

q A representação das estruturas de dados do ADT ficam

q A representação das estruturas de dados do ADT não faz parte

q O adjetivo abstrato de um tipo abstrato de dados enfatiza o fato

@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de Dados 14

q Em POO a estrutura mais importante para para implementar um novo

q Os métodos de um TAD devem operar sobre seus campos de forma

@Roberto S. Bigonha e Mariza A. S. Bigonha 2021 Tipos Abstratos de Dados 15

Tipo Abstrato de Dados

q Quanto mais rica em recursos para expressar as necessidades

q Simula 67, Modula 2, C++, Eiffel, Java e Phyton são exemplos

q Conclui-se que uma notação recomendada para modelar os

TAD Pilha de Inteiros

@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de Dados 18

1. public interface PilhaDeInt {

@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de Dados 19

q 1. public class Aluno {

Outro Exemplo: PilhaSóDeInteiros

Constantes Simbólicas de Módulo

public static class CS {

@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de Dados 24

public static class ExMin extends Exception {

public PilhadeInteiros( int tamanho ) {

@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de Dados 26

public int pop( ) throws ExMin {

public boolean vazia( ) { return (top == FUNDO)

Teste Interno da PilhaDeInteiros

@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de Dados 29

ADT PilhaDeInteiros ...

p3: Exceção de pilha cheia, id = 1

p3:Exceção de pilha vazia, id = 2

@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de Dados 31

@Roberto S. Bigonha e Mariza A.S.Bigonha 2021 Tipos Abstratos de Dados 33

q  O projeto, portanto é um exercício intelectual que tem por objetivo

q Abstrair-se significa concentrar-se no que o programa

q Abstração é o elemento básico de construção de

q Por exemplo, a abstração da entidade pessoa depende

§  Uma pessoa sob a perspectiva do emprego:

q  Gap semântico é a distância entre os conceitos

q  Essa nova visão levou a invenção do conceito

q  A representação das estruturas de dados do ADT ficam

q  A representação das estruturas de dados do ADT não faz parte

q  O adjetivo abstrato de um tipo abstrato de dados enfatiza o fato

q  Em POO a estrutura mais importante para para implementar um novo

q  Os métodos de um TAD devem operar sobre seus campos de forma

q  Quanto mais rica em recursos para expressar as necessidades

q  Simula 67, Modula 2, C++, Eiffel, Java e Phyton são exemplos

q  Conclui-se que uma notação recomendada para modelar os

q  1. public class Aluno {

q Em Java, no lugar de se definir a interface PilhaDeInt

q A orientação por objetos tem foco na identificação

§  Abstração, Modularidade, Encapsulação e controle de

q Encapsulação e controle de visibilidade