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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

esta representação não é totalmente realista. Esta representação conceitual de um objeto. é um modelo ideal que deve servir de como meta para projetistas de sistemas orientados a objetos. Analogamente. Por exemplo. apenas qual alavanca deve ser movida. 2. A interação entre os objetos é que permite se obter todas as funcionalidades de uma aplicação. a encapsulação é usada para esconder detalhes de implementação pouco importantes. muitas vezes não é necessário saber como um objeto foi implementado. uma bicicleta só é útil quando um outro objeto (ciclista) interage com ela.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. Entretanto.2 Mensagens Geralmente. 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). Basicamente. Empacotar as variáveis de um objeto sobre a proteção de seus métodos é chamado de encapsulação (seção ). quando se deseja trocar uma marcha na sua bicicleta. não é preciso saber como o mecanismo de troca de marchas funciona. apenas saber qual método deve ser invocado. Os métodos envolvem e escondem o núcleo do objeto de outros componentes (objetos) da aplicação. Objetos comunicam-se entre si por meio do envio de mensagens. um núcleo de variáveis dentro de uma membrana protetora de métodos. por razões de implementação ou eficiência.1. Pág 18 . os detalhes de implementação podem ser mudados sem afetar outras partes do programa. aumentar a velocidade da pedalagem e trocar de marcha. 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). Quando um objeto A deseja que o objeto B realize um dos seus métodos (de B). marcha atual é a quinta. um objeto que modela uma bicicleta poderia ter variáveis que indicam seu o estado atual: velocidade é 20 km/h. Assim. Muitas vezes. um objeto pode desejar expor algumas de suas variáveis ou esconder alguns de seus métodos. o objeto A envia uma mensagem para o objeto B. Por exemplo. em programas. Por exemplo. um objeto sozinho não é muito útil e aparece como um componente de uma aplicação maior que contém vários outros objetos. Exemplos de métodos deste objeto seriam: frear. As variáveis de um objeto fazem parte do seu núcleo (centro).

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

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

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

Este polimorfismo é classificado como polimorfismo de inclusão. Suponha que exista um método do Conta (retirada()). Por meio da utilização de herança. • Programadores podem definir classes abstratas que determinam comportamentos “genéricos”. contas_do_cliente[0] = conta_normal_do_joao.retirada(). Existem vários tipos de polimorfismo. Por dinâmico.• Subclasses oferecem comportamentos especializados a partir de elementos básicos comuns. Assim: Conta conta_normal_do_joao. é possível fazer com que a execução de um método dependa do tipo do objeto atribuído a variável. na verdade.3 Polimorfismo Segundo a terminologia de orientação a objetos.2. descrito no item anterior. 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. // O interpretador invoca o método de Conta contas_do_cliente[1]. Se a subclasse oferece um método de assinatura (nome.. contas_do_cliente[0]. 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. O primeiro tipo. contas_do_cliente[1] = conta_especial_do_joao. Conta contas_do_cliente[20] . Por acoplamento. entenda-se a escolha correta de um método a ser executado para uma variável declarada como de uma classe.. um novo método. oferecidos pela superclasse. onde ContaEspecial é uma subclasse de Conta. . Outro tipo bastante interessante de polimorfismo é conhecido como acoplamento dinâmico (dynamic binding). Outros programadores completam estes detalhes por meio de subclasses especializadas.retirada(). // O interpretador invoca o método de ContaEspecial Pág 22 . 2. Por exemplo: Sejam duas classes Conta e ContaEspecial. Devido às características de herança.. entenda-se tempo de execução.. pode-se atribuir um objeto de uma subclasse a uma variável da classe pai (mas não o contrário!). 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. mas que pode conter um objeto de uma subclasse desta. programadores podem reusar o código da superclasse várias vezes. é quando uma classe redefine a implementação de um método herdado. que foi redefinido por ContaEspecial. Com o acoplamento dinâmico.

2.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. 5 Considere um objeto do mundo real. Tente definir também subclasses Pág 23 . como um aparelho de som ou um forno. Liste as variáveis e métodos deste objeto.

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

