P. 1
ApostilaJava

ApostilaJava

|Views: 1,057|Likes:
Published by LaraMary

More info:

Published by: LaraMary on May 31, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

02/03/2013

pdf

text

original

Sections

  • 1.1 Um Pouco de História
  • 1.2 Por que Java é tão Interessante?
  • 1.3 Como Java Pode Mudar Minha Vida?
  • 1.4 Mas Afinal, o Que Java Pode Fazer?
  • 1.5 Arquitetura Java
  • 1.6 Desenvolvendo os Primeiros Programas em Java
  • 1.7 Exercícios:
  • 2. Conceitos de Orientação a Objetos
  • 2.1 Conceitos Básicos
  • 2.2 Características da Tecnologia de Objetos
  • 2.3 Exercícios
  • 3. Diferenças entre Java e C/C++
  • 4. Construções Básicas da Linguagem Java
  • 4.1 Variáveis e Tipos de Dados
  • 4.2 Operadores
  • 4.3 Expressões
  • 4.4 Controle de Fluxo
  • 4.5 Arrays e Strings
  • 4.6 Exercícios
  • 5. Classes e Objetos em Java
  • 5.1 Classe
  • 5.2 Ciclo de Vida de um Objeto
  • 5.3 Liberando Objetos não mais Utilizados
  • 5.4 Criando Classes
  • 5.5 Exercícios
  • 6. Outras Características da Linguagem Java
  • 6.1 Herança
  • 6.2 Ocultando variáveis
  • 6.3 Redefinindo (overriding) métodos
  • 6.4 Métodos e Classes Abstratas
  • 6.5 Classes e Métodos Finais
  • 6.6 Interfaces
  • 6.7 Utilizando Interfaces como Tipos de Dados
  • 6.8 Pacotes (Packages)
  • 6.9 Gerenciando Arquivos Fonte e Arquivos de Classe
  • 6.10 Exercícios
  • 7. Interface Gráfica
  • 7.2 Inserindo Widgets em Applets
  • 7.3 Modelo de Eventos do Java (1.1)
  • 7.4 Gerenciadores de Layout (Layout Managers)
  • 7.5 Cores e Fontes
  • 7.6 Exercícios
  • 8. Applets
  • 8.1 Introdução
  • 8.2 Ciclo de Vida de um Applet
  • 8.3 Métodos Utilizados para Desenho e Tratamento de Eventos
  • 8.4 Mostrando Imagens Dentro de um Applet
  • 8.5 Adicionando um Applet a uma Página HTML
  • 8.6 Exercícios
  • 9. Threads
  • 9.1 O que é uma Thread
  • 9.2 Utilizando o Método run de uma Thread
  • 9.3 Ciclo de Vida de uma Thread
  • 9.4 Sincronização de Threads
  • 9.5 Exercícios
  • 10. Entrada e Saída
  • 10.1 Introdução
  • 10.2 Leitura e Escrita de Arquivos
  • 10.3 Entrada e Saída de Dados (Padrão)
  • 10.4 Exercícios

Introdução a Linguagem Java

Apostila desenvolvida por Alexandre de Souza Pinto (Engenheiro de Computação – Unicamp Mestre em Engenharia Eletrica – Unicamp, Consultor da Software Design Informática-Campinas, SP) e formatada por Marco Aurélio Lopes Barbosa

Pág 1

1. INTRODUÇÃO.............................................................................................................5 1.1 Um Pouco de História...................................................................................................5 1.2 Por que Java é tão Interessante?.................................................................................6 1.3 Como Java Pode Mudar Minha Vida?......................................................................8 1.4 Mas Afinal, o Que Java Pode Fazer?.........................................................................9 1.5 Arquitetura Java.........................................................................................................10 1.6 Desenvolvendo os Primeiros Programas em Java..................................................12 1.7 Exercícios:....................................................................................................................16 2. CONCEITOS DE ORIENTAÇÃO A OBJETOS.....................................................17 2.1 Conceitos Básicos........................................................................................................17 2.2 Características da Tecnologia de Objetos ..............................................................20 2.3 Exercícios......................................................................................................................23 3. DIFERENÇAS ENTRE JAVA E C/C++..................................................................24 4. CONSTRUÇÕES BÁSICAS DA LINGUAGEM JAVA.........................................28 4.1 Variáveis e Tipos de Dados........................................................................................28 4.2 Operadores ..................................................................................................................31 4.3 Expressões....................................................................................................................35 4.4 Controle de Fluxo........................................................................................................37 4.5 Arrays e Strings...........................................................................................................42 4.6 Exercícios......................................................................................................................45 5. CLASSES E OBJETOS EM JAVA.........................................................................46 5.1 Classe.............................................................................................................................46 5.2 Ciclo de Vida de um Objeto.......................................................................................48 5.3 Liberando Objetos não mais Utilizados...................................................................52 Pág 2

5.4 Criando Classes...........................................................................................................54 5.5 Exercícios......................................................................................................................76 6. OUTRAS CARACTERÍSTICAS DA LINGUAGEM JAVA...................................80 6.1 Herança.........................................................................................................................80 6.2 Ocultando variáveis....................................................................................................81 6.3 Redefinindo (overriding) métodos............................................................................82 6.4 Métodos e Classes Abstratas......................................................................................83 6.5 Classes e Métodos Finais............................................................................................85 6.6 Interfaces......................................................................................................................86 6.7 Utilizando Interfaces como Tipos de Dados............................................................91 6.8 Pacotes (Packages)......................................................................................................92 6.9 Gerenciando Arquivos Fonte e Arquivos de Classe...............................................95 6.10 Exercícios....................................................................................................................97 7. INTERFACE GRÁFICA..........................................................................................100 7.1Widgets........................................................................................................................100 7.2 Inserindo Widgets em Applets................................................................................106 7.3 Modelo de Eventos do Java (1.1).............................................................................107 7.4 Gerenciadores de Layout (Layout Managers)......................................................112 7.5 Cores e Fontes............................................................................................................113 7.6 Exercícios....................................................................................................................114 8. APPLETS.................................................................................................................115 8.1 Introdução..................................................................................................................115 8.2 Ciclo de Vida de um Applet.....................................................................................116 8.3 Métodos Utilizados para Desenho e Tratamento de Eventos.............................117 8.4 Mostrando Imagens Dentro de um Applet............................................................118 Pág 3

........127 10....................................................................................................................................................................................3 Ciclo de Vida de uma Thread...............2 Utilizando o Método run de uma Thread..................................................................................125 9................................................................................... ENTRADA E SAÍDA................118 8........................................................120 9.................4 Exercícios ............... THREADS...................5 Adicionando um Applet a uma Página HTML......119 9..........................................................................................................................................................1 Introdução....4 Sincronização de Threads..........................................................1 O que é uma Thread.................................................................................................................................130 Pág 4 .........................................5 Exercícios................120 9..............................3 Entrada e Saída de Dados (Padrão).......123 9.........127 10...................129 10..................................................126 10......2 Leitura e Escrita de Arquivos................6 Exercícios...................................................................................................................................8.127 10....................121 9..................

