|
|
| (19 intermediate revisions by the same user not shown) |
| Line 1: |
Line 1: |
| {{NAVPO}}
| | #REDIRECT [[ist:Introdução aos Objectos]] |
| <!--{{TOCright}}-->
| |
| Esta secção apresenta conceitos fundamentais para a programação com objectos. Embora a maioria dos exemplos e da discussão utilize a linguagem Java, também se apresentam em paralelo outros baseados em C++. Quando relevante, podem ser utilizadas outras linguagens (e.g. PHP).
| |
| | |
| Embora algumas linguagens de programação com objectos não usem classes (e.g., as baseadas em protótipos), as que se discutem nestas páginas são, em geral, baseadas em sistemas de classes relacionadas por hierarquias de herança.
| |
| | |
| * [[O que é um objecto?|O que é um objecto]]
| |
| * [[Captura de características dos objectos]]
| |
| | |
| =Introdução à Programação com Objectos=
| |
| | |
| == Entidades Básicas ==
| |
| * [[Tipos primitivos em Java]]: dados atómicos simples;
| |
| * [[Classes, objectos e referências (Java)]]: referências e estruturas compostas ([[Comparação de Linguagens de Programação|contraste com C/C++]]);
| |
| | |
| == Organização de Memória e Visibilidade ==
| |
| | |
| A forma como as linguagens de programação organizam a memória e permitem a criação de objectos pode condicionar o modo de programar e a simplicidade de criação e destruição de objectos.
| |
| | |
| C++, tal como C, permite a criação de objectos em memória estática (numa secção do programa executável), na pilha das funções e no ''heap'' (reserva de memória dinâmica). Os objectos criados estaticamente existem durante todo o programa; os criados na pilha de funções (incluindo os que são criados em blocos internos de funções), são destruídos quando o contexto onde foram criados termina; os objectos criados no ''heap'' têm de ser destruídos explicitamente (através do operador '''delete'''). Note-se que, quando se mencionam objectos, não se referem apenas instâncias de classes, mas de qualquer tipo (incluindo os primitivos).
| |
| | |
| <cpp>
| |
| Gato g1; // objecto estático (criado a nível global)
| |
| Gato *pg1; // Ponteiro global para instância de Gato
| |
| </cpp>
| |
| <cpp>
| |
| void f() {
| |
| Gato g2; // objecto volátil criado na pilha de f
| |
| Gato *pg2; // ponteiro volátil criado na pilha de f
| |
| pg2 = new Gato(); // objecto criado no ''heap''
| |
| delete pg2; // objecto apontado por pg2 é destruído
| |
| } // g2 e pg2 são destruídos automaticamente
| |
| </cpp>
| |
| <cpp>
| |
| class A {
| |
| Gato g3; // objecto em A (inicializado e destruído com a instância de A)
| |
| Gato *pg3; // ponteiro em A (destruído com a instância de A)
| |
| public:
| |
| A() {
| |
| pg3 = new Gato(); // objecto criado no ''heap'' (fora da instância de A)
| |
| }
| |
| ~A() {
| |
| delete pg3; // destruição do objecto apontado por pg3
| |
| }
| |
| };
| |
| </cpp>
| |
| | |
| Em Java, embora referências e instâncias de tipos primitivos possam ser criados no contexto de outros objectos ou nos blocos de funções (pilha), as instâncias de classes apenas podem ser criadas no ''heap''. As entidades criadas em contextos voláteis são automaticamente destruídas (como em C/C++). Não existem instâncias criadas em contextos estáticos. As entidades criadas no ''heap'' devem ser destruídas quando já não são necessárias (para libertar a memória). No entanto, ao contrário do C++, em Java não existe nenhum operador de libertação explícita de memória, sendo a libertação da responsabilidade de um processo automático, o ''garbage collector''. Este processo destrói periodicamente os objectos que não são referenciados por outros ou por qualquer referência de um contexto activo (e.g., uma referência local a uma função).
| |
| | |
| <java5>
| |
| class A {
| |
| Gato g4; // referência em A
| |
| | |
| public A() {
| |
| // objecto criado no ''heap'' (fora da instância de A)
| |
| // será destruído quando a instância de A o for
| |
| g4 = new Gato();
| |
| }
| |
|
| |
| // g5 é destruído no fim de f
| |
| // objecto referenciado por g5 pode ser destruído depois
| |
| public void f() {
| |
| Gato g5; // referência volátil criada na pilha de f
| |
| g5 = new Gato(); // objecto criado no ''heap''
| |
| }
| |
| }
| |
| </java5>
| |
| | |
| Quanto à visibilidade, as entidades estão, em geral, acessíveis no contexto onde são declaradas (e.g., um bloco de uma função), ou são globais. No caso de entidades declaradas no contexto de objectos, o acesso é completo a nível da definição do objecto. O acesso de fora do objecto depende de vários factores, em geral controláveis por primitivas da linguagem. Ver as palavras chave '''public''' ou '''private''' em linguagens como o C++, o Java ou o PHP.
| |
| | |
| == Classes e Objectos ==
| |
| | |
| * [[Classes, objectos e referências (Java)|Definição de classes simples]]: conceitos de variável e método;
| |
| * O uso da palavra reservada <code>static</code>: definição de dados e funções partilhados;
| |
| | |
| == Convenções de Escrita ==
| |
| | |
| As convenções de escrita, embora irrelevantes do ponto de vista do compilador (no sentido de que o compilador aceitará o programa desde que correctamente especificado na linguagem em causa), são importantes do ponto de vista humano, pois melhoram a legibilidade do programa.
| |
| * [[Convenções de escrita de programas em Java]]
| |
| * [[Convenções de escrita de programas em C++]]
| |
| | |
| * Escrita e compilação de programas.
| |
| | |
| = Operadores, Expressões e Controlo de Fluxo =
| |
| | |
| ==Operadores e Expressões==
| |
| | |
| * Apresentação e discussão de operadores, expressões e operações de conversão de tipos primitivos e objectos em Java
| |
| * Aspectos relacionados noutras linguagens (C/C++/Smalltalk)
| |
| * Método <code>equals</code>
| |
| * ''[[Conversão de Tipos|Casts]]''
| |
| * Restrições às operações sobre booleanos
| |
| | |
| ==Controlo de Fluxo==
| |
| | |
| * [[Palavras chave da linguagem Java#if|if]]-[[Palavras chave da linguagem Java#else|else]]
| |
| * [[Palavras chave da linguagem Java#while|while]], [[Palavras chave da linguagem Java#for|for]], [[Palavras chave da linguagem Java#do|do]]-[[Palavras chave da linguagem Java#while|while]]
| |
| * [[Palavras chave da linguagem Java#break|break]], [[Palavras chave da linguagem Java#continue|continue]], [[Palavras chave da linguagem Java#return|return]]
| |
| * [[Palavras chave da linguagem Java#switch|switch]]-[[Palavras chave da linguagem Java#case|case]]-[[Palavras chave da linguagem Java#default|default]]
| |
| * [[Comparação de Linguagens de Programação|Comparação com outras linguagens semelhantes]]
| |
| * Exemplos simples
| |
| | |
| = Exemplos e Exercícios =
| |
| | |
| == Exemplos ==
| |
| * [[Exemplos de Classes em Java]]: ''"Hello world"''.
| |
| | |
| == Exercícios ==
| |
| * [[Introdução aos Objectos/Exercício 01: Gato simples|Exercício 01: Gato simples]]
| |
| * [[Introdução aos Objectos/Exercício 02: Energia|Exercício 02: Energia]]
| |
| | |
| [[category:OOP]]
| |
| [[category:Java]]
| |
| [[category:Teaching]]
| |