Incrementar(). 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). chamados de Unicode (C/C++ utilizam caracteres de 8 bits. Além disto.contador = 1.5 Sem Variáveis Globais Variáveis globais simplesmente não fazem parte da linguagem.3. a API de manipulação de Strings torna a representação de caracteres totalmente transparente para o programador. Assim.1. toda variável (método) em Java deve ser referenciado pelo seu nome qualificado. 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. MeuObjeto. Pág 25 . Exemplos: MinhaClasse MeuObjeto. se você estiver utilizando apenas caracteres Latin-1. que consiste do nome do pacote que contém a classe.1. Assim. Por exemplo. MeuObjeto. ele sabe exatamente onde encontrá-lo. Assim. os arquivos-fonte em Java possuem simplesmente as declarações das suas classes e métodos. todos os #defines e typedefs. #ifdef e nem typedef. Isto facilita a migração de programas Java para outros idiomas diferentes do inglês. Em Java. 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. separados por ponto. não existem diretivas como #define. 3. toda variável e método deve ser declarada dentro de uma classe. Java elimina a necessidade de arquivos de cabeçalhos (headers files). não há como distinguir um caracter Java de 16 bits de caracteres de 8 bits convencionais.MostraIncremento(). Também não existem funções ou procedimentos “globais”. Assim. no formato ASCII). MinhaClasse. um programador Tailândes pode usar o alfabeto Thai para nomear variáveis e métodos no seu código-fonte. Strings e identificadores (nomes de variáveis. métodos e classes) são compostos de caracteres de 16 bits. #include.incremento = 5.4 Caracteres Unicode Caracteres. MinhaClasse.1. o nome da classe (ou objeto) e o nome do membro (variável ou método) da classe.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. Em vez de cabeçalhos. 3.

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

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

/) sobre este tipo de variável. onde a declaração aparece em relação a outros elementos do código.io. while (in. ou seja.println("Usage: Count filename"). 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. nome e escopo.*. determina seu escopo. de entrada de caracteres) e mostra o número de caracteres lidos.4.out.1 Variáveis e Tipos de Dados Todas as variáveis em Java possuem um tipo. Reader in A declaração de uma variável sempre contém dois componentes: o tipo da variável e seu nome.*.-. Pág 28 . else System. } } 4. stream.read() != -1) count++. o método countChars define duas variáveis: int count = 0. a declaração int count define que a variável count é um inteiro (int). Por exemplo. 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. A localização de uma declaração de variável. import java. Inteiros só podem possuir valores integrais (positivos ou negativos) e pode-se utilizar os operadores aritméticos (+.err."). System.length >= 1) countChars(new FileReader(args[0])). 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. } public static void main(String[] args) throws Exception { if (args.println("Counted " + count + " chars. public class Count { public static void countChars(Reader in) throws IOException { int count = 0. Por exemplo.

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

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

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

alinhada com o while. System. o while realiza alguma ação enquanto uma certa condição continua verdadeira.println("Read a character. pode ser um bloco de código Java delimitado por chaves { }. Por exemplo: while (in. incluindo: Pág 37 . while é chamado de um comando de controle de fluxo. Um statement. Em Java. Count = " + count). execute statement. enquanto a expressão for verdadeira.read() != -1) count++. determina a ordem de execução do código.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. 4. todos os operadores binários (exceto o operador de atribuição) são avaliados da esquerda para a direita. na verdade.read() != -1) { count++. } Convenção: a chave { deve ficar no final da mesma linha que o while e a chave } deve começar uma nova linha. A sintaxe geral do while é: while (expression) statement Ou seja. algumas regras devem determinar qual deve ser avaliado primeiro. Os operadores de atribuição são avaliados da direita para a esquerda. De maneira geral. ou seja. A linguagem Java suporta vários tipos de controle de fluxo.out.

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

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

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

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

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

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

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

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

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

x = x. a variável origin cria um objeto SimplePoint utilizando: new SimplePoint(). Neste caso.0): public class Point { public int x = 0. 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. 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. Poderia-se criar um mecanismo para inicializar suas variáveis com valores diferentes de 0. this. Tanto width quanto height são inteiros e estão inteiramente contidos dentro de SimpleRectangle. Por outro lado. int y) { this. } } Agora. a criação de um objeto do tipo SimpleRectangle aloca memória para as suas variáveis. public int y = 0. ao criar um ponto. Assim. 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 . // a constructor! public Point(int x.1). pode-se definir valores iniciais: new Point(44.Como no exemplo anterior. As classes SimplePoint e SimpleRectangle são implementações simplificadas.y = y. a seguir. tem-se uma nova versão de SimplePoint.

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

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

