Como construir um compilador utilizando ferramentas Java
|
|
|
- Giuliana Fragoso Domingues
- 6 Há anos
- Visualizações:
Transcrição
1 Como construir um compilador utilizando ferramentas Java p. 1/8 Como construir um compilador utilizando ferramentas Java Aula 12 Análise Semântica Prof. Márcio Delamaro
2 Como construir um compilador utilizando ferramentas Java p. 2/8 O que é Preocupa com o significado de cada construção.
3 Como construir um compilador utilizando ferramentas Java p. 2/8 O que é Preocupa com o significado de cada construção. Depende da linguagem.
4 Como construir um compilador utilizando ferramentas Java p. 2/8 O que é Preocupa com o significado de cada construção. Depende da linguagem. Passeio(s) na árvore sintática
5 Como construir um compilador utilizando ferramentas Java p. 2/8 O que é Preocupa com o significado de cada construção. Depende da linguagem. Passeio(s) na árvore sintática Realizada em diversas fases, cada um relativa a diferentes aspectos.
6 Como construir um compilador utilizando ferramentas Java p. 3/8 Por que em fases? (1)ListNode class A { B varb; } (2)ClassDeclNode (8)ListNode Token: A (3)ClassBodyNode (9)ClassDeclNode (4)ListNode Token: B (10)ClassBodyNode class B { } Token: B (5)VarDeclNode (6)ListNode (7)VarNode Token: varb
7 Como construir um compilador utilizando ferramentas Java p. 4/8 Por que em fases? a. visita ao nó 1 b. visita ao nó 2, insere a classe A c. visita ao nó 3 (2)ClassDeclNode (1)ListNode (8)ListNode d. visita ao nó 4 Token: A (3)ClassBodyNode (9)ClassDeclNode e. visita ao nó 5 e verifica declaração f. visita ao nó 8 g. visita ao nó 9 e insere classe B h. visita ao nó 10 Token: B (4)ListNode Token: B (10)ClassBodyNode (5)VarDeclNode (6)ListNode (7)VarNode Token: varb
8 Como construir um compilador utilizando ferramentas Java p. 5/8 Por que em fases? Fase 1: a. visita ao nó 1 b. visita ao nó 2, insere a classe A (2)ClassDeclNode (1)ListNode (8)ListNode c. visita ao nó 3 Token: A (3)ClassBodyNode (9)ClassDeclNode d. visita ao nó 4 e. visita ao nó 5 f. visita ao nó 8 g. visita ao nó 9 e inserre classe B h. visita ao nó 10. Token: B (4)ListNode Token: B (10)ClassBodyNode (5)VarDeclNode (6)ListNode (7)VarNode Token: varb
9 Como construir um compilador utilizando ferramentas Java p. 6/8 Por que em fases? Fase 2: a. visita ao nó 1 b. visita ao nó 2 c. visita ao nó 3 d. visita ao nó 4 (1)ListNode (2)ClassDeclNode (8)ListNode Token: A (3)ClassBodyNode (9)ClassDeclNode (4)ListNode Token: B (10)ClassBodyNode e. visita ao nó 5 e verifica declaração f. visita ao nó 8 g. visita ao nó 9 h. visita ao nó 10 Token: B (5)VarDeclNode (6)ListNode (7)VarNode Token: varb
10 Como construir um compilador utilizando ferramentas Java p. 7/8 analisador semântico: parte 1 Analisa a declaração de classes.
11 Como construir um compilador utilizando ferramentas Java p. 7/8 analisador semântico: parte 1 Analisa a declaração de classes. Constrói tabela de símbolos.
12 Como construir um compilador utilizando ferramentas Java p. 7/8 analisador semântico: parte 1 Analisa a declaração de classes. Constrói tabela de símbolos. Ao encontrar um nó ClassDeclNode, o analisador semântico deve incluir a classe correspondente na tabela de símbolos.
13 Como construir um compilador utilizando ferramentas Java p. 7/8 analisador semântico: parte 1 Analisa a declaração de classes. Constrói tabela de símbolos. Ao encontrar um nó ClassDeclNode, o analisador semântico deve incluir a classe correspondente na tabela de símbolos. A árvore sintática não precisa ser completamente percorrida, somente os seus níveis mais altos.
14 Como construir um compilador utilizando ferramentas Java p. 7/8 analisador semântico: parte 1 Analisa a declaração de classes. Constrói tabela de símbolos. Ao encontrar um nó ClassDeclNode, o analisador semântico deve incluir a classe correspondente na tabela de símbolos. A árvore sintática não precisa ser completamente percorrida, somente os seus níveis mais altos. Tratamento de classes aninhadas.
15 Como construir um compilador utilizando ferramentas Java p. 8/8 Tratamento das classes ListNode Symtable ClassDeclNode ListNode class1 class2 class1 ClassBodyNode class2 ClassDeclNode ClassBodyNode class class1 { } class class2 { }
16 Como construir um compilador utilizando ferramentas Java p. 9/8 Tratamento das classes aninhadas ListNode Symtable class1 Symtable aninhada ClassDeclNode ListNode class2 class1 ClassBodyNode ClassDeclNode Symtable aninhada ListNode class2 ClassBodyNode ClassDeclNode ListNode class class1 { class aninhada{ } } aninhada ClassBodyNode ClassDeclNode class class2 { class aninhada { } } aninhada ClassBodyNode
17 Como construir um compilador utilizando ferramentas Java p. 10/8 Erros semânticos... Nessa fase da análise semântica, somente um tipo de erro semântico pode ser detectado: quando uma classe que já foi definida num determinado escopo é redefinida. class class1 { class class1 { } }
18 Como construir um compilador utilizando ferramentas Java p. 11/8 Implementação: main if ( parser.token_source.foundlexerror() + parser.contparseerror == 0) { if (print_tree) // exibir a árvore { PrintTree prt = new PrintTree(); prt.printroot(root); } ClassCheck tc = new ClassCheck(); try { tc.classcheckroot(root); System.out.println("0 Semantic error found"); } catch (SemanticException e) { System.out.println(e.getMessage()); } }
19 Como construir um compilador utilizando ferramentas Java p. 12/8 ClassCheck package semanalysis; import symtable.*; import syntactictree.*; public class ClassCheck { Symtable Maintable; // tabela de mais alto nível protected Symtable Curtable; // apontador para a tb corrente int foundsemanticerror; public ClassCheck() { EntrySimple k; } foundsemanticerror = 0; Maintable = new Symtable(); // cria tabela principal k = new EntrySimple("int"); // insere tipos básicos Maintable.add(k); k = new EntrySimple("string"); Maintable.add(k);
20 Como construir um compilador utilizando ferramentas Java p. 13/8 Tratando da raiz public void ClassCheckRoot(ListNode x) throws SemanticException { Curtable = Maintable; // tabela corrente = principal // chama análise para raiz da árvore ClassCheckClassDeclListNode(x); } // se houve erro, lança exceção if (foundsemanticerror!= 0) throw new SemanticException(foundSemanticError + " Semantic Errors found (phase 1)");
21 Como construir um compilador utilizando ferramentas Java p. 14/8 Tratando lista de classes public void ClassCheckClassDeclListNode(ListNode x) { if (x == null) return; try { ClassCheckClassDeclNode( (ClassDeclNode) x.node); } catch (SemanticException e) { // se um erro ocorreu na análise da classe, // dá a mensagem, mas faz a análise para próxima classe System.out.println(e.getMessage()); foundsemanticerror++; } ClassCheckClassDeclListNode(x.next); }
22 Como construir um compilador utilizando ferramentas Java p. 15/8 Tratando declaração de uma classe public void ClassCheckClassDeclNode(ClassDeclNode x) throws SemanticException { // salva apontador p/ tabela corrente Symtable temphold = Curtable; EntryClass nc; } if (x == null) return; // procura classe na tabela nc = (EntryClass) Curtable.classFindUp(x.name.image); if (nc!= null) // já declarada, ERRO { throw new SemanticException(x.name, "Class "+ x.name.image + " already declared"); } // inclui classe na tabela corrente Curtable.add(nc = new EntryClass(x.name.image, Curtable)); Curtable = nc.nested; // tabela corrente = tabela da classe ClassCheckClassBodyNode(x.body); Curtable = temphold; // recupera apontador p/ tabela corrente
23 Como construir um compilador utilizando ferramentas Java p. 16/8 Errata O erro reportado no slide anterior deveria ser verificado também na fase 2 apenas. No exemplo abaixo, B ainda não estaria na tabela de símbolos, mas o erro deveria ser apontado. Na fase i verifica-se a partir da tabela corrente. Na fase 2 a partir da tabela do nível anterior. class A { class B{} } class B {}
24 Como construir um compilador utilizando ferramentas Java p. 17/8 Como fica a tabela de símbolos Maintable Curtable Maintable 0 int 0 int 1 string 1 2 Próx. livre 2 string A Próx. livre Curtable (a) (b) Maintable Curtable int string A Próx. livre (c)
25 Como construir um compilador utilizando ferramentas Java p. 18/8 Regras de escopo Verifica-se se no escopo corrente já existe uma classe com o mesmo nome da classe sendo declarada.
26 Como construir um compilador utilizando ferramentas Java p. 18/8 Regras de escopo Verifica-se se no escopo corrente já existe uma classe com o mesmo nome da classe sendo declarada. Essa procura é feita por meio do método Symtable.classFindUp
27 Como construir um compilador utilizando ferramentas Java p. 18/8 Regras de escopo Verifica-se se no escopo corrente já existe uma classe com o mesmo nome da classe sendo declarada. Essa procura é feita por meio do método Symtable.classFindUp Procura a classe na tabela corrente.
28 Como construir um compilador utilizando ferramentas Java p. 18/8 Regras de escopo Verifica-se se no escopo corrente já existe uma classe com o mesmo nome da classe sendo declarada. Essa procura é feita por meio do método Symtable.classFindUp Procura a classe na tabela corrente. Caso não tenha encontrado, chama recursivamente a pesquisa utilizando a tabela de nível superior.
29 Como construir um compilador utilizando ferramentas Java p. 19/8 classfindup public EntryTable classfindup(string x) { EntryTable p = top; // para cada elemento da tabela corrente while (p!= null) { // verifica se é uma entrada de classe ou tipo simples // e então compara o nome if ( ((p instanceof EntryClass) (p instanceof EntrySimple)) && p.name.equals(x)) return p; p = p.next; // próxima entrada } if (levelup == null) // se não achou e é o nível mais externo return null; // retorna null } // procura no nível mais externo return levelup.mytable.classfindup(x);
30 Como construir um compilador utilizando ferramentas Java p. 20/8 Tratando o corpo da classe Só interessa o corpo da classe se dentro dele houver declaração de classe aninhada.
31 Como construir um compilador utilizando ferramentas Java p. 20/8 Tratando o corpo da classe Só interessa o corpo da classe se dentro dele houver declaração de classe aninhada. Então somente a lista de classes é que interessa.
32 Como construir um compilador utilizando ferramentas Java p. 20/8 Tratando o corpo da classe Só interessa o corpo da classe se dentro dele houver declaração de classe aninhada. Então somente a lista de classes é que interessa. Dentro da declaração de variáveis, métodos ou construtores, não existem declarações de classes.
33 Como construir um compilador utilizando ferramentas Java p. 21/8 Tratando o corpo da classe public void ClassCheckClassBodyNode( ClassBodyNode x) { if (x == null) return; ClassCheckClassDeclListNode(x.clist); }
34 Como construir um compilador utilizando ferramentas Java p. 22/8 Exercícios Diga como ficaria a tabela de símbolos após a primeira fase da analisador semântico ser concluída. Mostre também qual o programa fonte que gerou cada árvore.
35 Exercícios Como construir um compilador utilizando ferramentas Java p. 23/8
36 Exercícios Como construir um compilador utilizando ferramentas Java p. 24/8
37 Exercícios Como construir um compilador utilizando ferramentas Java p. 25/8
38 Exercícios Como construir um compilador utilizando ferramentas Java p. 26/8
39 Exercícios Como construir um compilador utilizando ferramentas Java p. 27/8
40 Como construir um compilador utilizando ferramentas Java p. 28/8 Análise semântica: parte 2 Nova classe VarCheck
41 Como construir um compilador utilizando ferramentas Java p. 28/8 Análise semântica: parte 2 Nova classe VarCheck Usa a estrutura montada na parte 1
42 Como construir um compilador utilizando ferramentas Java p. 28/8 Análise semântica: parte 2 Nova classe VarCheck Usa a estrutura montada na parte 1 Faz outras verificações em relação a classes e declaraçoes de variáveis.
43 Como construir um compilador utilizando ferramentas Java p. 28/8 Análise semântica: parte 2 Nova classe VarCheck Usa a estrutura montada na parte 1 Faz outras verificações em relação a classes e declaraçoes de variáveis. Não requer a análise de toda a árvore sintática.
44 Como construir um compilador utilizando ferramentas Java p. 29/8 Método main if ( parser.token_source.foundlexerror() + parser.contparseerror == 0) { if (print_tree) // exibir a árvore { PrintTree prt = new PrintTree(); prt.printroot(root); // chama método para imprimir árvore } VarCheck tc = new VarCheck(); try { tc.varcheckroot(root); System.out.println("0 Semantic Errors found"); } catch (SemanticException e) { System.out.println(e.getMessage()); } }
45 Como construir um compilador utilizando ferramentas Java p. 30/8 VarCheck package semanalysis; import symtable.*; import syntactictree.*; public class VarCheck extends ClassCheck { public VarCheck() { super(); } public void VarCheckRoot(ListNode x) throws SemanticException { ClassCheckRoot(x); // faz análise das classes VarCheckClassDeclListNode(x); if (foundsemanticerror!= 0) // se houve erro, lança exceção throw new SemanticException(foundSemanticError + " Semantic Errors found (phase 2)"); }
46 Como construir um compilador utilizando ferramentas Java p. 31/8 VarCheck: observações É subclasse de ClassCheck
47 Como construir um compilador utilizando ferramentas Java p. 31/8 VarCheck: observações É subclasse de ClassCheck Ou seja, ao criar um objeto dessa classe, são herdados os métodos vistos na parte 1 da analisador semântico.
48 Como construir um compilador utilizando ferramentas Java p. 31/8 VarCheck: observações É subclasse de ClassCheck Ou seja, ao criar um objeto dessa classe, são herdados os métodos vistos na parte 1 da analisador semântico. Antes de iniciar a análise, é chamado o método ClassCheckRoot(x) que realiza a primeira parte da análise.
49 Como construir um compilador utilizando ferramentas Java p. 32/8 Análise de uma lista de classes public void VarCheckClassDeclListNode(ListNode x) { if (x == null) return; try { VarCheckClassDeclNode( (ClassDeclNode) x.node); } catch (SemanticException e) { // se um erro ocorreu na análise da classe, // dá a mensagem, mas faz a análise para próxima classe System.out.println(e.getMessage()); foundsemanticerror++; } VarCheckClassDeclListNode(x.next); }
50 Como construir um compilador utilizando ferramentas Java p. 33/8 Análise de uma declaração de classe Se uma superclasse foi definida, verifica se a superclasse existe.
51 Como construir um compilador utilizando ferramentas Java p. 33/8 Análise de uma declaração de classe Se uma superclasse foi definida, verifica se a superclasse existe. Se existe, atualiza a tabela de símbolos.
52 Como construir um compilador utilizando ferramentas Java p. 33/8 Análise de uma declaração de classe Se uma superclasse foi definida, verifica se a superclasse existe. Se existe, atualiza a tabela de símbolos. Não verifica (ainda) circularidade
53 Como construir um compilador utilizando ferramentas Java p. 33/8 Análise de uma declaração de classe Se uma superclasse foi definida, verifica se a superclasse existe. Se existe, atualiza a tabela de símbolos. Não verifica (ainda) circularidade class A extends B class B extends C class C extends A
54 Como construir um compilador utilizando ferramentas Java p. 34/8 Análise de uma declaração de classe public void VarCheckClassDeclNode(ClassDeclNode x) throws SemanticException { Symtable temphold = Curtable; // salva tabela corrente EntryClass c = null; EntryClass nc; } if (x == null) return; if (x.supername!= null) { // verifica se superclasse foi definida c = (EntryClass) Curtable.classFindUp(x.supername.image); if (c == null) { // Se não achou superclasse, ERRO throw new SemanticException(x.position, "Superclass "+ x.supername.image + " not found"); } } nc = (EntryClass) Curtable.classFindUp(x.name.image); nc.parent = c; // coloca na tabela o apontador p/ superclasse Curtable = nc.nested; // tabela corrente = tabela da classe VarCheckClassBodyNode(x.body); Curtable = temphold; // recupera tabela corrente
55 Como construir um compilador utilizando ferramentas Java p. 35/8 Análise de uma declaração de classe // procura classe na tabela nc = (EntryClass) Curtable.classFindUp(x.name.image); // procura nos niveis mais externos if ( Curtable.levelup!= null ) { Symtable oneup = Curtable.levelup.mytable; EntryClass nc1 = (EntryClass) oneup.classfindup(x.name.image); if (nc1!= null) { // já declarada, ERRO throw new SemanticException(x.name, "Class " + x.name.image + " already declared"); } } nc.parent = c; // coloca na tabela o apontador p/ superclasse Curtable = nc.nested; // tabela corrente = tabela da classe VarCheckClassBodyNode(x.body); Curtable = temphold; // recupera tabela corrente }
56 Como construir um compilador utilizando ferramentas Java p. 36/8 Outras declarações Dentro de uma classe, existem declarações Classes aninhadas Variáveis Construtores Métodos
57 Como construir um compilador utilizando ferramentas Java p. 37/8 Trata o corpo de uma classe public void VarCheckClassBodyNode(ClassBodyNode x) { if (x == null) return; VarCheckClassDeclListNode(x.clist); VarCheckVarDeclListNode(x.vlist); VarCheckConstructDeclListNode(x.ctlist); } // se não existe constructor(), insere um falso if ( Curtable.methodFindInclass("constructor", null) == null) { Curtable.add(new EntryMethod("constructor", Curtable.levelup, true)); } VarCheckMethodDeclListNode(x.mlist); Obs: construtor falso.
58 Como construir um compilador utilizando ferramentas Java p. 38/8 Declaração de variáveis MyClass x, y;
59 Como construir um compilador utilizando ferramentas Java p. 38/8 Declaração de variáveis MyClass x, y; Verificar se MyClass existe na T.S.
60 Como construir um compilador utilizando ferramentas Java p. 38/8 Declaração de variáveis MyClass x, y; Verificar se MyClass existe na T.S. Funciona para int ou string?
61 Como construir um compilador utilizando ferramentas Java p. 38/8 Declaração de variáveis MyClass x, y; Verificar se MyClass existe na T.S. Funciona para int ou string? Cada variável na declaração é inserida na T.S. corrente.
62 Como construir um compilador utilizando ferramentas Java p. 38/8 Declaração de variáveis MyClass x, y; Verificar se MyClass existe na T.S. Funciona para int ou string? Cada variável na declaração é inserida na T.S. corrente. Declarações repetidas?
63 Como construir um compilador utilizando ferramentas Java p. 38/8 Declaração de variáveis MyClass x, y; Verificar se MyClass existe na T.S. Funciona para int ou string? Cada variável na declaração é inserida na T.S. corrente. Declarações repetidas? Não são verificadas pois não é possível ainda verificar se na superclasse existe uma variável com o mesmo nome.
64 Como construir um compilador utilizando ferramentas Java p. 39/8 Declaração de variáveis public void VarCheckVarDeclNode(VarDeclNode x) throws SemanticException { EntryTable c; ListNode p; } if (x == null) return; // acha entrada do tipo da variável c = Curtable.classFindUp(x.position.image); // se não achou, ERRO if (c == null) throw new SemanticException(x.position, "Class "+ x.position.image + " not found"); // para cada variável da declaracão, cria uma entrada na tabela for (p = x.vars; p!= null; p = p.next) { VarNode q = (VarNode) p.node; Curtable.add(new EntryVar(q.position.image, c, q.dim)); }
65 Como construir um compilador utilizando ferramentas Java p. 40/8 Declaração de construtor Verifica o tipo de cada parâmetro.
66 Como construir um compilador utilizando ferramentas Java p. 40/8 Declaração de construtor Verifica o tipo de cada parâmetro. Cria uma Entryrec com os tipos dos parâmetros.
67 Como construir um compilador utilizando ferramentas Java p. 40/8 Declaração de construtor Verifica o tipo de cada parâmetro. Cria uma Entryrec com os tipos dos parâmetros. Procura um construtor igual apenas na classe corrente.
68 Como construir um compilador utilizando ferramentas Java p. 40/8 Declaração de construtor Verifica o tipo de cada parâmetro. Cria uma Entryrec com os tipos dos parâmetros. Procura um construtor igual apenas na classe corrente. Insere um método com nome constructor na tabela de símboloscorrente.
69 Como construir um compilador utilizando ferramentas Java p. 41/8 Declaração de construtor public void VarCheckConstructDeclNode(ConstructDeclNode x) throws SemanticException { EntryMethod c; EntryRec r = null; EntryTable e; ListNode p; VarDeclNode q; VarNode u; int n; if (x == null) return; p = x.body.param; n = 0;
70 Como construir um compilador utilizando ferramentas Java p. 42/8 Declaração de construtor while (p!= null) // para cada parâmetro do construtor { q = (VarDeclNode) p.node; // q = no com a declaracão do parâmetro u = (VarNode) q.vars.node; // u = no com o nome e dimensão n++; // acha a entrada do tipo na tabela e = Curtable.classFindUp(q.position.image); // se não achou: ERRO if (e == null) throw new SemanticException(q.position, "Class " + q.position.image + " not found"); } // constrói a lista com os parâmetros r = new EntryRec(e, u.dim, n, r); p = p.next; if (r!= null) r = r.inverte(); // inverte a lista
71 Como construir um compilador utilizando ferramentas Java p. 43/8 Declaração de construtor // procura construtor com essa assinatura dentro da mesma classe c = Curtable.methodFindInclass("constructor", r); } if (c == null) { // se não achou, insere c = new EntryMethod("constructor", Curtable.levelup,0,r); Curtable.add(c); } else // construtor já definido na mesma classe: ERRO throw new SemanticException(x.position, "Constructor " + Curtable.levelup.name + "(" + (r == null? "" : r.tostr()) + ")" + " already declared");
72 Como construir um compilador utilizando ferramentas Java p. 44/8 Declaração de método Como declaração de construtor
73 Como construir um compilador utilizando ferramentas Java p. 44/8 Declaração de método Como declaração de construtor Usa o nome do método em vez da palavra constructor
74 Como construir um compilador utilizando ferramentas Java p. 44/8 Declaração de método Como declaração de construtor Usa o nome do método em vez da palavra constructor Procura o tipo de retorno para ver se foi declarado
75 Como construir um compilador utilizando ferramentas Java p. 44/8 Declaração de método Como declaração de construtor Usa o nome do método em vez da palavra constructor Procura o tipo de retorno para ver se foi declarado Insere na tabela normalmente
76 Como construir um compilador utilizando ferramentas Java p. 45/8 Análise semântica: parte 3 É a mais complexa das três.
77 Como construir um compilador utilizando ferramentas Java p. 45/8 Análise semântica: parte 3 É a mais complexa das três. Diversos aspectos são tratados.
78 Como construir um compilador utilizando ferramentas Java p. 45/8 Análise semântica: parte 3 É a mais complexa das três. Diversos aspectos são tratados. Declaração de classes e variáveis.
79 Como construir um compilador utilizando ferramentas Java p. 45/8 Análise semântica: parte 3 É a mais complexa das três. Diversos aspectos são tratados. Declaração de classes e variáveis. Comandos.
80 Como construir um compilador utilizando ferramentas Java p. 45/8 Análise semântica: parte 3 É a mais complexa das três. Diversos aspectos são tratados. Declaração de classes e variáveis. Comandos. Expressões.
81 Como construir um compilador utilizando ferramentas Java p. 45/8 Análise semântica: parte 3 É a mais complexa das três. Diversos aspectos são tratados. Declaração de classes e variáveis. Comandos. Expressões. Particularmente importante é a chacagem de tipos.
82 Como construir um compilador utilizando ferramentas Java p. 45/8 Análise semântica: parte 3 É a mais complexa das três. Diversos aspectos são tratados. Declaração de classes e variáveis. Comandos. Expressões. Particularmente importante é a chacagem de tipos. Ou seja: abrange toda a árvore sintática.
83 Como construir um compilador utilizando ferramentas Java p. 46/8 Checagem de tipo if ( expr ) comando 1; else comando 2; if ( b ) return 0;
84 Como construir um compilador utilizando ferramentas Java p. 47/8 Checagem de tipo IfNode VarNode Token: b ReturnNode IntConstNode Token: 0 procurar a variável b na tabela de símbolos pegar o tipo com que a variável foi declarada lançar uma exceção caso o tipo não seja int
85 Como construir um compilador utilizando ferramentas Java p. 48/8 Outros tipos de expressão Nem sempre expressão é apenas uma variável. Existem 13 tipos de ExpreNode como: IntConstNode, VarNode, AddNode, MultNode, RelationalNode Expressões podem ser compostas de subexpressões. Cada método que analisa um desses nós deve ser capaz de computar o tipo correspondente. Exemplo: if ( a + b > 10 ) return 0;
86 Como construir um compilador utilizando ferramentas Java p. 49/8 Exemplo IfNode RelationalNode ReturnNode AddNode Token: > IntConstNode IntConstNode VarNode Token: + VarNode Token: 10 Token: 0 Token: a Token: b
87 Como construir um compilador utilizando ferramentas Java p. 50/8 Tipo de uma expressão Antes de saber qual o tipo da expressão de controle RelationalNode, é necessário calcular o tipo de cada subexpressão.
88 Como construir um compilador utilizando ferramentas Java p. 50/8 Tipo de uma expressão Antes de saber qual o tipo da expressão de controle RelationalNode, é necessário calcular o tipo de cada subexpressão. É preciso saber se a + b e 10 são expressões do tipo inteiro para poderem ser comparadas por meio do operador >.
89 Como construir um compilador utilizando ferramentas Java p. 50/8 Tipo de uma expressão Antes de saber qual o tipo da expressão de controle RelationalNode, é necessário calcular o tipo de cada subexpressão. É preciso saber se a + b e 10 são expressões do tipo inteiro para poderem ser comparadas por meio do operador >. É preciso saber se as variáveis a e b são do tipo inteiro para poderem ser somadas e produzir um resultado inteiro.
90 Como construir um compilador utilizando ferramentas Java p. 50/8 Tipo de uma expressão Antes de saber qual o tipo da expressão de controle RelationalNode, é necessário calcular o tipo de cada subexpressão. É preciso saber se a + b e 10 são expressões do tipo inteiro para poderem ser comparadas por meio do operador >. É preciso saber se as variáveis a e b são do tipo inteiro para poderem ser somadas e produzir um resultado inteiro. O tipo é calculado de baixo para cima, a partir das subesxpressões mais simples.
91 Como construir um compilador utilizando ferramentas Java p. 50/8 Tipo de uma expressão Antes de saber qual o tipo da expressão de controle RelationalNode, é necessário calcular o tipo de cada subexpressão. É preciso saber se a + b e 10 são expressões do tipo inteiro para poderem ser comparadas por meio do operador >. É preciso saber se as variáveis a e b são do tipo inteiro para poderem ser somadas e produzir um resultado inteiro. O tipo é calculado de baixo para cima, a partir das subesxpressões mais simples. O método que analisa uma expressão retorna o seu tipo.
92 Como construir um compilador utilizando ferramentas Java p. 51/8 Regras do RelationalNode se os dois operandos forem inteiros, a expressão está OK e o seu tipo é int;
93 Como construir um compilador utilizando ferramentas Java p. 51/8 Regras do RelationalNode se os dois operandos forem inteiros, a expressão está OK e o seu tipo é int; se os dois operandos forem string, a expressão é válida somente se o operador for de igualdade ou desigualdade;
94 Como construir um compilador utilizando ferramentas Java p. 51/8 Regras do RelationalNode se os dois operandos forem inteiros, a expressão está OK e o seu tipo é int; se os dois operandos forem string, a expressão é válida somente se o operador for de igualdade ou desigualdade; idem para dois objetos de tipos comparáveis (tipos iguais ou um é subclasse do outro);
95 Como construir um compilador utilizando ferramentas Java p. 51/8 Regras do RelationalNode se os dois operandos forem inteiros, a expressão está OK e o seu tipo é int; se os dois operandos forem string, a expressão é válida somente se o operador for de igualdade ou desigualdade; idem para dois objetos de tipos comparáveis (tipos iguais ou um é subclasse do outro); strings e objetos podem ser comparados quanto à igualdade e à desigualdade com um outro operando que seja null.
96 Como construir um compilador utilizando ferramentas Java p. 52/8 Geração de código MyClass x; a = x.mymethod( b + c); criar as instruções para somar esses valores e produzir um resultado inteiro; chamar o método MyClass.myMethod(int).
97 Como construir um compilador utilizando ferramentas Java p. 53/8 Geração de código MyClass x; a = x.mymethod( b + c); transformar o valor inteiro de b em um string; concatenar o valor de a com esse valor transformado, produzindo como resultado um string; chamar o método MyClass.myMethod(string).
98 Como construir um compilador utilizando ferramentas Java p. 54/8 Método principal // verifica se pode operar sobre a árvore sintática if ( parser.token_source.foundlexerror() + parser.contparseerror == 0) { if (print_tree) // exibir a árvore { PrintTree prt = new PrintTree(); prt.printroot(root); // chama método para imprimir árvore } TypeCheck tc = new TypeCheck(); try { tc.typecheckroot(root); System.out.println("0 Semantic Errors found"); } catch (SemanticException e) { System.out.println(e.getMessage()); }
99 Como construir um compilador utilizando ferramentas Java p. 55/8 Análise da raiz public void TypeCheckRoot(ListNode x) throws SemanticException { // faz análise das variáveis e métodos VarCheckRoot(x); } // faz análise do corpo dos métodos TypeCheckClassDeclListNode(x); if (foundsemanticerror!= 0) // se houve erro, throw new SemanticException(foundSemanticEr " Semantic Errors foun
100 Como construir um compilador utilizando ferramentas Java p. 56/8 Declaração de classe public void TypeCheckClassDeclNode(ClassDeclNode x) throws SemanticException { Symtable temphold = Curtable; // salva tabela corrente EntryClass nc; } if (x == null) return; nc = (EntryClass) Curtable.classFindUp(x.name.image); if ( circularsuperclass(nc, nc.parent) ) { // se existe declaração circular, ERRO nc.parent = null; throw new SemanticException(x.position, "Circular inheritance"); } Curtable = nc.nested; // tabela corrente = tabela da classe TypeCheckClassBodyNode(x.body); Curtable = temphold; // recupera tabela corrente
101 Como construir um compilador utilizando ferramentas Java p. 57/8 Herança circular // verifica se existe referência circular de superclasses private boolean circularsuperclass(entryclass orig, EntryClass e) { if ( e == null) return false; if (orig == e ) return true; return circularsuperclass(orig, e.parent); }
102 Como construir um compilador utilizando ferramentas Java p. 58/8 Análise de construtor // acha a entrada do construtor na tabela t = Curtable.methodFind("constructor", r); CurMethod = t; // guarda método corrente // inicia um novo escopo na tabela corrente Curtable.beginScope(); // pega a entrada da classe corrente na tabela thisclass = (EntryClass) Curtable.levelup; } thisvar = new EntryVar("this", thisclass, 0); Curtable.add(thisvar); // inclui variável local "this" com no. 0 Returntype = null; // tipo de retorno do método = nenhum nesting = 0; // nível de aninhamento de comandos for Nlocals = 1; // inicializa número de variáveis locais TypeCheckMethodBodyNode(x.body); t.totallocals = Nlocals; // número de variáveis locais do método Curtable.endScope(); // retira variáveis locais da tabela
103 Como construir um compilador utilizando ferramentas Java p. 59/8 Tratamento dos comandos A partir desse ponto para baixo é feito o tratamento dos comandos que aparecem na árvore sintática.
104 Como construir um compilador utilizando ferramentas Java p. 59/8 Tratamento dos comandos A partir desse ponto para baixo é feito o tratamento dos comandos que aparecem na árvore sintática. Cada tipo de nó (cada comando) diferente é tratado de modo diferente.
105 Como construir um compilador utilizando ferramentas Java p. 59/8 Tratamento dos comandos A partir desse ponto para baixo é feito o tratamento dos comandos que aparecem na árvore sintática. Cada tipo de nó (cada comando) diferente é tratado de modo diferente. Pode ser um tratamento muito simples (BlockNode, PrintNode) ou complexo (VarDeclNode).
106 Como construir um compilador utilizando ferramentas Java p. 60/8 BlockNode public void TypeCheckBlockNode(BlockNode x) { Curtable.beginScope(); // início de um escopo TypeCheckStatementListNode(x.stats); Curtable.endScope(); // final do escopo, libera vars. locais } public void TypeCheckStatementListNode(ListNode x) { if (x == null) return; try { TypeCheckStatementNode( (StatementNode) x.node); } catch (SemanticException e) { System.out.println(e.getMessage()); foundsemanticerror++; } TypeCheckStatementListNode(x.next); }
107 Como construir um compilador utilizando ferramentas Java p. 61/8 PrintNode public void TypeCheckPrintNode(PrintNode x) throws SemanticException { type t; if (x == null) return; // t = tipo e dimensão do resultado da expressão t = TypeCheckExpreNode(x.expr); } // tipo tem que ser string e dimensão tem que ser 0 if ( t.ty!= STRING_TYPE t.dim!= 0 ) throw new SemanticException(x.position, "string expression required"); Notar os erros que podem ocorrer.
108 Como construir um compilador utilizando ferramentas Java p. 62/8 Declaração de variável local public void TypeCheckLocalVarDeclNode(VarDeclNode x) throws SemanticException { ListNode p; VarNode q; EntryVar l, u; EntryTable c; if (x == null) return; // procura tipo da declaração na tabela de símbolos c = Curtable.classFindUp(x.position.image); // se não achou, ERRO if (c == null) throw new SemanticException(x.position, "Class "+ x.position.image + " not found."); Verifica se tipo existe.
109 Como construir um compilador utilizando ferramentas Java p. 63/8 Declaração de variável local for (p = x.vars; p!= null; p = p.next) { q = (VarNode) p.node; l = Curtable.varFind(q.position.image); // se variável já existe é preciso saber que tipo de variável é if ( l!= null) { // verifica se é local, definida no escopo corrente if (l.scope == Curtable.scptr) // se for, ERRO throw new SemanticException(q.position, "Variable "+ p.position.image + " already declared");
110 Como construir um compilador utilizando ferramentas Java p. 64/8 Declaração de variáveis locais Procura a variável na tabela de símbolos.
111 Como construir um compilador utilizando ferramentas Java p. 64/8 Declaração de variáveis locais Procura a variável na tabela de símbolos. Se achou, pode ser um erro (ou não).
112 Como construir um compilador utilizando ferramentas Java p. 64/8 Declaração de variáveis locais Procura a variável na tabela de símbolos. Se achou, pode ser um erro (ou não). l.scope indica em qual scopo foi inserida a variável.
113 Como construir um compilador utilizando ferramentas Java p. 64/8 Declaração de variáveis locais Procura a variável na tabela de símbolos. Se achou, pode ser um erro (ou não). l.scope indica em qual scopo foi inserida a variável. Curtable.scptr indica qual o scopo corrente.
114 Como construir um compilador utilizando ferramentas Java p. 64/8 Declaração de variáveis locais Procura a variável na tabela de símbolos. Se achou, pode ser um erro (ou não). l.scope indica em qual scopo foi inserida a variável. Curtable.scptr indica qual o scopo corrente. Se forem iguais, significa que variável já existe no escopo corrente.
115 Como construir um compilador utilizando ferramentas Java p. 65/8 Declaração de variáveis locais // c.c. verifica se é uma variável de classe if (l.localcount < 0) // se for, dá uma advertência System.out.println("Line " + q.position.beginline + " Column " + q.position.begincolumn + " Warning: Variable " + q.position.image + " hides a class variable"); else // senão, é uma variável local em outro escopo System.out.println("Line " + q.position.beginline + " Column " + q.position.begincolumn + " Warning: Variable " + q.position.image + " hides a parameter or a local variable"); Advertência: esconde variável já definida.
116 Como construir um compilador utilizando ferramentas Java p. 66/8 Declaração de variáveis locais Curtable.add( new EntryVar(q.position.image, c, q.dim, Nlo ); Insere na tabela.
117 Como construir um compilador utilizando ferramentas Java p. 67/8 Comando de atribuição public void TypeCheckAtribNode(AtribNode x) throws SemanticException { type t1, t2; EntryVar v; if (x == null) return; // verifica se o nó filho tem um tipo válido if (! (x.expr1 instanceof DotNode x.expr1 instanceof IndexNode x.expr1 instanceof VarNode) ) throw new SemanticException(x.position, "Invalid left side of assignment");
118 Como construir um compilador utilizando ferramentas Java p. 68/8 Comando de atribuição // verifica se é uma atribuição para "this" if ( x.expr instanceof VarNode ) { EntryVar v = Curtable.varFind(x.expr.position.image); if ( v!= null && v.localcount == 0) // é a variável local 0? { throw new SemanticException(x.position, "Assigning to variable \"this\" is not legal"); } }
119 Como construir um compilador utilizando ferramentas Java p. 69/8 Comando de atribuição t1 = TypeCheckExpreNode(x.expr1); t2 = TypeCheckExpreNode(x.expr2); // verifica tipos das expressões // verifica dimensões if ( t1.dim!= t2.dim ) throw new SemanticException(x.position, "Invalid dimensions in assignment"); Compatibilidade de tipos. int[][] x, y; x = new int[10][10]; y = x[0];
120 Como construir um compilador utilizando ferramentas Java p. 70/8 Comando de atribuição // verifica se lado esquerdo é uma classe e direito é null, OK if (t1.ty instanceof EntryClass && t2.ty == NULL_TYPE ) return; // verifica se t2 é subclasse de t1 if (! ( issubclass(t2.ty,t1.ty) issubclass(t1.ty,t2.ty) ) ) throw new SemanticException(x.position, "Incompatible types for assignment ");
121 Como construir um compilador utilizando ferramentas Java p. 71/8 Atribuição de subclasses Nesse último caso, vale uma explicação sobre a semântica que queremos dar a este comando. Primeiro, se o tipo do lado direito for uma subclasse do tipo do lado esquerdo, então a atribuição é feita naturalmente, sem problemas. No caso inverso, antes de fazer a atribuição, o sistema de execução faz por conta própria a coerção dos tipos. Obviamente, se a coerção não puder ser feita, um erro de execução ocorre.
122 Como construir um compilador utilizando ferramentas Java p. 72/8 Atribuição de subclasse class A extends C { } int metha() { C var1; A var2; B var3; var1 = new A(); // OK var2 = var1; // OK c/ coerção var3 = var1; // ERRO } class B extends C... class C...
123 Como construir um compilador utilizando ferramentas Java p. 73/8 Análise das expressões Uma expressão em X ++ pode ser uma simples constante ou variável, ou uma expressão composta de diversas expressões mais simples.
124 Como construir um compilador utilizando ferramentas Java p. 73/8 Análise das expressões Uma expressão em X ++ pode ser uma simples constante ou variável, ou uma expressão composta de diversas expressões mais simples. O tipo de uma expressão é calculado com base nos tipos das suas subexpressões.
125 Como construir um compilador utilizando ferramentas Java p. 73/8 Análise das expressões Uma expressão em X ++ pode ser uma simples constante ou variável, ou uma expressão composta de diversas expressões mais simples. O tipo de uma expressão é calculado com base nos tipos das suas subexpressões. O método que trata uma expressão deve computar e retornar um objeto do tipo type.
126 Como construir um compilador utilizando ferramentas Java p. 74/8 Classe type public class type { public EntryTable ty; public int dim; // entrada na tabela // dimensão public type(entrytable t, int d) { ty = t; dim = d; }
127 Como construir um compilador utilizando ferramentas Java p. 75/8 Tipo de uma constante Para as constantes, obter o seu tipo é trivial.
128 Como construir um compilador utilizando ferramentas Java p. 75/8 Tipo de uma constante Para as constantes, obter o seu tipo é trivial. O próprio tipo do nó da árvore sintática determina qual o tipo da constante.
129 Como construir um compilador utilizando ferramentas Java p. 75/8 Tipo de uma constante Para as constantes, obter o seu tipo é trivial. O próprio tipo do nó da árvore sintática determina qual o tipo da constante. Somente no caso de uma constante inteira é necessária uma verificação extra.
130 Como construir um compilador utilizando ferramentas Java p. 75/8 Tipo de uma constante Para as constantes, obter o seu tipo é trivial. O próprio tipo do nó da árvore sintática determina qual o tipo da constante. Somente no caso de uma constante inteira é necessária uma verificação extra. Para verificar se é uma constante válida, utilizamos uma chamada ao método Integer.parseInt da API Java.
131 Como construir um compilador utilizando ferramentas Java p. 76/8 Constante inteira public type TypeCheckIntConstNode(IntConstNode x) throws SemanticException { int k; if (x == null) return null; } // tenta transformar imagem em número inteiro try { k = Integer.parseInt(x.position.image); } catch(numberformatexception e) { // se deu erro, formato é inválido // (possivelmente fora dos limites) throw new SemanticException(x.position, "Invalid int constant"); } return new type(int_type, 0);
132 Como construir um compilador utilizando ferramentas Java p. 77/8 Constante string ou null public type TypeCheckStringConstNode(StringConstNode x) { if (x == null) return null; return new type( STRING_TYPE, 0); } public type TypeCheckNullConstNode(NullConstNode x) { if (x == null) return null; return new type( NULL_TYPE, 0); }
133 Como construir um compilador utilizando ferramentas Java p. 78/8 Tipo de uma variável Para uma variável também não é difícil calcular seu tipo.
134 Como construir um compilador utilizando ferramentas Java p. 78/8 Tipo de uma variável Para uma variável também não é difícil calcular seu tipo. Basta consultar a tabela de símbolos.
135 Como construir um compilador utilizando ferramentas Java p. 78/8 Tipo de uma variável Para uma variável também não é difícil calcular seu tipo. Basta consultar a tabela de símbolos. Isto é feito utilizando o conhecido método Symtable.varFind
136 Como construir um compilador utilizando ferramentas Java p. 78/8 Tipo de uma variável Para uma variável também não é difícil calcular seu tipo. Basta consultar a tabela de símbolos. Isto é feito utilizando o conhecido método Symtable.varFind O nome está no nó VarNode sendo analisado.
137 Como construir um compilador utilizando ferramentas Java p. 79/8 Tipo de um VarNode public type TypeCheckVarNode(VarNode x) throws SemanticException { EntryVar p; if (x == null) return null; // procura variável na tabela p = Curtable.varFind(x.position.image); } // se não achou, ERRO if (p == null) throw new SemanticException(x.position, "Variable " + x.position.image + " not found"); return new type(p.type, p.dim);
138 Como construir um compilador utilizando ferramentas Java p. 80/8 Chamada de método calcula o tipo da expressão que está no seu primeiro filho e que representa a expressão à esquerda do. na chamada do método
139 Como construir um compilador utilizando ferramentas Java p. 80/8 Chamada de método calcula o tipo da expressão que está no seu primeiro filho e que representa a expressão à esquerda do. na chamada do método se a dimensão é maior que zero. Caso seja, um erro foi encontrado, pois um array não pode ter um método associado a ele;
140 Como construir um compilador utilizando ferramentas Java p. 80/8 Chamada de método calcula o tipo da expressão que está no seu primeiro filho e que representa a expressão à esquerda do. na chamada do método se a dimensão é maior que zero. Caso seja, um erro foi encontrado, pois um array não pode ter um método associado a ele; se o tipo calculado corresponde a uma classe. Caso não seja, um erro foi encontrado, pois tipos simples não podem ter métodos.
141 Como construir um compilador utilizando ferramentas Java p. 81/8 Tipo de um CallNode public type TypeCheckCallNode(CallNode x) throws SemanticException { EntryClass c; EntryMethod m; type t1, t2; if (x == null) return null; // calcula tipo do primeiro filho t1 = TypeCheckExpreNode(x.expr); // se for array, ERRO if ( t1.dim > 0 ) throw new SemanticException(x.position, "Arrays do not have methods"); // se não for uma classe, ERRO if (! (t1.ty instanceof EntryClass)) throw new SemanticException(x.position, "Type " + t1.ty.name + " does not have methods");
142 Como construir um compilador utilizando ferramentas Java p. 82/8 Chamada de método Em seguida são calculados os tipos para cada um dos argumentos.
143 Como construir um compilador utilizando ferramentas Java p. 82/8 Chamada de método Em seguida são calculados os tipos para cada um dos argumentos. Utilizando o nome do método, que é um dos filhos do nó corrente, e a lista de tipos dos argumentos, realiza-se uma busca na tabela de símbolos para achar o método adequado.
144 Como construir um compilador utilizando ferramentas Java p. 82/8 Chamada de método Em seguida são calculados os tipos para cada um dos argumentos. Utilizando o nome do método, que é um dos filhos do nó corrente, e a lista de tipos dos argumentos, realiza-se uma busca na tabela de símbolos para achar o método adequado. A busca deve ser feita na classe adequada, ou seja, na classe que foi calculada no início.
145 Como construir um compilador utilizando ferramentas Java p. 82/8 Chamada de método Em seguida são calculados os tipos para cada um dos argumentos. Utilizando o nome do método, que é um dos filhos do nó corrente, e a lista de tipos dos argumentos, realiza-se uma busca na tabela de símbolos para achar o método adequado. A busca deve ser feita na classe adequada, ou seja, na classe que foi calculada no início. A entrada do método na tabela de símbolos diz-nos qual é o tipo retornado pela chamada.
146 Como construir um compilador utilizando ferramentas Java p. 83/8 Tipo de um CallNode // pega tipos dos argumentos t2 = TypeCheckExpreListNode(x.args); // procura o método desejado na classe t1.ty c = (EntryClass) t1.ty; m = c.nested.methodfind(x.meth.image, (EntryRec) t2.ty); // se não achou, ERRO if (m == null) throw new SemanticException(x.position, "Method " + x.meth.image + "(" + (t2.ty == null? "" : ((EntryRec) t2.ty).tostr()) + ") not found in class " + c.name); } return new type(m.type, m.dim);
147 Como construir um compilador utilizando ferramentas Java p. 84/8 Expressão de adição/subtração AddNode possui dois filhos ExpreNode e o tipo de operação a ser executada.
148 Como construir um compilador utilizando ferramentas Java p. 84/8 Expressão de adição/subtração AddNode possui dois filhos ExpreNode e o tipo de operação a ser executada. São calculados os tipos das subexpressões.
149 Como construir um compilador utilizando ferramentas Java p. 84/8 Expressão de adição/subtração AddNode possui dois filhos ExpreNode e o tipo de operação a ser executada. São calculados os tipos das subexpressões. Expressões devem ter tipo sem dimensão.
150 Como construir um compilador utilizando ferramentas Java p. 84/8 Expressão de adição/subtração AddNode possui dois filhos ExpreNode e o tipo de operação a ser executada. São calculados os tipos das subexpressões. Expressões devem ter tipo sem dimensão. Dois inteiros podem ser somados ou subtraídos.
151 Como construir um compilador utilizando ferramentas Java p. 84/8 Expressão de adição/subtração AddNode possui dois filhos ExpreNode e o tipo de operação a ser executada. São calculados os tipos das subexpressões. Expressões devem ter tipo sem dimensão. Dois inteiros podem ser somados ou subtraídos. Soma pode ser realizada entre strings e inteiros.
152 Como construir um compilador utilizando ferramentas Java p. 85/8 Tipo de um AddNode public type TypeCheckAddNode(AddNode x) throws SemanticException { type t1, t2; int op; // operação int i, j; if (x == null) return null; op = x.position.kind; t1 = TypeCheckExpreNode(x.expr1); t2 = TypeCheckExpreNode(x.expr2); // se dimensão > 0, ERRO if ( t1.dim > 0 t2.dim > 0 ) throw new SemanticException(x.position, "Can not use " + x.position.image + " for arrays");
153 Como construir um compilador utilizando ferramentas Java p. 86/8 Tipo de um AddNode i = j = 0; if (t1.ty == INT_TYPE) i++; else if (t1.ty == STRING_TYPE) j++; if (t2.ty == INT_TYPE) i++; else if (t2.ty == STRING_TYPE) j++; } // dois operadores inteiro, OK if (i == 2) return new type(int_type, 0); // um inteiro e um string. Só pode somar if ( op == langxconstants.plus && i+j == 2) return new type(string_type, 0); throw new SemanticException(x.position, "Invalid types for " + x.position.image);
Como construir um compilador utilizando ferramentas Java
Como construir um compilador utilizando ferramentas Java p. 1/3 Como construir um compilador utilizando ferramentas Java Aula 11 Tabela de Símbolos Prof. Márcio Delamaro delamaro@icmc.usp.br Como construir
Como construir um compilador utilizando ferramentas Java
Como construir um compilador utilizando ferramentas Java p. 1/2 Como construir um compilador utilizando ferramentas Java Aula 10 Exibição da árvore sintática Prof. Márcio Delamaro delamaro@icmc.usp.br
Como construir um compilador utilizando ferramentas Java
Como construir um compilador utilizando ferramentas Java p. 1/4 Como construir um compilador utilizando ferramentas Java Aula 9 Construção da árvore sintática Prof. Márcio Delamaro delamaro@icmc.usp.br
Programação Estruturada e Orientada a Objetos
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DO RIO GRANDE DO NORTE Programação Estruturada e Orientada a Objetos Docente: Éberton da Silva Marinho e-mail: ebertonsm@gmail.com eberton.marinho@ifrn.edu.br
Programação Orientada a Objectos - P. Prata, P. Fazendeiro
Quando um programa viola as restrições semânticas da linguagem, a JVM assinala um erro ao programa, sob a forma de exceção. Uma exceção é um erro recuperável O controlo da execução do programa é transferido
Programação Orientada a Objectos - P. Prata, P. Fazendeiro
6 Exceções Quando um programa viola as restrições semânticas da linguagem, a JVM assinala um erro ao programa, sob a forma de exceção. Uma exceção é um erro recuperável O controlo da execução do programa
Exceções AULA 13. Ricardo Massa F. Lima Sérgio C. B. Soares
Introdução a Programação IF669 http://www.cin.ufpe.br/~if669 Exceções AULA 13 Ricardo Massa F. Lima rmfl@cin.ufpe.br Sérgio C. B. Soares scbs@cin.ufpe.br Exceções Objetivo Depois desta aula você será capaz
Quando um programa viola as restrições semânticas da linguagem, a JVM assinala um erro ao programa, sob a forma de exceção.
6 Exceções Quando um programa viola as restrições semânticas da linguagem, a JVM assinala um erro ao programa, sob a forma de exceção. Uma exceção é um erro recuperável - O controlo da execução do programa
Como construir um compilador utilizando ferramentas Java
Como construir um compilador utilizando ferramentas Java p. 1/2 Como construir um compilador utilizando ferramentas Java Aula 1 - Introdução Prof. Márcio Delamaro delamaro@icmc.usp.br Como construir um
Tipos de dados e comandos POO
Tipos de dados e comandos POO Prof. Marcio Delamaro 1/46 Objetivo Vamos ver quais são os tipo de dados primitivos da linguagem Vamos ver quais são os principais comandos 2/46 Tipos Tipo Tamanho int 4 bytes
Linguagem Java - Introdução
Linguagem Java - Introdução Identificadores válidos resultado teste01 _numeroclientes $fortuna Identificadores Identificadores inválidos 101dalmatas 34 #x Palavras reservadas abstract assert*** boolean
Tipos, Literais, Operadores
Tipos, Literais, Operadores Identificadores São palavras utilizadas para nomear variáveis, métodos e classes Na linguagem Java, o identificador sempre começa por letra, sublinhado(_) ou cifrão ($) Não
Tipos, Literais, Operadores
Tipos, Literais, Operadores Identificadores São palavras utilizadas para nomear variáveis, métodos e classes Na linguagem Java, o identificador sempre começa por letra, sublinhado(_) ou cifrão ($) Não
4 Conceito de Herança
4 Conceito de Herança Hierarquia de classes e mecanismo de ligação Herança Uma classe pode herdar operações de uma superclasse e as suas operações podem ser herdadas por subclasses. O mecanismo de herança
Programação Orientada a Objectos - P. Prata, P. Fazendeiro. Hierarquia de classes e mecanismo de ligação
4 Conceito de Herança Hierarquia de classes e mecanismo de ligação Herança Uma classe pode herdar operações de uma superclasse e as suas operações podem ser herdadas por subclasses. O mecanismo de herança
Tratamento de Exceções
Tratamento de Exceções Universidade Católica de Pernambuco Ciência da Computação Prof. Márcio Bueno poonoite@marciobueno.com Fonte: Material da Profª Karina Oliveira Introdução Exceções São eventos que
Recapitulando. Construtores: (Overload assinatura) public Circle() {...} public Circle(double x, double y, double r) {... }
Recapitulando Orientação a objetos: programas organizados em torno da definição de classes, instanciação de objetos e troca de mensagens. Declaração de variáveis de referencia: Circle c; Criação/instanciação
Universidade de Mogi das Cruzes Implementação Orientada a Objetos - Profª. Danielle Martin. Guia da Sintaxe do Java
Guia da Sintaxe do Java TIPOS PRIMITIVOS DE DADOS DO JAVA São os tipos nativos de dados do Java, que podem ser usados na declaração de atributos, variáveis, parâmetros. Tipo primitivo Tamanho Valor padrão
Tratamento de Exceções. Julio Cesar Nardi
Tratamento de Exceções Julio Cesar Nardi Tratamento de Exceções Objetivos: Identificar os tipos de erros em programas Java; Compreender o mecanismo de controle de exceções; Agenda Controle de Exceções
Linguagem de Programação II Implementação
Linguagem de Programação II Implementação Prof. Alessandro Borges 2 Tópicos Implementação em Java Variáveis Palavras reservadas Pacotes Identificador this Acessando membros de outros objetos API Java Nossa
Tratamento de Exceções. LPG II Java. Tratamento de Exceções. Conceito de Exceções. Exemplo
Tratamento de Exceções LPG II Java Tratamento de Exceções Introdução Princípios do tratamento de exceções em Java Cláusula try Cláusula catch Cláusula finally Hierarquia de exceções em Java Considerações
Programação por Objectos. Java
Programação por Objectos Java Parte 6: Herança e Polimorfismo LEEC@IST Java 1/50 Herança revisão (1) A herança é um mecanismo em que a subclasse constitui uma especialização da superclasse. A superclasse
Palavras Reservadas da Linguagem Java
Palavras Reservadas da Linguagem Java Palavras Reservadas da Linguagem Java: Categorias Tipos de dados primitivos Literais Pseudo-variáveis Desvio e controle de fluxo Pacotes Exceções Modificadores de
Como construir um compilador utilizando ferramentas Java
Como construir um compilador utilizando ferramentas Java p. 1/3 Como construir um compilador utilizando ferramentas Java Aula 7 Análise Sintática no JavaCC Prof. Márcio Delamaro delamaro@icmc.usp.br Como
Como construir um compilador utilizando ferramentas Java
Como construir um compilador utilizando ferramentas Java p. 1/3 Como construir um compilador utilizando ferramentas Java Aula 3 A linguagem X ++ Prof. Márcio Delamaro delamaro@icmc.usp.br Como construir
Variáveis primitivas e Controle de fluxo
Variáveis primitivas e Controle de fluxo Material baseado na apostila FJ-11: Java e Orientação a Objetos do curso Caelum, Ensino e Inovação, disponível para download em http://www.caelum.com.br/apostilas/
Herança (parte 2) Redefinição de métodos AULA 11
Introdução a Programação IF669 http://www.cin.ufpe.br/~if669 Herança (parte 2) Redefinição de métodos AULA 11 Ricardo Massa F. Lima rmfl@cin.ufpe.br Sérgio C. B. Soares scbs@cin.ufpe.br Na aula passada
Classes e Objetos. Sintaxe de classe em Java
Classes e Objetos Classes e Objetos A Programação Orientada a Objetos (POO) é uma técnica de programação que se baseia na construção de classes e utilização de objetos. Os objetos são formados por dados
Algoritmos II prof. Daniel Oliveira
Algoritmos II prof. Daniel Oliveira Revisar conceitos abordados na disciplina anterior Abordar conceitos vistos com a linguagem C# Variáveis e listas Expressões Estruturas de controle do tipo condicional
Compiladores Análise Semântica
Compiladores Análise Semântica Fabio Mascarenhas - 2013.2 http://www.dcc.ufrj.br/~fabiom/comp Árvores Sintáticas Abstratas (ASTs) A árvore de análise sintática tem muita informação redundante Separadores,
1. Estude e implemente a classe Exemplo1 apresentada abaixo:
P. Fazendeiro & P. Prata POO FP09/1 Exceções Uma exceção (Exception) é um sinal gerado pela máquina virtual de Java em tempo de execução indicando uma situação de erro da qual é possível recuperar. O objectivo
Fundamentos de Programação. Turma CI-240-EST. Josiney de Souza.
Fundamentos de Programação Turma CI-240-EST Josiney de Souza josineys@inf.ufpr.br Agenda do Dia Aula 8 (30/09/15) Comentários sobre exercícios propostos Desvio condicional Simples Composto Exercícios Propostos
Linguagem Algorítmica OO. Linguagem Algorítmica
UFSC-CTC-INE INE5384 - Estruturas de Dados Linguagem Algorítmica OO Prof. Ronaldo S. Mello 2002/2 Linguagem Algorítmica Independente de linguagem de programação OO Utilizada para: Exemplificar os algoritmos
Herança. Prof. Fernando V. Paulovich 23 de agosto de 2010
Herança SCC0604 - Programação Orientada a Objetos Prof. Fernando V. Paulovich http://www.icmc.usp.br/~paulovic paulovic@icmc.usp.br Instituto de Ciências Matemáticas e de Computação(ICMC) Universidade
Apêndice A. Alguns construtores e métodos importantes e úteis da classe Vector são:
Apêndice A Classe Vector A classe Vector permite a representação de um vetor de dados de maneira similar à de um array, visto na disciplina Programação Orientada a Objetos I, mas com maior flexibilidade.
Notas de Aula 09: Tratamento de exceções
Notas de Aula 09: Tratamento de exceções Objetivos da aula: Compreender o conceito de exceção Aprender a tratar exceções nos programas Entender a hierarquia das exceções Criar e lançar uma exceção proprietária
Análise de Programação
Análise de Programação Fundamentos da Linguagem de Programação Java Prof. Gilberto B. Oliveira Variáveis Atributos: Variáveis Declaradas fora de um método, sem o modificador static Variáveis membro ou
Aula 9 Herança. Prof. Jefersson Alex dos Santos
Aula 9 Herança Prof. Jefersson Alex dos Santos Roteiro Introdução Conversão de tipo explícita (Cast) Acesso Protegido A classe Object A classe Class Reflexão Recomendações de Projeto Herança Técnica necessária
Universidade Estadual da Paraíba - UEPB Curso de Licenciatura em Computação
Universidade Estadual da Paraíba - UEPB Curso de Licenciatura em Computação Análise Semântica Disciplina: Compiladores Equipe: Luiz Carlos dos Anjos Filho José Ferreira Júnior Compiladores Um compilador
Introdução a classes e objetos. Prof. Marcelo Roberto Zorzan Prof a. Rachel Reis
Introdução a classes e objetos Prof. Marcelo Roberto Zorzan Prof a. Rachel Reis Estruturas de Seleção if... else Operador condicional (? : ) switch Aula de Hoje Estruturas de Repetição: while/do... while/for
Compiladores Análise Semântica
Compiladores Análise Semântica Fabio Mascarenhas 2018.1 http://www.dcc.ufrj.br/~fabiom/comp Análise Semântica Muitos erros no programa não podem ser detectados sintaticamente, pois precisam de contexto
UNIP - Ciência da Computação e Sistemas de Informação. Estrutura de Dados. AULA 5 Pilhas
UNIP - Ciência da Computação e Sistemas de Informação Estrutura de Dados AULA Pilhas Estrutura de Dados A Estrutura de Dados Pilha Pilha é uma estrutura de dados usada em programação, que tem uma regra
TRATAMENTO DE EXCEÇÕES
Uma exceção em Java é um sinal que alguma condição excepcional aconteceu; Algo de errado aconteceu! Exemplos: solicitação de abertura de um arquivo não encontrado; índice de um array fora de faixa; uma
Tratamento de Exceções cont. Profa. Thienne Johnson EACH/USP
Tratamento de Exceções cont. Profa. Thienne Johnson EACH/USP Java, como programar Deitel & Deitel Capítulo 14 continuação Todas as classes de exceção de Java herdam, direta ou indiretamente, da classe
Tratamento de Exceção. Tratamento de Exceções. Vantagens de TE. Exemplos de Exceções. Exemplo: Divide1 (sem TE)
DCC / ICEx / UFMG Tratamento de Exceção Tratamento de Exceções Eduardo Figueiredo http://www.dcc.ufmg.br/~figueiredo Uma exceção é uma indicação de problema na execução do programa Exceção foge ao fluxo
PROGRAMAÇÃO ORIENTADA A OBJETOS -TRATAMENTO DE EXCEÇÕES. Prof. Angelo Augusto Frozza, M.Sc.
PROGRAMAÇÃO ORIENTADA A OBJETOS -TRATAMENTO DE EXCEÇÕES Prof. Angelo Augusto Frozza, M.Sc. frozza@ifc-camboriu.edu.br ROTEIRO 4. Sistemas de Tratamento de Exceções Exceções genéricas Classes de exceções
Processamento da Informação Estruturas de seleção simples e composta
Processamento da Informação Estruturas de seleção simples e composta Prof. Jesús P. Mena-Chalco CMCC/UFABC Q1/2017 1 Expressões Booleanas 2 Fonte: http://pt.wikipedia.org/wiki/george_boole Expressões Booleanas
MsC. João Maria MsC. Liviane Melo
Disciplina: Programação Orientada à Objetos AULA 02 Corpo docente: MsC. Alexandro Vladno Edmilson Campos MsC. Fábio Procópio Esp. Felipe Dantas MsC. João Maria MsC. Liviane Melo 2 Tipo Tamanho Alcance
Interfaces POO. Prof. Marcio Delamaro
Interfaces POO Prof. Marcio Delamaro Programação Orientada a Objetos Prof Marcio Delamaro ICMC/USP 1/41 O que é interface É um template de classe Outras classes podem seguir esse template Chamamos isso
Laboratório de programação II
Laboratório de programação II Herança e Polimorfismo Edson Moreno edson.moreno@pucrs.br http://www.inf.pucrs.br/~emoreno Herança Mecanismo da Orientação a Objeto que permite criar novas classes aproveitando
Sobrecarga. Algoritmos e Programação II. Aula 3 Sobrecarga
Algoritmos e Programação II Aula 3 Sobrecarga *Adaptado do material do Prof. Júlio Machado Sobrecarga Em várias linguagens é comum encontrarmos rotinas que fazem basicamente a mesma coisa, porém, com nomes
Compiladores Análise Semântica
Compiladores Análise Semântica Fabio Mascarenhas - 2013.1 http://www.dcc.ufrj.br/~fabiom/comp Árvores Sintáticas Abstratas (ASTs) A árvore de análise sintática tem muita informação redundante Separadores,
Programação Java. Tratamento de Exceções
Programação Java Tratamento de Exceções Grupo de Linguagens de Programação Departamento de Informática PUC-Rio Motivações para Exceções Um método pode detectar uma falha mas não estar apto a resolver sua
Tratamento de Exceções. Java Avançado. Tratamento de Exceções. Conceito de Exceções. Exemplo
Tratamento de Exceções Java Avançado Tratamento de Exceções Roberto Vedoato vedoato@joinville.udesc.br Introdução Princípios do tratamento de exceções em Java Cláusula try Cláusula catch Cláusula finally
COMPORTAMENTOS - Observações
COMPORTAMENTOS - Observações O próprio objeto realiza operações de consulta ou alteração dos valores dos seus atributos Essas operações são definidas em seus métodos Os métodos também são utilizados para
Compiladores. Bruno Lopes. Bruno Lopes Compiladores 1 / 31. Instituto de C
ompiladores Análise Léxica Bruno Lopes Bruno Lopes ompiladores 1 / 31 Front-end Lida com a linguagem de entrada Teste de pertinência: código fonte linguagem fonte? Programa está bem formado? Sintaticamente?
Lista 05 Herança. public class PessoaFisica extends Pessoa { private String RG; public PessoaFisica(){ super(); } public String getrg(){ return RG; }
Lista 05 Herança 1. Analisando a classe Java abaixo podemos observar que a mesma possui apenas um atributo, um construtor e dois métodos. Perceba que dentro do método main estão sendo invocados métodos
Como construir um compilador utilizando ferramentas Java
Como construir um compilador utilizando ferramentas Java p. 1/2 Como construir um compilador utilizando ferramentas Java Aula 4 Análise Léxica Prof. Márcio Delamaro delamaro@icmc.usp.br Como construir
EXPRESSÕES BOOLEANAS. Ex: boolean b = false; // declara uma variável do tipo boolean e atribui false
Cursos: Análise, Ciência da Computação e Sistemas de Informação Programação I - Prof. Aníbal Notas de aula 4 EXPRESSÕES BOOLEANAS O tipo primitivo boolean É um tipo de dados primitivo em Java que possui
Programação Orientada a Objectos - P. Prata, P. Fazendeiro. Hierarquia de classes e mecanismo de ligação
4 Conceito de Herança Hierarquia de classes e mecanismo de ligação Herança Uma classe pode herdar operações de uma superclasse e as suas operações podem ser herdadas por subclasses. O mecanismo de herança
Tratamento de Exceções
Tratamento de Exceções Carlos Bazilio Isabel Rosseti Depto de Ciência e Tecnologia Pólo Universitário de Rio das Ostras Universidade Federal Fluminense Motivação prever na implementação do sistema situações
Linguagem de Programação III
Linguagem de Programação III Aula-4 Construtores e Sobrecarga Prof. Esbel Tomás Valero Orellana Até Aqui Modelos e POO Classes e sua implementação em Java Encapsulamento Tipos de dados nativos em Java
Programação Orientada a Objetos SANTOS, Rafael (PLT)
Programação Orientada a Objetos SANTOS, Rafael (PLT) Possibilita atribuições em sequência na mesma instrução Retorna o valor atribuído Atribuições compostas: incluem a própria variável: +=, *=, -=, etc
Universidade da Beira Interior Cursos: Engenharia Informática, Matemática /Informática e Ensino da Informática
6 Polimorfismo Sobrecarga (overloading) de métodos: public class x { public void m1( ) {... sobrecarga do método m1 public void m1 ( int p ) {... Diz-se que o nome de um método foi sobrecarregado ( overloaded
nome = n; cargo = c; salario = s; public void print() { System.out.println(nome cargo salario); public void aumento( double fator){
UNIVERSIDADE FEDERAL DE SANTA CATARINA - Departamento de Automação e Sistemas PROGRAMAÇÃO DE SISTEMAS AUTOMATIZADOS - 2016/2 - P2 Nome: ------------------------------------------------------------------------------------------------------
Linguagem de Programação III
Linguagem de Programação III Aula-7 Reutilização de Classes Prof. Esbel Tomás Valero Orellana Até Aqui Introdução a POO e sua implementação em Java Atributos, métodos e encapsulamento dos mesmos Trabalhando
Universidade Federal de Goiás Bacharelado em Ciências da Computacão Compiladores
Universidade Federal de Goiás Bacharelado em Ciências da Computacão Compiladores 2013-2 Compilador para a Linguagem Cafezinho Especificação dos trabalhos: T2 (Geração da Representação Intermediária e Análise
Tratamento de Exceções. Grupo de Linguagens de Programação Departamento de Informática PUC-Rio
Tratamento de Exceções Grupo de Linguagens de Programação Departamento de Informática PUC-Rio Terminologia Definições: Exceção é a ocorrência de uma condição anormal durante a execução de um método Falha
Programação Orientada a Objetos. Métodos e Atributos. Métodos. Métodos. Alexandre César Muniz de Oliveira. Parte III
Programação Orientada a Objetos Alexandre César Muniz de Oliveira Métodos e Atributos Parte III Métodos [mod] tipo nome ([tipo arg]) [throws exc]{ [mod]: zero ou mais modificadores separados por espaços
Java 2 Standard Edition Tipos, literais, operadores e controle de fluxo
Java 2 Standard Edition Tipos, literais, operadores e controle de fluxo Helder da Rocha www.argonavis.com.br 1 Operadores e controle de fluxo da execução Este módulo explora as estruturas procedurais da
CAP. VI ANÁLISE SEMÂNTICA
CAP. VI ANÁLISE SEMÂNTICA VI.1 Introdução Semântica SIGNIFICADO, SENTIDO LÓGICO, COERÊNCIA,... Diferença entre SINTAXE e SEMÂNTICA Sintaxe : descreve as estruturas de uma linguagem; Semântica : descreve
Laboratório de Programação. Aula 12 Java 5COP088. Aula 12 Exceções Prof. Dr. Sylvio Barbon Junior. Sylvio Barbon Jr
5COP088 Laboratório de Programação Aula 12 Exceções Prof. Dr. Sylvio Barbon Junior 1 Sumário: 1) Manipulação de Exceções; 1) Try e Catch 2) Finally 3) Propagação (Throw e Throws) 2) Erros e Exceções Comuns;
Polimorfismo e Ligação Dinâmica. Alcides Pamplona Polimorfismo e Ligação Dinâmica
Alcides Pamplona Linguagem de Programação CESBD 2010 Alcides Pamplona alcides.pamplona@gmail.com Tópicos Ligação Dinamica Polimorfismo Verificação Dinâmica de Tipos 2 Introdução A vinculação ou ligação
Capítulo 7. Expressões e Sentenças de Atribuição
Capítulo 7 Expressões e Sentenças de Atribuição Introdução Expressões são os meios fundamentais de especificar computações em uma linguagem de programação Para entender a avaliação de expressões, é necessário
Universidade Federal de Uberlândia Faculdade de Computação. Linguagem C: Operadores relacionais e lógicos estruturas condicionais If...
Universidade Federal de Uberlândia Faculdade de Computação Linguagem C: Operadores relacionais e lógicos estruturas condicionais If... Else Switch Prof. Renato Pimentel 1 Operações relacionais Operações
Estrutura de Dados Listas
Universidade Federal da Paraíba Centro de Informática Departamento de Informática Estrutura de Dados Listas 1 Tiago Maritan tiago@ci.ufpb.br Conteúdos Abordados O Conceito de Listas Listas com Representação
JAVA. Tópicos Especiais de Programação Orientada a Objetos. sexta-feira, 28 de setembro de 12
JAVA Tópicos Especiais de Programação Orientada a Objetos 1 TRY CATCH 2 O que fazer quando algo inesperado acontece? 3 O que fazer quando algo inesperado acontece? Com JAVA podemos nos prevenir!!! 3 O
Sintaxe Geral Tipos de Dados. Prof. Angelo Augusto Frozza, M.Sc.
Sintaxe Geral Tipos de Dados Comentários Comentários: De linha: // comentário 1 // comentário 2 De bloco: /* linha 1 linha 2 linha n */ De documentação: /** linha1 * linha2 */ Programa Exemplo: ExemploComentario.java
Tratamento de Erros. Sérgio Luiz Ruivace Cerqueira
Tratamento de Erros Sérgio Luiz Ruivace Cerqueira sergioruivace@gmail.com Agenda Introdução Try, catch, finally Unchecked Exceptions Como levantar exceções Boas práticas O problema Calculadora numero1:
Programação Java. - Herança e Polimorfismo - Marco Fagundes Marco Fagundes -
Programação Java - Herança e Polimorfismo - Marco Fagundes mfagundes@tre-pa.gov.br 1 Tópicos Herança Ligação Dinâmica Polimorfismo 2 Herança Herança é um conceito que mapeia as classes relacionadas entre
Análise Semântica e Representação Intermédia
Análise Semântica e Representação Intermédia Compiladores, Aula Nº 22 João M. P. Cardoso 1 Representação do fluxo de controlo Nós de enunciados Nó if Árvore de expressão para a condição Nó para o corpo
Seleção Múltipla Laços (while, do-while, for) AULA 05
Introdução a Programação IF669 http://www.cin.ufpe.br/~if669 Seleção Múltipla Laços (while, do-while, for) AULA 05 Ricardo Massa F. Lima rmfl@cin.ufpe.br Sérgio C. B. Soares scbs@cin.ufpe.br Até aqui...
Fabrício J. Barth. BandTec - Faculdade de Tecnologia Bandeirantes
Árvores Fabrício J. Barth BandTec - Faculdade de Tecnologia Bandeirantes Setembro de 2011 Tópicos Introdução Árvores binárias Implementação em Java Ordens de percurso em árvores binárias Altura de uma
Computação L2. Linguagem C++ Observação: Material Baseado na Disciplina Computação Eletrônica.
Computação L2 Linguagem C++ ovsj@cin.ufpe.br Observação: Material Baseado na Disciplina Computação Eletrônica. Alfabeto São os símbolos ( caracteres ) permitidos na linguagem: Letras (maiúsculas e minúsculas);
Prova 2 PMR3201 1o. semestre 2016 Prof. Thiago Martins
Prova 2 PMR3201 1o. semestre 2016 Prof. Thiago Martins Instruções: Escreva o nome e o número USP na folha de papel almaço. Os códigos fornecidos na seção Códigos-fonte de apoio podem ser referenciados
Simulado de Linguagem de Programação Java
Simulado de Linguagem de Programação Java 1. Descreva o processo de criação de programas em Java, desde a criação do código-fonte até a obtenção do resultado esperado, por meio de sua execução. Cite as
Tratamento de Exceções em Java
Universidade Federal do Amazonas Departamento de Ciência da Computação IEC481 Projeto de Programas Tratamento de Exceções em Java Professor: César Melo Slides baseados em materiais preparados pela Profa.
Programação Orientada a Objetos
Programação Orientada a Objetos Engenharia da Computação Professor: Rosalvo Ferreira de Oliveira Neto Dados Pessoais Rosalvo Ferreira de Oliveira Neto MSc. em ciência da computação (UFPE) rosalvo.oliveira@univasf.edu.br
INSTRUÇÕES DE REPETIÇÃO
Cursos: Análise, Ciência da Computação e Sistemas de Informação Programação I - Prof. Aníbal Notas de aula 6 INSTRUÇÕES DE REPETIÇÃO As instruções de repetição permitem fazer com que a execução de uma
Mecanismo de exceções em Java
Mecanismo de exceções em Java (POO) Centro de Cálculo Instituto Superior de Engenharia de Lisboa Pedro Alexandre Pereira (palex@cc.isel.ipl.pt) Conceito de exceção Erro de execução provocado por condição
Programação de Computadores II TCC /Turma A 1
Programação de Computadores II TCC 00.174/Turma A 1 Professor Leandro A. F. Fernandes http://www.ic.uff.br/~laffernandes Conteúdo: Tratamento de exceções Material elaborado pelos profs. Anselmo Montenegro
Linguagem de Programação III
Linguagem de Programação III Aula-5 Estruturas de Decisão e Controle. Arrays em Java Prof. Esbel Tomás Valero Orellana Até Aqui Modelos e POO Classes e sua implementação em Java Encapsulamento Tipos de
Introdução a classes e objetos. Prof. Marcelo Roberto Zorzan
Introdução a classes e objetos Prof. Marcelo Roberto Zorzan Aula de Hoje Abstração de Dados Classes e Objetos Definição de Métodos Métodos com parâmetro Abstração de Dados Processo mental através do qual
Tratamento de Exceção. Programação Orientada a Objetos Java (Rone Ilídio)
Tratamento de Exceção Programação Orientada a Objetos Java (Rone Ilídio) Tratamento de exceção Exceção é uma contração de Evento de Exceção Evento de exceção impede a execução normal de um programa Quando
Programação Orientada a Objectos - P. Prata, P. Fazendeiro
5 Polimorfismo Sobrecarga (overloading) de métodos: public class x { public void m1( ) {... sobrecarga do método m1 public void m1 ( int p ) {... - Diz-se que o nome de um método foi sobrecarregado ( overloaded
Polimorfismo. O que é polimorfismo?
O que é polimorfismo? Polimorfismo Significa que variáveis podem referenciar mais do que um tipo. Não é um conceito novo e várias linguagens de programação aplicam. Funções são polimórficas quando seus