Fundamentos de Programação em JAVA (4.ª Ed. Atualizada e Aumentada) by Grupo Lidel

ȱ ȱ

ȱ ȱ ȱ ȱ 'LVWULEXLomR

/LGHO ² HGLo}HV WpFQLFDV OGD

6('( 5 ' (VWHIkQLD 5 & 'WR /,6%2$ ,QWHUQHW ² OLYUDULDO[#OLGHO SW 5HYHQGD ² UHYHQGD#OLGHO SW )RUPDomR 0DUNHWLQJ ² IRUPDFDR#OLGHO SW PDUNHWLQJ#OLGHO SW (QV /tQJXDV ([SRUWDomR ² GHSLQWHUQDFLRQDO#OLGHO SW )D[

/,95$5,$6 /,6%2$ $Y 3UDLD GD 9LWyULD ² /,6%2$ ² 7HO H PDLO OLYUDULDO[#OLGHO SW 32572 5 'DPLmR GH *yLV ² 32572 ² 7HO H PDLO GHOSRUWR#OLGHO SW

&RS\ULJKW QRYHPEUR )&$ ² (GLWRUD GH ,QIRUPiWLFD /GD ,6%1 &DSD -RVp 0DQXHO 5HLV ,OXVWUDomR GD &DSD 0LJXHO 0RQWHQHJUR ,PSUHVVmR H DFDEDPHQWR 5ROR )LOKRV ,, 6 $ ² ,QG~VWULDV *UiILFDV 'HSyVLWR /HJDO 1

2V QRPHV FRPHUFLDLV UHIHUHQFLDGRV QHVWH OLYUR WrP SDWHQWH UHJLVWDGD

0DUFDV 5HJLVWDGDV GH )&$ ² (GLWRUD GH ,QIRUPiWLFD /GD ± ȱ

ȱ ȱ

(VWH SLFWRJUDPD PHUHFH XPD H[SOLFDomR 2 VHX SURSyVLWR p DOHUWDU R OHLWRU SDUD D DPHDoD TXH UHSUHVHQWD SDUD R IXWXUR GD HVFULWD QRPHDGDPHQWH QD iUHD GD HGLomR WpFQLFD H XQLYHUVLWiULD R GHVHQYROYLPHQWR PDVVLYR GD IRWRFySLD 2 &yGLJR GR 'LUHLWR GH $XWRU HVWDEHOHFH TXH p FULPH SXQLGR SRU OHL D IRWRFySLD VHP DXWRUL]DomR GRV SURSULHWiULRV GR FRS\ULJKW 1R HQWDQWR HVWD SUiWLFD JHQHUDOL]RX VH VREUHWXGR QR HQVLQR VXSHULRU SURYRFDQGR XPD TXHGD VXEVWDQFLDO QD FRPSUD GH OLYURV WpFQLFRV $VVLP QXP SDtV HP TXH D OLWHUDWXUD WpFQLFD p WmR HVFDVVD RV DXWRUHV QmR VHQWHP PRWLYDomR SDUD FULDU REUDV LQpGLWDV H ID]r ODV SXEOLFDU ILFDQGR RV OHLWRUHV LPSRVVLELOLWDGRV GH WHU ELEOLRJUDILD HP SRUWXJXrV /HPEUDPRV SRUWDQWR TXH p H[SUHVVDPHQWH SURLELGD D UHSURGXomR QR WRGR RX HP SDUWH GD SUHVHQWH REUD VHP DXWRUL]DomR GD HGLWRUD

Índice geral Agradecimentos..........................................................................................................................XI Sobre o livro...............................................................................................................................XIII 1 - Criação de um programa.......................................................................................................1 1.1 Resolução de problemas............................................................................................................. 1 1.1.1 Resolução de problemas em computador........................................................................ 6 1.1.2 Técnicas de descrição de algoritmos.............................................................................. 10 1.1.3 Criação de algoritmos.................................................................................................... 12 1.2 Do algoritmo ao programa........................................................................................................ 12 1.2.1 Representação digital de informação............................................................................. 12 1.2.2 Componentes de um computador................................................................................... 14 1.2.3 Linguagens de programação.......................................................................................... 15 1.2.4 A linguagem JAVA........................................................................................................ 16 1.3 Executar um programa.............................................................................................................. 17 1.3.1 Tradução de linguagens de programação....................................................................... 18 1.3.2 Compilar um programa em JAVA................................................................................. 18 1.4 Um primeiro programa em JAVA............................................................................................ 20 O problema do Gestor Orçamental................................................................................................... 25 Resumo............................................................................................................................................. 26 Exercícios propostos......................................................................................................................... 27 2 - Manipulação de informação simples............................................................................29 2.1 Estrutura de um programa......................................................................................................... 29 2.2 Variáveis................................................................................................................................... 31 2.3 Constantes................................................................................................................................. 32 2.4 Tipos de dados primitivos......................................................................................................... 32 2.4.1 Representação de números inteiros................................................................................ 33 2.4.2 Representação de números reais.................................................................................... 33 2.4.3 Representação de carateres............................................................................................ 34 2.4.4 Representação de valores lógicos.................................................................................. 35 2.5 Instrução de atribuição.............................................................................................................. 35 2.6 Expressões................................................................................................................................. 36 2.6.1 Expressões aritméticas................................................................................................... 36 2.6.2 A classe Math................................................................................................................. 39 2.6.3 Conversões de tipo......................................................................................................... 39 2.6.4 Expressões lógicas......................................................................................................... 41 O problema do Gestor Orçamental................................................................................................... 42 Resumo............................................................................................................................................. 42 Exercícios propostos......................................................................................................................... 43 3 - Comunicação básica com o utilizador..........................................................................47 3.1 Escrita de mensagens................................................................................................................ 47 © FCA - Editora de Informática

VII

Fundamentos de Programação em JAVA

10.7 Um exemplo – loja de material fotográfico.......................................................................... 226 O problema do Gestor Orçamental................................................................................................. 231 Resumo........................................................................................................................................... 232 Exercícios propostos....................................................................................................................... 235 11 - Coleções..............................................................................................................................239 11.1 Tipos genéricos..................................................................................................................... 239 11.2 A classe ArrayList<E>....................................................................................................... 240 11.2.1 Criação de um ArrayList....................................................................................... 241 11.2.2 Manipulação de um ArrayList. ............................................................................. 242 11.3 A classe HashMap<K,V>....................................................................................................... 246 11.3.1 Criação de um HashMap<K,V>................................................................................. 247 11.3.2 Manipulação de um HashMap<K,V>........................................................................ 247 O problema do Gestor Orçamental................................................................................................. 253 Resumo........................................................................................................................................... 253 Exercícios propostos....................................................................................................................... 254 12 - Ficheiros.............................................................................................................................257 12.1 Fluxos de dados..................................................................................................................... 257 12.2 Ficheiros de texto.................................................................................................................. 258 12.2.1 Manipulação de ficheiros de texto............................................................................ 259 12.2.2 A classe FicheiroDeTexto. ................................................................................... 261 12.3 A classe Scanner. ................................................................................................................ 265 12.4 Ficheiros de objetos.............................................................................................................. 266 12.4.1 Manipulação de ficheiros de objetos........................................................................ 266 12.4.2 A classe FicheiroDeObjectos. ............................................................................. 267 12.5 Exceções............................................................................................................................... 271 O problema do Gestor Orçamental................................................................................................. 274 Resumo........................................................................................................................................... 274 Exercícios propostos....................................................................................................................... 276 13 - Interfaces gráficas.......................................................................................................279 13.1 Criação da interface.............................................................................................................. 279 13.1.1 Desenho numa janela............................................................................................... 280 13.1.2 Adição de componentes à janela.............................................................................. 283 13.1.3 Gestão de eventos..................................................................................................... 286 13.2 Um exemplo – animais da quinta.......................................................................................... 291 O problema do Gestor Orçamental................................................................................................. 297 Resumo........................................................................................................................................... 297 Exercícios propostos....................................................................................................................... 298 Anexo ..........................................................................................................................................301 Glossário de termos correspondentes em português europeu e português do brasil.....................................................................................................305 Índice remissivo........................................................................................................................307

Sobre o livro Objetivos e abordagem Este livro tem como objetivo principal apoiar a aprendizagem de conceitos básicos de programação, utilizando, para isso, a linguagem JAVA. Os temas abordados correspondem às matérias que geralmente são lecionadas em disciplinas de introdução à programação de nível universitário. Os alunos destas disciplinas são os principais destinatários. No entanto, este livro pode ser útil para qualquer pessoa interessada em se iniciar na difícil, mas aliciante, arte de programar. A aprendizagem da programação é uma tarefa complexa que coloca desafios importantes. Muitos alunos confundem aprender a programar com aprender a sintaxe de uma linguagem de programação. Nada poderia estar mais errado. Programar é, antes de mais, delinear estratégias que permitam resolver problemas. Aqui reside a grande dificuldade sentida por muitos alunos, mais habituados a tarefas de memorização e de aplicação automática de fórmulas. Neste contexto, o papel de um livro de programação será, na nossa opinião, o de um auxiliar e de uma referência, que deve sugerir, apoiar e complementar tarefas práticas de programação. Nesta perspetiva, a ferramenta principal de um estudante de programação deverá ser um computador com as ferramentas necessárias para poder desenvolver programas. As características principais de um bom aluno de programação passam pelo método, pela agilidade mental, pela capacidade de trabalho, mas também pela persistência em não desistir perante um problema de difícil solução. É claro que um computador só consegue executar programas escritos numa linguagem de programação, pelo que as soluções terão que ser expressas numa destas linguagens. A escolha da linguagem JAVA justifica-se por ser, na nossa opinião, aquela que entre as linguagens de programação utilizadas atualmente em ambientes profissionais mais se adequa a uma fase de aprendizagem. É uma linguagem que, nos seus aspetos básicos, apresenta uma sintaxe relativamente simples, cuja aprendizagem não é difícil para a maioria dos estudantes. A possibilidade de desenvolver applets que podem ser integrados em páginas Web pode desempenhar um papel relevante na motivação dos alunos. A nossa experiência enquanto docentes de disciplinas de introdução à programação vem reforçar esta convicção. Sendo a linguagem JAVA uma linguagem orientada aos objetos, poderia parecer adequado iniciar a aprendizagem pelos conceitos fundamentais deste paradigma de programação. © FCA - Editora de Informática

XIII

Fundamentos de Programação em JAVA

No entanto, o paradigma de programação procedimental continua a ser muito utilizado, pelo que se torna importante a sua aprendizagem também. Para além disso, programar utilizando este paradigma é um excelente exercício para o desenvolvimento de capacidades de resolução de problemas que podem ser aplicadas nos mais diversos campos. Deste modo, mesmo correndo o risco de parecer pouco natural, consideramos que os alunos devem começar pelo paradigma procedimental, passando posteriormente ao paradigma orientado aos objetos. É desta forma que este livro está organizado.

Organização do livro Conteúdos temáticos Nos primeiros oito capítulos são apresentados os conceitos básicos da programação procedimental. Os restantes capítulos apresentam e usam conceitos da programação orientada aos objetos.

Sínteses e resumos Cada capítulo inicia com uma síntese da matéria que irá ser tratada ao longo do mesmo e termina com um breve e útil resumo sobre os conteúdos explanados nesse capítulo.

Desafios, exercícios , problemas e sugestões Destacados num lettering diferente com um filete lateral de cor cinza, são apresentados ao leitor desafios, exercícios, problemas e/ou sugestões, que lhes permitem colocar em prática, de forma autónoma, o que aprendeu em cada capítulo.

Exercícios propostos No final de cada capítulo é proposto um conjunto de exercícios ao leitor. As soluções para alguns destes problemas podem ser encontradas na página Web de suporte a este livro em http://www.fca.pt. Recomenda-se vivamente que o leitor antes de ver as soluções propostas tente encontrar as suas próprias soluções para os problemas apresentados e só depois as compare com as soluções fornecidas.

Glossário de termos correspondentes em português europeu e português do Brasil Uma novidade: este livro inclui, no final, um glossário com a correspondência dos principais termos técnicos em português europeu e português do Brasil e que poderá ser muito útil aos nossos leitores brasileiros.

XIV

Criação de um programa

1 - Criação de um programa A informática e as comunicações desempenham um papel fundamental nas sociedades modernas. Atualmente é difícil encontrar setores de atividade que não dependam, direta ou indiretamente, do apoio de computadores. O funcionamento dos computadores só é possível através da conjugação dos seus componentes físicos, o hardware, com programas, o software, que incluem as instruções a executar. Pode dizer-se que os programas fornecem conhecimentos e estratégias de resolução de problemas, indispensáveis para que o computador possa desempenhar o seu papel. Cabe ao programador fornecer estes conhecimentos e estratégias, pelo que a capacidade de encontrar soluções para problemas é fundamental para um bom programador. A programação é, assim, a arte de analisar um problema e encontrar um conjunto de ações (um algoritmo) capaz de o resolver corretamente. Este capítulo começa por apresentar o conceito de algoritmo e por descrever e exemplificar algumas técnicas para o seu desenvolvimento (secção 1.1). Para desenvolver programas corretos e eficazes, todo o programador necessita de ter um conhecimento sobre a estrutura e o funcionamento de um computador, bem como sobre as diversas linguagens de programação que pode utilizar. Alguns destes conceitos são abordados na secção 1.2, que inclui também uma apresentação das características gerais da linguagem JAVA. Os passos necessários para executar um programa, com particular ênfase no caso dos programas em JAVA, são abordados na secção 1.3. Finalmente, na secção 1.4, é feita uma primeira apresentação da estrutura de um programa escrito nesta linguagem de programação.

1.1 Resolução de problemas A escrita de um programa de computador tem, normalmente, como objetivo resolver um ou mais problemas. Contrariamente ao que se possa pensar, na maioria das vezes, a principal dificuldade não reside na sintaxe ou na semântica da linguagem de programação utilizada, mas na procura de soluções para o problema em causa, independentemente da forma ou da linguagem usadas para descrever essas soluções. Assim sendo, o passo mais importante na criação de um programa é a definição do seu algoritmo.

Fundamentos de Programação em JAVA

Esta questão coloca-se também a quem se inicia na programação. Muitas vezes confunde-se aprender a programar com aprender a sintaxe e a semântica de uma linguagem de programação. Na realidade, aprender a programar é bastante mais complexo. Um bom programador não é aquele que conhece até à exaustão todos os detalhes de uma linguagem de programação, mas aquele que é capaz de encontrar soluções eficazes para problemas de programação. Claro que um bom conhecimento da linguagem de programação utilizada é importante, mas de pouco serve sem uma boa capacidade de resolução de problemas. Para que se possa encontrar uma solução para um determinado problema é, evidentemente, necessário começar por o compreender. De seguida, o problema deve ser analisado no sentido de procurar soluções adequadas. Muitos dos erros cometidos por programadores inexperientes são causados por uma deficiente compreensão e análise do problema que pretendem resolver. Se estas tarefas forem levadas a cabo com êxito, facilita-se em muito a construção de um programa, pois não é difícil codificar numa linguagem de programação uma solução previamente construída e descrita (mesmo que de uma forma informal). Evidentemente que, depois de escrever o código do programa, será necessário verificar se o mesmo resolve o problema em causa. Para isso, é importante efetuar testes, utilizando diversos conjuntos de dados de entrada, procurando abarcar todas as situações possíveis de utilização. A resolução de problemas é uma tarefa difícil, para a qual não há receitas nem fórmulas que se possam aplicar em função do tipo de problema. Daí que dificilmente se obtém sucesso utilizando estratégias de estudo que privilegiem a memorização da sintaxe de uma linguagem ou de um conjunto de soluções para exercícios tipo. O método, a experiência e a agilidade mental adquiridas com a prática ao longo do tempo são fundamentais. A aprendizagem da programação é, assim, um processo baseado na prática e que exige tempo e experiência. Programar é, pois, a melhor maneira de aprender a programar. Uma das principais dificuldades da programação reside no facto de habitualmente ter de se procurar soluções genéricas para os problemas e não soluções para um caso específico. Veja-se um exemplo: dados os números 10, 30, 20 e 15 é fácil e imediato identificar qual deles é o maior. No entanto, se se pretender um método genérico que identifique qual é o maior de um conjunto de quatro números inteiros (n1, n2, n3 e n4), será necessário elaborar um algoritmo detalhado que especifique todas as operações envolvidas. Neste caso, uma vez que os números não são conhecidos, é necessário procurar uma solução genérica capaz de determinar o maior de qualquer conjunto de quatro números. Algo como: Comparar n1 com n2 e guardar o maior deles numa variável auxiliar i Comparar n3 com n4 e guardar o maior deles numa variável auxiliar j Comparar i com j, o maior deles será o maior dos quatro números

Vetores e matrizes

8 - Vetores e matrizes Como já foi referido, as variáveis de qualquer tipo primitivo apenas podem conter um valor em cada momento. Por exemplo, uma variável int só pode conter um número inteiro, uma variável double só pode conter um número real e assim por diante. Esta é uma limitação importante, pois em muitos programas é útil dispor de uma forma de poder guardar um conjunto de valores sob um determinado nome. Por exemplo, considere-se que é necessário escrever um programa que leia uma lista de notas de alunos, calcule a nota média e liste quais as notas acima da média. Uma vez que é necessário armazenar todas as notas, poder-se-ia pensar na utilização de uma variável para cada uma delas. Esta solução, ainda que possível se for conhecido o número de alunos, apresenta desvantagens sérias. Basta pensar o que sucederia se o número de alunos fosse elevado ou se, uma vez o programa desenvolvido, o número de alunos se modificasse. Neste capítulo, serão apresentadas estruturas de dados que permitem ultrapassar estas limitações (secção 8.1) e as matrizes (secção 8.2).

8.1 Vetores Uma solução melhor para o problema acima descrito passa pela utilização de uma tabela unidimensional ou vetor. Um vetor é uma entidade que contém uma lista de elementos, todos do mesmo tipo. Este conjunto de elementos é referenciado pelo nome do vetor, permitindo, assim, agrupar um qualquer número de elementos do mesmo tipo sob uma única designação. No caso do problema das notas, basta criar um vetor de números inteiros com capacidade para armazenar todas as notas.

8.1.1 Criação de um vetor A criação de um vetor apresenta algumas diferenças em relação à criação de variáveis dos tipos primitivos. Em primeiro lugar, é necessário declarar uma referência para o vetor. Uma referência é uma variável capaz de armazenar um endereço de memória, neste caso o endereço de memória onde posteriormente vai ser criado o vetor. Uma referência para um vetor de números inteiros pode ser criada através de: int[] notas; © FCA - Editora de Informática

137

Fundamentos de Programação em JAVA

Esta declaração permite criar uma referência de nome notas que vai referenciar um vetor de valores do tipo int. O par de parêntesis retos que aparece entre o tipo e o nome da referência indica que se trata de uma referência para um vetor. Uma vez obtida a referência, é possível criar o vetor. Para isso, utiliza-se o operador new: notas = new int[50];

Esta instrução cria um vetor com espaço para armazenar 50 números inteiros do tipo int. Os 50 elementos ficam em posições consecutivas na memória e o endereço do primeiro elemento fica armazenado na referência notas. Esta situação pode ser descrita pelo diagrama da Figura 8.1: notas @ @

@+1

@+2

@+3

@+4

...

@+48

@+49

... Figura 8.1 - Representação em memória de um vetor

A referência armazena o endereço do primeiro elemento do vetor, que foi representado no diagrama pelo símbolo @. Dado que todos os elementos ficam em posições consecutivas de memória, pode-se considerar que o segundo elemento fica em @+1, o terceiro em @+2 e assim sucessivamente, até que o último elemento fica em @+49. Nesta representação, a unidade é igual ao número de células de memória ocupadas por cada elemento. O programador não tem, no entanto, que se preocupar com o endereço de memória onde fica cada elemento do vetor, pois o acesso é feito através de índices e é o intérprete de JAVA que traduz esses índices para as posições de memória ocupadas pelos elementos respetivos. A declaração e a instrução de criação de um vetor podem ser fundidas numa única instrução: int[] notas = new int[50];

A criação de vetores que contenham elementos de outros tipos é semelhante. Em seguida, podem ser observados alguns exemplos: //Cria um vetor capaz de armazenar 20 double double[] vDouble = new double[20]; //Cria um vetor capaz de armazenar 20 boolean boolean[] vBoolean = new boolean[20];

138

Classes e objetos

9 - Classes e objetos A programação orientada a objetos tem vindo a afirmar-se como uma alternativa válida para o desenvolvimento de software. Na realidade, muitas das linguagens de programação modernas, incluindo o JAVA, suportam este paradigma de programação. Neste capítulo, é feita uma primeira abordagem à programação orientada a objetos, nomeada mente, aos seus dois conceitos mais fundamentais: o conceito de classe e o conceito de objeto. Para além dos conceitos gerais sobre este tema, são apresentadas duas classes predefinidas de utilização muito frequente: a classe String e a classe SringTokenizer. É igualmente abordada a utilização de vetores de objetos, mostrando-se como permite a criação de estruturas de dados mais complexas.

9.1 Noções básicas A programação orientada aos objetos refere-se à construção de programas que funcionam essencialmente à custa de entidades (objetos) que possuem características próprias e que são capazes de desempenhar determinadas tarefas. É através destas funcionalidades e dos mecanismos de interação entre objetos que os programas trabalham. Assim, de acordo com este paradigma, desenhar um programa consiste em definir os objetos necessários, as suas funcionalidades e o modo como comunicam entre si, de forma a atingir os objetivos pretendidos. Um objeto é uma combinação de dados ou atributos (variáveis) e ações (subprogramas) íntima e logicamente relacionados. Na terminologia da programação orientada aos objetos é comum denominar os subprogramas por métodos, pelo que daqui em diante é utilizada esta designação. Um objeto pode ser caracterizado por três componentes: Identidade; © FCA - Editora de Informática

161

Fundamentos de Programação em JAVA

Atributos; Comportamento. A identidade permite ao programador e ao sistema identificar o objeto, os atributos permitem caracterizá-lo, enquanto o seu comportamento define o conjunto de funcionalidades que pode executar por opção própria ou a pedido de outro objeto. É comum ter num programa objetos semelhantes, com o mesmo comportamento, mas com atributos e identidade diferentes. Em JAVA, como em qualquer linguagem orientada aos objetos, não é possível definir objetos sem definir primeiro a classe a que pertencem. Uma classe pode ser usada para criar um ou mais objetos, definindo os seus atributos e comportamentos. Funciona como um molde que pode ser utilizado para construir qualquer número de objetos semelhantes ou, dito de outra forma, objetos dessa classe. Desta forma, a definição de uma classe implica a especificação dos atributos (variáveis) e dos comportamentos (métodos) que os objetos criados a partir dela devem possuir. Um objeto é, assim, definido como uma instância de uma classe e possui todas as variáveis (atributos) e métodos (comportamentos) definidos para essa classe. Uma vantagem da programação orientada aos objetos é, então, permitir reunir na mesma entidade os seus atributos e comportamentos, o que permite modelar de forma mais simples e aproximada os elementos do mundo real. A relação entre uma classe e um objeto dessa classe é semelhante à relação entre uma espécie e os diversos elementos dessa espécie. Por exemplo, a espécie cão define um conjunto de características (nome, raça, cor) e comportamentos (correr, ladrar, etc...) que os elementos dessa espécie possuem. Cada elemento da espécie tem estes atributos e é capaz de apresentar estes comportamentos. Por exemplo, o Scott, elemento da espécie cão, da raça Golden Retriever, castanho e que é capaz de correr e ladrar. Por outro lado, pode também existir a Lassie, também elemento da espécie cão, da raça Pastor Alemão, cinzento e também capaz de correr e ladrar. Transpondo este exemplo para a programação orientada aos objetos, poderia existir uma classe Cao que definisse que os objetos desta classe tivessem os atributos nome, raca e cor e apresentassem os comportamentos correr e ladrar. Posteriormente, seria possível criar objetos a partir do molde definido pela classe (os objetos scott e lassie no exemplo). Cada um deles deveria ter valores para os atributos (um nome, uma raça e uma cor) e seria capaz de apresentar os comportamentos definidos (correr e ladrar).

162

Princípios de programação orientada aos objetos

10 - Princípios de programação orientada aos objetos No Capítulo 9 foram apresentados os conceitos básicos que regem o funcionamento de classes e objetos, as estruturas fundamentais em programação orientada aos objetos. No entanto, para tirar verdadeiro partido deste paradigma de programação, é necessário conhecer e aplicar um conjunto de princípios que o tornam verdadeiramente poderoso. Em particular, destacam-se o princípio do encapsulamento e as noções de herança e polimorfismo, os quais são centrais neste paradigma que, hoje em dia, é utilizado em muitos projetos de desenvolvimento de software em larga escala. Neste capítulo, para além de serem apresentados os conceitos de encapsulamento, herança e polimorfismo, serão igualmente abordados outros aspetos relevantes, como sejam as classes abstratas e as interfaces.

10.1 Mais sobre classes e objetos Como já foi referido, numa linguagem orientada aos objetos, os programas funcionam através da criação de objetos, dos comportamentos que estes são capazes de apresentar e da comunicação entre eles, sendo permitido a um objeto solicitar a outro um determinado comportamento, de entre os que tem definidos. Os objetos não podem ser criados sem um “molde” que defina os seus atributos e comportamentos. Este “molde” é a classe, pelo que antes de criar um objeto é necessário que exista a respetiva classe. A partir desta podem ser criados vários objetos, cada um deles com atributos próprios, mas com os mesmos comportamentos. As linguagens de programação orientadas aos objetos, como o JAVA, incluem muitas classes já definidas a partir das quais é possível criar de imediato objetos. No entanto, na maior parte dos projetos de programação, a utilização exclusiva de classes predefinidas na linguagem não é suficiente. Muitas vezes é necessário definir novas classes que possam servir de “molde” a objetos que satisfaçam as necessidades do programador. © FCA - Editora de Informática

201

Fundamentos de Programação em JAVA

No caso da linguagem JAVA, a definição de classes obedece à seguinte sintaxe: public class NomeDaClasse { //Declarações //Construtores //Métodos }

As variáveis de instância ou atributos, os construtores e os métodos de uma classe são genericamente chamados membros da classe. A classe Rectangulo, definida no Capítulo 9, tem como membros quatro variáveis de instância, um construtor e quatro métodos: public class Rectangulo { //Declaração de variáveis de instância private int posX, posY, comp, larg; //Construtor (recebe os valores iniciais dos atributos) public Rectangulo(int pX, int pY, int c, int l) 0pWRGRV GH¿QHP FRPSRUWDPHQWRV

public void desenhaRect(Graphics g) public void apagaRect(Graphics g) public void mudaPosicao(Graphics g, int pX, int pY) public void mudaTamanho(Graphics g, int c, int l) }

As declarações de variáveis efetuadas numa classe podem ser de dois tipos: variáveis de instância ou variáveis de classe. As variáveis de instância servem para armazenar atributos específicos de cada objeto, como sejam o comprimento ou a largura no caso dos retângulos. Cada objeto desta classe tem um comprimento e uma largura, embora os seus valores possam ser diferentes de objeto para objeto.

202