Entretanto. Se uma classe possui vários construtores. é Pág 50 . Se uma classe (como SimplePoint e SimpleRectangle. assumir que não há problemas em se inspecionar/modificar tais variáveis.2. Um objeto “ideal” oferece métodos pelos quais se consegue inspecionar ou modificar o seu estado. Manipulando ou inspecionando as suas variáveis 2. 5. 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. Um construtor que não possui argumentos é chamado de construtor default. int h) public Rectangle(Point p. Portanto. 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?). a largura e a altura. a programação orientada a objetos desencoraja a manipulação direta das variáveis de um objeto. que não faz nada. estes devem possuir um número diferente de argumentos e/ou argumentos de tipos distintos.public Rectangle(Point p) public Rectangle(int w. vistas no começo da seção) não definir explicitamente um construtor. em situações práticas. algumas vezes faz sentido utilizar diretamente as variáveis de um objeto. ou nenhum valor. então. 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. corre-se o risco de colocar o objeto em um estado inconsistente. int w. Executando (invocando) seus métodos Como já foi discutido. Assim. int h) public Rectangle() Cada um destes construtores permite se definir valores iniciais para diferentes aspectos do retângulo: a origem. Estes métodos garantem que um objeto nunca entrará em um estado inconsistente. é correto afirmar que todas as classes possuem pelo menos um construtor. Por exemplo. largura e altura. 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). Tais modificações devem ser realizadas por meio de métodos.2 Utilizando Objetos Pode-se utilizar um objeto de duas maneiras: 1. As classes Point e Rectangle permitem livre acesso a suas variáveis. o compilador é capaz de determinar qual construtor deve ser invocado. origem. Se um objeto oferece acesso a suas variáveis. Desta forma. é razoável. Assim. a linguagem Java automaticamente oferece um construtor sem argumentos.

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

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

finalize(). Assim que uma outra thread torna-se ativa. 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. O coletor de lixo é uma thread que executa com baixa prioridade de forma síncrona ou assíncrona. 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). 5. atribuindo null a variável que o referenciava (origin): protected void finalize() throws Throwable { origin = null. Por exemplo. } O método finalize é um membro da classe Object.2 Finalização Antes que um objeto seja “coletado”. o método finalize da classe Rectangle libera o objeto Point. O coletor de lixo executa assincronamente. objetos não marcados (ou seja.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. 5. a sua execução. quando o sistema está ocioso. Uma classe deve redefinir o método finalize para realizar as finalizações necessárias para os objetos daquele tipo. em sistema como o Windows 95/NT. dependendo da situação e do sistema onde Java está rodando. não mais referenciados) são considerados como lixo e então são “coletados” (liberando a memória alocada para aqueles objetos). A classe Object fica no topo da hierarquia de classes de Java e é “pai” de todo mundo.preocupar em destruí-los. o coletor de lixo termina a sua execução. Durante a finalização.3. Um objeto está sujeito a coleta de lixo quando não existem mais referências para ele.3. Este processo é chamado de finalização. o coletor roda sincronamente quando o sistema fica sem memória disponível ou quando um programa Java requisita. o coletor dá ao objeto uma oportunidade de se “limpar” por meio da chamado do método finalize do objeto. Note que o Pág 53 . super. 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. Por exemplo. 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. explicitamente. Este processo é denominado de coleta de lixo (garbage collection).

Para isto. 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. vamos analisar cada uma das estruturas da figura acima. A classe Stack usa então um objeto da classe Vector para armazenar seus elementos.método finalize de Rectangle executa o método super. A figura a seguir lista a classe e identifica a estrutura do código. Entretanto. ou seja.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. 5. A seguir. pode-se apenas remover (adicionar) elementos do (ao) topo da pilha. Stack impõe as restrições de uma estrutura LIFO ao objeto Vector. Vector. Pág 54 . para armazenar os seus elementos.4 Criando Classes Esta seção mostra como escrever classes a partir das quais objetos são criados. LIFO).

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

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

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

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

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

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

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

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

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

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

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

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