Depois de algum tempo. Entretanto. da Sun Microsystems. etc.” Antoine de Saint Exupery 1.) a partir de um computador portátil chamado *7 (Star Seven). Gosling usou o próprio C++ como modelo. O fenômeno Java cativou a imaginação de programadores em todo mundo e está proporcionando o desenvolvimento de uma nova geração de aplicações distribuídas. onde tentou-se projetar um sistema de controle remoto para uso doméstico. uma linguagem considerada atual devido às suas características de orientação a objetos. Este nome surgiu pois. Introdução Nunca anteriormente nenhuma nova linguagem de programação recebeu tanta atenção e tornou-se tão popular em tão pouco tempo. aproveitando a sintaxe básica da linguagem e a sua natureza orientada a objetos e retirando aquelas características que tornavam a linguagem mais complexa. Desde o seu surgimento. Este sistema permitiria ao usuário controlar vários dispositivos (TV. Ao terminar de projetar sua nova linguagem. Not when you have nothing more to add. em inglês. telefones. Gosling e sua equipe perceberam rapidamente que C++ não era a linguagem mais adequada para aquele projeto. Oak também foi utilizado em um projeto de vídeo sob demanda (Video on Demand. a Sun descobriu que o nome Oak já estava registrado por outra companhia e decidiu trocar o nome da linguagem para Java (segundo a lenda. Para desenvolver esta nova linguagem. But when you have nothing more to take away. dificultavam bastante o desenvolvimento das aplicações. Apesar dos projetos Green e VOD não tenham gerado produtos comerciais. como herança múltipla de classes e leaks de memória. Gosling chegou a uma conclusão simples: era necessário criar sua própria linguagem de programação. video-cassete. começaram a desenvolver seu software utilizando C++. 1. pode-se observar um belo pinheiro). Esta linguagem deveria ser simples o bastante para evitar todos aqueles problemas que estavam relacionados com o C++. da janela do escritório de Gosling. em Pág 5 .1 Um Pouco de História Em 1990. Aspectos do C++. Oak foi usado pela primeira vez em um projeto chamado Green. Então. Gosling e sua equipe. Gosling a chamou de Oak (pinheiro. um senhor chamado James Gosling recebeu a tarefa de criar aplicações para eletrodomésticos. Java tornou-se uma escolha atraente para o desenvolvimento de aplicações Internet/intranet. VOD) como base para um software de controle de uma TV interativa. luzes.“You know you've achieved perfection in design. eles proporcionaram a linguagem Oak uma chance de desenvolver-se a amadurecer.

Um dos desafios fundamentais está relacionado com a instalação segura de aplicações que consumam o mínimo de recursos do sistema. a equipe Java percebeu que a linguagem que desenvolveram era perfeita para programação Web. Surgiu então o conceito de applets. Os conceitos fundamentais de Java são absorvidos rapidamente e. A Netscape Communications.). foi projetada desde o início para ser orientada a objetos. não sendo necessário um extensivo treinamento por parte dos programadores. adicionou suporte a Java na versão 2. interface gráfica. Outros fornecedores de browsers. como a Microsoft (Internet Explorer 3. portanto. A seguir. de acordo com as necessidades da aplicação em particular.1 Simples. cada vez mais complexos. etc.0 do seu navegador. possam executar em qualquer plataforma de hardware e software e possam ser estendidas dinamicamente. A “nova” linguagem foi rapidamente considerada como uma poderosa ferramenta para desenvolver aplicações Internet. Por ser parecida. multimídia.2 Por que Java é tão Interessante? A linguagem Java foi projetada para atender às necessidades do desenvolvimento de aplicações em um ambiente distribuído (rede) e heterogêneo. No segundo trimestre de 1995. Além disto. Java. são apresentadas algumas características da linguagem Java que a tornam tão interessante e adequada para o desenvolvimento de uma nova geração de aplicações.0). Estas bibliotecas podem ser facilmente estendidas. 1. ao contrário de C++. via herança. networking. também seguiram o exemplo. Em 1993. desenvolveram um browser Web completo (chamado HotJava) para demonstrar o poder da linguagem Java. depois da World Wide Web ter transformado a Internet em um ambiente rico em gráficos. que desenvolve o browser Netscape. Java acaba se tornando uma linguagem familiar pois possui o “look and feel” do C++. A linguagem é acompanhada de um grande número de bibliotecas de classes já testadas e que proporcionam várias funcionalidades (E/S.homenagem ao gosto da equipe por café. Orientada a Objetos e Familiar Uma das características principais de Java é a simplicidade da linguagem. com C++. o máximo possível. O paradigma de orientação a objetos. a Sun anunciou oficialmente o Java.2. os programadores conseguem ser produtivos em pouco tempo. 1. Java é uma ilha da Indonésia famosa por produzir tal bebida). criado a cerca de 30 anos. Pág 6 . pequenos programas que podiam ser incluídos em páginas Web. provou-se adequado para o desenvolvimento dos sistemas atuais.

aspectos de segurança são de fundamental importância. 1. O interpretador da linguagem possui algumas otimizações que permitem a execução mais eficiente de código Java. Esta arquitetura neutra e portável é chamada de Máquina Virtual Java (Java Virtual Machine. Além disto. Além de prover verificações durante a compilação. nem aritmética de apontadores. Como Java foi desenvolvida para operar em ambientes distribuídos. a natureza interpretada de Java resolve o problema de distribuição de código binário. Assim. seu desempenho. Desta forma. A neutralidade da arquitetura é apenas uma parte de um sistema verdadeiramente portável.2. A linguagem possui características de segurança e a própria plataforma realiza verificações em tempo de execução. Obviamente.2. não existem incompatibilidades de tipos de dados entre arquiteturas de software/hardware diferentes. o compilador Java gera bytecodes.3 Arquitetura Neutra e Portável Para suportar a distribuição em ambientes heterogêneos. seção ). JVM. Desta forma.2. é inferior ao de linguagens compiladas para linguagem de máquina (C++. aplicações escritas em Java estão “seguras” contra códigos não autorizados que tentam criar vírus ou invadir sistemas de arquivos. Java também define os tamanhos de seus tipos básicos e o comportamento de seus operadores aritméticos. aplicações que necessitam de grande poder computacional podem ter suas seções mais críticas reescritas em código nativo (compilado a partir da linguagem C. As próprias características do Java ajudam o programador a seguir bons hábitos de programação. um formato intermediário neutro projetado para o transporte eficiente em múltiplos ambientes de software/hardware.1. Pág 7 . elimina-se um importante tipo de erro que atormentava os programadores C++. A liberação da memória dos objetos que não são mais referenciados é feita por meio de um mecanismo chamado garbage collection (coleta de lixo). Assim. 1. as aplicações devem ser capazes de executar em uma variedade de sistemas operacionais e de arquiteturas de hardware. por exemplo). em geral. Java possui um segundo nível de verificações (em tempo de execução).4 Alto Desempenho Desempenho é um fator que sempre deve ser levado em consideração. Não existem tipos como apontadores.2 Robusta e Segura Java foi projetada para criar software altamente confiável. por exemplo). pela característica interpretada da linguagem. O modelo de gerência de memória é extremamente simples: objetos são criados por meio de um operador new. Para acomodar esta diversidade de plataformas.

Java deve tornar seus programas melhores e exigir menos esforço de desenvolvimento do que outras linguagens. Java suporta multithreading no nível da linguagem (suporte nativo e não por meio de bibiotecas externas). as características discutidas nos itens anteriores podem ser encontradas em uma variedade de ferramentas de desenvolvimento de software. que podem melhorar consideravelmente o desempenho das aplicações. ou seja. poderosa. Atualmente.Existem soluções como compiladores Just-in-Time (JIT). Multithreaded e Dinâmica O interpretador da linguagem Java pode executar os bytecodes em qualquer máquina onde exista o ambiente de execução (run-time environment) instalado. Assim. a linguagem oferece uma série de primitivas sofisticadas de sincronização (semáforos. o ciclo de desenvolvimento. A linguagem Java é dinâmica pois as classes (código) somente são ligadas (linked) a aplicação quando necessário.2. ao mesmo tempo. para aplicações fundamentalmente interativas. seguro e de alto desempenho. Aplicações de rede. Desenvolver aplicações em Java resulta em um software que é portável em múltiplas plataformas de hardware e software (sistemas operacionais. como browsers. A grande novidade é a maneira como Java (e seu ambiente de execução) combinaram estas qualidades e produziram uma linguagem flexível e. Resumindo. interfaces gráficas). Provavelmente.3 Como Java Pode Mudar Minha Vida? Consideradas individualmente. Assim. pode-se dizer que. Além disto. Esta característica proporciona a possibilidade de se atualizar transparentemente as aplicações. através da própria rede). que compilam os byte-codes Java para a linguagem nativa da máquina em particular. obtem-se um alto grau de interatividade com o usuário da aplicação. ligar e testar). Um fato importante é que todas as bibliotecas de sistema da linguagem Java foram desenvolvidas para serem “thread safe”. 1. Novos módulos podem ser ligados sob demanda a partir de diversas fontes (inclusive. Por exemplo. 1.5 Interpretada. A capacidade da linguagem Java de executar várias threads dentro de um programa (processo) permite que uma aplicação seja construída de tal forma que para cada atividade seja reservada uma thread exclusiva de execução. Java pode ajudálo a: Pág 8 . incremental e leve. os usuários não notam diferenças significativas entre aplicações desenvolvidas em Java e outras linguagens compiladas. a fase de ligação (linking) de um programa é simples. Pela característica interpretada da linguagem. tipicamente precisam realizar várias tarefas “simultaneamente”. um usuário utilizando um browser pode rodar várias animações enquanto busca uma imagem e faz um “scroll” da página Web. não existe a possibilidade de ocorrência de conflitos caso threads concorrentes executem funções destas bibliotecas. por exemplo). prototipação e testes tende a ser mais rápido do que o método tradicional (compilar.

entrada/saída. consegue-se criar aplicações 100% Java (100% Pure Java) que executam corretamente em qualquer plataforma: Write once. strings. por exemplo) a partir de um servidor central. Mas Afinal. Entretanto. Utilizando a extensa biblioteca (API) Java. tempo. estrutura de dados. especialmente para aqueles programadores familiarizados com C ou C++. Esta API central proporciona as seguintes funcionalidades: • Fundamentais: Objetos. Java não serve apenas para escrever applets bonitinhos e divertidos para WWW. Evitar dependências de plataforma: utilizando alguns conselhos simples de programação. é fácil de aprender. o Que Java Pode Fazer? 1. A característica de orientação a objetos e a extensa API (Application Program Interface) permite que um programador reutilize facilmente código desenvolvido (e testado) por outras pessoas.• • • • • • Iniciar rapidamente o desenvolvimento: embora Java seja uma linguagem orientada a objetos. métodos. os programas em Java mais conhecidos são os applets. Em vez de executar em um browser. Distribuir software mais facilmente: pode-se facilmente atualizar aplicações (applets. que não executam em browsers) para uma ampla variedade de aplicações. Applet é um programa que possui determinadas características que o permitem executar em um browser (que possui suporte a Java). threads. números. WWW. Escrever um código melhor: a linguagem encoraja boas práticas de programação.4 Provavelmente. Escrever menos código: comparações de métricas de programas (número de classes. Como a API do Java suporta todos estes tipos de programas? A API do Java é dividida em pacotes (packages) de componentes de software que oferecem uma ampla gama de funcionalidades. data. Servlets são similares a applets pois também são extensões a um ambiente de execução. etc.) sugerem que um programa escrito em Java pode ser até quatro vezes menor do que um mesmo programa desenvolvido em C++. Por que? Escreve-se menos linhas de código em Java e a linguagem é mais simples que C++. Existe uma API central (core API) que está incluída em qualquer implementação da plataforma Java. Desenvolver programas mais rapidamente: o tempo necessário para desenvolver uma aplicação em Java pode ser até duas vezes menor do que construir o mesmo programa em C++. e seu esquema de gerência de memória (garbage collection) ajuda a evitar os temidos leaks de memória. run anywhere. Pág 9 . por exemplo). os servlets executam em servidores Java (mail. Java é uma linguagem de propósito geral e uma poderosa plataforma de software. Outro tipo de programa especial do Java é o servlet. pode-se desenvolver programas Java standalone (isto é. etc.

• Segurança: suporte. controle de acesso e certificados. gerência de chaves públicas e privadas. para assinaturas eletrônicas.1 A Linguagem de Programação Java Java é uma linguagem de programação de alto nível com as seguintes características (apresentadas nos itens anteriores): • • • • • • • • • • Simples Arquitetura neutra.5 Arquitetura Java Na realidade. processamento de fala. já a interpretação acontece cada vez que o programa é executado. Java tem dois significados: é uma linguagem de programação e uma plataforma. em alto e baixo nível. Os programas podem se adaptar automaticamente a locais específicos e apresentar a linguagem apropriada.• Applets: funções utilizadas pelos applets.5. telefonia. portável Interpretada Orientada a objetos Distribuída Alto desempenho Multithreaded Robusta Segura Dinâmica Java possui uma característica um tanto rara: um programa Java é compilado e interpretado. Além da API central. animação. TCP and UDP sockets. Java possui extensões padronizadas. groupware. 1. and endereços IP. servidores. A figura abaixo ilustra esta situação: Pág 10 . Com o compilador. Os bytecodes são independentes de arquitetura de software/hardware. • Serialização: permite um esquema de persistência leve e uma comunicação via Remote Method Invocation (RMI). 1. • Java Database Connectivity (JDBC): oferece um acesso uniforme a uma grande variedade de bancos de dados relacionais. Estas extensões definem API´s para manipulação de imagens 3D. • Networking: URLs. é feita a tradução de um programa Java para um código intermediário chamado de bytecode. entre outras. Observe que a compilação ocorre apenas uma vez. Com o interpretador cada instrução bytecode é analisada (parse) e executada no computador. • Internacionalização: auxilia o desenvolvimento de programas que possam ser localizados para usuários de todo o mundo.

é a fundação (base) da plataforma Java e já existem implementações da JVM para diversas plataformas de hardware/software. A plataforma Java possui dois componentes: • A Máquina Virtual Java (JVM) • A Interface de Programação de Aplicação (Application Programming Interface. JVM). Assim. A JVM também pode ser implementada diretamente em hardware. apresentada no item anterior.2 A Plataforma Java Plataforma é o ambiente de hardware ou software onde um programa é executado. O produto da compilação (bytecodes) pode então ser executado em qualquer implementação da Máquina Virtual Java. é uma implementação da JVM. presente em uma ferramenta de desenvolvimento ou em um browser. O conceito de bytecodes auxilia a tornar o lema “write once. Pág 11 . A plataforma Java difere da maioria das outras pelo fato de ser uma plataforma (de software.5. Solaris e Macintosh sem a necessidade de recompilação (figura a seguir). API) A Máquina Virtual Java. Pode-se compilar os programas Java em qualquer plataforma que possuir um compilador Java. Todo interpretador Java. 1.Pode-se imaginar os bytecodes como a “linguagem assembly” da Máquina Virtual Java (Java Virtual Machine. apenas) que executa sobre outras plataformas baseadas em hardware e software (sistema operacional). o mesmo programa Java pode executar em Windows NT. run anywhere” possível.

1. compiladores just-in-time podem aproximar o desempenho de Java ao do código nativo sem ameaçar a portabilidade da linguagem. Programa Java API Java Máquina Virtual Java Plataforma Hardware Por ser um ambiente independente de plataforma.6 Desenvolvendo os Primeiros Programas em Java Plataforma Java Antes de iniciar o desenvolvimento de programas em Java. O JDK contém toda a API central (core API) e sua documentação.2 (a Sun passou a denominar a versão 1. As principais ferramentas que acompanham o JDK são: • javac: compilador que pode compilar qualquer tipo de programa Java • java: interpretador utilizado para executar aplicações Java (standalone) • appletviewer: ambiente para execução de applets Java Além destas ferramentas. Java tende a possuir um desempenho pior do que aplicações em código nativo. gerador de documentação.com/j2se/1.2. Note que.8.A API do Java é uma grande coleção de componentes de software. a versão da API que é suportada pelos browsers atuais (IE 5. 1. Entretanto. A figura a seguir ilustra um programa Java. desenvolvida pela própria Sun.sun. etc. O JDK é gratutito para download e pode ser obtido em: http://java. compiladores e interpretadores otimizados. Entretanto.html Pág 12 . A ferramenta mais comumente utilizada chama-se Java Development Kit (JDK). que oferecem muitas funcionalidades úteis como elementos de interface gráfica (GUI).) que serão apresentados ao longo do curso. A versão mais recente do JDK é a 1.2 do JDK de Java 2). a API e a JVM da plataforma Java “isolam” o programa Java das diferenças das plataformas de hardware. “compactador” de classes. standalone ou applet. o JDK oferece outros utilitários (depurador.6) é a 1. é necessário possuir um ambiente de desenvolvimento Java. além de exemplos de applets. que executa em uma plataforma Java. A API Java é agrupada em bibliotecas (packages) de componentes relacionados.0 e Communicator 4.4/index. prontos para uso.

Word. independentes de plataforma.1. o compilador vai criar um arquivo chamado HelloWorldApp. Textpad.java com o seguinte código Java: /** * A classe HelloWorldApp implementa uma aplicação que * simplesmente mostra "Hello World!" na saída padrão (monitor). que são interpretados pelo ambiente de execução do Java.1 Aplicação “Hello World” Nesta seção. */ class HelloWorldApp { public static void main(String[] args) { System.println("Hello World!").6. execute o interpretador Java: java HelloWorldApp Observação Importante: o argumento do interpretador Java é o nome da classe a ser executada e não o nome do arquivo. Pág 13 . etc. //Mostra a string } } Compilar o Código Fonte No prompt do DOS. Executar a Aplicação No prompt do DOS. O nome da classe deve ser digitado da mesma maneira que foi definido no código fonte (maiúsculas/minúsculas).class no mesmo diretório do arquivo fonte (HelloWorldApp.java Se a compilação tiver êxito.java). Se a compilação falhar. Criar um Arquivo Fonte em Java Usando um editor de texto qualquer (notepad. crie um arquivo (ASCII) chamado HelloWorldApp.).out. O arquivo gerado contém os bytecodes Java. verifique se o programa foi digitado corretamente (cuidado com as letras maiúsculas/minúsculas). execute o compilador Java: javac HelloWorldApp. são descritos os passos para a criação de uma aplicação Java “standalone”.

Definindo uma Classe Na linguagem Java. então. usa os delimitadores /** e */. System. Quando se executa uma aplicação. invoca o método main definido dentro daquela classe. utiliza uma outra classe. A linguagem Java não suporta funções ou variáveis globais.. A classe System oferece acesso a funções do sistema operacional. O interpretador. delimitado por /* e */. Utilizando Classes e Objetos Os outros componentes de uma aplicação Java são os objetos. via interpretador Java. classes. A linguagem Java suporta um terceiro tipo de comentário. As variáveis e os métodos da classe são delimitados por um par de chaves. O Método main O ponto de entrada de qualquer aplicação Java é o método main. O método main controla o fluxo do programa.2 Anatomia da Aplicação Uma vez executada a primeira aplicação Java.6. Pág 14 . Comentários em Java A aplicação “Hello World” tem dois blocos de comentários. especifica-se o nome da classe a ser executada. } A palavra-chave class começa a definição de uma classe denominada name. métodos e comandos (statements) da linguagem Java escritos para implementar as funcionalidades desejadas. aloca recursos e executa quaisquer outros métodos que fazem parte da funcionalidade da aplicação. vamos analisar esta aplicação standalone. A aplicação “Hello World”. no início do programa. Em Java. uma linha de código é explicada por meio de um comentário marcado com os caracteres //. que é parte da API que acompanha o ambiente Java. por exemplo. Portanto. O primeiro bloco. Depois. A aplicação “Hello World” não possui variáveis e tem um único método chamado main. o esqueleto de qualquer programa Java é uma definição de classe. na verdade. cada método (função) e variável deve existir dentro de uma classe ou objeto (uma instância de uma classe). a forma mais simples de se definir uma classe é: class name { .1.. estilo C.

Graphics.java Se a compilação tiver êxito.).html no mesmo diretório que contém a classe HelloWorld. etc. independentes de plataforma. Este arquivo HTML deve conter o seguinte código: <HTML> <HEAD> <TITLE> Um Programa Simples </TITLE> </HEAD> <BODY> Aqui está o meu applet: <APPLET CODE="HelloWorld.java com o seguinte código Java: import java. verifique se o programa foi digitado corretamente (cuidado com as letras maiúsculas/minúsculas). que pode ser executado em um browser Web. import java. 25).class. Criar um Arquivo HTML que Inclua o Applet Utilizando um editor de texto qualquer. são descritos os passos para a criação de um applet Java. crie um arquivo chamado Hello. 50.1.class" WIDTH=150 HEIGHT=25> Pág 15 . Criar um Arquivo Fonte em Java Usando um editor de texto qualquer (notepad. que são interpretados pelo ambiente de execução. public class HelloWorld extends Applet { public void paint(Graphics g) { g.class no mesmo diretório do arquivo fonte (HelloWorld. O arquivo gerado contém os bytecodes Java.Applet.java). execute o compilador Java: javac HelloWorld.applet.3 Applet “Hello World” Nesta seção.drawString("Hello world!".awt. } } Compilar o Código Fonte No prompt do DOS. Se a compilação falhar.6. crie um arquivo (ASCII) chamado HelloWorld. Word. o compilador vai criar um arquivo chamado HelloWorld. Textpad.

como o Applet Viewer que acompanha o JDK.html Para utilizar o Applet Viewer. No browser. no campo Location.7 Exercícios: 2. Explorar. deve-se carregar o arquivo HTML em um ambiente que possa executar applets Java. Este ambiente pode ser um browser compatível com Java ou um programa para visualização de applets. Qual a diferença entre um applet Java e uma aplicação standalone? 3. algumas das várias fontes para programadores Java. pode-se digitar. para carregar o applet. executar e observar o código-fonte de alguns exemplos disponíveis.html 1. digite no prompt do DOS: appletviewer c:\src\Hello. na Internet. 5. Como você acha que a citação apresentada no início da apostila se relaciona com Java? Pág 16 .</APPLET> </BODY> </HTML> Executar o Applet Para executar o applet. uma URL do tipo: file:/home/asouza/HTML/Hello. Por que os applets Java são considerados como uma aplicação neutra (em termos de plataforma)? 4.

etc. Como outras linguagens de programação modernas. Conceitos de Orientação a Objetos Linguagens de programação. SmallTalk. Benefícios da tecnologia de objetos são observados à medida que um número cada vez maior de empresas “migram” seus produtos para este tipo de modelo. com fome) e um comportamento (latindo. o conceito de “orientação a objetos” continua um pouco confuso e é propagado como a “bala de prata” que vai resolver todos os problemas do mundo do software. Além disto. Por exemplo. um cachorro tem um estado (nome. bicicleta. com exceção dos tipos de dados primitivos. como os próprios idiomas humanos.1. objetos de software são modelados de acordo com os objetos do mundo real. Analogamente. lambendo).2.1 2. evoluem ao longo do tempo. pode-se alcançar. se for necessário). cor. pode-se representar objetos do mundo real utilizando objetos de software. Infelizmente. ou seja. seguindo os paradigmas de desenvolvimento mais utilizados. cadeira. o conceito de objetos é fundamental para o entendimento desta tecnologia. tudo em Java é um objeto (até mesmo os tipos primitivos podem ser encapsulados dentro de objetos. Portanto. Como uma linguagem orientada a objetos. objetos de software podem ser usados para modelar conceitos abstratos (por exemplo. Um objeto de software armazena seu estado em variáveis e implementa seu comportamento com métodos. Java é um amálgama de várias técnicas desenvolvidas ao longo dos anos. Por exemplo. raça. comendo. um evento de interface gráfica que representa a ação do usuário pressionando uma tecla). Há um constante refinamento e aperfeiçoamento para atender às exigências cada vez maiores dos usuários. Pode-se olhar a sua volta e encontrar vários exemplos de objetos: cachorro. 2. Na verdade. televisão. uma visão superficial de programação orientada a objetos é afirmar que este paradigma é simplesmente uma nova maneira de organizar o código fonte. Java aproveita os melhores conceitos e funcionalidades de linguagens mais antigas (principalmente Eiffel. Objective C e C++). a linguagem Java é orientada a objetos. O paradigma de orientação a objetos já demonstrou que é muito mais do que uma simples “moda”. resultados que não seriam possíveis de se obter com técnicas procedurais. Java vai além do C++ pois estende o modelo de objetos e remove as maiores complexidades da linguagem. Por exemplo. Estes objetos do mundo real compartilham duas características: possuem um estado e tem um comportamento. com técnicas de programação orientada a objetos. como C++.1 Conceitos Básicos Objetos Como o próprio nome “orientado a objetos” indica. Pág 17 . possuem também estado e comportamento. Assim.

a encapsulação é usada para esconder detalhes de implementação pouco importantes. apenas qual alavanca deve ser movida. um objeto que modela uma bicicleta poderia ter variáveis que indicam seu o estado atual: velocidade é 20 km/h. Assim. não é preciso saber como o mecanismo de troca de marchas funciona. Muitas vezes. apenas saber qual método deve ser invocado. esta representação não é totalmente realista. Empacotar as variáveis de um objeto sobre a proteção de seus métodos é chamado de encapsulação (seção ). Esta capacidade de um objeto controlar quais componentes podem acessar seus métodos e variáveis é chamada de Controle de Acesso (a ser descrita mais detalhadamente nas próximas aulas do curso).2 Mensagens Geralmente. Por exemplo.A ilustração a seguir é uma representação comum do conceito de objeto: Detalhes de implementação (privados) API (pública) Tudo que o objeto de software conhece (estado) e pode fazer (comportamento) é expressado pela variáveis e métodos do objeto. quando se deseja trocar uma marcha na sua bicicleta. Esta representação conceitual de um objeto. As variáveis de um objeto fazem parte do seu núcleo (centro). Exemplos de métodos deste objeto seriam: frear. Pág 18 . uma bicicleta só é útil quando um outro objeto (ciclista) interage com ela.1. um objeto sozinho não é muito útil e aparece como um componente de uma aplicação maior que contém vários outros objetos. Quando um objeto A deseja que o objeto B realize um dos seus métodos (de B). Objetos comunicam-se entre si por meio do envio de mensagens. 2. Estas variáveis e métodos são formalmente chamados de variáveis de instância e métodos de instância a fim de distinguí-los de variáveis e métodos de classe (descritos no item Classes). Por exemplo. o objeto A envia uma mensagem para o objeto B. em programas. os detalhes de implementação podem ser mudados sem afetar outras partes do programa. marcha atual é a quinta. Os métodos envolvem e escondem o núcleo do objeto de outros componentes (objetos) da aplicação. aumentar a velocidade da pedalagem e trocar de marcha. A interação entre os objetos é que permite se obter todas as funcionalidades de uma aplicação. Basicamente. Por exemplo. Entretanto. é um modelo ideal que deve servir de como meta para projetistas de sistemas orientados a objetos. um objeto pode desejar expor algumas de suas variáveis ou esconder alguns de seus métodos. muitas vezes não é necessário saber como um objeto foi implementado. Analogamente. por razões de implementação ou eficiência. um núcleo de variáveis dentro de uma membrana protetora de métodos.

muitas vezes existem vários objetos do mesmo tipo. o objeto que recebe a mensagem precisa de mais informações para saber exatamente o que fazer. Pág 19 . Resumindo. Em software orientado a objetos. Tais fôrmas de software são chamadas de classes . Por exemplo. cria-se um objeto daquele tipo e o sistema aloca memória para as variáveis de instância definidas para a classe. uma classe é uma fôrma (protótipo) que define as variáveis e métodos comuns a todos os objetos de um certo tipo. Assim. Por exemplo. Quando se cria uma instância de uma classe. utilizando a terminologia de orientação a objetos. o estado de cada bicicleta é independente e pode ser diferente de outras bicicletas. Assim. Depois de criado. deve-se instanciá-la a fim de utilizar seus objetos.3 Classes No mundo real.1. pode-se dizer que um objeto bicicleta é uma instância de uma classe de objetos conhecida como bicicletas. depois de criar a classe bicicleta. pode-se invocar os métodos de instância do objeto. quando você quer trocar as marchas em uma bicicleta. Entretanto. três componentes fazem parte de uma mensagem: • o objeto para onde a mensagem é endereçada (bicicleta) • o nome do método a realizar (mudar a marcha) • parâmetro(s) necessário(s) para realizar o método (segunda marcha) Observação: objetos não precisam estar no mesmo processo ou na mesma máquina para enviar e receber mensagens de uns para os outros. deve-se indicar qual a marcha desejada. pode-se tirar vantagem de que os objetos do mesmo tipo são similares e criar uma “fôrma” para estes objetos. Esta informação acompanha a mensagem como um parâmetro.Mensagem Objeto A Objeto B Algumas vezes. Desta forma. 2. Bicicletas possuem estado e comportamento comuns. Valores de variáveis de instância existem para cada instância (objeto) da classe. é possível ter vários objetos do mesmo tipo que compartilham características.

Em um programa estruturado. ou seja. dentro de um objeto. classes podem também definir variáveis de classe (class variables) e métodos de classe (class methods). todos os objetos daquela classe compartilham as mesmas variáveis de classe. Infelizmente. Resumindo. tanto sua variáveis quanto os métodos que manipulam estas variáveis. O sistema cria uma única cópia de uma variável de classe. • Modularidade: Pág 20 . o objeto pode manter informações e métodos privados que podem ser mudados a qualquer momento sem afetar os outros objetos. Encapsulação permite esconder. no mínimo. O problema surge quando se deseja tornar uma variável disponível a outras funções. é uma ferramenta poderosa que oferece dois benefícios principais aos programadores: o código fonte de um objeto pode ser escrito e mantido independentemente do código fonte de outros objetos. na programação estruturada também pode-se esconder os dados dentro de uma função simplesmente criando variáveis locais. estas três características: • Encapsulação • Herança • Polimorfismo 2. Além disto. uma linguagem de programação deve oferecer.1 Encapsulação Uma das principais diferenças entre o paradigma de programação estruturada e o modelo de orientação a objetos é a característica de encapsulação. De que maneira este ocultamento de informação difere da abordagem estruturada? Por exemplo. apesar de simples. é possível controlar acessos de outros componentes aos dados do objeto. não podem acessar métodos ou variáveis de instância. ou seja. a idéia de encapsulação. Na programação orientada a objetos. Pode-se acessar variáveis e métodos de classe sem ter a necessidade de se instanciar um objeto da classe. 2.2. desta forma qualquer função dentro do programa pode acessar os dados. • Ocultamento da informação: um objeto possui uma interface pública que outros objetos podem utilizar para comunicar-se com ele. que podem ser acessadas por qualquer método do objeto mas não são visíveis por outros objetos. Métodos de classe só podem manipular variáveis de classe. consegue-se criar variáveis de instância. a solução é criar variáveis globais. Assim.2 Características da Tecnologia de Objetos Para ser considerada verdadeiramente orientada a objetos.Além das variáveis e métodos de instâncias.

2. subclasses não estão limitadas ao comportamento herdado de sua superclasse.2. A árvore de herança. mas se lhe disserem que é uma bicicleta. Os métodos e variáveis são herdados através dos níveis. Por exemplo. etc. se uma montain bike possui um conjunto extra de marchas. Além disto. você poderia sobrecarregar o método “mudar marcha” de tal forma que seja possível escolher este novo conjunto de marchas. Sistemas orientados a objetos permitem também que classes sejam definidas em termos de outras classes. por exemplo) Entretanto. Mountain bikes e bicicletas de corrida compartilham certos comportamentos (frear. quanto mais baixa na hierarquia for a posição de uma classe. podemos citar: Pág 21 . Por exemplo. O conceito de herança pode ser aplicado para mais de um nível. a classe bicicleta é uma superclasse de mountain bikes e bicicletas de corrida. pedais. Na terminologia de orientação a objetos. Analogamente. mountain bikes e bicicletas de corrida são diferentes tipos de bicicletas. ou hierarquia de classe pode ser tão “profunda” quanto necessário. assento. Em geral.2 Herança De maneira geral. Mountain bikes e bicicletas de corrida compartilham alguns estados (velocidade. cada subclasse herda os métodos da superclasse. Por exemplo. objetos são definidos em termos de classes. mountain bikes e bicicletas de corrida são subclasses da classe bicicleta. Subclasses podem adicionar variáveis e métodos a aqueles herdados. você consegue imaginar o objeto (duas rodas. por exemplo). Subclasses também podem redefinir (override) métodos herdados e oferecer implementações especializadas para estes métodos. Bicicletas Mountain Bikes Bicicletas de Corrida Cada classe herda o estado (na forma das declarações de variáveis) da superclasse. Consegue-se obter muitas informações sobre um objeto conhecendo a sua classe. você pode não saber o que é uma penny-farthing. Como benefícios do conceito de herança.). mais especializado é o seu comportamento.

mas que pode conter um objeto de uma subclasse desta. pode-se atribuir um objeto de uma subclasse a uma variável da classe pai (mas não o contrário!). contas_do_cliente[0] = conta_normal_do_joao. Devido às características de herança. // O interpretador invoca o método de Conta contas_do_cliente[1]. Outros programadores completam estes detalhes por meio de subclasses especializadas.. Com o acoplamento dinâmico.retirada(). parâmetro de retorno e argumentos) parecida com a do método herdado então não se trata de uma redefinição e sim de uma sobrecarga pois criou-se.. ContaEspecial conta_especial_do_joao. entenda-se a escolha correta de um método a ser executado para uma variável declarada como de uma classe. Por exemplo: Sejam duas classes Conta e ContaEspecial.. Este polimorfismo é classificado como polimorfismo de inclusão. . A superclasse abstrata define e pode implementar parcialmente o comportamento de uma classe mas a maioria das informações da classe fica indefinida ou não é implementada. entenda-se tempo de execução. Por acoplamento. um novo método. 2. descrito no item anterior. Conta contas_do_cliente[20] . • Programadores podem definir classes abstratas que determinam comportamentos “genéricos”. Suponha que exista um método do Conta (retirada()). Outro tipo bastante interessante de polimorfismo é conhecido como acoplamento dinâmico (dynamic binding). O primeiro tipo. oferecidos pela superclasse.. Existem vários tipos de polimorfismo.3 Polimorfismo Segundo a terminologia de orientação a objetos. é quando uma classe redefine a implementação de um método herdado. polimorfismo significa que uma mesma mensagem enviada a diferentes objetos resulta em um comportamento que é dependente da natureza do objeto que está recebendo a mensagem. que foi redefinido por ContaEspecial.retirada().2. Por meio da utilização de herança. Assim: Conta conta_normal_do_joao. na verdade. programadores podem reusar o código da superclasse várias vezes. é possível fazer com que a execução de um método dependa do tipo do objeto atribuído a variável. onde ContaEspecial é uma subclasse de Conta. Se a subclasse oferece um método de assinatura (nome. contas_do_cliente[1] = conta_especial_do_joao. Por dinâmico. contas_do_cliente[0].• Subclasses oferecem comportamentos especializados a partir de elementos básicos comuns. // O interpretador invoca o método de ContaEspecial Pág 22 .

2. Liste as variáveis e métodos deste objeto.3 1 2 3 Exercícios Quais são os dois principais componentes de um objeto? Qual a relação entre classe e objeto? Quais os benefícios do uso do conceito de mensagens para descrever a interação entre objetos? 4 Quais são as três principais características presentes no paradigma de orientação a objetos? Defina cada um destes conceitos. Tente definir também subclasses Pág 23 . 5 Considere um objeto do mundo real. como um aparelho de som ou um forno.

1 Argumentos de Linha de Comando Como visto no exemplo da seção .2 Valor de Saída do Programa Observe. se existirem. existe uma série de diferenças importantes entre as linguagens como o mecanismo de tratamento de exceções. Este método tem a seguinte assinatura: public static void main(String args[]) O argumento da função é um vetor de strings. Pág 24 .length (assim como para qualquer vetor em Java).3. 3. programadores C++ devem tomar cuidado para não ter uma falsa sensação de familiaridade com Java só porque as linguagens compartilham uma série de palavras-chaves.1.exit() com o valor desejado. deve-se usar o método System. O tamanho do vetor argv é dado por argv. Diferenças entre Java e C/C++ Java é bastante parecido com C. convencionalmente chamado de args ou argv. Apesar de Java utilizar muitas das terminologias do C++. Entretanto. da linha de comando. que a função main() deve ser declarada com parâmetro de retorno do tipo void.1. toda a aplicação Java standalone deve possuir uma classe que defina o método main(). na seção . Se for necessário retornar algum valor.3 Comentários Java suporta os mesmo delimitadores de comentário do C/C++ (/* */ e //) além de um terceiro tipo (/** */). o que torna relativamente simples que programadores C aprendam a linguagem. 3. as analogias entre Java e C++ não são tão fortes quanto aquelas entre Java e C. o primeiro elemento do array não é o nome da classe e sim o primeiro argumento da linha de comando.Os elementos deste vetor são os argumentos. Este último tipo serve para produzir documentação on-line. por meio da ferramenta javadoc (a ser apresentada no final do curso). não é possível retornar um valor de seu programa Java com return na função main(). A seguir são abordadas algumas das principais diferenças entre as linguagens. Ao contrário de C. 3. Assim.1. Portanto.

Java define um mapeamento entre os nomes dos pacotes/classes e os diretórios onde estão de tal forma que quando o compilador Java precisa ler um determinado arquivo de classe. separados por ponto. o nome da classe (ou objeto) e o nome do membro (variável ou método) da classe. Java elimina a necessidade de arquivos de cabeçalhos (headers files). todos os #defines e typedefs. Exemplos: MinhaClasse MeuObjeto. MinhaClasse. Assim. a API de manipulação de Strings torna a representação de caracteres totalmente transparente para o programador.1. que consiste do nome do pacote que contém a classe. MeuObjeto. toda variável (método) em Java deve ser referenciado pelo seu nome qualificado. Por exemplo. Além disto. não há como distinguir um caracter Java de 16 bits de caracteres de 8 bits convencionais.incremento = 5. Em Java. se você estiver utilizando apenas caracteres Latin-1. Também não existem funções ou procedimentos “globais”. Assim. Em vez de cabeçalhos. MeuObjeto. Strings e identificadores (nomes de variáveis. métodos e classes) são compostos de caracteres de 16 bits. Pág 25 . no formato ASCII). os arquivos-fonte em Java possuem simplesmente as declarações das suas classes e métodos. ele sabe exatamente onde encontrá-lo. um programador Tailândes pode usar o alfabeto Thai para nomear variáveis e métodos no seu código-fonte. Isto facilita a migração de programas Java para outros idiomas diferentes do inglês.4 Caracteres Unicode Caracteres. #include. O formato Unicode é compatível com o ASCII pois os 256 primeiros caracteres Unicode são idênticos aos caracteres do padrão ISO8859-1 (Latin-1). Assim. Um dos problemas principais de C/C++ é a quantidade de contexto necessária para se entender o código de outros programadores: deve-se ler todos os cabeçalhos relacionados.Incrementar().6 Sem Pré-processador // Variável de instância // Método de instância // Variável de classe // Método de classe Java não inclui nenhum tipo de pré-processador. Assim.MostraIncremento(). #ifdef e nem typedef.1. 3. MinhaClasse. 3.5 Sem Variáveis Globais Variáveis globais simplesmente não fazem parte da linguagem.contador = 1.3. não existem diretivas como #define. chamados de Unicode (C/C++ utilizam caracteres de 8 bits. toda variável e método deve ser declarada dentro de uma classe.1.

obtém-se o mesmo efeito simplesmente declarando uma classe com as variáveis de instância apropriadas. Para substituir o efeito do typedef basta declarar classes. Exemplo: class Direcao { public static final int Norte = 1. a linguagem Java torna-se bastante livre de contexto. } Utilizar classes que contêm constantes proporciona uma vantagem em relação aos tipos enumerados de C/C++. na forma de diretivas #ifdef ou #if. a saída é utilizar constantes em Java para obter os mesmos resultados da compilação condicional (bons compiladores conseguem realizar compilação condicional implicitamente. programadores podem ler. você não pode utilizar estes nomes em nenhum outro enum. public static final int Oeste = 4. Pág 26 .Em Java. nomes definidos via enums devem ser únicos: se você possui um tipo enumerado chamado HotColors contendo os nomes Vermelho e Amarelo. Em C/C++. public static final int Leste = 3. Ou seja.1. compilação condicional não é necessária em Java pois a linguagem é independente de plataforma e.1. não existem partes do código específicas para uma determinada plataforma. 3. Teoricamente. Não há a necessidade de estruturas ou uniões quando se possui classes. pode-se utilizar o mesmo nomes em diferentes classes pois os nomes são qualificados pela classe que os contêm. Com Java. entender e modificar código de maneira mais fácil e rápida. public static final int Sul = 2.7 Sem tipo struct ou union Java não possui estruturas ou uniões como tipos de dados. Java não possui nenhum mecanismo de compilação condicional. Removendo todos estes recursos. portanto. Nestes casos. Pode-se obter algo similar declarando uma classe que possua apenas constantes. obtém-se os efeitos de #define utilizando constantes. ou seja. Na prática.8 Sem tipos enumerados Java não possui tipos enum. a compilação não será realizada em um trecho de código se o compilador conseguir provar que este trecho nunca será executado). 3. afinal de contas uma classe efetivamente define um novo tipo. a compilação condicional também é utilizada para fins de depuração.

leva a programas mais difíceis de entender e modificar. Variáveis não podem ser definidas em interfaces. • Não é possível realizar aritmética de ponteiros. Removendo os apontadores. uma vez.1. Existem duas razões para estas restrições: • Apontadores são famosos por ser uma fonte quase inesgotável de bugs. foi descartada de Java. temos um ambiente mais seguro e robusto.3. e todos os problemas que pode causar. esta restrição não parecerá tão importante.9 Sem herança múltipla Herança múltipla. Na verdade.auxilia a simplificação do código-fonte. simplifica-se a linguagem e elimina-se vários potenciais bugs. -. <<). Mas. Interfaces só podem declarar métodos e constantes.1. 3. Uma interface não é uma definição de uma classe. Pág 27 .1. As vantagens da herança múltipla são proporcionadas por interfaces (que serão discutidas mais profundamente em uma aula próxima). acostumado com o modelo de programação Java. ++. • Não é possível calcular o tamanho em bytes de qualquer tipo primitivo ou objeto. 3. o uso de apontadores é essencial apenas para programação de baixo nível (device drivers.12 Sem apontadores Java não possui apontadores e não permite manipular endereços de memória de nenhuma forma: • Não é possível converter referência de objetos ou vetores em inteiros ou vice-versa. Na verdade. A experiência mostra que o uso de goto. por exemplo). Para um programador C.11 Sem sobrecarga de operadores Em Java não é possível sobrecarregar os operadores aritméticos padrões (+. em geral. 3. a falta de apontadores pode ser uma restrição infeliz do Java. é uma definição de um conjunto de métodos que uma ou mais classes irão implementar. Esta decisão de projeto da linguagem.1. Eliminando-os.10 Sem goto Java não possui um comando goto. • Apontadores e aritmética de ponteiros podem ser utilizadas para “contornar” os mecanismos de segurança do Java.

o método countChars define duas variáveis: int count = 0. Por exemplo. Reader in A declaração de uma variável sempre contém dois componentes: o tipo da variável e seu nome. A localização de uma declaração de variável. stream. Mesmo um método pequeno como este utiliza muitas das construções básicas de Java e classes que pertencem a API central da linguagem./) sobre este tipo de variável. de entrada de caracteres) e mostra o número de caracteres lidos.4. a declaração int count define que a variável count é um inteiro (int). Pág 28 . Construções Básicas da Linguagem Java A classe Count apresentada a seguir possui um método chamado countChars que lê e conta os caracteres de um Reader (um objeto que implementa um fluxo. onde a declaração aparece em relação a outros elementos do código. } public static void main(String[] args) throws Exception { if (args. ou seja. O tipo de dados de uma variável determina quais valores a variável pode conter e as operações que podem ser realizadas sobre ela. while (in.read() != -1) count++. public class Count { public static void countChars(Reader in) throws IOException { int count = 0. import java.err. else System.io. Inteiros só podem possuir valores integrais (positivos ou negativos) e pode-se utilizar os operadores aritméticos (+. Por exemplo. nome e escopo. } } 4.1 Variáveis e Tipos de Dados Todas as variáveis em Java possuem um tipo.-.*. determina seu escopo.println("Counted " + count + " chars.length >= 1) countChars(new FileReader(args[0])).println("Usage: Count filename"). System.").*.out.

Existem duas grandes categorias de tipos de dados na linguagem Java: primitivo e referência. A tabela a seguir apresenta todos os tipos primitivos suportados por Java. Tipo
byte short int long float double char boolean

Tamanho/Formato 8-bit complemento de 2 16-bit complemento de 2 32-bit complemento de 2 64-bit complemento de 2 32-bit IEEE 754 64-bit IEEE 754 16-bit Unicode true ou false

Descrição Byte-length integer Short integer Integer Long integer Single-precision floating point Double-precision floating point A single character A boolean value (true or false)

Uma variável de um tipo primitivo contém um único valor de tamanho/formato apropriados. O valor da variável count em countChars pode assumir desde 0 (valor inicial) até o número que representa o número de caracteres lidos. Vetores (arrays), classes e interfaces são tipos de referência. O valor de uma variável deste tipo, em contraste com os tipos primitivos, é uma referência para o valor ou conjunto de valores representados pela variável. A referência é como o endereço de um amigo: o endereço não é o seu amigo, mas é uma forma de se alcançá-lo. O método countChars usa uma variável do tipo de referência, in¸ que é um objeto Reader. Assim, pode-se utilizar o nome do objeto para acessar suas variáveis ou chamar algum de seus métodos. Observação Importante: Em Java, tipos primitivos sempre são passados por valor; já vetores e objetos são passados por referência. Exemplo: int a,b; a = 1; b = a; a = 2; // a = 2 e b = 1 pois int é um tipo primitivo (passagem por valor) Button p, q; p = new Button(); q = p; // q refere-se ao mesmo objeto que p (passagen por referência) p.setLabel(“Ok”); // Uma mudança no objeto via p String s = q.getLabel(); // s contém “Ok” Convenção: Nomes de variáveis começam com uma letra minúscula e nomes de classes com uma letra maiúscula. Se o nome da variável consiste de mais de uma palavra, as palavras são agrupadas e cada palavra depois da primeira começa com uma letra maiúscula (exemplo: numeroClientes). O escopo de uma variável corresponde ao bloco de código onde a variável é acessível e determina quando a variável é criada e destruída. A localização da declaração da variável

Pág 29

dentro do programa estabelece o seu escopo. De acordo com o seu escopo, uma variável pode ser das seguintes categorias:
• • • •

Variável membro Variável local Parâmetro de método Parâmetro de tratamento de exceção

Uma variável membro está associada a um objeto ou a uma classe. Pode ser declarada em qualquer lugar dentro de uma classe, desde que fora de um método. Uma variável membro está acessível para todo código dentro da classe. A classe Count não declara nenhuma variável membro. Variáveis locais são declaradas em qualquer ponto dentro de um método ou de um bloco de código dentro de um método. No método countChars, count é uma variável local. O escopo de count vai da declaração da variável até o fim do método countChars. Parâmetros de métodos são argumentos formais de métodos e construtores que são utilizados para passar valores para os métodos. Em countChars, in é um parâmetro do método. O escopo de um parâmetro é todo o método que o declara. Parâmetros de tratamento de exceção são similares aos parâmetros de método mas são argumentos de um tratador (handler) de exceções em vez de um método ou construtor. O método countChars não possui tratadores de exceção e, portanto, não possui parâmetros desta categoria. Variáveis locais e variáveis membros podem ser inicializadas na sua própria declaração. Por exemplo, o método countChars fornece um valor inicial de zero para a variável count: int count = 0;

Pág 30

Parâmetros de método de tratadores de exceção não podem ser inicializados desta forma. O valor do parâmetro é determinado pelo objeto que invoca o método. Pode-se declarar qualquer variável como final, incluindo parâmetros. O valor de uma variável final não pode ser alterado depois de inicializado. Para declarar uma variável deste categoria, basta usar a palavra chave final antes do tipo: final int aFinalVar = 0; Pode-se adiar, se necessário, a inicialização da variável. Porém depois de inicializada a primeira vez, novas modificações não são permitidas. Exemplo: final int blankfinal; ... blankfinal = 0; 4.2 Operadores

Operadores realizam alguma função em um, dois ou três operandos. Por exemplo, ++ é um operador unário, = é um operador binário. Java possui um único operador ternário ? : (equivalente a um if-else). Além de realizar uma função, um operador também retorna um valor. O valor e seu tipo dependem do operador e dos tipos de operandos. Por exemplo, operadores aritméticos retornam números. O tipo de dado retornado vai depender do tipo de operandos: se dois inteiros são somados, o resultado é um inteiro. Os operadores de Java podem ser divididos nestas categorias: aritméticos, relacionais e condicionais, bitwise e lógicos e de atribuição. Tais categorias são descritas a seguir. 4.2.1 Operadores Aritméticos

Java suporta vários operadores aritméticos para número inteiros e de ponto flutuante. A tabela a seguir lista os operadores aritméticos binários da linguagem: Operador
+ * / %

Uso
op1 + op2 op1 - op2 op1 * op2 op1 / op2 op1 % op2

Descrição Soma op1 e op2 Subtrai op2 de op1 Multiplica op1 por op2 Divide op1 por op2 Calcula o resto da divisão de op1 por op2

Observação: A linguagem Java estende a definição do operador + para incluir concatenação de strings. Por exemplo, o método countChars utiliza o + para concatentar “Counted”, o valor de count e “ chars”: Pág 31

retorna o valor antes do incremento Incrementa op de 1. A tabela abaixo apresenta os operadores relacionais de Java: Pág 32 . retorna o valor antes do decremento Decrementa op de 1.."). Analogamente. o método countChars() utiliza o operador != para determinar se o valor retornado por in. no exemplo. -.out. ++ que incrementa seu operando de 1 e – que decrementa seu operando de 1. Ambas as versões incrementam o operando de 1. retorna o valor depois do decremento 4.2. Por exemplo. Entretanto. } while (count++ < 6). Esta operação automaticamente converte o valor de count para o tipo String. do { . short. count = 0.2 Operadores Relacionais e Condicionais Um operador relacional compara dois valores e determina o relacionamento entre eles.System.read não é igual a 1.println("Counted " + count + " chars. retorna o valor depois do incremento Decrementa op de 1. Os operadores + e . o laço abaixo irá executar uma vez a menos se mudarmos count++ para ++count.têm versões pré-fixa e pós-fixa. ++ também possui uma versão pré-fixa onde o operador aparece antes do operando. A tabela abaixo resume a função destes operadores: Operador ++ ++ --- Uso op++ ++op op---op Descrição Incrementa op de 1. Observe que. o operador ++ aparece depois de seu operando (versão pósfixa). or char Negates aritmeticamente op Existem também dois outros operadores aritméticos unários. O método countChars usa ++ para incrementar a variável count cada vez que é lido um caracter da entrada: count++. Por exemplo. op++ retorna o valor do operando antes incrementá-lo e ++op retorna o valor do operando depois de incrementá-lo.possuem versões unárias que realizam as seguintes operações: Operador + - Uso +op -op Descrição Promove op to int se é um byte..

Operador
> >= < <= == !=

Uso
op1 > op2 op1 >= op2 op1 < op2 op1 <= op2 op1 == op2 op1 != op2

Retorna True se op1 é maior que op2 op1 é maior ou igual a op2 op1 é menor que op2 op1 é menor ou igual a op2 op1 e op2 são iguais op1 e op2 não são iguais

Em geral, operadores relacionais são utilizados com operadores condicionais para construir expressões mais complexas. Um destes operadores é &&, que realiza a operação E (booleana). Por exemplo: 0 < index && index < NUM_ENTRIES Em algumas situações, o segundo operando de um operador condicional nem chega a ser calculado. Considere a expressão: ((count > NUM_ENTRIES) && (in.read() != -1)) Se count é menor do que NUM_ENTRIES, o operando a esquerda de && retorna false. Neste caso, o valor de retorno de && pode ser determinado sem calcular o valor do operando a direita. Assim, o interpretador não irá executar o método in.read da expressão. O operador & é similar ao && se os seus operandos são do tipo boolean. Entretanto, & sempre calcula ambos os seus operandos. Analogamente, | é similar a | | se ambos os operandos são booleanos. Java suporta cinco operadores condicionais binários: Operador
&& || ! & |

Uso
op1 && op2 op1 || op2 ! op op1 & op2 op1 | op2

Retorna true se
op1 e op2 são ambos true, calcula condicionalmente op2 op1 ou op2 é true, calcula condicionalmente op2 op é false op1 e op2 são ambos true, sempre calcula op1 e op2 op1 ou op2 é true, sempre calcula op1 e op2

Além disto, Java possui um outro operador condicional, o operador : ?. É um operador ternário que, basicamente, funciona como uma “abreviatura” da expressão if-else: expression ? op1 : op2 O operador ?: avalia expression e retorna op1 se expression é verdadeira e op2 se é falsa. 4.2.3 Operadores Bitwise

Um operador bitwise permite realizar manipulação de bits. A tabela abaixo apresenta os operadores deste tipo: Pág 33

Operador
>> << >>> & | ^ ~

Uso
op1 >> op2 op1 << op2 op1 >>> op2 op1 & op2 op1 | op2 op1 ^ op2 ~op2

Operação shift dos bits de op1 p/ direita por uma distância dada por op2 shift dos bits de op1 p/ esquerda por uma distância dada por
op2
shift dos bits de op1 p/ direita por uma distância dada por op2 (unsigned)

bitwise and bitwise or bitwise xor bitwise complemento

Por exemplo, a expressão a seguir desloca (shift) os bits do inteiro 13 para a direita (uma posição): 13 >> 1; A representação binária do número 13 é 1101. Assim, o resultado da operação de shift é 110 ou 6 em decimal. Um shift a direita de 1 é equivalente, mas bem mais eficiente do que dividir o operando da esquerda por 2. Analogamente, um shift a esquerda equivale a uma multiplicação por 2. O operador and bitwise executa a função and, de forma paralela, em cada par de bits da cada operando. Suponha a seguinte operação: 12 & 13 O resultado é igual a 12. A representação binária de 12 é 1100 e a de 13 é 1101. Assim: 1101 & 1100 -----1100 O operador | realiza a função ou inclusivo e ^ realiza a função ou exclusivo. O operador complemento ~ inverte o valor de cada bit do operando: se o bit do operando é 1 o resultado é 0 e se o bit do operando é 0, o resultado é 1. 4.2.4 Operadores de Atribuição

O operador = é utilizado para se atribuir um valor a outro. O método countChars utiliza = para inicializar count: int count = 0; Java proporciona vários operadores “short cuts” que permitem realizar operações aritméticas, lógicas e bitwise juntamente com a atribuição. Por exemplo: Pág 34

i += 2; é equivalente a: i = i + 2; 4.3 Expressões

Expressões é que realizam o trabalho de um programa Java. Entre outras coisas, expressões são utilizadas para calcular e atribuir valores para variáveis e ajudar a controlar o fluxo de execução de um programa. Assim, o trabalho de uma expressão é duplo: realizar o cálculo indicado pelos elementos da expressão e retornar algum valor que é o resultado desta computação. Então, podemos definir um expressão da seguinte forma: série de variáveis, operadores e chamadas de métodos que retorna um único valor. Como discutido no item anterior, operadores retornam um valor. Portanto, o uso de um operador é uma expressão. Por exemplo: count++ é uma expressão que retorna o valor de count antes que a operação de incremento ocorra. O tipo de dado retornado por uma expressão depende dos elementos utilizados nesta expressão. A expressão count++ retorna um inteiro pois ++ retorna o mesmo valor que seu operando (count é um inteiro). O método counntChars() contém, além da expressão count++, algumas outras expressões, como esta: in.read() != -1 Tal expressão é interessante pois consiste, na verdade, de duas expressões. A primeira é uma chamada de método: in.read() Uma chamada de método é uma expressão que retorna o valor do método. Portanto, o tipo de dado desta expressão é o mesmo tipo de dado do parâmetro de retorno do método. O método in.read() tem como parâmetro de retorno um inteiro, assim a expressão in.read retorna um inteiro. A segunda expressão utiliza o operador !=. Na expressão em questão, os operandos de != são in.read() e -1. Note que in.read() é um operando válido para esta expressão pois retorna um inteiro. Assim, in.read() != -1 compara dois inteiros, o valor retornado por in.read() e -1. O valor retornado por != é true ou false dependendo do resultado da comparação. Pág 35

postfix operators unary operators creation or cast multiplicative [] . explicitamente. que a ordem de como a expressão é avaliada também é importante. que Java permite a construção de expressões compostas de várias partes (expressões) menores desde que os tipos de dados requeridos por uma parte da expressão sejam compatíveis com os tipos de dados das outras partes. Por exemplo. na expressão composta x + y / 100. a expressão a seguir fornece resultados diferentes dependendo de que operação é realizada primeiro: x + y / 100 Você pode determinar. o operador de divisão tem uma precedência maior do que o de adição. (params) expr++ expr-++expr --expr +expr -expr ~ ! new (type)expr * / % Pág 36 . Operadores com precedência maior são avaliados antes de operadores com uma precedência relativa menor. x + y / 100 é equivalente a x + (y / 100) Para tornar o código fácil de ler e manter. Note. sempre que possível. Operadores que estão em uma mesma linha da tabela possuem igual precedência. Operadores com precedência maior são calculados primeiro. Por exemplo. Entretanto. o compilador vai calcular primeiro a expressão y / 100. a partir destes dois exemplos. Portanto. deve-se ser explícito e indicar com parênteses quais operadores devem ser avaliados primeiro. Se não for determinado explicitamente a ordem desejada para o cálculo das operações. para o compilador Java como deve ser avaliada uma expressão utilizando parênteses. Os operadores nesta tabela estão listados em ordem de precedência: quanto mais alta a posição na tabela. poderia se escrever (x + y) / 100. Por exemplo. também. isto não vale para todas as expressões.Pode-se observar. Considere esta expressão composta: x*y*z Neste exemplo em particular. maior a sua precedência. A tabela a seguir mostra a precedência dos operadores Java. Assim. para tornar a expressão anterior nãoambígua. a ordem com que a expressão é avaliada não é importante pois os resultados das multiplicações são independentes de ordem. o compilador toma esta decisão baseado na precedência atribuída aos operadores e outros elementos utilizados em uma expressão.

ou seja. Um statement. 4. algumas regras devem determinar qual deve ser avaliado primeiro.println("Read a character. Count = " + count). Em Java.additive shift relational equality bitwise AND bitwise exclusive OR bitwise inclusive OR logical AND logical OR conditional assignment + << >> >>> < > <= >= instanceof == != & ^ | && || ? : = += -= *= /= %= &= ^= |= <<= >>= >>>= Quando operadores de igual precedência aparecem em uma mesma expressão .4 Controle de Fluxo O método countChars utiliza um while para realizar um laço que lê e conta todos os caracteres da entrada : while (in. execute statement. na verdade. A linguagem Java suporta vários tipos de controle de fluxo. A sintaxe geral do while é: while (expression) statement Ou seja.out. Por exemplo: while (in. determina a ordem de execução do código. Os operadores de atribuição são avaliados da direita para a esquerda. o while realiza alguma ação enquanto uma certa condição continua verdadeira. pode ser um bloco de código Java delimitado por chaves { }. while é chamado de um comando de controle de fluxo. } Convenção: a chave { deve ficar no final da mesma linha que o while e a chave } deve começar uma nova linha. De maneira geral.read() != -1) { count++. enquanto a expressão for verdadeira. System. incluindo: Pág 37 . alinhada com o while.read() != -1) count++. todos os operadores binários (exceto o operador de atribuição) são avaliados da esquerda para a direita.

. } else if (testscore >= 70) { grade = 'C'. A outra forma do else é o else if que executa um bloco de código baseado em outra expressão. Exemplo: int testscore.1.Comando tomada de decisão laço exceção miscelâneos Palavra-chave if-else. continue. do-while try-catch-finally.1 If-else if (DEBUG) System.. // código para realizar a ação OK . } else { .out.. switch-case for.. } else { grade = 'F'. label: . // código para realizar a operação Cancel } ... return 4. throw break. while. if (testscore >= 90) { grade = 'A'.println("DEBUG: x = " + x). a forma mais simples do if pode ser escrita como: if (expression) statement else é utilizado quando um diferente conjunto de operações deve ser executado quando a expressão é falsa: if (response == OK) { . Esta é a versão mais simples do if: o código é executado caso a condição dada seja verdadeira... Generalizando. char grade. } Pág 38 . } else if (testscore >= 60) { grade = 'D'. } else if (testscore >= 80) { grade = 'B'.

O break faz com que o fluxo de controle saia do switch e continue na primeira expressão após do switch. case 10: System. poderíamos implementar tal funcionalidade com if: int month. break. o valor do mês e executa o bloco de código apropriado.out. case 4: System.1. } else if (month == 2) { System. case 6: System.out. break. .println("January").println("February").out. break. Ou seja.out. case 8: System. neste caso.out. break. Exemplo: int month. case 11: System. Note que. break. case 3: System. na facilidade de leitura do código. break.println("September")..println("May").println("June").println("October"). break. switch (month) { case 1: System. apenas um bloco de código é executado (o primeiro onde a condição é verdadeira) e o fluxo de controle sai do if sem avaliar as demais condições. break. break.out. if (month == 1) { System.out. mas apenas um else. case 9: System.println("April"). Deve-se fazer esta escolha baseado.out. case 5: System.println("July").out. case 7: System.out. } O switch avalia sua expressão. principalmente.out. 4..println("March").Um if pode ter um número qualquer de else if. sem um break Pág 39 .println("November"). Obviamente. O break é necessário pois os case estão em “cascata”.out.println("August"). break. case 2: System. Um ponto interessante do switch é o break colocado depois de cada case. apesar de alguns valores de testscore satisfazerem mais de uma expressão.out. case 12: System. Decidir quando utilizar if ou switch depende do “feeling” do programador. break. break.out.println("February").2 Switch O switch é utilizado para realizar uma execução condicional baseada em uma expressão.println("December").println("January").

println("June"). case 11: System.println("February"). } Finalmente. case 7: System.out. break.out. switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: numDays = 31. break. Pág 40 .println("April").println("October"). case 2: if ( ((year % 4 == 0) && !(year % 100 == 0)) || (year % 400 == 0) ) numDays = 29.println("January"). break. case 2: System. break. case 8: System.println("August"). break. existem algumas situações onde deseja-se proceder sequencialmente pelos case.println("November"). case 5: System. case 10: System.out.out. break. Exemplo: int month.out. case 3: System. int numDays. break. case 4: case 6: case 9: case 11: numDays = 30.println("May").out. case 9: System.println("March"). else numDays = 28. break.println("September"). break.out. break. Exemplo: int month.out. switch (month) { case 1: System. break. pode-se usar default no final do switch para tratar todos os valores que não foram explicitamente tratados por um dos case. Entretanto. case 6: System. case 4: System.println("July").out. break. o fluxo de controle irá passar sequencialmente pelos próximos case. break.explícito.out. break.out.

a priori... é similar ao while exceto que a expressão é avaliada apenas no final da iteração do laço: do { statements } while (booleanExpression). i < length. as restrições do laço (instrução de inicialização. int i. Quando a expressão é avaliada como false. Exemplo: // a é um vetor de algum tipo .. 4. Qualquer (ou todos) componente do for pode ser vazio.. Esta expressão é avaliada no início de cada nova iteração do laço. for (i = 0.1. // faz alguma coisa com o elemento de a . quando os comando do laço devem ser executados. Finalmente. critério de terminação e instrução de incremento). } 4. that's not a valid month!"). Java possui duas outras comandos de laço: for e do-while. o laço termina. terminação. o do-while. } A forma geral do for é dada por: for (inicialização.length.1 Tratadores de Exceção Pág 41 .. o do-while é o tipo de laço menos utilizado. incremento) statements inicialização é uma expressão que inicia o laço – é executada uma vez no começo do laço. i++) { . sempre. incremento é uma expressão que é chamada a cada iteração do laço. O outro laço suportado pelo Java. break.println("December").out. terminação é uma expressão que determina quando encerrar o laço..1 Laços Além do while. Em geral. break.out. O for é utilizado quando se sabe. default: System.println("Hey. int length = a.1. Por exemplo.case 12: System. pelo menos uma vez. mas pode ser útil em determinadas situações.

a função pode levantar (throw) uma exceção para indicar a ocorrência de um erro (e seu tipo) para quem invocou a função. ou seja que permitem a mudança do fluxo de controle para labels pré-definidos.1. continue e return (comandos de branching) break faz com que o fluxo de controle “salte” para o bloco de código (statement) imediatamente subsequente ao bloco de código atual. simplesmente coloque um valor (ou expressão que calcula o valor) depois do return: return ++count.Quando um erro ocorre em um método Java. 4. Quando um método é declarado como void. O método que chamou a função que levantou a exceção pode usar try. Assim. Pode-se também tratar dados compostos de múltiplos caracteres via objeto String. catch e finally para capturar e tratar estas exceções. O continue faz com que o fluxo de controle vá para a condição de terminação do laço. 4. isto significa que o controle retorna ao “topo” do laço. Em laços do tipo for e while. O valor retornado deve ser compatível com o tipo do parâmetro de retorno declarado pelo método. Observação 1: continue e break possuem versões “labeled”. deve se utilizar a versão de return sem valor.1 break. Tais versões funcionam como uma alternativa ao famigerado goto e. Existem duas formas de return: uma retorna um valor e a outra não. O return é utilizado para sair do método atual e retornar para o ponto imediatamente subsequente a chamada do método. 4. Return. Em laços do-while.5. O conceito de exceção será abordado mais profundamente nas próximas aulas do curso. devem ser evitadas.1 Array Pág 42 . Para retornar um valor. o controle retorna para o “fundo” do laço.5 Arrays e Strings Como outras linguagens de programação. Java permite agrupar e gerenciar múltiplos valores por meio de um objeto array (vetor). a condição de terminação é reavaliada neste ponto e o laço continua ou não dependendo dos resultados do teste. portanto. Observação 2: continue somente pode ser chamado dentro de um laço.

length que retorna o tamanho atual do vetor. A parte int[] da declaração indica que arrayOfInts é um vetor de inteiros. em particular o uso do vetor args: public static void main(String[] args) throws Exception { if (args. deve-se utilizar int[] arrayOfInts. Após alocar memória ao vetor. ao criar um vetor. length é uma propriedade oferecida por todos os vetores em Java. Observe no exemplo acima que o laço for possui a expressão arrayOfInts. A declaração de um vetor.O método countChars não utiliza um vetor. Em geral. else System. O tipo do vetor inclui os tipos dos dados que compõem o vetor. para declarar um vetor de inteiros. mas o método main declara um vetor como parâmetro de entrada. Se o seu programa tentar acessar qualquer elemento deste vetor antes de se alocar memória para ele. j ++) { arrayOfInts[j] = j.out. Vamos analisar novamente o método main. A expressão a seguir aloca memória suficiente para que arrayOfInts armazene 10 elementos do tipo inteiro: int[] arrayOfInts = new int[10]. Por exemplo. como qualquer outra variável. deve-se instanciar o objeto.length >= 1) countChars(new FileReader(args[0])).err. tem dois componentes: o tipo e o nome. pode-se atribuir e recuperar os valores dos elementos: for (int j = 0. } Observação Importante: Em Java. } Pág 43 . Esta declaração não aloca nenhuma memória para armazenar os elementos do vetor. os índices de um vetor começam em 0 e vão até o tamanho do vetor menos 1.println("Usage: Count filename"). utiliza-se o operador new (o operador new será apresentado com maior profundidade nas próximas aulas). Para alocar memória aos elementos de um vetor.length. usa-se o operador new mais o tipo de dado dos elementos do vetor mais o número de elementos (delimitado por [ ] ): elementType[] arrayName = new elementType[arraySize]. System. Para isto. Esta seção mostra como criar e utilizar vetores em Java. j < arrayOfInts. o compilador irá exibir um erro e se recusará a compilar o seu programa.println("[j] = " + arrayOfInts[j]).

lang.5. Vetores podem armazenar qualquer tipo de dado de Java. no pacote java. i ++) { arrayOfStrings[i] = new String("Hello " + i). Observação Importante: objetos String são imutáveis. 4. O método main utiliza String na declaração do vetor args: String[] args Este código declara explicitamente um vetor que contém objetos String. o programa implicitamente aloca dois objetos String.. cada elemento contém uma referência para um objeto String. incluindo tipos referência como objetos e outros vetores. uma vez criados. String arrayOfStrings[] = {“Joao”. com os argumentos da linha de comando. deve-se alocar os objetos String separadamente: for (int i = 0. portanto. O método main verifica a existência de pelo menos um elemento em args e.. i < arrayOfStrings.length. em caso afirmativo. Assim. Os colchetes vazios indicam que o tamanho do vetor é desconhecido em tempo de compilação pois o vetor é passado. “ Maria”}. um para cada literal. mas ainda não foi alocada memória para as strings propriamente ditas. utiliza o primeiro elemento do vetor (nome) para abrir um arquivo. main não precisa se preocupar em alocar memória para args. chamada Pág 44 .O ambiente de execução Java aloca o espaço para o vetor args e. memória suficiente foi alocada para conter as referências. o código a seguir declara um vetor que pode conter objetos String: String[] arrayOfStrings = new String[10]. “Jose”. em tempo de execução.2 String Uma sequência de caracteres é chamada de string e é implementada em Java pela classe String. Neste ponto. O método countChars também utiliza dois objetos na forma de strings literais: "Counted " ." Neste caso. ou seja. Existe uma classe diferente. " chars. Por exemplo. } Também é possível realizar a inicialização de um vetor durante sua própria declaração. ou seja. Os elementos neste vetor são de tipos de referência. eles não podem ser modificados.

StringBuffer que pode ser usada para criar e manipular caracteres sob demanda (“on the fly”).. O método countChars usa esta funcionalidade para imprimir sua saída. x+=2) ++count. os valores da matriz do exercício anterior. Converta este laço para um do-while. 5. Escreva um código que mostre. 6. Escreva um laço (while. Escreva um laço while que execute 20 vezes. do-while) que resulte em um laço infinito.. 8." Duas destas strings são literais: Counted e chars. do { . Pág 45 . x<12. Quantas vezes o laço abaixo irá executar? Qual o valor de x quando o laço terminar? for (int x=3. O código a seguir concatena 3 strings para produuzir sua saída: "Counted " + count + " chars.6 1 Exercícios Faça um programa que realize um “eco” (apresente na tela) de seus argumentos da linha de comando. Dada uma matriz bidimensional. } while (count++ <= 15). for. Java permite que se concatene strings utilizando o operador +. na verdade é um inteiro que é convertido para string e então concatenado às demais. 7. 12. A terceira string. Como você criaria uma matriz bidimensional de 20 x 10 elementos utilizando Java? 9. Escreva um laço for que inicialize uma matriz 10x15 com valores de 0 a 149. a do meio. 11. 2 Qual a principal diferença entre os tipos primitivos e os tipos de referência em Java? 3 O que é escopo de uma variável? Como é possível determiná-lo? 4 Quantas vezes o código abaixo será executado? Qual será o valor do contador quando o laço terminar? int count = 10. de forma tabular. Escreva um laço for que inicialize um vetor de 50 inteiros com os valores 50 a 99. como descobrir as suas dimensões? (dica: uma matriz em Java pode ser vista como um vetor de vetores) 10. 4.

Pág 46 . apresenta exemplos práticos do uso destes conceitos em Java. 5.1 Classe O código a seguir define uma classe.5. as variáveis recebem o valor 0 (expressões de atribuição para os dois membros da classe). Classes e Objetos em Java Esta seção aborda como a linguagem Java implementa os conceitos de orientação a objetos (seção 2). deve-se instanciar a classe. cujo tipo é SimplePoint. public SimplePoint origin = new SimplePoint(). origin. que representa um ponto em um espaço bidimensional. O código a seguir define uma outra classe. memória é alocada para o objeto e seus membros x e y. SimpleRectangle. A classe SimplePoint possui duas variáveis membro do tipo inteiro. Além disto. O nome de uma classe pode ser utilizado da mesma forma que o nome de um tipo primitivo para declarar variáveis. width e height. Quando um novo objeto é criado. Além disto. x e y. que representa um retângulo: public class SimpleRectangle { public int width = 0. um novo tipo de dado). } Este segmento de código declara uma classe (na verdade. Para criar um objeto da classe SimplePoint. } Além de duas variáveis membros do tipo inteiro. A palavra-chave public que antecede a declaração de x e y indica que qualquer outra classe pode acessar livremente estas duas variáveis. public int y = 0. chamada SimplePoint. public class SimplePoint { public int x = 0. SimpleRectangle possui uma terceira variável. public int height = 0.

As classes SimplePoint e SimpleRectangle são implementações simplificadas. 78) Os valores 44 e 78 são passados para o construtor da classe e atribuídos então as variáveis x e y do objeto: Pág 47 . Por outro lado. Neste caso. pode-se definir valores iniciais: new Point(44. public int y = 0. this.x = x.1). Poderia-se criar um mecanismo para inicializar suas variáveis com valores diferentes de 0. tem-se uma nova versão de SimplePoint.0): public class Point { public int x = 0. como ilustrado a seguir: Esta figura mostra a diferença entre tipos primitivos e tipos de referência (seção 4. origin simplesmente referencia um objeto SimplePoint que está em outro lugar. a seguir. chamada Point que contém um construtor que pode ser utilizado para inicializar um novo objeto da classe Point para um valor diferente de (0. } } Agora. int y) { this.Como no exemplo anterior.y = y. Assim. a variável origin cria um objeto SimplePoint utilizando: new SimplePoint(). // a constructor! public Point(int x. Tanto width quanto height são inteiros e estão inteiramente contidos dentro de SimpleRectangle. a criação de um objeto do tipo SimpleRectangle aloca memória para as suas variáveis. ao criar um ponto.

w. na verdade. uso e destruição). 5.2 Ciclo de Vida de um Objeto Tipicamente. int h) { this(new Point(0. } // a method for moving the rectangle public void move(int x. cria-se um objeto por meio de uma instanciação de classe. } public Rectangle(Point p) { origin = p. int w. apresentando o ciclo de vida de um objeto (criação. Uma vez que um objeto terminou seu trabalho. um método para calcular a área do retângulo e um método finalize que “limpa” a variável de referência do objeto: public class Rectangle { public int width = 0. Esta expressão realiza. super. // four constructors public Rectangle() { origin = new Point(0. Por exemplo. } public Rectangle(Point p. 0).y = y. height = h. width = w. três ações: Pág 48 . int y) { origin.finalize(). int h) { origin = p. um programa Java cria muitos objetos de várias classes. que possui quatro construtores.1 Criando Objetos Em Java. public Point origin. } // a method for computing the area of the rectangle public int area() { return width * height. 0). } public Rectangle(int w. } } As seções a seguir descrevem com detalhes o código acima. h). o código a seguir cria um objeto do tipo Rectangle a partir da classe Rectangle: Rectangle rect = new Rectangle(). chamada Rectangle. ele é destruído e seus recursos são “reciclados” para que outros objetos possam utilizá-los. 5. Estas interações é que irão proporcionar as funcionalidades de uma aplicação.x = x. Estes objetos interagem entre si via envio/recebimento de mensagens.2. um método para mover o retângulo. } protected void finalize() throws Throwable { origin = null.A seguir. public int height = 0. tem-se uma nova versão de SimpleRectangle. origin.

O operador new exige um único argumento: uma chamada a um construtor. Inicializando um Objeto Como visto no código da classe Rectangle. Declarando um Objeto A declaração de um objeto não é uma parte necessária para a criação de um objeto. podem aparecer da seguinte forma: Rectangle rect. • Instanciação: new é o operador Java que cria um novo objeto. aloca espaço para o objeto. classes e interfaces (a serem discutidas em uma próxima aula) podem ser usadas como tipos de dados. 0). 200). o valor da variável é uma referência para o valor representado pela variável.1). Lembre-se que classes e interfaces são tipos de referência (seção 4. que incializa o objeto. Observe. embora muitas vezes apareça na mesma linha. Rectangle(100. alocando a memória necessária. Em Java. O operador new retorna uma referência para uma variável: Rectangle rect = new Rectangle(100. classes podem oferecer um ou mais construtores para inicializar um objeto. o operador new cria o objeto e o construtor o inicializa. 200). 200) é o argumento de new. possui largura igual a 100 e altura igual a 200. ou seja. Como outras declarações de variáveis. Os construtores de uma classe sempre possuem o mesmo nome da classe e não possuem parâmetro de retorno. Declarações apenas notificam o compilador que vai se utilizar o nome rect para referenciar uma variável cujo tipo é Rectangle. • Inicialização: Rectangle() é uma chamada para o construtor de Rectangle. Para criar um novo objeto. Instanciando um Objeto O operador new cria um objeto. Aqui. a declaração Rectangle rect não cria um novo objeto. Assim. Por exemplo: new Rectangle(100. ou seja.• Declaração: Rectangle rect é uma declaração de variável que informa ao compilador que o nome rect será utilizado para referir-se a um objeto da classe Rectangle. apenas uma variável que pode referenciar um objeto Rectangle. rect refere-se para um objeto Rectangle cuja origem está em (0. Depois desta expressão. deve-se utilizar o operador new. as declarações dos construtores de Rectangle: Pág 49 . Assim. Cada classe em Java oferece um conjunto de construtores para inicializar seus objetos.

Tais modificações devem ser realizadas por meio de métodos. a linguagem Java automaticamente oferece um construtor sem argumentos. Um objeto “ideal” oferece métodos pelos quais se consegue inspecionar ou modificar o seu estado. que não faz nada. a programação orientada a objetos desencoraja a manipulação direta das variáveis de um objeto. assumir que não há problemas em se inspecionar/modificar tais variáveis.2. Note que não se consegue colocar um objeto Point e um Retângulo em um estado inconsistente modificando as suas variáveis (e se fosse um triângulo?). int h) public Rectangle(Point p. 5. em situações práticas. suponha que o objeto Rectangle representa um objeto retangular em um programa de desenho e que o usuário moveu este objeto para um outro local. Se uma classe (como SimplePoint e SimpleRectangle. int w. ou nenhum valor. Manipulando ou inspecionando as suas variáveis 2. Se um objeto oferece acesso a suas variáveis. uma classe pode proteger suas variáveis contra manipulação direta por outros objetos se estas manipulações podem ameaçar a consistência do objeto. int h) public Rectangle() Cada um destes construtores permite se definir valores iniciais para diferentes aspectos do retângulo: a origem.public Rectangle(Point p) public Rectangle(int w. é Pág 50 . o compilador é capaz de determinar qual construtor deve ser invocado. Portanto. corre-se o risco de colocar o objeto em um estado inconsistente. Assim. Desta forma. As classes Point e Rectangle permitem livre acesso a suas variáveis. Assim. Entretanto. estes devem possuir um número diferente de argumentos e/ou argumentos de tipos distintos. Java proporciona um mecanismo de controle onde as classes podem restringir ou permitir o acesso a suas variáveis e métodos (tal mecanismo será descrito com mais detalhe em uma aula posterior).2 Utilizando Objetos Pode-se utilizar um objeto de duas maneiras: 1. Um construtor que não possui argumentos é chamado de construtor default. então. Se uma classe possui vários construtores. é razoável. Por exemplo. a largura e a altura. algumas vezes faz sentido utilizar diretamente as variáveis de um objeto. Executando (invocando) seus métodos Como já foi discutido. é correto afirmar que todas as classes possuem pelo menos um construtor. origem. largura e altura. vistas no começo da seção) não definir explicitamente um construtor. Estes métodos garantem que um objeto nunca entrará em um estado inconsistente.

Pode-se utilizar este tipo de variável da mesma maneira que os tipos de variáveis vistos anteriormente. A classe retângulo oferece duas maneiras equivalentes de realizar isto: 1. o programa não possui nenhuma referência (variável) para o objeto recém-criado. Esta expressão cria um novo objeto retângulo e imediatamente acessa a sua variável height (que. com um ponto (. como descrito na seção . Para mover rect para uma nova localização. Pág 51 . objectReference. possui o valor default dado pelo construtor). no caso. 37). Executando o método move Referenciando as Variáveis de um Objeto Suponha que você tenha criado um retângulo chamado rect. Esta expressão move o retângulo. De maneira geral. Executando (invocando) os Métodos de um Objeto Para mover rect para uma nova localização.origin = new Point(15. 37). Pode-se utilizar também qualquer expressão que retorne uma referência para um objeto. atribuindo para a origem um novo ponto.height.height * rect. Por exemplo: height = new Rectangle().origin.variable A primeira parte do nome da variável. Assim. deve refernciar um objeto.) no meio: objectReference. poderíamos usar as outras duas variáveis do objeto. rect. Por isto. para se referir a uma variável de um objeto. Observação: depois de executada a expressão acima. Para calcular a área de rect. este objeto está sujeito à “coleta de lixo” (descrita em um dos itens a seguir). deve-se escrever: rect.origin é a variável que contém o ponto de origem de rect. acrescenta-se o nome da variável à referência do objeto.move(15. height e width (ou simplesmente executar o método area()): area = rect. utilizando o método move(). devemos escrever: rect.width. é possível utilizar o operador = para atribuir um valor a rect. Manipulando diretamente a variável origin do objeto 2.necessário atualizar o ponto de origem do objeto.

15 e 37. você obterá uma resposta distinta se enviar a mesma mensagem para um outro objeto (bob): int areaOfRectangle = bob. Provavelmente. Se o método não possuir argumentos.methodName(). Para aqueles métodos que retornam algum valor. 50). pode-se utilizar a invocação do método em expressões.origin = new Point(15. Esta técnica de gerência de memória é entediante e bastante suscetível a erros (memory leaks). Assim. Java permite que se crie quantos objetos forem necessários (obviamente. e o programador não precisa se Pág 52 . 5. Como descrito no item anterior. 50) retorna um objeto retângulo.methodName(argumentList).) no meio. 50). Esta expressão é equivalente àquela descrita no item anterior: rect.area().Esta expressão invoca o método move() de rect() com dois parâmetros (inteiros). com um ponto (. usá-lo para tomar decisões (if-else) ou controlar um laço: int areaOfRectangle = new Rectangle(100. Por exemplo. destrua-os quando não precisar mais deles. o objeto é um retângulo chamado rect. pode-se atribuir o valor de retorno a uma variável. Como mostrado. explicitamente. ou objectReference. como area(). objectReference deve ser uma referência para um objeto (variável ou uma expressão que retorna uma referência de um objeto). Neste caso.area() A expressão new Rectangle(100. Além disto.area().3 Liberando Objetos não mais Utilizados A maioria das linguagens orientadas a objetos exige que o programador mantenha um controle sobre todos os objetos criados e que. A notação utilizada para invocar o método de um objeto é similar a aquela usada para referenciar as suas variáveis: acrescenta-se o nome do método à referência do objeto.y. Observação: Lembre-se que invocar o método de um objeto equivale a enviar uma mensagem para aquele objeto.x e origin. 37). o número de objetos é limitado pelos recursos disponíveis no sistema). O método move o objeto rect pois atribui novos valores às variáveis origin. podemos usar: new Rectangle(100. define-se os argumentos para o método dentro de parênteses. utiliza-se parênteses vazios: objectReference. pode-se invocar o método area() para calcular a área deste objeto recém-criado.

Este processo é chamado de finalização. objetos não marcados (ou seja. Assim que uma outra thread torna-se ativa. explicitamente. dependendo da situação e do sistema onde Java está rodando. } O método finalize é um membro da classe Object. O ambiente de execução Java (JVM) remove os objetos quando percebe que eles não são mais utilizados. Depois que todos os caminhos para os objetos são investigados. atribuindo null a variável que o referenciava (origin): protected void finalize() throws Throwable { origin = null. O coletor de lixo executa assincronamente. super. O coletor de lixo é uma thread que executa com baixa prioridade de forma síncrona ou assíncrona. quando o sistema está ocioso. 5. em sistema como o Windows 95/NT. o coletor dá ao objeto uma oportunidade de se “limpar” por meio da chamado do método finalize do objeto. Por exemplo. Uma classe deve redefinir o método finalize para realizar as finalizações necessárias para os objetos daquele tipo. a sua execução. Note que o Pág 53 .preocupar em destruí-los. Por exemplo. o coletor roda sincronamente quando o sistema fica sem memória disponível ou quando um programa Java requisita. Referências são armazenadas em variáveis e são descartadas quando estas variáveis saem de escopo (pode-se também remover uma referência de um objeto atribuindo à variável o valor null). A classe Object fica no topo da hierarquia de classes de Java e é “pai” de todo mundo. O coletor de Java é do tipo mark-sweep: ele inspeciona as áreas de memória dinâmica em busca de objetos e marca aqueles que estão sendo referenciados.finalize().2 Finalização Antes que um objeto seja “coletado”.3. não mais referenciados) são considerados como lixo e então são “coletados” (liberando a memória alocada para aqueles objetos).1 Coletor de Lixo (Garbage Coletor) A plataforma Java possui um coletor de lixo que periodicamente libera a memória utilizada pelos objetos que não são mais necessários. o método finalize da classe Rectangle libera o objeto Point.3. Durante a finalização. Este processo é denominado de coleta de lixo (garbage collection). um objeto pode desejar liberar outros recursos do sistema como arquivos e sockets ou eliminar referências para outros objetos de tal forma que estes tornem-se também candidatos à coleta de lixo. o coletor de lixo termina a sua execução. Um objeto está sujeito a coleta de lixo quando não existem mais referências para ele. 5.

Stack impõe as restrições de uma estrutura LIFO ao objeto Vector. A classe Vector é um vetor de objetos que tem uma característica muito interessante: é capaz de alocar dinamicamente espaço para novos objetos à medida que seja necessário.método finalize de Rectangle executa o método super. Para isto. vamos analisar cada uma das estruturas da figura acima. pode-se apenas remover (adicionar) elementos do (ao) topo da pilha. Entretanto. A classe Stack usa então um objeto da classe Vector para armazenar seus elementos. para armazenar os seus elementos. Vector.finalize para dar a oportunidade a classe pai de realizar uma “limpeza” final (a utilização do método finalize será discutida com maior detalhe em uma próxima aula). Esta implementação de uma pilha utiliza um outro objeto. será apresentado um pequeno exemplo que implementa uma pilha (last-in-first-out. LIFO). Pág 54 . ou seja. A seguir. 5.4 Criando Classes Esta seção mostra como escrever classes a partir das quais objetos são criados. A figura a seguir lista a classe e identifica a estrutura do código.

•final: serve para declarar que a classe não pode ser “derivada” (ou seja. utiliza-se a palavra-chave implements seguida de uma lista. na ordem que podem (ou devem) aparecer na declaração. serão apresentadas razões para utilizar classes do tipo “finais”. •abstract: serve para declarar que a classe não pode ser instanciada (criada).4. Em uma próxima aula. Todos os demais elementos são opcionais.1 Declaração da Classe O lado esquerdo da figura a seguir mostra os componentes que podem fazer parte da declaração de uma classe. A discussão mais detalhada de tais elementos será feita ao longo do curso. •extends Super: o elemento extends identifica que a classe Super é a superclasse da classe declarada. independente do pacote a que ela pertença. em Java. O texto em itálico identifica o nome de uma classe (ou interface). o conceito de interfaces em Java será apresentado com maior profundidade em uma próxima aula. pode-se agrupar classes em pacotes. o programador indica que tal classe pode ser utilizada por qualquer outra. ou packages).5. posteriormente. Pág 55 . ter subclasses). O lado direito do diagrama descreve o propósito do componente. •class NameofClass: a palavra-chave class indica ao compilador que o código a seguir é uma declaração de uma classe cujo nome é NameofClass. Novamente. Também. Utilizando a palavra-chave public. •implements Interfaces: para declarar que uma classe implementa uma ou mais interfaces. uma classe pode ser utilizada apenas por classes que fazem parte do mesmo package (package é um conceito equivalente a uma bibliotecas de objetos. Os componentes indispensáveis em uma declaração de classe são: a palavra-chave class e o nome da classe. serão apresentadas situações onde é vantajoso se utilizar uma classe deste tipo. •public: por default. delimitada por vírgulas. O conceito de herança em Java será abordado com mais detalhes em uma próxima aula. A lista a seguir apresenta algumas explicações básicas sobre cada um destes componentes da declaração de uma classe. dos nomes das interfaces.

de mesmo nome). A classe Stack define. 5. Lembre-se que finalize é um método especial que proporciona a “limpeza” dos objetos da classe Stack. Rigorosamente falando. Observação: variáveis e métodos são chamados de membros da classe. No exemplo da classe pilha. não-abstrata que não implementa nenhuma interface.3 Construtores da Classe Todas as classes Java possuem construtores que são utilizados para inicializar um novo objeto daquele tipo. no código Pág 56 . O corpo de uma classe contém todo o código que proporciona o ciclo de vida dos objetos instanciados a partir da classe: construtores para incializar novos objetos. o compilador Java assume algumas “declarações” default: uma subclasse de Object nãofinal. a classe Stack define um único construtor: public Stack() { items = new Vector(10). pop. e finalize. da classe Vector). Baseando-se no número e no tipo de argumentos passados para o construtor é que o compilador consegue determinar qual construtor utilizar. Também são definidos um construtor. um método finalize que realiza a “limpeza” dos objetos.4.4. por exemplo. } Note que os construtores de uma mesma classe devem possuir uma lista de argumentos diferentes. não-pública. 5. métodos que implementam o comportamento da classe e de seus objetos e. vemos que a declaração da classe é bastante simples e indica que tal classe é pública e que seu nome é Stack.2 Corpo da Classe O corpo da classe segue a declaração e é delimitado por chaves: { e }. uma variável membro que armazena os itens da pilha (items. e quatro métodos: push.Observação: se o programador não declarar explicitamente os componentes opcionais. um construtor que atribui um tamanho inicial para a pilha: public Stack(int initialSize) { items = new Vector(initialSize). Construtores sempre possuem o mesmo nome da classe. } Como já visto. No exemplo. isEmpty. o default. declarações das variáveis que guardam o estado da classe e de seus objetos. Por exemplo. em seu corpo. Java suporta a sobrecarga de construtores de tal forma que uma classe pode possuir vários construtores (obviamente. os construtores não são classificados nem como métodos ou variáveis. Stack poderia definir. quando necessário.

i <= numImages..framesPerSecond = fps. i++) { . this.. for (int i = 0. O construtor da classe a seguir. Note que se nenhum construtor for definido explicitamente para a classe. // Load all the images. Pág 57 .. atribui alguns valores default. . Analogamente. class AnimationThread extends Thread { int framesPerSecond. this. o compilador escolhe o construtor default: new Stack(). laços e outras expressões..numImages = num. Entretanto. Este construtor “automático” oferecido pelo sistema não faz nada (ou seja. ou seja. } } .abaixo. o número de imagens (numImages) e depois carrega as imagens. o compilador sabe que deve usar o construtor que tem como argumento um único valor (do tipo inteiro): new Stack(10). } Observe que o corpo de um construtor é como o corpo de um método. this. como a velocidade de exibição das imagens (framesPerSecond). uma linha no construtor de AnimationThread apresenta um código que não será visto em métodos comuns: super("AnimationThread"). no código abaixo. contém declarações de variáveis locais. é uma função “vazia”). derivada da classe Thread. Image[] images.images = new Image[numImages].. int num) { super("AnimationThread").. AnimationThread(int fps. int numImages. o ambiente de execução do Java (JVM) automaticamente irá proporcionar um construtor default.

Na maioria das vezes. o construtor da superclasse deve ser a primeira expressão dentro do construtor da subclasse.7). apenas o código dentro da classe Stack pode acessá-la. •static: define que a variável é uma variável de classe em vez de uma variável de instância. e estes métodos podem construir um objeto da classe e retornar a sua referência.4.4. Thread. A classe em questão pode possuir métodos de classe (públicos). •public: qualquer classe pode instanciar a classe declarada. em certos casos) invocar o construtor da superclasse para aproveitar o código de inicialização e/ou para que a classe funcione corretamente.4 Variáveis A classe Stack utiliza a seguinte linha de código para definir sua única variável membro: private Vector items. Pode-se definir quatro níveis de acesso: public. e private.4. •package: apenas classes que fazem parte do mesmo pacote podem construir um objeto da classe em questão. package. especificam quais objetos podem criar instâncias da classe: •private: nenhuma outra classe pode instanciar a classe. ou seja. chamados de fábricas. Ou seja. Esta declaração refere-se a uma variável membro e não a um outro tipo de variável (local. Este construtor da classe Thread tem como parâmetro uma String que define o nome da thread. A variável declarada tem nome items e é do tipo Vector.Esta expressão invoca o construtor da superclasse de AnimationThread. que devem ser associados aos construtores. protected. Além disso. 5. •protected: apenas subclasses da classe em questão podem criar instâncias dela. static também pode ser utilizado na declaração de métodos (seção 5. Os componentes listados abaixo.6. é interessante (e até necessário. A declaração de uma variável pode possuir os seguintes componentes: •accessLevel: permite controlar quais outras classes têm acesso à variável membro. por exemplo) pois aparece no corpo da classe mas fora de qualquer método ou construtor. Observação: Se presente. Pág 58 . Estes níveis são detalhados na seção 5. a palavra-chave private identifica a variável itens como uma variável privada.

. Ocorrerá um erro em tempo de compilação caso seu programa tente alterar o valor de alguma variável final. A seguinte declaração define uma constante chamada AVOGADRO.023e23. objetos ou interfaces). Por convenção. o nome de valores constantes é composto de letras maiúsculas. Não se pode declarar mais de uma variável membro com o mesmo nome dentro de uma classe.023x1023. mas uma subclasse pode utilizar o mesmo nome de uma variável declarada pela superclasse.. } } 5. final double AVOGADRO = 6. cujo valor é 6.4. // um método que utiliza o mesmo nome de uma variável membro public Vector items() { . ou boolean. tipos primitivos (int. •name: o nome da variável pode ser qualquer identificador Java válido (por convenção. passado como argumento da função. •type: pode-se utilizar. •transient: esta palavra chave é utilizada no caso de serialização de objetos para identificar aquelas variáveis que não precisam ser serializadas (serialização vai ser abordada no fim do curso). Pág 59 . para definir uma variável membro. Além disto. uma variável membro e um método podem possuir o mesmo nome. por exemplo) ou tipos de referência (vetores. Este método insere um objeto. •volatile: é utilizada para evitar que o compilador realize algumas otimizações na variável.•final: indica que o valor da variável não pode ser alterado. começando com uma letra minúscula). no topo da pilha e retorna o próprio objeto.5 Métodos A figura abaixo mostra o código do método push da classe Stack. float. Por exemplo. o código abaixo está correto: public class Stack { private Vector items.

4. Os únicos componentes indispensáveis em qualquer declaração são: o nome do método.7). Na próxima aula. utilizando um dos quatro níveis de acesso: public. Pág 60 . A figura abaixo mostra todos os elementos que podem estar presentes na declaração: •accesLevel: como as variáveis. Um dos tópicos das próximas aulas está relacionado com a utilização de métodos nativos. •abstract: um método abstrato não possui implementação e deve ser membro de uma classe abstrata. package. evitando inconsistências. •static: define que o método é um método de classe em vez de um método de instância (seção 5. seu tipo de retorno.6 descreve cada um destes níveis de acesso.4. um método possui duas partes principais: declaração e corpo. abordaremos a necessidade de se escrever métodos finais e como estes métodos afetam as subclasses •native: métodos implementados em linguagens diferentes de Java são chamados métodos nativos e são declarados utilizando a palavra-chave native.Como uma classe. O corpo do método é onde a “a ação ocorre”. pode-se controlar quais classes podem acessar um método. Estes métodos podem ser declarados como syncronized para garantir que as threads acessem as informações compartilhadas de forma segura. tipo de retorno. protected. abordaremos a necessidade de se escrever métodos abstratos e como estes métodos afetam as subclasses. nome e argumentos. •synchronized: threads concorrentes muitas vezes invocam métodos que acessam os mesmos dados. A seção 5. Ele contém todas as instruções Java que implementam a função. Declaração do Método Uma declaração de método possui vários componentes. e private. •final: um método final não pode ser redefinido por subclasses. e um par de parênteses ( ). Na próxima aula. A declaração de um método define todos os seus atributos como: nível de acesso. a maioria deles pode ser declarada implicitamente.

Stack declara o método pop que retorna uma referência para o tipo Object: public synchronized Object pop() { int len = items. por sua vez. exista uma hierarquia de classes onde ImaginaryNumber é uma subclasse de java. Por exemplo. utiliza-se o operador return. é uma subclasse de Object: Pág 61 . que retorna um boolean: public boolean isEmpty() { if (items.1).1). items. Object obj = null. else return false. •[ throws exceptions ]: caso o método possa “levantar” alguma exceção (seção ). Métodos também podem retornar tipos de referência.size() == 0) return true. } Quando um método retorna um objeto. if (len == 0) throw new EmptyStackException().•returnType: em Java. •methodName: o nome do método pode ser qualquer identificador Java válido. para retornar um valor. Por exemplo. é necessário que um método declare o tipo de dado do valor a ser retornado. obj = items. a classe Stack declara o método isEmpty. Se o método não retorna nenhum valor. a classe do objeto retornado deve ser uma subclasse (ou a própria classe) do tipo de retorno declarado. Todo método que não foi declarado como void deve conter pelo menos um return. deve-se usar a palavra-chave void como tipo de retorno. } Um erro de compilação ocorrerá caso tente-se escrever um método onde o valor de retorno não é compatível com o tipo definido na declaração da função. return obj. a declaração deve indicar o tipo desta exceção.Number que.size(). •( paramlist ): é por meio dos parâmetros de um método que passamos as informações para a função. Suponha que. Retornando um Valor de um Método Dentro do corpo do método.lang.removeElementAt(len .elementAt(len .

Em outras linguagens isto poderia ser feito definindo nomes diferentes para cada método drawString(). “é” um número. são declarados também o número e o tipo dos argumentos necessários. Isto porque ImaginaryNumber. números.. } void draw(float f) { . } void draw(int i) { . drawInteger(). Assim. class DataRenderer { void draw(String s) { . entretanto. Nome do Método Java suporta sobrecarga de métodos de tal forma que vários métodos podem compartilhar o mesmo nome. ..) em uma área de desenho. double futureValue. por exemplo). métodos sobrecarregados são diferenciados pelo número e tipo dos seus argumentos.. é necessário escrever um método que saiba imprimir cada tipo de dado. int numPeriods) { double I. } Este método pode retornar um ImaginaryNumber mas não um Object. denominator.. um Object não é necessariamente um número (pode ser uma String. baseado no valor do empréstimo: double computePayment(double loanAmt. o método a seguir calcula os pagamentos mensais de um empréstimo. I = rate / 100.. partial1.. etc.... Por exemplo. suponha que você esteja escrevendo uma classe que imprime vários tipos de dados (strings. Por exemplo.Agora. double rate. Passando Informação para um Método Quando se declara um método. Pág 62 . answer. podemos utilizar o mesmo nome para todos estes métodos desde que possuam parâmetros de tipos diferentes. } } Na verdade.0. suponha que um método tenha como tipo de retorno um Number: public Number returnANumber() { . Em Java. por ser uma subclasse Number..

radius. Por exemplo: class Circle { int x.pow((1 + I). public Circle(int x. public Circle(int x. separadas por vírgulas. y. Neste caso. deve-se referenciála utilizando a palavra-chave this (este objeto): class Circle { int x. Observe que o construtor da classe aceita 3 argumentos que têm os mesmos nomes das variáveis-membros. dizemos que o argumento ocultou (hide) a variável-membro. invocar alguma das funções deste objeto. em Java. Importante também salientar que o argumento de um método pode ter o mesmo nome que uma das variáveis-membro da classe do objeto. temos um exemplo de um construtor que aceita um vetor de objetos (da classe Point) como argumento: Polygon polygonFrom(Point[] listOfPoints) { . int y. no corpo do método.. por exemplo).((futureValue * partial1) / denominator).. y ou radius dentro do corpo do construtor refere-se aos seus argumentos e não às variáveismembro do objeto. Para acessar uma variável-membro do construtor. int radius) { this. Argumentos que ocultam variáveis-membros são muitas vezes utilizados em construtores para inicializar uma classe. A seguir.. os nomes dos argumentos ocultam as variáveis-membro. Isto inclui tipos primitivos (inteiros. onde cada declaração é um par nome/tipo. números reais. y. y e radius. radius.) e tipos de referências (objetos e vetores). O que se pode fazer é passar um objeto para um método e.numPeriods)). } } A classe Circle tem 3 variáveis-membro: x.. pode-se passar como argumento para um método qualquer tipo de dado válido. answer = ((-1 * loanAmt) / denominator) .x = x. Pág 63 . o valor futuro (se a dívida for inteiramente paga -> valor futuro igual a 0) e o número de períodos.0 . Portanto. int radius) { .partial1 = Math. denominator = (1 . Em Java. return answer.partial1) / I. a utilização de x. O conjunto de argumentos de qualquer método é uma lista de declarações de variáveis. não se pode passar métodos como argumentos de outros métodos. } Observação: Diferente de outras linguagens (C. Como foi dito. } Este método possui quatro argumentos: o valor do empréstimo. etc. a taxa de juros. int y. (0.

. os valores das variáveis (1) é que são passados para o método e não as suas referências. Observação Importante: Passagem por Valor Em Java.. int r = -1. b). . int green. Qualquer alteração realizada nestas cópias locais não se reflete nas variáveis originais (r. g. greenValue.y = y. blueValue. -1). Quando o fluxo de controle entra no método getRGBColor. and blue have been created // and their values are -1 . as variáveis r. Quando o argumento é do tipo primitivo.this. Ou seja. o método recebe o valor (uma cópia) da variável passada como argumento. Considere o seguinte exemplo. ao executar getRGBColor. int blue) { // red. g e b para utilizar dentro do método. os argumentos entram no escopo (ou seja são alocados) e são inicializados com os valores passados para o método: class Pen { int redValue. que tenta recuperar a cor atual de um objeto (pen): . os argumentos são passados por valor. No momento que o método getRGBColor é executado. pen. void getRGBColor(int red.radius = radius. green. this. significa que o método não pode alterar a referência armazenada pela variável. o método possui a sua própria cópia dos valores de r. System. } } Ou seja. g e b). e b possuem valor –1. g = -1. verde e azul) nas variáveis r. blue = " + b). green = " + g + ". } } Observação: Os nomes dos argumentos de um método não podem ser iguais ao nome de alguma variável local dentro do corpo do método. era receber os valores de volta (vermelho. g e b.getRGBColor(r.. passagem por valor significa que o método não pode alterar o valor da variável passada como argumento. A intenção do código. o método abaixo não funciona como esperado: class Pen { Pág 64 .println("red = " + r + ".out. Entretanto. g. b = -1. Quando o argumento é do tipo de referência. Então podemos visualizar a chamada a getRGBColor como: getRGBColor(-1. -1. Assim....

A passagem por valor garante ao programador uma certa segurança: os métodos não podem modificar variáveis que estão fora de seu escopo. Note que o método agora atribui os valores das cores para as variáveis membros do objeto RGBColor. na verdade. g e b ainda continuam iguais a –1. pen. objetos e vetores também são passados por valor. como um método pode retornar mais de um valor ou modificar variáveis fora de seu escopo? (observação: se for necessário retornar somente um valor podemos utilizar return). b). int green. g. System. é desejável que um método seja capaz de modificar um ou mais argumentos (por exemplo. A saída para esta situação é utilizar. greenValue. porém o seu valor é.int redValue.. } Agora. a própria função getRGBColor citada acima). podemos rescrever getRGBColor para que faça aquilo que é esperado. vanos rescrever getRGBColor para que o método aceite um objeto RGBColor como argumento.. } } Quando o fluxo de controle voltar para a expressão println. blue = blueValue. vamos criar um novo tipo de objeto RGBColor que guarda os valores de vermelho. green. as atribuições realizadas a estes argumentos dentro do método não tem nenhum efeito. . como argumentos. Aproveitando este fato. Então. class Pen { Pág 65 . no código a seguir os argumentos de getRGBColor (red. Portanto. blue = " + b). Ou seja. // this method does not work as intended void getRGBColor(int red. . r. o argumento do método vai estar referenciando o mesmo objeto que a variável original.getRGBColor(r. Observe que. g = -1. green = greenValue. green e blue) não existem mais.out.. b = -1. Entretanto. muitas vezes. . verde e azul: class RGBColor { public int red. Primeiramente. green = " + g + ". uma referência para um objeto.. os tipos de referência. blue.. int blue) { red = redValue.println("red = " + r + ".. int r = -1. blueValue.

blue). saturation. em geral.red = redValue. pen. O objeto atual é aquele que teve o seu método invocado. Observação: no corpo de um método. aColor. this. } } Desta forma. Exemplo 2: class ASillyClass { boolean aVariable. HSBColor (int hue. .hue = hue. aColor. int saturation. isto só é necessário caso exista alguma ambigüidade relacionada com o nome do método.println("red = " + penColor.green = greenValue. é utilizada com a intenção de tornar o código mais claro. brightness.red + ".. System. poderíamos escrever: . Também pode-se utilizar a palavra-chave super para referir-se a membros da superclasse que o objeto atual redefiniu ou sobrecarregou. int brightness) { this. Novamente. Exemplo 1: class HSBColor { int hue. this. void getRGBColor(RGBColor aColor) { aColor. RGBColor penColor = new RGBColor().saturation = saturation.. Pág 66 .green + "..blue = blueValue.out.int redValue. green = " + penColor.getRGBColor(penColor).brightness = brightness. As modificações feitas no objeto RGBColor dentro do método getRGBColor afetam o objeto original pois a variável original (penColor) e o argumento do método (aColor) referem-se ao mesmo objeto. blue = " + penColor. pode-se utilizar a palavra-chave this para referir-se explicitamente a membros do objeto atual. blueValue.. } Pode-se também utilizar this para chamar um dos métodos do objeto atual. greenValue. void aMethod() { aVariable = true.

aMethod(). System.println(aVariable). System.} } class ASillierClass extends ASillyClass { boolean aVariable.aVariable). Depois.out. A tabela a seguir apresenta os níveis de acesso permitidos: nível de acesso private protected public package classe X X X X X* X subclasse pacote (package) X X X mundo X Pág 67 .4. super. Em Java. A linguagem Java suporta quatro níveis de acesso distintos: privado (private). void aMethod() { aVariable = false. protegido (protected).aMethod(). pacote (package). aMethod() invoca o método da superclasse: super. público (public) e o nível default.println(super.out. que possuem diferentes valores: false true 5. pode-se utilizar especificadores de acesso (access especifiers) para proteger tanto variáveis quanto os métodos de uma classe. } } Primeiramente. Então o método aMethod imprime as duas versões de aVariable. Este controle é definido na própria declaração da variável (ou método). Isto faz com que a versão oculta de aVariable (aquela que foi declarada na superclasse ASillyClass) receba o valor true.6 Controle de Acesso a Membros da Classe Como visto na seção 2. Tal característica é denominada de encapsulação. um dos benefícios do paradigma de orientação a objetos é a possibilidade de se “proteger” variáveis e métodos do acesso por parte de outros objetos. aMethod() atribui a variável aVariable (que oculta a variável declarada na superclasse) o valor false.

a ser descrita ainda nesta seção. Vamos abordar com maior detalhe cada um destes níveis: Privado (Private) Este é o nível de acesso mais restritivo. a. A segunda coluna indica se as subclasses (independente do pacote a qual pertencem) possuem acesso a variável/método. // ilegal ^ Pág 68 . class Alpha { private int iamprivate. Como pode se observar.A primeira coluna indica se a própria classe possui acesso ao membro (variável ou método). A classe a seguir contém uma variável e um método privados. private void privateMethod() { System. possuem acesso ao membros. utiliza-se a palavra-chave private em sua declaração. Um membro privado é acessível apenas pela própria classe que o definiu.iamprivate = 10.java:9: Variable iamprivate in class Alpha not accessible from class Beta.out. } } Apenas objetos da classe Alpha podem inspecionar ou modificar a variável iamprivate e podem executar o método privateMethod. // ilegal } } A classe Beta não pode acessar a variável iamprivate ou executar o método privateMethod de um objeto da classe Alpha e o compilador Java geraria uma mensagem de erro do tipo: Beta. deve-se declarar como privadas aquelas variáveis/métodos que só devem ser utilizados pela classe Para declarar um membro privado.println("privateMethod"). A quarta coluna indica se todas as classes possuem acesso as variáveis/métodos. A terceira coluna indica se classes. que estão no mesmo pacote da classe em questão. Ou seja.iamprivate = 10. Por exemplo: class Beta { void accessMethod() { Alpha a = new Alpha(). // ilegal a. *: Este nível de acesso possui uma pequena particularidade. a. a classe sempre possui acesso aos seus próprios membros.privateMethod().

out. Um objeto possui acesso a membros privados de outros objetos do mesmo tipo. } } Isto é perfeitamente válido. boolean isEqualTo(Alpha anotherAlpha) { if (this. Isto ocorre pois as restrições de acesso se aplicam às classes (todas as instância de uma classe) e não aos objetos (uma instância da classe). protected void protectedMethod() { System. Primeiramente. vamos analisar como o protected afeta classes que estão no mesmo pacote. utiliza-se a palavra-chave protected.Beta. Pág 69 . class Alpha { protected int iamprotected. a classe Gamma pode acessar os membros protegidos de Alpha: package Greek. Assim. else return false. // ilegal 2 errors Observação importante: programadores novatos geralmente perguntam se um objeto Alpha pode acessar membros privados de outro objeto Alpha. Considere esta versão de Alpha que é declarada dentro de um pacote chamado Greek e possui uma variável e um método protegidos: package Greek. a. Para declarar um membro protegido.iamprivate == anotherAlpha.println("protectedMethod").java:12: No method matching privateMethod() found in class Alpha.iamprivate) return true.privateMethod(). } } Suponha que a classe Gamma também foi declarada como membro do pacote Greek (e não é uma subclasse de Alpha). Isto é ilustrado no exemplo a seguir: class Alpha { private int iamprivate. Protegido (protected) Este nível de acesso permite que a classe. suas subclasses e todas as classes no mesmo pacote (package) acessem seus membros.

class Delta extends Alpha { void accessMethod(Alpha a. // válido a.protectedMethod(). // válido a. Para declarar um membro público. utiliza-se a palavra-chave public: package Greek.class Gamma { void accessMethod() { Alpha a = new Alpha().iamprotected = 10. // ilegal d.iamprotected = 10. Qualquer classe. package Latin. se a subclasse pertencer ao mesmo pacote da classe com o membro protegido. Observe o seguinte exemplo: import Greek. possui acesso aos membros públicos de uma classe.out. vamos investigar como protected afeta as subclasses de Alpha. public void publicMethod() { System.*. a. // válido } } Agora. } } Pág 70 .println("publicMethod"). Público (public) O nível de acesso mais simples é o público. // ilegal d. Delta d) { a. public class Alpha { public int iampublic. // válido } } Agora. mas apenas em objetos do tipo Delta ou suas subclasses. Considere a classe Delta que é uma subclasse de Alpha mas pertence a um outro pacote.protectedMethod().protectedMethod(). A classe Delta pode acessar iamprotected e protectedMethod.iamprotected = 10. em qualquer pacote. Latin. A classe Delta não pode acessar os membros protegidos de objetos do tipo Alpha. então a subclasse possui acesso ao membro.

package Roman. ou seja. Por exemplo: package Greek. a.publicMethod(). Assim. // válido } } Pág 71 . class Beta { void accessMethod() { Alpha a = new Alpha(). class Alpha { int iampackage.iampublic = 10.out. void packageMethod() { System. de tal forma que esta não possua nenhum relacionamento (superclasse/subclasse) com Alpha: import Greek. // válido a. class Beta { void accessMethod() { Alpha a = new Alpha(). // válido } } Observe que a classe Beta continua com acesso aos membros públicos de Alpha. } } Todas as classes declaradas no mesmo pacote de Alpha possuem acesso a iampackage e packageMethod.*. Este nível permite que classes do mesmo pacote acessem os membros da classe.Rescrevendo a classe Beta.println("packageMethod").iampackage = 10. quando não se atribui explicitamente um nível de acesso para uma variável/método de uma classe. Pacote (package) Este nível de acesso é o default. // válido a.packageMethod(). a. o código abaixo é válido: package Greek.

independentemente do número de instâncias criadas para aquela classe. Exemplo: myClass myObject.5. Por exemplo. um membro declarado em uma classe é uma variável/método de instância. O ambiente de execução aloca memória para variáveis de classe apenas uma única vez. public int x() { return x. Existem também variáveis de classe (que são declaradas utilizando a palavra-chave static). // válido O mesmo raciocínio é válido para os métodos: classes podem possuir métodos de instância e de classe. . Observação Importante: métodos de instância podem acessar variáveis de instância e de classe. O sistema aloca a memória na primeira vez que encontra uma referência no código a aquela classe. a classe abaixo declara uma variável de instância (um inteiro chamado x) e dois métodos de instância. Toda vez que se cria uma instância de uma classe. Todas as instâncias (objetos) compartilham a mesma cópia das variáveis de classe. // válido myClass. métodos de classe somente podem acessar as variáveis de classe declaradas. } public void setX(int newX) { x = newX. x e setX: class AnIntegerNamedX { int x. para executar um método de classe não é necessário criar um objeto da classe.. o ambiente de execução cria uma cópia de cada variável de instância da classe para o novo objeto. } tem-se uma variável de instância.7 Membros de Instância X Membros de Classe Quando se declara uma variável como aFloat em myClass: class MyClass { float aFloat. } } Pág 72 . Além disto.4.mystaticvariable = 1. myObject.mystaticvariable = 1. Em contrapartida. Por default. Pode-se acessar uma variável de classe por meio de um objeto ou da própria classe..

static public int x() { return x. Note que o código acima está manipulando duas cópias diferentes de x: uma que pertence ao objeto myX e outra que pertence ao objeto anotherX. utiliza-se também a palavra-chave static: class AnIntegerNamedX { private int x.x = 2 Para especificar que uma variável membro é uma variável de classe.x = " + myX. Assim. Considere o seguinte exemplo: AnIntegerNamedX myX = new AnIntegerNamedX(). terá a seguinte saída: myX.x = 2 anotherX. que cria dois objetos da classe AnIntegerNamedX. para especificar que um método é um método de classe. anotherX. Por exemplo.x()). atribui valores a x e mostra o resultado. mostrado anteriormente. Analogamente. a saída deste trecho de código é: myX.println("anotherX. myX. } Pág 73 . } } Neste caso. public int x() { return x. que é compartilhada por todos os objetos da classe AnIntegerNamedX.println("myX. } public void setX(int newX) { x = newX.out.x = 1 anotherX. a variável x declarada abaixo é uma variável de classe: class AnIntegerNamedX { static int x.x = " + anotherX.x = 2. o mesmo trecho de código.setX(1). utiliza-se a palavrachave static.x = 2 A saída é diferente pois agora x é uma variável de classe e só existe uma cópia da variável.x()).Observação: os métodos de instância atuam sobre as variáveis de instância do objeto atual.out. System. AnIntegerNamedX anotherX = new AnIntegerNamedX(). System.

numa ação denominada “levantar uma exceção” (throwing an exception).out. x = newX.4. 5. } static public void setX(int newX) { x = newX. x). Para solucionar este problema. Para isto.x()). o ambiente de execução envia este objeto ao seu programa.println("AnIntegerNamedX. deve-se escrever um código de tratamento de exceção: Pág 74 . podemos acessar membros de classe por meio do nome da própria classe: AnIntegerNamedX. } } Quando se tenta compilar o código acima. } } Como já foi dito. ^ 2 errors Isto ocorre pois métodos de classe não podem acessar variáveis de instância (no caso. devemos tornar x uma variável de classe: class AnIntegerNamedX { static private int x.x = " + AnIntegerNamedX. System. Pode-se acessar a variável x a partir da classe AnIntegerNamedX (isto não pode ser feito com variáveis de instância). static public int x() { return x.setX(1).8 Tratamento de Exceções Exceção é um tipo especial de objeto que é criado quando algo sai errado em um programa. ocorrerão erros de compilação: AnIntegerNamedX.java:7: Can't make a static reference to nonstatic variable x in class AnIntegerNamedX.static public void setX(int newX) { x = newX. Note que não é mais necessário criar os objetos myX e anotherX. Após criar uma exceção. É responsabilidade do seu programa capturar (catch) esta exceção. ^ AnIntegerNamedX.java:4: Can't make a static reference to nonstatic variable x in class AnIntegerNamedX. return x.

utiliza-se as cláusulas try e catch.outroMetodo(). o código do bloco catch é ignorado. } Para capturar uma exceção. caso contrário ocorrerá um erro de compilação.metodoQuePodeGerarUmaExcecao(). pode realizar o tratamento de exceção (via try e catch) ou “repassá-la” utilizando throws. Este método. por sua vez. Pode-se “passar para a frente” a exceção. Pode-se acessar os métodos. } catch (Excecao e) { System.try { a. o restante do código é ignorado e o fluxo de controle do programa “salta” para o bloco catch. Por outro lado. A tabela abaixo lista alguma das exceções mais comuns em Java: Exceção ArithmeticException ArrayIndexOutOfBounds Exception ArrayStoreException Descrição Caused by math errors such as division by zero Caused by bad array indexes Caused when a program tries to store the wrong type of data in an array Pág 75 . Tal exceção não será tratada por GetURL e sim enviada para o método que invocou GetURL. O parâmetro de catch é o tipo de exceção a ser capturada (tal como o argumento de um método). Observação: não é necessário realizar o tratamento de exceção no mesmo método onde ela foi levantada.out. utilizando-se a palavra-chave throws: protected void GetURL() throws MalformedURLException No exemplo acima. da exceção por meio deste argumento. A documentação on-line da API da linguagem Java indica quais métodos podem levantar exceções e quais são os tipos destas exceções.println(“Exceção !!!”). A linguagem Java define várias exceções (objetos) que podem ser geradas pelos métodos das classes de sua API. se existirem. Para um mesmo bloco try podem existir mais de um bloco catch (cada um capturando um determinado tipo de exceção). a. se nenhuma exceção for gerada. Estas exceções devem ser sempre tratadas pelo código do seu programa. Todo o código que pode levantar uma exceção é colocado em um bloco try. dentro do método GetURL pode ser levantada uma exceção (MalformedURLException). Caso ocorra uma exceção em algum ponto do bloco.

5 Exercícios 1. Considere o seguinte trecho de código: class UmaClasse { private int x. 2.x = x. Agora. such as inability to read from a file Caused by referencing a null object Caused when a conversion between strings and numbers fails Caused when there's not enough memory to allocate a new object Caused when an applet tries to perform an action not allowed by the browser's security setting Caused when the system runs out of stack space Caused when a program attempts to access a nonexistent characterposition in a string Observação: pode-se tratar todos os tipos de exceção utilizando um único bloco catch utilizando catch (Exception e) pois Exception é a superclasse de todos os objetos de exceção. considere o código abaixo: class OutraClasse { public float x. } } O código acima é válido? Justique. public void UmaClasse(int a) { x = a. } O código acima é válido? É possível criar classes sem construtores? Como Java trata esta questão? Pág 76 .FileNotFoundException IOException NullPointerException NumberFormatException OutOfMemoryException SecurityException StackOverflowException StringIndexOutOfBounds Exception Caused by an attempt to access a nonexistent file Caused by general I/O failures. } public void UmaClasse(int x) { this. 5.

out. O código abaixo é válido? public class OutraClasse { private int x. em Java.finalize(). Seria interessante permitir que outros objetos acessem diretamente suas variáveis (vértices do triângulo)? Por que? Como você implementaria. 6. tal classe? 4. 5. } } class B extends A { protected void finalize throws Throwable { System. o compilador não tem como saber que os objetos referenciados pelo vetor de X não são mais utilizados). Faça um programa que instancie e utilize um objeto da classe Stack (seção 5. colocada no início do construtor de uma classe? 9.println(“Fim de B”). Note que você pode inserir qualquer tipo de objeto nesta pilha (inclusive colocar objetos de tipos diferentes na mesma pilha). Por que? 8. Considere o código abaixo: class A { protected void finalize throws Throwable{ System.finalize()? Justifique. Justifique esta afirmativa com exemplos. Como visto na seção 5. // um método que utiliza o mesmo nome de uma variável membro public int x() { . Porém. em certas situações é importante a existência do método finalize. Apesar do ambiente Java realizar a liberação automática da memória alocada aos objetos. qual será a saída do programa? E se tirarmos a linha super. Qual a função da instrução super().4). Como você faria para liberar a memória alocada para os objetos referenciados pelo vetor de X? Dica: pensar em uma maneira de “forçar” a coleta de lixo. Suponha que você deva criar uma classe que represente um triângulo. Suponha que no seu programa exista um objeto X que possui um vetor (variável membro) com milhares de referências a objetos que você sabe que não serão mais utilizados. Como se declara constantes em Java? Dê um exemplo. super..out. Insira e retire alguns objetos desta pilha.3.. 7. o ambiente de execução Java (JVM) remove os objetos quando percebe que eles não são mais utilizados. } } Quando um objeto da classe B for liberado. este objeto X é utilizado para outros fins dentro do seu programa (ou seja.println(“Fim de A”). 10. } } Pág 77 . Este processo é denominado de coleta de lixo (garbage collection).3.

x + “ x = “ + x). this.. int y) { System.x + “ x = “ + x). Considere a seguinte classe: class MaisUmaClasse { int x. } public B metodo2() { return objetoA. public void modificaX(int x) { this. A objetoA = new A().} public void atribui(int x..y = y. O código abaixo é válido? Justifique. y=0.} } Qual será a saída do seguinte trecho de código? Justifique.modificaX(1).atribui(1. public Ponto() { x=0.. 13.y = y. . .out.2). } 12.println(“x = “ + this. System.x = x.11. } public static void modificaY (int y) { this. Ponto p = new Ponto(). B objetoB = new B(). objeto1.x = x.. p. Suponha que a classe B seja uma subclasse de A. .this.. public A metodo1() { return objetoB.. static int y. } } . Qual a finalidade das palavras-chave this e super? Dê exemplos. MaisUmaClasse objeto1 = new MaisUmaClasse(). Pág 78 .out. Qual será a saída do trecho de código abaixo? Justifique class Ponto { int x. 14. y. MaisUmaClasse objeto2 = new MaisUmaClasse().println(“x = “ + this.

Escreva um programa que levante.x + “ y = “ + objeto1.modificaX(2). por exemplo) com atributos públicos (raça.modificaY(2). imprimirFilhos(). public static MaisUmaClasse A () { return a.y). etc. Implemente também métodos que manipulem as variáveis privadas (novoFilho(). idade) e privados (filhos. algum tipo de exceção (divisão por zero.). Por que o código abaixo é inválido? class MaisUmaClasse { private int a. Crie uma classe em Java (cachorro. 20. propositadamente. System. System.println (“Objeto1: x =” + objeto1.objeto2. Pág 79 .out. Como se “repassa” uma exceção. objeto2. Escreva o código que realize o tratamento desta exceção e imprima a sua descrição (dica: utilize o método getMessage() da superclasse Exception). Quando você utiliza no seu programa um método que pode levantar uma exceção. nome. Quantas exceções podem ser associadas a um único bloco try? 18. Dê um exemplo.x + “ y = “ + objeto2. por exemplo).out. esta exceção? 17. 19. 15.modificaY(1). cor. objeto1.println (“Objeto2: x =” + objeto2.} } 16. sugestão: utilizar um vetor).y). no seu código. é obrigatório tratar.

Uma subclasse pode utilizar os membros herdados da maneira como foram definidos pelas superclasses. Mesmo que na declaração da classe a palavra-chave extends seja omitida.6. perto do topo da hierarquia. definida no pacote java. a classe possui uma superclasse (classe Object. Definição de subclasse: classe que estende outra classe.lang). toda classe possui uma superclasse. Uma subclasse herda estado e comportamento das suas classes ancestrais. Outras Características da Linguagem Java A seção anterior. Desta forma. A figura abaixo mostra o topo da hierarquia de classes da linguagem: A classe Object define e implementa um comportamento que toda a classe de Java precisa. pode-se especificar apenas uma superclasse para cada classe (ou seja. a palavra-chave extends declara que uma classe é subclasse de uma outra. 6. implementam um comportamento genérico. subclasses nos níveis mais baixos da hierarquia possuem um comportamento mais especializados. em Java. É a mais geral das classes.1 Herança Como foi apresentado na seção anterior. Em Java. não há suporte para herança múltipla). Quais membros são herdados pela subclasse? Pág 80 . descreveu as características da linguagem que todo programador Java necessita saber para utilizar objetos e escrever classes. ocultar algumas variáveis ou redefinir os métodos herdados. Classes e Objetos em Java. Esta seção apresenta alguns conceitos mais avançados que ajudarão a organizar e projetar melhor o seu código. podemos dizer que. O termo superclasse refere-se ao ancestral direto da classe e também a todas as outras que são superclasses das classes ancestrais. Suas subclasses mais imediatas.

definido na superclasse. Uma outra característica interessante da linguagem é que uma classe pode acessar um membro oculto.aNumber A palavra-chave super permite que um método faça referência a variáveis ocultas ou a métodos redefinidos da superclasse. As subclasses não herdam os membros da superclasse caso a subclasse declare um membro com o mesmo nome. A lista a seguir cita os membros que são herdados por uma subclasse: • • • Subclasses herdam os membros da superclasse declarados como públicos (public) ou protegidos (protected). dizemos que a subclasse oculta a variável da superclasse. Pág 81 . Subclasses herdam aqueles membros da superclasse declarados sem especificadores de acesso (público. Considere o seguinte exemplo: class Super { Number aNumber. Note que construtores não são herdados pelas subclasses. Mas é possível acessar a variável aNumber. } class Subbie extends Super { Float aNumber. Portanto. porém pode ser uma fonte de muitos erros. Ocultando variáveis • 6. a menos que a subclasse explicitamente oculte a variável ou redefina o método. Subclasses não herdam os membros privados (private) da superclasse. desde que estejam no mesmo pacote que a superclasse. variáveis membro definidas na subclasse ocultam variáveis de mesmo nome declaradas na superclasse. deve-se ser cuidadoso no momento de escolher os nomes das variáveis da subclasse de tal forma a ocultar apenas aquelas variáveis desejadas. No caso de variáveis. } A variável aNumber na classe Subbie oculta a variável aNumber definida na classe Super. desta forma: super. privado ou protegido). a partir da classe Subbie.Regra: Uma subclasse herda todos os membros de sua superclasse que são acessíveis à subclasse. Esta característica da linguagem Java traz grande flexibilidade.2 Como foi dito. No caso de métodos. dizemos que a subclasse redefine o método herdado.

desejarão redefinir este método e imprimir algo mais relevante. todas as classes descendem da classe Object. i < n. A saída do método toString seria a representação textual do objeto. mas não pode definir um acesso mais restritivo. result. um método protected definido na superclasse pode ser redefinido como público na subclasse mas não pode ser redefinido como privado.elementAt[i].toString()).3 Redefinindo (overriding) métodos A possibilidade de uma subclasse redefinir um método da sua superclasse permite que uma classe herde de uma outra cujo comportamento é “próximo” ao desejado e então complemente ou modifique o comportamento da superclasse. Por exemplo. else result. Vamos reconsiderar o exemplo da classe Stack e redefinir o métod toString.append(". que retorna um objeto String contendo o nome da classe do objeto e o seu código hash. uma listagem dos itens da pilha seria algo interessante a se fazer: public class Stack { private Vector items. Para a classe Stack. O especificador de acesso do método redefinido pode permitir acesso menos restritivo que o método da superclasse.append(items. Pág 82 . A maioria. o nome do método e os tipos dos parâmetros devem ser iguais aos do método que está sendo redefinido. Object possui um método chamado toString. senão todas as classes.toString(). if (i == n-1) result. } return result. } } Observe que o tipo de retorno.6. Por exemplo. i++) { result. // code for Stack's methods and constructor not shown // overrides Object's toString method public String toString() { StringBuffer result = new StringBuffer().append("]").append("["). for (int i = 0.").

comida no mundo real. Na próxima seção. Por exemplo.1 Executando o método que foi redefinido Algumas vezes. não se deseja redefinir completamente um método. pode-se modelar um conceito abstrato.3. necessita-se apenas adicionar maior funcionalidade ao método herdado. Ao tentar redefinir um método final.3. } 6.finalize(). na programação orientada a objetos. void iamfinal() { ^ 1 error Uma subclasse também não pode redefinir métodos declarados como static na superclasse. a implementação do método finalize da classe Stack executa o método finalize definido na superclasse (Object): protected void finalize() throws Throwable { items = null.3.3 Métodos que uma subclasse deve redefinir Uma subclasse deve redefinir métodos que são declarados como abstract na superclasse.lang representa o conceito abstrato de um Pág 83 . Comida representa o conceito abstrato e não é capaz de criar uma instância própria. o compilador irá exibir uma mensagem de erro similiar a esta: FinalTest. por exemplo. Alguém já viu uma instância (objeto) do tipo comida? Não. ou a subclasse também deve ser abstrata. O que existe são instâncias de cenouras. serão discutidos os conceitos de métodos e classes abstratas. 6. etc.6. Para fazer isto. Simplesmente. chocolates. Method void iamfinal() is final in class ClassWithFinalMethod.4 Métodos e Classes Abstratas Algumas vezes. como tal não deve ser instanciada.2 Métodos que uma subclasse não pode redefinir Uma subclasse não pode redefinir métodos que estão declarados como final na superclasse. uma subclasse não pode redefinir um método de classe.java:7: Final methods can't be overridden. a classe Number do pacote java. bananas. é preciso executar o método da superclasse utilizando a palavra-chave super. super. maçãs. Analogamente. 6. uma classe representa um conceito abstrato e. Por exemplo. Considere. Em outras palavras.

Por exemplo. Pode-se tirar vantagem destas similaridades e declarar estas classes como subclasses de uma classe única: GraphicObject. que precisam ser implementados por todas as subclasses. tais como a variável posição e o método mover (moveTo). os objetos gráficos são bastante diferentes: desenhar um círculo é bem diferente de desenhar um retângulo. as classes (círculo. retângulos. Em uma aplicação de desenho. deve-se declarar uma classe abstrata..java:6: class AbstractTest is an abstract class. a classe GraphicObject possuiria uma implementação como: Pág 84 . GraphicObject também declara métodos abstratos como desenhar (draw). suponha que você deseja criar uma classe com um método abstrato dentro dela.número. GraphicObject. desenhar). ^ 1 error Uma classe abstrata pode conter métodos abstratos.) devem saber como desenhar a si mesmos – eles compartilham o comportamento (desenhar) mas diferem em como este comportamento é implementado.. Classes. redimensionar. new AbstractTest(). linhas. Primeiramente. Para declarar uma classe como abstrata. que representam um conceito abstrato e não podem ser instanciadas. cor) e comportamento (mover. todos os objetos (retângulos. Esta classe Number é a superclasse de classes como Integer e Float.) compartilham alguns estados (posição. como Number. utiliza-se a palavra-chave abstract antes da palavra-chave class: abstract class Number { . etc. curvas Bezier. não faz sentido definir uma implementação “default” para a superclasse. que possui variáveis membros e métodos que são compartilhados (inteiramente) por todas as subclasses. métodos que não possuem implementação definida. It can't be instantiated. Uma classe abstrata é uma classe que só pode ser utilizada como superclasse. etc. são chamadas de classes abstratas. Por isto. o compilador irá mostrar um erro parecido com este: AbstractTest. Cada subclasse vai implementar o método draw de maneira diferente. Então. por exemplo: Entretanto. ou seja. } Se você tentar instanciar uma classe abstrata. Ou seja. círculos. Esta é uma situação perfeita para a criação de uma superclasse abstrata.

} Cada subclasse não abstrata de GraphicObject. necessariamente. Esta classe é tão vital para a operação do compilador e do interpretador que o ambiente Java deve garantir que quaisquer métodos ou objetos que usem uma String acessem a classe definida pelo ambiente e não um outro tipo de String.... ou seja. Ao tentar compilar uma subclasse de uma classe final. Isto garante que as Strings näo possuem nenhum comportamento estranho. Por exemplo. deve definir uma implementação para o método draw: class Circle extends GraphicObject { void draw() { . a classe não pode ser derivada (possuir subclasses). indesejável ou imprevisível. } } class Rectangle extends GraphicObject { void draw() { . } } Observação: Uma classe abstrata não precisa.5 Classes e Métodos Finais Pode-se declarar uma classe como final. void moveTo(int newX. . y.abstract class GraphicObject { int x. a classe String de Java é uma classe final por esta razão. Além disto. Porém. ou não definir uma implementação para um método abstrato que foi herdado. o verificador Pág 85 . int newY) { . inconsistente. deve ser declarada como uma classe abstrata. podendo causar danos ou acessando informação privada. você pode declarar sua classe como final. A subclasse parece e age como a classe original mas faz coisas bastante diferentes (e devastadoras)... como Circle e Rectangle... Para prevenir este tipo de ataque. possuir um método abstrato. Existem pelo menos duas razões para desejar que uma classe possua tal característica: • Segurança: Um mecanismo que hackers utilizam para atacar sistemas é criar uma subclasse de uma classe e substituir a classe original pela subclasse. o compilador exibirá uma mensagem de erro. } abstract void draw(). 6. qualquer classe que possuir um método abstrato..

Boas práticas de projeto: por razões do projeto orientado a objetos... a declaração será: final class ChessAlgorithm { . Pode-se pensar que uma dada classe é “perfeita” ou.. utiliza-se a palavra-chave final antes da palavrachave class na declaração da classe. verificando se a classe que está sendo executada não é uma subclasse de uma classe final. pode-se desejar criar uma classe final.6 Interfaces Pág 86 . Para isto. Para especificar que uma classe é final. o que se deseja é.java:6: Can't subclass final classes: class ChessAlgorithm class BetterChessAlgorithm extends ChessAlgorithm { ^ 1 error As vezes. BoardLocation newLocation) { . conceitualmente... Por exemplo. } Quaisquer tentativas de criar uma subclasse de ChessAlgorithm irão resultar em um erro de compilação. Pode-se querer que um método seja final porque sua implementação não pode ser alterada ou porque tal método é crítico para manter o estado do objeto consistente ... como este: Chess. utiliza-se a palavra-chave final nas declarações de método para indicar para o compilador que tais métodos não podem ser redefinidos por subclasses. } 6.• bytecode do interpretador também garante que nenhum tipo de ataque deste tipo está sendo feito. suponha que você deseja declarar sua classe (perfeita) ChessAlgorithm como final. Por exemplo. } . final void nextMove(ChessPiece pieceMoved. em vez de tornar a sua classe ChessAlgorithm final.. na verdade. que não deve possuir subclasses. você poderia querer tornar apenas o método nextMove final: class ChessAlgorithm { . proteger apenas alguns dos métodos da classe de serem redefinidos por uma subclasse.

} } Se o AlarmClock tiver espaço. um objeto deve fazer duas coisas: 1. O exemplo é bem simples mas mostra como criar e utilizar uma interface e também dá algumas “dicas“ sobre quando utilizar interfaces ou classes abstratas. uma interface Java é um mecanismo que objetos utilizam para interagir. o AlarmClock vai executar o método wakeUp do objeto dorminhoco. } else { sleepers[index] = theSleeper. Uma interface Java define um conjunto de métodos mas não define uma implementação para eles. Pág 87 . long time) { int index = findNextSlot(). o português é uma interface entre duas pessoas. Definição: Uma interface é uma coleção de definições de métodos (sem implementação). new AlarmThread(index). Depois do período de tempo determinado. Uma interface também pode incluir declarações de constantes. if (index == NOROOM) { return false. Uma classe que implementa a interface deve implementar todos os métodos definidos na interface. Pedir para que o despertador o “acorde”. De acordo com esta definição. Para satisfazer o primeiro requisito. um objeto executa o método letMeSleepFor do AlarmClock. então ele registra o objeto “dorminhoco” (sleeper). Assim. inicia uma nova thread AlarmThread e retorna true. sleepFor[index] = time. um objeto que queira usar o despertador deve implementar o método wakeUp de tal forma que o AlarmClock possa avisar o objeto “dorminhoco” que o tempo já passou. Para utilizar os “serviços” do AlarmClock. Considere o seguinte exemplo que apresenta duas classes que utilizam uma interface para interagir. Analogamente.Em inglês (ou português). A classe AlarmClock (despertador) é uma “provedora de serviços” – ela avisa objetos que um determinado período de tempo passou. 2. Implementar o método WakeUp (acordar). Mas como isto é feito? Isto é feito por meio do tipo de dado do objeto dorminhoco que está sendo registrado. uma interface é um dispositivo ou sistema que entidades utilizam para interagir entre si.start(). um controle remoto é uma interface entre você e a televisão. return true. que é implementado da seguinte forma: public synchronized boolean letMeSleepFor(Sleeper theSleeper.

que é o nome da interface: public interface Sleeper { public void wakeUp(). Mas Java não possui herança múltipla. portanto. Qualquer objeto que seja um Sleeper (e que. O tipo de dado deste argumento é Sleeper. Por exemplo. abstratos. class GUIClock extends Applet implements Sleeper { . clock. public long ONE_SECOND = 1000. } Não.letMeSleepFor(this. GUIClock. muitos objetos que desejam utilizar AlarmClock já possuem uma superclasse. A seguinte classe Sleeper não faria a mesma coisa que a interface Sleeper? abstract class Sleeper { public abstract void wakeUp(). Entretanto. Isto significa que o objeto implementa todos os métodos definidos pela interface. que é um applet que mostra o tempo atual e utiliza um objeto AlarmClock para acordá-lo a cada minuto para que ele possa atualizar o display. possa ser passado como parâmetro do método letMeSleepFor) implementa esta interface. GUIClock não pode ser subcclasse de Sleeper e Applet.. então todos os objetos que desejarem utilizar AlarmClock devem ser instâncias de uma subclasse de Sleeper.Note que o primeiro argumento de letMeSleepFor é o objeto que quer ser acordado. considere a seguinte classe. a classe GUIClock é uma subclasse de Applet – caso contrário não seria possível executá-lo em um browser. ONE_MINUTE). surgem algumas questões importantes : Por que não utilizar uma classe abstrata? Observe que uma interface é simplesmente uma lista de métodos não implementados. public long ONE_MINUTE = 60000. // in milliseconds // in milliseconds Pág 88 .. } } Depois que vimos a utilização de uma interface. ou seja. } A interface Sleeper define o método wakeUp mas não o implementa. Por exemplo. Se Sleeper é uma classe abstrata. A interface também define duas constantes úteis (ONE_SECOND e ONE_MINUTE). public void wakeUp() { repaint(). Classes que implementam esta interface “herdam” as constantes e devem implementar o método wakeUp. ou seja. As duas soluções não são equivalentes.

uma interface pode possuir múltiplas “superinterfaces”.1 Definindo uma Interface A figura a seguir mostra que uma definição de interface possui dois componentes: a declaração e o corpo da interface: Declaração da Interface A declaração da interface Sleeper utiliza os dois elementos obrigatórios da linguagem: a palavra-chave interface e o nome da interface. Isto não ocorre no caso de herança múltipla. interfaces e herança múltipla são soluções bem distintas: • • • Uma classe só herda constantes de uma interface. 6. independente da sua hierarquia de classes. Apesar de interfaces resolverem muitos problemas parecidos. além do modificador de acesso (public): Pág 89 . sem ser obrigado a criar artificialmente uma relação de herança entre elas. Ou seja. Uma classe não poder herdar implementações de métodos de uma interface. A hierarquia de interfaces é independente da hierarquia de classes. Importante: Java permite herança de multiplas interfaces.Então as interfaces proporcionam herança múltipla? Muitas vezes interfaces são apresentadas como uma alternativa para herança múltipla de classes. Declaração de métodos que uma ou mais classes esperam implementar.6. Interfaces são úteis nos seguintes casos: • • Captura de similaridades entre classes não relacionadas. Afinal. qual a utilidade de interfaces? Você pode usar uma interface para definir um comportamento que pode ser implementado por qualquer classe. Classes que implementam a mesma interface podem ou não estar relacionadas em uma hierarquia de classes.

Se nâo for especificado que a interface é pública.ONE_SECOND Classes que implementam uma interface podem acessar estas constantes como se fossem variáveis herdadas: public class GUIClock extends Applet implements Sleeper { Pág 90 . Entretanto. Todas as constantes declaradas são. ela pode ser utilizada por qualquer classe. Por exemplo: Sleeper. Uma interface pode ser derivada de outras interfaces. deve-se referenciar o nome da interface. implicitamente. A lista de “superinterfaces” é uma lista delimitada por vírgulas. Uma declaração completa de interface é mostrada na figura abaixo: Caso a interface seja declarada como public.public interface Sleeper { . } Uma interface pode ter outro componente: uma lista de “superinterfaces”. implicitamente. uma interface pode ser derivada de mais de uma interface. public long ONE_MINUTE = 60000. } Todos os métodos declarados na interface são. estáticas (static) e finais (final). públicos e abstratos.. Para utilizar as constantes definidas na interface. Por exemplo: public interface Sleeper { public void wakeUp(). públicas. Corpo da Interface O corpo da interface contém a declaração de todos os métodos da interface. apenas as classes que estão definidas no mesmo pacote podem acessá-la. public long ONE_SECOND = 1000. como ocorre com as classes. O corpo da interface também pode possuir declarações de constantes..

6. Note que toda vez que você realizar uma modificação em uma interface. private boolean letMeSleepFor(Sleeper theSleeper. A assinatura do método (o nome e o número e o tipo dos parâmetros) do método da classe deve ser idêntico ao da assinatura do método definido na interface. ela deve implementar todos os métodos declarados na interface (e em suas superinterfaces. clock. } } 6..2 Implementando uma Interface O exemplo da classe GUIClock já demonstrou como implementar uma interface (Sleeper): public class GUIClock extends Applet implements Sleeper { .7 Utilizando Interfaces como Tipos de Dados Quando se define uma nova interface. se for o caso). int time) { . Ou. Programadores que utilizam a interface certamente vâo reclamar bastante.6. essencialmente.. deve-se antecipar ao máximo todos os usos da sua interface e especificá-la completamente desde o início. public void wakeUp() { repaint()... Por exemplo: private Sleeper[] sleepers = new Sleeper[MAX_CAPACITY]. define-se um novo tipo de dado (referência). Portanto.letMeSleepFor(this. Pág 91 .. a classe deve ser declarada como abstrata. todas as classes que implementam a interface antiga terão problemas pois elas não implementam mais a interface. Você pode utilizar nomes de interface como um tipo comum de variável... } Observação: Interfaces não podem crescer. public void wakeUp() { // update the display } } Lembre-se que quando uma classe implementa uma interface. ONE_MINUTE).

. public class Rectangle extends Graphic implements Draggable { . seguindo o exemplo acima. para evitar conflitos de nomes e para controlar o acesso.. Assim. variáveis e métodos) públicos são acessíveis fora do pacote onde foram definidos. de entrada/saída no pacote java.java: package graphics. coloca-se a palavra-chave package no início do arquivo onde a classe ou interface é definida. public class Circle extends Graphic implements Draggable { . • Os nomes das classes de um pacote não irão conflitar com nomes de classes de outros pacotes. e restringir o acesso por parte de classes definidas fora do pacote.awt.8. o código a seguir coloca a classe Circle (que está no arquivo Circle. pode-se agrupar classes relacionadas em pacotes (packages). simplesmente coloca-se a classe ou interface dentro dele. deve-se incluir package no arquivo Rectangle.applet.. 6. Para isto.6. Por exemplo.io e as classes de elementos de interface gráfica estão no pacote java. As classes e interfaces que fazem parte do kit de desenvolvimento Java (JDK) são membros de vários pacotes: classes dos applets estão no pacote java. Pacotes também podem conter interfaces.. } Deve-se incluir a palavra-chave package no início de todo arquivo que define uma classe ou interface que pertence ao pacote. Pág 92 . Podemos citar as seguintes vantagens da utilização de pacotes: • Fica mais fácil para outros programadores determinar quais classes e interfaces estão relacionadas.java) no pacote graphics: package graphics.1 Criando um Pacote Para criar um pacote. } Lembrete: Apenas membros (classes. • Pode-se permitir que classes dentro de um mesmo pacote tenham acesso irrestrito entre si.8 Pacotes (Packages) Para tornar as classes mais fáceis de se encontrar e utilizar.

aconselha-se que todas as classes e interfaces pertençam a pacotes “com nome”. Este pacote default deve ser utilizado apenas para pequenas aplicações ou no início do desenvolvimento de aplicações mais complexas.meupacote 6. ou importar todo o pacote. que é um pacote que não possui nome. este é o nome completo da classe Rectangle declarada no pacote graphics: graphics. br. deve-se: • • • refrir-se ao membro utilizando o seu nome completo. de maneira inversa. Mas se os pacotes forem definidos com o mesmo nome.Rectangle Para criar uma instância desta classe: graphics. e o pacote não foi importado. sua classe ou interface será automaticamente incluída no pacote default.Observação Importante: se você não utilizar a palavra-chave package. Para utilizar membros públicos fora do seu pacote.minhaempresa. deve-se utilizar o nome completo (long name) que inclui o nome do pacote. para definir o nome dos seus pacotes. Por exemplo.meupacote.Rectangle myRect = new graphics. O conceito de pacote permite que classes em pacotes diferentes possuam o mesmo nome sem causar erros de compilação.8. ocorrerão problemas.passos. Por exemplo: com. importar o membro do pacote. Ou seja. Referenciar um Membro do Pacote pelo Nome Quando se deseja utilizar um membro de um pacote diferente. Definindo um Nome para o Pacote Com programadores em todo mundo escrevendo classes e interfaces em Java. Convenção: Empresas utilizam os seus nomes de domínio da Internet. Como evitar esta situação? Utilizando uma convenção.2 Utilizando Membros de um Pacote Apenas membros (classes. Importar um Membro do Pacote Pág 93 . métodos e variáveis) são acessíveis fora do pacote onde foram definidos. provavelmente dois programadores utilizem o mesmo nome para duas classes diferentes.uemg.Rectangle().

Para importar um membro específico do pacote. o ambiente de execução Java automaticamente importa três pacotes: • • • O pacote default (que não possui nome) O pacote java. pode-se referenciar qualquer classe ou interface do pacote graphics pelo seu nome curto: Circle myCircle = new Circle(). Se ambos pacotes forem importados. e ambos os pacotes são importados. o código a seguir não importa todas as classes do pacote graphics que começam om a letra “A”: import graphics. deve-se colocar a palavra-chave import no início do arquivo (antes das definições de classes e interfaces. foi definida uma classe Rectangle no pacote graphics. pode-se referenciar a classe círculo pelo seu nome curto: Circle myCircle = new Circle(). Neste caso. O asterisco só pode ser utilizado para importar todas as classes de um pacote.lang O pacote atual Nomes Ambíguos Caso uma classe em um pacote possua o mesmo nome que uma classe definida em outro pacote. o código abaixo torna-se ambíguo: Rectangle rect.Circle.*. deve-se referenciar tais classes pelo seu nome completo. Importar Todo o Pacote Para importar todas as classes e interface pertencentes a um pacote. para importar a classe Circle do pacote graphics: import graphics.awt também possui uma classe chamada Rectangle. O pacote java. Por exemplo. de compilação // não funciona ! Irá gerar um erro Por conveniência. deve-se obrigatoriamente ser mais específico e indicar exatamente qual classe Rectangle deseja-se referenciar: Pág 94 .A*. Rectangle myRectangle = new Rectangle(). No exemplo anterior. utiliza-se o import junto com o caracter * : import graphics. Por exemplo. Ele não pode ser usado para importar um subconjunto de classes do pacote. Agora. mas depois da declaração do package). Agora.

pode estar em qualquer diretório do sistema de arquivos. Cada componente do nome do pacote corresponde a um subdiretório. por sua vez.Rectangle rect.java caminho do arquivo Além disto. Este arquivo fonte deve ficar em um diretório cujo nome é igual ao do pacote que contém a classe ou interface. Assim. cada empresa utiliza o seu domínio de Internet invertido para denominar os seus pacotes. o compilador cria um arquivo de saída para cada classe e interface definida.graphics. A estratégia é a seguinte.passos.java (UNIX) (Windows) Ao compilar o arquivo fonte.passos. O diretório graphics.class: Pág 95 . supondo que a UEMG/Passos tenha um pacote chamado graphics que contém um arquivo chamado Rectangle. este arquivo ficaria em: package br.graphics br/uemg/passos/graphics/Retangle. o código fonte da classe Rectangle deve estar em um arquivo chamado Rectangle. O diagrama a seguir mostra como isto funciona. a UEMG/Passos possui o domínio passos.9 Gerenciando Arquivos Fonte e Arquivos de Classe O ambiente de desenvolvimento JDK baseia-se em um sistema de arquivos hierárquico para gerenciar os arquivos fonte (.Rectangle Nome da classe graphics/Rectangle. Por exemplo. assim todos os pacotes desenvolvidos na Universidade deveriam ter seus nomes precedidos por br. 6. O nome (longo) do membro do pacote e o caminho (pathname) do arquivo são “paralelos” (considerando o separador de arquivos do Unix “/” e não do Windows “\”): graphics.uemg. embora a especificação da linguagem Java não determine isto.class).java br\uemg\passos\graphics\Retangle.java) e de classes (.java e o arquivo deve estar em um diretório chamado graphics. Por exemplo. por convenção. O código fonte de uma classe ou interface deve ser colocado em um arquivo texto cujo nome é igual ao nome da classe e cuja extensão é .java.br.uemg.uemg. O nome do arquivo é igual ao nome da classe ou interface e sua extensão é .java.

por exemplo: fontes\br\uemg\passos\graphics\Retangle.) e o arquivo . o compilador e o interpretador podem construir o resto do caminho do arquivo baseado no nome do pacote e da classe Por exemplo. ele não precisa estar no mesmo diretório que o arquivo fonte. Definindo o Class Path Há duas maneiras para se alterar o class path: • Definir a variável de ambiente CLASSPATH (não recomendado) • Utilizar a opção -classpath quando invocar o compilador ou o interpretador. Entretanto.Como o arquivo . pode-se definir diretórios separados para os arquivos fonte e os arquivos de classes. Ou seja.java (Windows) classes\br\uemg\passos\graphics\Retangle. ele deve ser capaz de encontrar o arquivo correspondente.zip que contém todas as classes do JDK.class deve incluir o diretório classes mas não os subdiretórios br ou passos. Cada diretório definido no class path é um local onde os diretórios dos pacotes podem aparecer. Quando o compilador encontra uma nova classe enquanto compila a sua aplicação. quando o interpretador encontra uma nova classe enquanto está executando a sua aplicação.class deve estar em uma série de diretórios que reflete o nome do pacote.zip) definido no class path (caminho de classes). o diretório atual e os arquivo . A partir dos diretórios listados no classpath. o compilador e o interpretador procuram o diretório atual (. o class path para a estrutura de diretórios classes\br\uemg\passos\graphics\Retangle. Tanto o compilador quanto o interpretador procuram por classes em cada diretório (ou arquivo .class (Windows) Desta forma. um arquivo . Em outras palavras.java. afinal de contas. Mas. por exemplo. Analogamente. você pode fornecer o seu diretório de classes a outros programadores sem ter que revelar o código-fonte. Definição: O class path é uma lista de diretórios ou arquivos compactados onde o compilador/interpretador realiza a busca por classes ou interfaces.zip das classes do JDK já fazem parte automaticamente do seu class path. ele deve ser capaz de executar os métodos desta classe. para que se preocupar em seguir esta convenção de nomes diretórios/arquivos? Isto é necessário pois somente desta forma o compilador e o interpretador Java são capazes de encontrar todas as classes e interfaces utilizadas pela sua aplicação. Por default. Pág 96 .

bat. é fácil esquecer de que uma mudança foi feita e corre-se o risco de.Não é recomendado alterar a variável de ambiente CLASSPATH pois tal mudança pode ser duradoura (se estiver no autoexec. um dia. } class Carnivoro { int numeroDeDentes.zip javac -classpath ..zip (UNIX) (Windows) Observação Importante: ao definir o class path desta forma.C:\JDK\lib\classes. O interpretador. seu programa não funcionar pois o compilador/interpretador carregou uma classe “antiga” que estava em um diretório “esquecido” definido no class path. na ordem. } 3.:~/classes:/JDK/lib/classes. A segunda opção é preferível pois define o class path apenas para a execução atual do compilador/interpretador. então. 6. } Por que o código abaixo irá gerar um erro de compilação? class Aluno extends Mamifero. Também é aconselhável incluir o diretório atual. Considere o seguinte código class Mamifero { int idade. deve-se sempre incluir o arquivo classes. } 2. por exemplo). Qual é a superclasse de: class Pessoa { String nome.C:\classes. Assim. Portanto.zip do JDK em seu class path. Quando o interpretador Java está procurando por uma classe ele procura as entradas no seu class path. Carnivoro { int matricula. não realiza a busca nos demais diretórios. até que a primeira classe com o nome correto seja encontrada. Considere a seguinte classe: class MinhaClasse { Pág 97 . Observação: A ordem dos diretórios no class path é importante. O exemplo abaixo mostra como utilizar a opção -classpath para definir o seu classpath: javac -classpath .10 Exercícios 1. você redefine completamente o class path atual.

System. 6. protected int y. int w. Dê um exemplo de uma entidade do mundo real que possa ser modelada como uma classe abstrata.x = 2. public int getX() { return x. super. não pode ter subclasses)? Indique duas razões para criar uma classe com esta característica. Pág 98 . 5.println(“ x = “ + this. O trecho de código abaixo está correto? Justifique.out. Em Java.} public MinhaClasse() { x=y=z=w=0. Suponha que você criou um método em uma classe. É possível que uma classe abstrata defina a implementação de alguns métodos? É possível que uma classe não-abstrata não defina a implementação de um de seus métodos? 7.} } Quais os membros (variáveis/métodos) de MinhaClasse que são herdados por uma subclasse definida no mesmo pacote? 4. Defina alguns métodos e constantes para tal interface. class MinhaClasse implements UmaInterface. como se declara uma classe que não pode ser derivada (isto é.out.println(“ x = “ + super. public static voi main (String args[]) { x = 1.private int x. Quais são as diferenças entre uma classe abstrata e uma interface? 11. 8. 5.x). porém não que ele possa ser redefinido pelas subclasses.x). Como você declararia este método? Dê um exemplo em Java. } class B extends A { public int x. O que acontece quando uma classe é declarada desta maneira? class MinhaClasse implements MinhaInterface 10. Defina uma interface chamada BomAluno. Considere as classes: class A { public int x. deseja que ele seja herdado por subclasses. } Qual a saída do programa definido na classe B (java B)? Justifique. A declaração da classe abaixo está correta? Justifique. Escreva a definição desta classe em Java. 13. public int z. System. O que é uma interface? O que podemos definir em uma interface Java? 9. OutraInterface 12.

Dê exemplos. que não pertença a este pacote. 17. por exemplo. Quais os 3 pacotes que o ambiente Java importa automaticamente? 19. Pág 99 . UmaInterface a = new UmaClasse().passos... 18. }. O que é um pacote? Qual a sua finalidade? 15. 14.. Dê exemplos. Como se adiciona uma classe ou interface a um pacote.interface UmaInterface { . } 16. } class UmaClasse implements UmaInterface { . 21.maquinas que possua uma classe carro.seunome. Como o nome de um pacote em Java se relaciona com a estrutura de diretórios do sistema de arquivo. Quais são as 3 maneiras de se utilizar uma classe ou interface que pertence a um outro pacote? Dê exemplos. Crie um pacote chamado br. O que é o class path? Como ele pode ser definido? 20.. A classe abaixo pertence a qual pacote? class A { int x.uemg. Defina uma aplicação. que utilize a classe carro.

1. Graphical User Interface) para aplicações stand-alone e applets Java. teclas pressionadas e mudam seu estado ou alteram algum dado interno da aplicação.1 Component Um componente é um widget genérico que não pode ser instanciado (Component é uma classe abstrata). o componente é apagado e então desenhado Pág 100 . como botões e text-fields.1 Widgets A figura abaixo ilustra a hierarquia de classes dos componentes gráficos (widgets) do pacote AWT: Cada um destes componentes será apresentado nas subseções a seguir. Alguns métodos importantes: • public void disable(): desabilita o componente (em relação às ações do usuário) • public void enable(): habilita o componente (em relação às ações do usuário) • public Graphics getGraphics(): retorna o contexto gráfico do componte • public void paint(Graphics g): faz com que o componente seja (re)desenhado na tela (no contexto gráfico fornecido) • public void repaint(): redesenha o componente. Estes componentes respondem a eventos iniciados pelo usuário. Uma interface gráfica (GUI) consiste de componentes (widgets). 7. como cliques no mouse. Interface Gráfica Esta seção mostra como se pode criar interfaces gráficas (GUI. 7. posicionados de alguma forma em um applet ou em uma janela de uma aplicação stand-alone. Todos os widgets gráficos são subclasses de Component. utilizando o pacote AWT (Abstract Windowing Toolkit).7.

1.0).• public void setForeground(Color c): define a cor do primeiro plano do componente Ex.*.*.4 Checkbox A classe Checkbox representa um label com um pequeno botão.awt. add(b). Por exemplo: import java.2 Button A classe Button representa um (botão) que possui um label que pode ser “pressionado” por meio de um clique do mouse.3 Canvas A classe Canvas é um componente gráfico genérico que representa uma região onde se pode desenhar coisas como retângulos. } } Pág 101 .applet. O estado de um checkbox é verdadeiro (botão pressionado) ou falso (botão liberado). TextField tf = new TextField(“0”). public class ButtonWidget extends Applet { public void init() { Button b = new Button("OK").awt.0.0). deriva-se a classe Canvas e o método paint é então redefinido de acordo com a aplicação (desenhar uma figura qualquer.*.setBackground(new Color(255.setForeground(new Color(0. import java. TextField tf = new TextField(“0”). tf. 7. por exemplo). import java. círculos e strings. } } Alguns métodos importantes: • public Button(String label): Cria um botão com o label dado 7. add(m). • public void setBackground(Color c): define a cor de “fundo” do componente Ex. Exemplo: import java. public class CheckboxWidget extends Applet { public void init() { Checkbox m = new Checkbox("Allow Mixed Case"). • public void paint(Graphics g): normalmente. o estado inicial (default) é falso.1. tf.applet.1.*.255. 7..

boolean state) : Construtor utilizado quando o checkbox é membro de um CheckBoxGroup public boolean getState() : obtém o estado do checkbox (true ou false) public void setState(boolean state) : define o estado do checkbox 7. Checkbox cb1. Por exemplo: import java. public class ChoiceWidget extends Applet { public void init() { Choice rgb = new Choice().cbg.*. } } Pág 102 .6 Choice A classe Choice representa uma lista de seleção.awt. cb2 = new Checkbox("Show uppercase only".awt.addItem("Green"). rgb. rgb.Alguns métodos importantes: • • • • public Checkbox(String label): Cria um checkbox com o label especificado public Checkbox(String label. rgb. Em um checkboxgroup. } } 7.true).5 CheckBoxGroup A classe CheckBoxGroup é utilizada para controlar o comportamento de um grupo de objetos checkbox.applet. public class CheckboxGroupWidget extends Applet { public void init() { // create button controller CheckboxGroup cbg = new CheckboxGroup().applet.addItem("Red").*. Os itens desta lista são adicionados ao objeto Choice por meio do método addItem. Objetos checkbox controlados com um ckeckboxgroup podem ser chamados de radio buttons. Por exemplo: import java.1.*.addItem("Blue").1.*. import java. import java. cb1 = new Checkbox("Show lowercase only". add(cb2). em um dado instante. add(rgb).cbg. Checkbox cb2.false). apenas um dos objetos checkbox pode ser verdadeiro (ou seja estar “marcado”). add(cb1). CheckboxGroup g.

boolean multipleSelections):cria uma lista que mostra o número de linhas especificado.7 Label A classe Label representa uma string de texto mostrada na tela. Múltiplos argumentos podem ser selecionados se passarmos true como segundo argumento do construtor de List.*.*.Alguns métodos importantes: • • • • public int getSelectedIndex(): retorna o índice (numérico) do item selecionado public String getSelectedItem() : retorna o label (string) do item selecionado public void select(int pos) : define o item selecionado (por meio do índice) public void select(String str) : define o item selecionado (por meio do label) 7. add(l).8 List A classe List é uma lista de seleção que permite a escolha de um ou mais itens. l. Por exemplo: import java. l. public class ListWidget extends Applet { public void init() { List l = new List(2.*. pode-se selecionar mais de um item da lista Pág 103 . } } Alguns métodos importantes: • public List(int rows.awt.addItem(“Pera”). l. // right justify add(new Label("right justified label".awt.addItem(“Maçã”).RIGHT)).addItem(“Banana”).applet. Se multipleSelections for true.1.Label. true). public class LabelWidget extends Applet { public void init() { add(new Label("a label")). Por exemplo: import java. } } 7. import java.1.*.applet. import java.

Alguns métodos importantes: • • • • public String getSelectedText():Obtém o texto selecionado.*.awt. 7.1.*. ela é a superclasse dos widgets de edição de texto (TextField e TextArea).VERTICAL) especificada. Existem scroll bars verticais e horizontais. public void setText(String t): Define o conteúdo (texto) do componente.10 TextComponent A classe TextComponent não pode ser instanciada.11 TextArea Representa um campo de texto com várias linhas. Exemplo: import java.1.HORIZONTAL ou Scrollbar. sb = new Scrollbar(Scrollbar. 7.HORIZONTAL).applet. public String getText():Obtém todo o texto do componente. Scrollbar sb. Exemplo: Pág 104 . add(sb). } } Alguns métodos importantes: • public Scrollbar(int orientation):Constrói um scroll bar com a orientação (Scrollbar.1)).• • • • public void addItem(String item) : Adiciona um item a lista public int getSelectedIndex(): retorna o item selecionado (indíce numérico) public int[] getSelectedIndexes() : retorna os itens selecionados (vetor de índices numéricos) public void select(int index): seleciona um item (índice numérico) 7. public class ScrollbarWidget extends Applet { public void init() { // using a GridLayout ensures Scrollbar fills applet setLayout(new GridLayout(1. A largura e altura do campo são definidas pelo seu construtor.1.9 Scrollbar Esta classe representa um “barra rolante” que contém um valor inteiro. o usuário não pode modificar o conteúdo do componente. public void setEditable(boolean t): Se nâo-editável. import java.

1. Em geral. Exemplo: import java.awt.*. add(disp). public class TextAreaWidget extends Applet { public void init() { TextArea disp = new TextArea("A TextArea".*. import java. import java.*. int cols): Cria um campo texto com o conteúdo inicial e o tamanho (número de colunas) do campo. public TextField(String text. int rows. public class TextFieldWidget extends Applet { public void init() { TextField f1 = new TextField("type something"). 7.13 Frame Esta classe representa objetos que são janelas. public class MinhaApp extends Frame { Pág 105 . int cols): Cria uma área de texto com o número especificado de linhas e colunas.applet. import java. 3.1.*. são utilizados por aplicações Java standalone.applet.*. add(f1). Exemplo: import java. A largura do campo é especificada pelo construtor da classe e um texto inicial também pode ser especificado. 7. } } Alguns métodos importantes: • • public TextField(String text): Cria um campo texto com o conteúdo inicial especificado. } } Alguns métodos importantes: • public TextArea(String text.awt. além do texto inicial. 30).*.awt.applet.12 TextField Um campo texto representa um widget que mostra uma linha de texto.import java.

por exemplo: add(b). Inserindo Widgets em Applets 7. A fórmula básica para se inserir um widget em um applet é a seguinte: 1. int height): redimensiona a janela (largura e altura) e a posiciona nas coordenadas (x.250. setLayout(new BorderLayout()). disp = new TextArea("A TextArea". public void show(): exibe a janela public void hide(): oculta a janela public void reshape(int x. TextField tf = new TextField("0"). é importante entender o conceito de um Container. Frame f. reshape(250. p = new Panel(). Como os widgets adicionados aos applets vão aparecer na tela? Para responder esta questão. 2. 30). } } Alguns métodos importantes: • • • • • public Frame(): cria uma nova janela public void SetTitle(String title): define o título da janela. add(tf).2 Todos os widgets que podem ser adicionados a um applet são subclasses da classe Component. 3.y).250).public static void main(String args[]) { MinhaApp app = new MinhaApp(). Panel p. add("North".add(disp).250. setTitle("Minha Janela"). Adicionar o componente ao applet. Containers contêm objetos Pág 106 . int y. por exemplo: Button b = new Button("Hit me"). } public MinhaApp() { TextArea disp. show(). p). int widht. Criar o componente (widget) com o operador new. p.

AWTEvent. import java.a região do applet deve então ser subdividida.que irão aparecer na tela. Entretanto. o layout manager. public void init() { b = new Button("Hit me"). add(tf). todos os eventos são subclasses de java. Por conveniência. então. 7. Um layout manager é um objeto que posiciona e redimensiona os componentes de um container de acordo com um algoritmo. utiliza-se um layout manager. podemos adicionar widgets ao applet. FlowLayout é o layout manager default para applets. Observação Importante: O modelo de eventos apresentado nesta seção refere-se a versão 1. Os diferentes tipos de layout managers serão apresentados em uma próxima seção. Estes containers possuem uma região associada. O simples fato de se adicionar um Component a um Container faz com que este componente (widget) seja desenhado na tela.*.awt. estes estímulos são chamados de eventos. Por exemplo. um layout manager não será suficiente para posicionar seus applets .event. etc. por sua vez. da classe FlowLayout. tf = new TextField("0"). no método init: import java. Este modelo de eventos é incompatível com o modelo de eventos anterior (versão 1.1) é suportado pelos browsers Pág 107 . } } Para organizar a apresentação (layout) dos widgets dentro de um container. teclas pressionadas.)? Na linguagem Java.awt. add(b).1 da linguagem Java.0). public class MeuApplet extends Applet { Button b. TextField tf. posiciona os componentes da esquerda para a direita até que não haja mais espaço e. O novo modelo de eventos (versão 1. Assim. todos os tipos de evento do AWT são colocados no pacote java. Em geral. Os eventos são representados por diversas classes em Java. continua a posicionar os objetos na “linha” abaixo.*. o applet é um tipo de container associado com uma região retangular dentro de uma janela de um browser (Applet é uma subclasse de Panel que. Cada uma destas sub-regiões é um container e possui o seu layout manager associado. Por exemplo. é uma subclasse de Container).awt.1) Como os componentes da GUI respondem a estímulos do usuário (cliques no mouse.3 Modelo de Eventos do Java (1.applet.

Um objeto que gera eventos (botão. Uma interface de ouvinte pode definir mais de um método.awt. etc. todos os ouvintes de um tipo de evento devem implementar uma interface correspondente.event.awt. O modelo de eventos é baseado no conceito de event listener (ouvinte de eventos).0) é suportado pelos browsers mais antigos (Communicator 3.mais recentes (Communicator 4. Por exemplo.). cada um destes tipos de evento corresponde a execução de um método diferente nos objetos ouvintes. executando um método destes ouvintes e passando para eles um objeto da classe Event. Um ouvinte de eventos é um objeto interessado em receber eventos. e os métodos definidos na interface Classe de Evento ActionEvent ComponentEvent Interface do Ouvinte ActionListener ComponentListener Métodos do Ouvinte actionPerformed() componentHidden() componentMoved() componentResized() componentShown() focusGained() focusLost() itemStateChanged() keyPressed() keyReleased() keyTyped() mouseClicked() mouseEntered() mouseExited() mousePressed() mouseReleased() mouseDragged() mouseMoved() textValueChanged() FocusEvent ItemEvent KeyEvent MouseEvent FocusListener ItemListener KeyListener MouseListener MouseEvent TextEvent MouseMotionListener TextListener Pág 108 . A tabela a seguir lista algumas classes de eventos definidas no pacote java. o objeto que o gerou avisa todos os objetos ouvintes. botão liberado.x e IE 3. Por exemplo. uma classe de eventos como MouseEvent representa vários tipos de eventos do mouse (botão pressionado. Para que este modelo funcione.x). por exemplo) mantém uma lista de ouvintes que estão interessados em ser notificados quando os eventos ocorrerem e oferece métodos que permitem que objetos se “cadastrem” nesta lista de ouvintes. objetos ouvintes dos eventos da classe ActionEvent deve implementar a interface ActionListener. O pacote java.event define uma interface específica para cada classe de evento.x e 5.x). a interface do objeto ouvinte correspondente. enquanto o outro modelo (versão 1. Quando um evento ocorre.x e IE 4.

text field. este objeto fonte é algum tipo de widget (botão. um evento da classe ActionEvent é gerado e o método do applet ouvinte (actionPerformed()) será executado. escondido ou mostrado O componente ganhou ou perdeu o foco Usuário pressionou ou soltou uma tecla Usuário pressionou ou soltou o botão do mouse. portanto a classe Button gera eventos da classe ActionEvent. Neste exemplo. o objeto ouvinte deve se registrar no objeto “fonte” dos eventos. pesquisando na documentação. etc. ele possui um método chamado addXListener() para adicionar um ouvinte e um método chamado removeXListener() para remover um ouvinte.). redimensionado. A tabela a seguir lista alguns widgets e os eventos que eles podem gerar: Widget Button CheckBox Choice Component Eventos que pode gerar ActionEvent ItemEvent ItemEvent ComponentEvent FocusEvent KeyEvent MouseEvent List ActionEvent ItemEvent Significado do evento Usuário clicou no botão Usuário selecionou ou de-selecionou um item Usuário selecionou ou de-selecionou um item O componente foi movido. mostra como o modelo de eventos do Java funciona. o mouse entrou ou saiu do componente ou o usuário moveu o mouse Usuário deu um clique duplo em um item da lista Usuário selecionou ou de-selecionou um item da lista Usuário alterou o texto Usuário terminou de editar o texto Janela foi aberta. por sua vez. que é uma extensão do exemplo da seção . quando o usuário clicar o botão. Este método. podemos observar que a classe Button possui os métodos addActionListener() e removeActionListener(). iconificada. fechada. Por exemplo. o applet se registra como um ouvinet dos eventos gerados pelo botão. Assim. basta olhar a documentação da API da classe. O applet a seguir. deiconificada TextComponent TextEvent TextField ActionEvent Window WindowEvent Dica: Para descobrir quais eventos um widget pode gerar. O registro do objeto ouvinte segue esta convenção: se o objeto fonte gera eventos do tipo X. Pág 109 . No caso do AWT. incrementa o conteúdo do text field do applet.WindowEvent WindowListener windowActivated() windowClosed() windowClosing() windowDeactivated() windowDeiconified() windowIconified() windowOpened() Depois de implementar os métodos da interface de eventos desejada.

é um evento associado ao Component. decrementar o valor do text field caso o foco saia do botão temos que registrar o applet como um FocusListener dos eventos gerados pelo botão. na verdade.awt. import java. Entretanto.applet.*. como o botão é uma subclasse de Component.getText()). // O applet é o ouvinte dos eventos do // tipo Action Event gerados pelo botão b. TextField tf. Pág 110 } . import java. todos os objetos do pacote AWT herdam os eventos de Component.event. public void init() { b = new Button("Hit me"). public class MeuApplet extends Applet implements ActionListener.applet.valueOf(v)). } Observação: como todos os widgets são subclasses de Component.*. O código a seguir mostra como isto pode ser feito: import java.parseInt(tf. add(b). Assim. public class MeuApplet extends Applet implements ActionListener { Button b.*.addActionListener(this).setText(String.event. } public void actionPerformed(ActionEvent e) { // Converte a string dentro do text field p/ um valor // inteiro int v = Integer.*. por exemplo. v = v+1.awt. podemos garantir que o botão também gera tais eventos. se quisermos. add(tf).awt.*.import java. Este tipo de evento (FocusEvent). tf = new TextField("0"). import java.awt. // Muda o valor do text field tf. import java.*.

} public void focusLost(FocusEvent e) { // Converte a string dentro do text field p/ um valor // inteiro int v = Integer. // Muda o valor do text field tf. add(tf). b.parseInt(tf. tf = new TextField("0"). public void init() { b = new Button("Hit me"). // Muda o valor do text field tf.getText()).getText()).valueOf(v)).addActionListener(this).FocusListener { Button b. } public void focusGained(FocusEvent e) { // Não faz nada quando o foco do mouse volta para o botão } } Pág 111 .setText(String.parseInt(tf.addFocusListener(this). add(b).setText(String.valueOf(v)). TextField tf. // O applet é o ouvinte dos eventos do // tipo Action Event e Focus Event gerados pelo botão b. } public void actionPerformed(ActionEvent e) { // Converte a string dentro do text field p/ um valor // inteiro int v = Integer. v = v+1. v = v-1.

add(new Button("B2")).applet.7. South. Os componentes das posições North.1 FlowLayout Um gerenciador da classe FlowLayout posiciona os widgets da esquerda para a direita até que não haja mais espaço na linha.4. 7. de acordo com algum algoritmo. import java. East.2 BorderLayout A classe BorderLayout possui as posições North. consequentemente.awt.4.class CODEBASE="/applets/magelang/AWTTraining/Examples/" width=50 height=90> </applet> 7.4 Gerenciadores de Layout (Layout Managers) Um gerenciador de layout é um objeto que posiciona e redimensiona os componentes em um container AWT. Exemplo: import java.*. os objetos são colocados em uma linha abaixo.awt.applet. A partir daí. public class FlowLayoutTest extends Applet { public void init() { setLayout(new FlowLayout()). South. Center onde os widgets podem ser colocados. Este gerenciador é o default para a classe Panel e. // default add(new Button("B1")).Applet. Esta seção aborda alguns dos gerenciadores mais utilizados na prática. West. } } O mesmo applet terá um layout diferente dependendo da largura e altura do seu container: <applet code=FlowLayoutTest.class CODEBASE="/applets/magelang/AWTTraining/Examples/" width=150 height=35> </applet> <applet code=FlowLayoutTest.*. add(new Button("B3")). West são colocados na “borda” e os componentes na posição Center ocupam o espaço no centro.Applet. public class BorderLayoutTest extends Applet { public void init() { setLayout(new BorderLayout()). import java. para a classe Applet. East. Exemplo: import java. Pág 112 .

awt. Color é uma classe que encapsula informações sobre cores. } } 7. public class ColorTest extends java. add("Center". } } Pode-se também definir a cor de um container. add(new Button("3")).applet. // lower right button } } 7. O terceiro elemento a ser adicionado será o primeiro elemento da segunda linha e assim por diante.*. com widgets. Deve-se preencher.Applet. add(new Button("1")). Por exemplo.red e Color. o applet abaixo mostra um label vermelho: import java.5 Cores e Fontes Widgets possuem cores de primeiro e segundo plano (foreground e backgorund). Green e Blue) ou HSV ou utilizar cores pré-definidas como Color. add(new Button("5")).2)). o primeiro elemento adicionado em um grid de 3 linhas x 2 colunas será o primeiro elemento da primeira linha.add("North". add(new Button("6")). Por exemplo.public class GridLayoutTest extends Applet { public void init() { setLayout(new GridLayout(3. import java. Neste caso.new TextArea("Some random text\nin a TextArea")).4. todos os componentes adicionados ao container possuirão aquela cor. new Label("A Header Maybe")).awt.new TextField("Type some text here")). new Button("HELP")).*.red). add(lab). add("East".setForeground(Color. Para definir estas cores utiliza-se o método setForeground e setBackground. add("South". lab. // uppper left button add(new Button("2")). Pág 113 .blue. add(new Button("4")).3 GridLayout A classe GridLayout posiciona os componentes em linhas e colunas.new Button("QUIT")). Exemplo: import java. add("West".applet. Pode-se criar objetos Color com parâmetros RGB (Red.Applet { public void init() { Label lab = new Label("A Red Label"). o “grid” linha por linha.

Em um applet que possui vários botões. Escreva um applet que possua um campo texto. Escreva um applet que mostra um checkbox com o texto Aperte Aqui. Escreva um applet que mostra o texto Java é legal! 5. 30). como é possível determinar qual botão foi pressionado (dica: pesquisar a classe java. Font.awt. } } 7. Escreva um applet que possua um checkbox e um campo texto. Font. 6. 9. Como se pode alterar o nome mostrado em um botão (pesquisar métodos da classe Button)? 3. Qual é o único argumento do construtor da classe Button? 2. o label deve mostrar o nome do botão. A lista deve possuir 10 opções.getFontList().event)? 4. 11.BOLD.6 Exercícios 1. Mude o label do checkbox toda a vez que o usuário escrever no campo texto. 12.As fontes de um widget podem ser definidas pelo método setFont. Escreva um applet que mostre uma área de texto. Escreva um applet que possua uma lista e uma área de texto.EventObject que é a superclasse de todos os eventos do pacote java. Escreva um applet que contenha dois labels e dois botões organizados em duas linhas. 8. 13. Quando o usuário selecionar uma opção. Escreva um applet que possua um botão chamado Enviar Mensagem. 10. Escreva um applet que possua uma lista contendo o nome de cinco filmes. g.Applet { public void paint(Graphics g) { Font f = new Font("Helvetica".*. Font é uma classe que armazena informações de uma fonte.getDefaultToolkit(). 14. Para criar um objeto Font: Font myFont = new Font("Helvetica". 16). public class FontTest extends java. Exemplo: import java. g.drawString("Helvetica 16 point Bold". esta opção deve ser impressa na área de texto Pág 114 . Quando o usuário clicar o botão.applet. Escreva um applet que contenha um botão e um label.BOLD. basta usar: String[] fontList = Toolkit. Cada linha deve possuir um label seguido de um botão. A área de texto deve possuir cinco linhas. cujo texto inicial é Escreva Aqui. 10. 7. Escreva um applet que possua um checkboxgroup. Para obter uma lista de fontes disponíveis.setFont(f). 12).awt.util.

como será mostrado nas próximas seções. import java. Exemplo de um Applet Simples O código a seguir refere-se a um applet chamado Simple. a primeira vez que um usuário visita a página Web onde está o applet. Este exemplo será utilizado nas próximas seções para ilustrar conceitos comuns à maioria dos applets Java.... por exemplo. } public void destroy() { addItem("preparing for unloading..awt.8. public class Simple extends Applet { StringBuffer buffer.Applet..applet.. addItem("initializing. } Pág 115 .. A figura a seguir mostra a hierarquia de herança da classe Applet. Este applet mostra uma string sempre que passa por um fato importante da sua “vida” como. "). import java. } public void stop() { addItem("stopping. "). 8. "). } public void start() { addItem("starting. public void init() { buffer = new StringBuffer()."). Esta hierarquia é muito importante pois determina a maioria das tarefas que um applet pode fazer.Graphics. que acompanha o kit de desenvolvimento Java.. Applets Esta seção apresenta os aspectos fundamentais relacionados ao desenvolvimento de applets Java.1 Introdução Cada applet é implementado por uma subclasse da classe Applet.

Por exemplo. 5..x e IE 3. • stop: executado ao terminar a execução do applet. .2 Ciclo de Vida de um Applet A classe Applet oferece uma série de métodos relacionados com a execução de applets. . 0.x) não suportam tal versão. } public void destroy() { .toString(). . } public void paint(Graphics g) { //Draw a Rectangle around the applet's display area. //Draw the current string inside the rectangle.append(newWord).println(newWord).width .1.. Browsers mais antigos (Netscape 3. é uma subclasse de Applet. por exemplo quando a página Web é vistada ou quando o usuário “restaura” a janela do browser. • destroy: executado para realizar a “limpeza” final do applet antes de ser descarregado. definindo métodos que o sistema chama de “marcos” (milestones). buffer. public void init() { . como qualquer outro applet. getSize(). • start: executado ao iniciar a execução do applet.1 do JDK. A maioria dos applets redefine estes métodos de acordo com suas necessidades. } } Observação: Os exemplos de applet desta apostila utilizam a API da versão 1. A classe Simple redefine quatro métodos da classe Applet de tal forma que possa responder a estes eventos importantes: • init: executado cada vez que o applet é (re)carregado.drawRect(0. o applet HelloWorld. apresentado na Pág 116 . } . Alguns applets muito simples não redefinem nenhum destes métodos. getSize(). . public class Simple extends Applet { .1). .. 15). } public void start() { . Nem todo applet precisa redefinir cada um destes métodos. . 8. g. repaint(). } O applet Simple. eventos importantes na “vida” do applet.out. Estes métodos são executados à medida que estes marcos vão acontecendo. . } public void stop() { . .void addItem(String newWord) { System. por exemplo quando o usuário deixa a página ou minimiza o browser..height .drawString(buffer. g.

Muitos applets não redefinem o método destroy pois o método stop (que é chamado antes do destroy) faz todo o trabalho necessário para finalizar a execução do applet. destroy pode ser utilizado por applets que querem liberar outros recursos. não redefine estes métodos. é utilizado pelos applets (e aplicações stand-alone) para implementar interfaces gráficas. etc. Métodos de desenho referem-se a funções relacionadas a apresentação do applet na tela: desenhando imagens ou mostrando uma interface gráfica (botões. De qualquer forma... os métodos para carregar imagens em um applet simplesmente não funcionam dentro do construtor do applet. A maioria dos applets que redefinem o método start também devem redefinir o método stop. Muitos applets implementam o método paint para desenhar a representação do applet na página Web. Por outro lado. apresentado na seção 7.). utilizando o método paint. 8. Por exemplo. O método init é útil para realizar inicializações que não demorem muito. ele apenas mostra uma string. Tratamento de eventos refere-se a detecção e processamento de eventos de entrada (por exemplo.. Pág 117 . • update: um método que pode ser utilizado junto com o paint para melhorar o desempenho do applet. O método stop deve suspender a execução das threads do applet a fim de liberar recursos quando o applet não estiver sendo visto pelo usuário.3 Métodos Utilizados para Desenho e Tratamento de Eventos Applets herdam os métodos de desenho e de tratamento de eventos da classe Component do pacote AWT (Abstract Windowing Toolkit). Por exemplo.. usuário pressiona uma tecla). } O método paint é um dos dois métodos de apresentação que um applet pode redefinir: • paint: o método de apresentação básico. Em geral. usuário clica no mouse. check-box. . um applet que apresenta uma animação deve pará-la quando o usuário tiver “minimizado” a página. O método start em geral é utilizado para iniciar uma ou mais threads que realizam alguma tarefa do applet. o método init é o lugar ideal para executar os métodos que carregam imagens. O motivo pelo qual applets não devem possuir construtores é que um applet não tem garantias que o ambiente de execução (browser) está pronto até que o método init seja executado.seção 1. } . . O applet Simple define sua aparência na tela redefinindo o método paint: class Simple extends Applet { . O pacote AWT. public void paint(Graphics g) { . o método init deve conter o código que normalmente seria colocado em um construtor.

public class MostraImagem extends Applet { Image im.Applets herdam os métodos paint e update da classe Applet que. herda os métodos da classe Component do AWT. } public void paint(Graphics g) { g. passando como parâmetros um objeto da classe Image. Para desenhar a imagem. Exemplo: <applet code=”MeuApplet. import java. utilizamos a classe abstrata Image. utilizamos o método drawImage da classe Graphics. Podemos imaginar esta classe como um “apontador” de imagens.Applet. do pacote AWT.1) foi apresentado na seção 7.class). Estes três parâmetros são obrigatórios. respectivamente. os parâmetros width e height definem a largura e altura do applet. } } 8. O modelo de eventos do Java (1.drawImage(im.*. Os parâmetros desta função são a URL onde está localizada a imagem e o nome do arquivo da imagem. além do tamanho e da largura da imagem. public void init() { im = getImage(getCodeBase(). Também é obrigatória a Pág 118 .class” width=120 height=120> </applet> A tag <applet> possui alguns atributos: code é o nome do arquivo que contém os bytecodes do applet (. 15. this). 10.awt. 8. por sua vez. A classe Applet possui um método chamado getImage que serve para carregar imagens (nos formatos JPEG ou GIF). "foto. Por exemplo: import java.applet.4 Mostrando Imagens Dentro de um Applet Para exibir imagens dentro de um applet.jpg").5 Adicionando um Applet a uma Página HTML Para incluir um applet em uma página HTML basta utilizar a tag HTML <applet>.

Pág 119 . A tag <applet> possui outros atributos. Desenvolva um applet que possua uma lista de seleção (classe Choice) e que. Quais são os três atributos obrigatórios da tag <applet>.tag </applet>.6 Exercícios 1. Dica: o applet deve implementar a interface java. dependendo do item escolhido.event. 8.ItemListener e utilizar o método repaint().awt. Este arquivo HTML pode ser visualizado por meio de um browser compatível com Java ou utilizando a ferramenta do JDK chamada appletviewer. mostre uma imagem diferente. O que é o ciclo de vida de um applet? Quais métodos do applet são invocados durante seu ciclo de vida? 2. opcionais. Qual a sua finalidade? 4. que não serão abordados nesta seção. É possível executar um applet sem possuir um browser compatível com Java? 3.

A figura a seguir mostra este relacionamento: Observe que não há nada de novo no conceito de uma única thread. dentro de uma thread. não pode ser executada isoladamente. estão acostumados em escrever programas seqüenciais. uma thread deve existir dentro de um programa (processo). é um fluxo de controle dentro de um programa. Uma thread é similar aos programas sequenciais descritos acima. Pág 120 . Esta seção apresenta o suporte da linguagem Java para programação envolvendo várias threads. Em qualquer instante. uma seqüência de execução e um fim. também apenas uma única instrução está sendo executada. durante a execução do programa. Estes programas seqüenciais possuem um início. 9. Dentro de um browser é possível fazer um “scroll” da página. também chamada de contexto de execução ou processo leve.9. uma única instrução está sendo executada. uma thread não é um programa (processo). Uma única thread tem um começo. Todos os programadores. Na verdade. Em qualquer instante. A grande novidade do conceito de threads é a possibilidade de utilizar várias threads dentro de um mesmo programa (processo). Threads Threads são uma podersosa ferramenta que permite realizar mais de uma tarefa “simultaneamente” em um mesmo processo (programa em execução). toca uma música ou imprime a página. uma sequência de execução e um fim. enquanto o browser carrega uma imagem. executando ao mesmo tempo e realizando tarefas distintas. Entretando.1 O que é uma Thread Uma thread. independente da linguagem. ou seja. A figura a seguir ilustra esta idéia: Um browser é um exemplo de uma aplicação com várias threads (multithreaded).

9.2

Utilizando o Método run de uma Thread

O método run de uma thread permite que esta realize alguma tarefa. O código deste método implementa o comportamento da thread. A thread pode fazer tudo que pode ser implementado na linguagem Java: calcular um expressão matemática, ordenar alguns dados, realizar alguma animação, etc. A classe Thread implementa uma thread genérica que, por default, não faz nada. Ou seja, a implementação do método run é vazia. Existem duas maneiras de implementar o método run de uma thread, descritas nas seções a seguir. 9.2.1 Criando uma Subclasse de Thread e Redefinindo o Método run

A primeira maneira possível de desenvolver uma thread é criando uma subclasse de Thread e redefinindo o seu método (vazio) run. O exemplo a seguir faz justamente isto: public class SimpleThread extends Thread { public SimpleThread(String str) { super(str); } public void run() { for (int i = 0; i < 10; i++) { System.out.println(i + " " + getName()); try { sleep(1000)); } catch (InterruptedException e) {} } System.out.println("ACABOU! " + getName()); } } O primeiro método da classe SimpleThread é o construtor. O parâmetro do construtor é uma String que corresponde ao nome da thread. Este parâmetro é repassado para o construtor da classe Thread. O próximo método da classe é o run. O método run é o “coração” de qualquer thread, é neste método que se determina o que a thread vai fazer. No nosso exemplo, a thread irá executar um laço (10 vezes). A cada iteração do laço, o método vai mostrar o número da iteração e o nome da thread e vai “dormir” (método sleep) por 1 segundo. Depois que o laço terminar, o método run irá imprimir ACABOU! junto com o nome da thread. A classe a seguir, TwoThreadTest, define um método main que cria dois objetos SimpleThread: um com nome “Chocolate” e outro com o nome de “Sorvete”. public class TwoThreadsTest { public static void main (String[] args) { Pág 121

new SimpleThread("Chocolate”).start(); new SimpleThread("Sorvete").start(); } } O método main também inicia cada thread, imediatamente após a sua criação, executando o método start. Ao executar esta classe, teremos uma saída parecida com esta: 0 Chocolate 0 Sorvete 1 Chocolate 1 Sorvete 2 Chocolate 2 Sorvete 3 Chocolate 3 Sorvete 4 Chocolate 4 Sorvete 5 Chocolate 5 Sorvete 6 Chocolate 6 Sorvete 7 Chocolate 7 Sorvete 8 Chocolate 8 Sorvete 9 Chocolate 9 Sorvete ACABOU! Chocolate ACABOU! Sorvete Observe que as saídas das threads estão intercaladas, isto porque cada objeto SimpleThread está sendo executado simultaneamente. 9.2.2 Implementando a Interface Runnable

Outra forma de desenvolver threads é implementar a interface Runnable que define o método run. Adaptando o exemplo da seção anterior, temos: public class SimpleThread implements Runnable { String nome; public SimpleThread(String str) { nome = str; } Pág 122

public void run() { for (int i = 0; i < 10; i++) { System.out.println(i + nome); try { Thread.sleep(1000); } catch (InterruptedException e) {} } System.out.println("ACABOU! " + nome); } } Observe que agora SimpleThread não é uma subclasse de Thread e, portanto, não pode mais executar o construtor e o método getName desta classe. Para executar o método sleep, que também pertence a classe Thread, devemos colocar agora o nome da classe pois tal método é estático (ou seja, é um método de classe e pode ser executado sem termos que instanciar um objeto da classe Thread). A classe TwoThreadsTest também deve sofrer uma modificação: para executar as threads devemos chamar o construtor da classe Thread, passando como parâmetro um objeto da classe SimpleThread (que implementa a interface Runnable). public class TwoThreadsTest { public static void main (String[] args) { SimpleThread t1 = new SimpleThread("Chocolate"); SimpleThread t2 = new SimpleThread("Sorvete"); new Thread(t1).start(); new Thread(t2).start(); } } Regra básica: Em geral, se a thread (classe) que você está desenvolvendo deve ser subclasse de uma outra (Applet, por exemplo) utiliza-se a técnica descrita nesta seção. Caso contrário, podemos utilizar a maneira descrita na seção anterior. 9.3 Ciclo de Vida de uma Thread

O diagrama a seguir mostra os estados em que uma thread pode estar durante o seu ciclo de vida. A figura também mostra quais métodos causam uma transição para outros estados.

Pág 123

processamento) foi reservado para a thread.3.9. Neste estado. ela não é executada. mesmo que o processador esteja disponível. Enquanto a thread está neste estado. Obviamente.1 Criando uma Thread Para criar uma thread. a thread está executando (running). 9. que retiram a thread do estado “Not runnable”. uma thread no estado runnable pode estar. ou seja. 9. temos uma thread “vazia” . utiliza-se o construtor da classe. O que ocorre é um escalonamento entre as threads para permitir o compartilhamento do processador da máquina. o conceito é um pouco mais complexo: a thread está em um estado “executável” (runnable).nenhum recurso do sistema (memória.3 Tirando uma Thread do Estado Runnable Uma thread vai para o estado “not runnable” quando um destes eventos ocorre: • O método sleep é executado • A thread executa o método wait. Após executar o construtor. Muitos computadores possuem um único processador. Pág 124 . Depois da execução do método start. deve-se executar o método start.3. esperando que uma determinada condição seja satisfeita • A thread está bloqueada esperando E/S de dados. na verdade. Na verdade. como para qualquer outro objeto. a thread fica no estado “New Thread” (ver figura acima). Assim. O método start reserva os recursos do sistema necessários para que a thread possa ser executada e executa o método run da thread.3. esperando a sua vez de utilizar a CPU. existem eventos.2 Iniciando uma Thread Para iniciar uma thread que está no estado “New Thread”. relacionados com as 3 situações descritas acima. é impossível executar mais de uma thread ao mesmo tempo.

i++) System. variável. a thread “morre” e os recursos do sistema reservados para ela são liberados. A maneira mais simples. } public void run() { imprimeValor(). Sempre que duas ou mais threads compartilham algum recurso (arquivo. Adaptando o exemplo da seção . é a utilização de métodos synchronized. apresentada nesta seção.4 Terminando com uma Thread A thread termina a sua execução quando o método run termina. Existem várias formas de sincronizar threads. etc. Ou seja. i < 50.out. } public static void imprimeValor() { for (int i = 0. Este mecanismo garante que enquanto uma thread estiver executando um método synchronized. cada thread contém todos os dados e métodos necessários para a sua execução e não precisa de recursos ou métodos externos. existem situações onde as threads podem compartilhar dados. temos uma thread que imprime os valores 0 a 49 (método imprimeValor). ficarão bloqueadas até que este retorne.println(i + " " + getName()). Por exemplo. Entretanto.3. } } Se executarmos a classe TwoThreadsTest. Pág 125 .) deve-se sincronizá-las de alguma forma.4 Sincronização de Threads Até agora. Após o fim deste método. public class SimpleThread extends Thread { public SimpleThread(String str) { super(str).9. 9. temos visto exemplos de threads independentes. As threads que desejarem executar este método. nenhuma outra thread pode executar este mesmo método. imagine uma aplicação Java onde uma thread (produtora) escreve dados em um arquivo enquanto uma outra thread (consumidor) lê os dados do mesmo arquivo. teremos uma saída parecida com esta: 0 1 2 0 1 3 .

49 0 1 2 3 . Explique o que significam métodos synchronized e qual a sua finalidade. Esta técnica de sincronização pode ser utilizada para organizar o compartilhamento de recursos entre as threads (por exemplo.. chamada biscoito. a thread que faz o decremento deve verificar se o valor da variável é positivo..5 Exercícios 1. . a variável não deve ser decrementada. o que acontece se tiramos a instrução sleep(1000) do método run das threads? Qual será a saída do programa? Explique este novo comportamento do programa. Uma deve incrementar uma variável e outra decrementar. 49 Isto ocorre pois. em aplicações produtor x consumidor). o método imprimeValor só pode ser executado por uma thread. 4. Mostre o valor da variável na tela. 3.. teremos a seguinte saída: 0 1 2 3 . Se quisermos que apenas uma thread execute este método em um dado instante. se uma classe define dois ou mais métodos synchronized.. Ainda com relação ao exemplo da seção . Crie um programa que possua duas threads.. apenas um destes métodos do objeto pode ser executado por uma thread em um determinado instante. 9. Assim uma das threads fica bloqueada. Desta forma. Qual é a nova saída do programa? 2. no programa mostrado na seção . devemos defini-lo com synchronized: public synchronized static void imprimeValor() { . Isto ocorre pois as threads estão executando “simultaneamente” o método imprimeValor.... Crie uma terceira thread. aguardando que a outra thread termine de executar o método imprimeValor. Pág 126 . Observação: na verdade. agora. Ou seja. Entretanto. se não for. o mecanismo synchronized é válido por objeto.

10. são sempre os mesmos.io contém uma grande coleção de classes que representam vários tipos de canais (streams). descritos acima. serão apresentadas algumas destas classes. Os construtores destas classes têm como parâmetro Pág 127 . Entrada e Saída Muitas vezes. as aplicações necessitam buscar informações de uma fonte externa ou enviar dados para um destino externo. um programa deve abrir um stream (canal) para a fonte de informação (um arquivo. 10. em algum lugar da rede ou em outro programa. A informação pode estar em vários lugares: em um arquivo.2 Leitura e Escrita de Arquivos Para realizar a leitura e escrita de arquivos utilizamos as classes FileInputStream e FileOutputStream. por exemplo) e ler a informação de maneira sequencial: Analogamente. para buscar informações. também não importa qual o tipo de dado que está sendo lido ou escrito. Esta seção mostra alguns exemplos de como realizar esta troca de informação. por exemplo. Nas seções a seguir.10. Leitura abrir um stream enquanto houver mais informação ler informação fechar o stream Escrita abrir um stream enquanto houver mais informação escrever informação fechar o stream O pacote java. respectivamente. um programa pode enviar informações para um destino externo abrindo um stream para este destino e escrevendo a informação sequencialmente: Importante: não importa de onde a informação vem nem para onde está indo.1 Introdução Em Java. os algoritmos de leitura e escrita.

Pág 128 . out. while ((c = in. FileOutputStream out = new FileOutputStream(outputFile). Depois. Então.um objeto da classe File.*. são criados os dois streams. FileInputStream e FileOutputStream são adequadas para escrever dados binários (bytes). porém utiliza outras classes: import java. O exemplo a seguir também realiza a cópia de um arquivo para outro. int c.txt"). Finalmente. FileWriter outputFile = new FileWriter("ola. BufferedReader in = new BufferedReader(inputFile). Cada dado lido é escrito no FileOutputStream (método write). O exemplo abaixo realiza a cópia dos dados de um arquivo para outro: import java.txt").write(c). public class CopyBytes { public static void main(String[] args) throws IOException { FileReader inputFile = new FileReader("oi. in. A classe File representa um arquivo . } } Inicialmente. FileWriter e PrintWriter. File outputFile = new File("ola. BufferedReader.txt").quando este método retorna -1 significa que se chegou ao fim do arquivo).read()) != -1) out.close(). FileInputStream in = new FileInputStream(inputFile).io.io. o programa realiza um laço onde faz uma leitura do FileInputStream (método read .txt"). o programa cria dois objetos da classe File que representam os arquivos de entrada e saída do programa.o construtor desta classe tem como parâmetro o nome do arquivo. public class CopyBytes { public static void main(String[] args) throws IOException { File inputFile = new File("oi.close(). um da classe FileInputStream (para a leitura de dados) e FileOutputStream (para a escrita de dados).*. as duas streams são fechadas (método close). Para manipular mais facilmente texto (strings) podemos utilizar as classes FileReader.

String s. O programa a seguir lê duas strings.print("Digite um valor: ").close().*.lang possui três variáveis stream que representam: • A entrada padrão do sistema (normalmente o teclado): in • A saída padrão do sistema (normalmente o monitor): out • A saída de erro padrão do sistema (normalmente o monitor): err A variável in é da classe InputStream e as variáveis out e err são da classe PrintStream. in. Para imprimir strings na saída padrão utilizamos os métodos print ou println. 10.close(). armazena-as em duas variáveis e as exibe na tela: import java. out. BufferedReader ent = new BufferedReader(new InputStreamReader(System.flush(). System.PrintWriter out = new PrintWriter(outputFile). } } A diferença principal com relação ao exemplo anterior é que neste programa fazemos a leitura e a escrita de linhas de texto (métodos readLine e println). while ((s = in. Note que é necessário executar o método flush do objeto PrintWriter para que os dados sejam efetivamente escritos no arquivo de saída. Pág 129 .3 Entrada e Saída de Dados (Padrão) A classe System do pacote java. out. Já para ler algum valor do teclado.io. a = ent.x. devemos criar um objeto da classe BufferedReader que possui o método readLine.in)).out.readLine()) != null) out. public class Eco { public static void main(String[] args) throws IOException { String a.println(s).readLine().

out.out.System. Faça um programa que leia dez strings que estão em um arquivo texto e que as exiba na tela.4 Exercícios 1. Faça um programa que leia dez strings digitadas pelo usuário e que escreva estas strings em um arquivo. 2. } } 10.print("Digite outro valor: "). Pág 130 .readLine(). x = ent.println("Você digitou: " + a + " " + x).close(). ent. System.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->