System.out. } } Primeiramente. System. pode-se utilizar especificadores de acesso (access especifiers) para proteger tanto variáveis quanto os métodos de uma classe.6 Controle de Acesso a Membros da Classe Como visto na seção 2.aMethod(). 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 .println(aVariable). Depois. Tal característica é denominada de encapsulação. público (public) e o nível default. A linguagem Java suporta quatro níveis de acesso distintos: privado (private). Isto faz com que a versão oculta de aVariable (aquela que foi declarada na superclasse ASillyClass) receba o valor true. aMethod() atribui a variável aVariable (que oculta a variável declarada na superclasse) o valor false. void aMethod() { aVariable = false. Em Java.aMethod().4. super.println(super. 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() invoca o método da superclasse: super.out. Este controle é definido na própria declaração da variável (ou método). protegido (protected). que possuem diferentes valores: false true 5.aVariable).} } class ASillierClass extends ASillyClass { boolean aVariable. pacote (package). Então o método aMethod imprime as duas versões de aVariable.

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

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

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

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

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

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

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

Caso ocorra uma exceção em algum ponto do bloco. pode realizar o tratamento de exceção (via try e catch) ou “repassá-la” utilizando throws. Todo o código que pode levantar uma exceção é colocado em um bloco try. } catch (Excecao e) { System. Para um mesmo bloco try podem existir mais de um bloco catch (cada um capturando um determinado tipo de exceção). o restante do código é ignorado e o fluxo de controle do programa “salta” para o bloco catch. o código do bloco catch é ignorado. Estas exceções devem ser sempre tratadas pelo código do seu programa. se existirem. se nenhuma exceção for gerada. A linguagem Java define várias exceções (objetos) que podem ser geradas pelos métodos das classes de sua API. dentro do método GetURL pode ser levantada uma exceção (MalformedURLException). } Para capturar uma exceção. 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 . a. Pode-se acessar os métodos. 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.out.try { a. 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. da exceção por meio deste argumento.metodoQuePodeGerarUmaExcecao(). utilizando-se a palavra-chave throws: protected void GetURL() throws MalformedURLException No exemplo acima. Por outro lado. por sua vez. Este método.outroMetodo().println(“Exceção !!!”). caso contrário ocorrerá um erro de compilação. utiliza-se as cláusulas try e catch. Pode-se “passar para a frente” a exceção.

} } O código acima é válido? Justique.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 a) { x = a. } O código acima é válido? É possível criar classes sem construtores? Como Java trata esta questão? Pág 76 . 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. Agora. Considere o seguinte trecho de código: class UmaClasse { private int x. considere o código abaixo: class OutraClasse { public float x.5 Exercícios 1. 2. } public void UmaClasse(int x) { this. 5.x = x.

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

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

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

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

dizemos que a subclasse redefine o método herdado. No caso de variáveis. variáveis membro definidas na subclasse ocultam variáveis de mesmo nome declaradas na superclasse. porém pode ser uma fonte de muitos erros. } class Subbie extends Super { Float aNumber. 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). a partir da classe Subbie. desta forma: super. definido na superclasse. Pág 81 . 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. Mas é possível acessar a variável aNumber. Portanto. Considere o seguinte exemplo: class Super { Number aNumber. desde que estejam no mesmo pacote que a superclasse. Esta característica da linguagem Java traz grande flexibilidade. No caso de métodos.2 Como foi dito.Regra: Uma subclasse herda todos os membros de sua superclasse que são acessíveis à subclasse. 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. Subclasses não herdam os membros privados (private) da superclasse. Note que construtores não são herdados pelas subclasses. dizemos que a subclasse oculta a variável da superclasse. Subclasses herdam aqueles membros da superclasse declarados sem especificadores de acesso (público. } A variável aNumber na classe Subbie oculta a variável aNumber definida na classe Super. a menos que a subclasse explicitamente oculte a variável ou redefina o método. privado ou protegido). Ocultando variáveis • 6.

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

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

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

int newY) { . Isto garante que as Strings näo possuem nenhum comportamento estranho.. A subclasse parece e age como a classe original mas faz coisas bastante diferentes (e devastadoras). deve definir uma implementação para o método draw: class Circle extends GraphicObject { void draw() { . podendo causar danos ou acessando informação privada. Porém.. o compilador exibirá uma mensagem de erro. } abstract void draw().5 Classes e Métodos Finais Pode-se declarar uma classe como final. a classe não pode ser derivada (possuir subclasses). indesejável ou imprevisível. o verificador Pág 85 . 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. } } class Rectangle extends GraphicObject { void draw() { . Para prevenir este tipo de ataque.abstract class GraphicObject { int x. } } Observação: Uma classe abstrata não precisa. você pode declarar sua classe como final.. Além disto. a classe String de Java é uma classe final por esta razão. y. Ao tentar compilar uma subclasse de uma classe final. 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. ou seja. ou não definir uma implementação para um método abstrato que foi herdado. como Circle e Rectangle... void moveTo(int newX. Por exemplo. qualquer classe que possuir um método abstrato. } Cada subclasse não abstrata de GraphicObject... necessariamente. deve ser declarada como uma classe abstrata. 6.. possuir um método abstrato. inconsistente. .

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

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

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

uma interface pode possuir múltiplas “superinterfaces”. interfaces e herança múltipla são soluções bem distintas: • • • Uma classe só herda constantes de uma interface.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.6. Importante: Java permite herança de multiplas interfaces. Interfaces são úteis nos seguintes casos: • • Captura de similaridades entre classes não relacionadas. sem ser obrigado a criar artificialmente uma relação de herança entre elas. além do modificador de acesso (public): Pág 89 .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. independente da sua hierarquia de classes. 6. Ou seja. Uma classe não poder herdar implementações de métodos de uma interface. Afinal. Isto não ocorre no caso de herança múltipla. Apesar de interfaces resolverem muitos problemas parecidos. Declaração de métodos que uma ou mais classes esperam implementar. Classes que implementam a mesma interface podem ou não estar relacionadas em uma hierarquia de classes. qual a utilidade de interfaces? Você pode usar uma interface para definir um comportamento que pode ser implementado por qualquer classe. A hierarquia de interfaces é independente da hierarquia de classes.

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

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

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

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

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

o compilador cria um arquivo de saída para cada classe e interface definida. A estratégia é a seguinte.java e o arquivo deve estar em um diretório chamado graphics.java) e de classes (.graphics br/uemg/passos/graphics/Retangle. cada empresa utiliza o seu domínio de Internet invertido para denominar os seus pacotes.java.Rectangle Nome da classe graphics/Rectangle.uemg.java caminho do arquivo Além disto. este arquivo ficaria em: package br.Rectangle rect. por sua vez. O diretório graphics. Por exemplo.uemg. Assim.br. o código fonte da classe Rectangle deve estar em um arquivo chamado Rectangle. 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 é . 6.class: Pág 95 . assim todos os pacotes desenvolvidos na Universidade deveriam ter seus nomes precedidos por br. supondo que a UEMG/Passos tenha um pacote chamado graphics que contém um arquivo chamado Rectangle.graphics. embora a especificação da linguagem Java não determine isto. Por exemplo. Cada componente do nome do pacote corresponde a um subdiretório. O nome do arquivo é igual ao nome da classe ou interface e sua extensão é . 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. Este arquivo fonte deve ficar em um diretório cujo nome é igual ao do pacote que contém a classe ou interface.java. a UEMG/Passos possui o domínio passos. O diagrama a seguir mostra como isto funciona.passos.java (UNIX) (Windows) Ao compilar o arquivo fonte.class). pode estar em qualquer diretório do sistema de arquivos.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 (.java br\uemg\passos\graphics\Retangle.passos.

zip) definido no class path (caminho de classes). ele deve ser capaz de encontrar o arquivo correspondente.zip das classes do JDK já fazem parte automaticamente do seu class path. o class path para a estrutura de diretórios classes\br\uemg\passos\graphics\Retangle. o compilador e o interpretador podem construir o resto do caminho do arquivo baseado no nome do pacote e da classe Por exemplo. Analogamente. um arquivo .zip que contém todas as classes do JDK. Ou seja. Quando o compilador encontra uma nova classe enquanto compila a sua aplicação.java (Windows) classes\br\uemg\passos\graphics\Retangle. você pode fornecer o seu diretório de classes a outros programadores sem ter que revelar o código-fonte.class deve incluir o diretório classes mas não os subdiretórios br ou passos. Pág 96 .class deve estar em uma série de diretórios que reflete o nome do pacote. Entretanto. ele não precisa estar no mesmo diretório que o arquivo fonte. quando o interpretador encontra uma nova classe enquanto está executando a sua aplicação. Definição: O class path é uma lista de diretórios ou arquivos compactados onde o compilador/interpretador realiza a busca por classes ou interfaces.java. 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. Em outras palavras.Como o arquivo .) e o arquivo . por exemplo: fontes\br\uemg\passos\graphics\Retangle. Cada diretório definido no class path é um local onde os diretórios dos pacotes podem aparecer. o diretório atual e os arquivo . A partir dos diretórios listados no classpath. Mas.class (Windows) Desta forma. pode-se definir diretórios separados para os arquivos fonte e os arquivos de classes. Tanto o compilador quanto o interpretador procuram por classes em cada diretório (ou arquivo . 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 exemplo. o compilador e o interpretador procuram o diretório atual (. afinal de contas. Por default.

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

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

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

Interface Gráfica Esta seção mostra como se pode criar interfaces gráficas (GUI. posicionados de alguma forma em um applet ou em uma janela de uma aplicação stand-alone. utilizando o pacote AWT (Abstract Windowing Toolkit). Todos os widgets gráficos são subclasses de Component. Estes componentes respondem a eventos iniciados pelo usuário.7. o componente é apagado e então desenhado Pág 100 .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. Graphical User Interface) para aplicações stand-alone e applets Java. 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. como cliques no mouse. 7.1.1 Component Um componente é um widget genérico que não pode ser instanciado (Component é uma classe abstrata). teclas pressionadas e mudam seu estado ou alteram algum dado interno da aplicação. 7. como botões e text-fields. Uma interface gráfica (GUI) consiste de componentes (widgets).

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

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

1.8 List A classe List é uma lista de seleção que permite a escolha de um ou mais itens.applet. 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 . Por exemplo: import java. boolean multipleSelections):cria uma lista que mostra o número de linhas especificado.1. l. } } 7.awt.addItem(“Pera”). l.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. Se multipleSelections for true. } } Alguns métodos importantes: • public List(int rows. l.addItem(“Banana”).addItem(“Maçã”). Múltiplos argumentos podem ser selecionados se passarmos true como segundo argumento do construtor de List.*.7 Label A classe Label representa uma string de texto mostrada na tela. true).*. add(l). import java. Por exemplo: import java.awt.*.applet. import java. public class LabelWidget extends Applet { public void init() { add(new Label("a label")).*.RIGHT)).Label. // right justify add(new Label("right justified label".

applet. sb = new Scrollbar(Scrollbar. public void setEditable(boolean t): Se nâo-editável. Exemplo: Pág 104 . public String getText():Obtém todo o texto do componente.1.HORIZONTAL ou Scrollbar.awt.1)).HORIZONTAL). A largura e altura do campo são definidas pelo seu construtor.10 TextComponent A classe TextComponent não pode ser instanciada.11 TextArea Representa um campo de texto com várias linhas.• • • • 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.*. 7.*. ela é a superclasse dos widgets de edição de texto (TextField e TextArea). Exemplo: import java.9 Scrollbar Esta classe representa um “barra rolante” que contém um valor inteiro. Existem scroll bars verticais e horizontais. Scrollbar sb. 7. public class ScrollbarWidget extends Applet { public void init() { // using a GridLayout ensures Scrollbar fills applet setLayout(new GridLayout(1. import java.VERTICAL) especificada. Alguns métodos importantes: • • • • public String getSelectedText():Obtém o texto selecionado. public void setText(String t): Define o conteúdo (texto) do componente.1. add(sb). } } Alguns métodos importantes: • public Scrollbar(int orientation):Constrói um scroll bar com a orientação (Scrollbar.1. o usuário não pode modificar o conteúdo do componente.

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

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

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

x e IE 3. Por exemplo. Um objeto que gera eventos (botão. Uma interface de ouvinte pode definir mais de um método. a interface do objeto ouvinte correspondente.).awt. cada um destes tipos de evento corresponde a execução de um método diferente nos objetos ouvintes. Por exemplo. objetos ouvintes dos eventos da classe ActionEvent deve implementar a interface ActionListener. 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 .x e IE 4.event define uma interface específica para cada classe de evento. executando um método destes ouvintes e passando para eles um objeto da classe Event. etc. 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. enquanto o outro modelo (versão 1.awt.0) é suportado pelos browsers mais antigos (Communicator 3. Um ouvinte de eventos é um objeto interessado em receber eventos. O pacote java. uma classe de eventos como MouseEvent representa vários tipos de eventos do mouse (botão pressionado.x e 5.x). A tabela a seguir lista algumas classes de eventos definidas no pacote java. o objeto que o gerou avisa todos os objetos ouvintes.event. O modelo de eventos é baseado no conceito de event listener (ouvinte de eventos).mais recentes (Communicator 4. todos os ouvintes de um tipo de evento devem implementar uma interface correspondente. Quando um evento ocorre. botão liberado. Para que este modelo funcione.x).

WindowEvent WindowListener windowActivated() windowClosed() windowClosing() windowDeactivated() windowDeiconified() windowIconified() windowOpened() Depois de implementar os métodos da interface de eventos desejada. iconificada. O applet a seguir. Pág 109 . 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. deiconificada TextComponent TextEvent TextField ActionEvent Window WindowEvent Dica: Para descobrir quais eventos um widget pode gerar. portanto a classe Button gera eventos da classe ActionEvent. um evento da classe ActionEvent é gerado e o método do applet ouvinte (actionPerformed()) será executado. O registro do objeto ouvinte segue esta convenção: se o objeto fonte gera eventos do tipo X. 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. redimensionado. basta olhar a documentação da API da classe. 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. etc. por sua vez. Por exemplo. text field. podemos observar que a classe Button possui os métodos addActionListener() e removeActionListener(). Este método. fechada. quando o usuário clicar o botão. Assim. incrementa o conteúdo do text field do applet. pesquisando na documentação. No caso do AWT. que é uma extensão do exemplo da seção . mostra como o modelo de eventos do Java funciona. este objeto fonte é algum tipo de widget (botão. ele possui um método chamado addXListener() para adicionar um ouvinte e um método chamado removeXListener() para remover um ouvinte.). o objeto ouvinte deve se registrar no objeto “fonte” dos eventos. o applet se registra como um ouvinet dos eventos gerados pelo botão. Neste exemplo.

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

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

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

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

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

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

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

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. } . . A maioria dos applets que redefinem o método start também devem redefinir o método stop. ele apenas mostra uma string. public void paint(Graphics g) { . 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. Por exemplo. De qualquer forma. O método start em geral é utilizado para iniciar uma ou mais threads que realizam alguma tarefa do applet. usuário pressiona uma tecla). . não redefine estes métodos. } 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. os métodos para carregar imagens em um applet simplesmente não funcionam dentro do construtor do applet..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). destroy pode ser utilizado por applets que querem liberar outros recursos. Tratamento de eventos refere-se a detecção e processamento de eventos de entrada (por exemplo. Muitos applets implementam o método paint para desenhar a representação do applet na página Web. 8. é utilizado pelos applets (e aplicações stand-alone) para implementar interfaces gráficas. utilizando o método paint.). usuário clica no mouse. O pacote AWT. apresentado na seção 7. • update: um método que pode ser utilizado junto com o paint para melhorar o desempenho do applet. 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. O método init é útil para realizar inicializações que não demorem muito. Por exemplo.. um applet que apresenta uma animação deve pará-la quando o usuário tiver “minimizado” a página. Em geral.. o método init deve conter o código que normalmente seria colocado em um construtor. check-box.seção 1. o método init é o lugar ideal para executar os métodos que carregam imagens. Pág 117 . 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. Por outro lado.. etc. O applet Simple define sua aparência na tela redefinindo o método paint: class Simple extends Applet { .

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

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

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

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

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

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

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

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

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

devemos criar um objeto da classe BufferedReader que possui o método readLine.PrintWriter out = new PrintWriter(outputFile). Pág 129 .3 Entrada e Saída de Dados (Padrão) A classe System do pacote java.readLine(). String s.close().println(s).close().flush(). in. while ((s = in. } } 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). O programa a seguir lê duas strings. a = ent.io. public class Eco { public static void main(String[] args) throws IOException { String a. Já para ler algum valor do teclado.in)).out. armazena-as em duas variáveis e as exibe na tela: import java. 10.x.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. out. System. Note que é necessário executar o método flush do objeto PrintWriter para que os dados sejam efetivamente escritos no arquivo de saída. out. Para imprimir strings na saída padrão utilizamos os métodos print ou println. BufferedReader ent = new BufferedReader(new InputStreamReader(System.readLine()) != null) out.print("Digite um valor: ").*.

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

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)//-->