Várias respostas sobre JAVA

Prévia do material em texto

w w w .r evis t adolinux.com.br 
Cur s o de I nt r odução à L inguagem JAVA 
Rodrigo Mello - mello@virgos.com.br 
O geek que sabia Java
 
Parte I
 
 
Nascida de um projeto da Sun para descobrir qual seria a nova onda da informática, a 
linguagem Java cada vez mais ganha novos adeptos e defensores. Apropriada para a 
criação de aplicativos independentes de plataforma, a linguagem ganhou muita 
popularidade desde 1995, quando foi publicamente anunciada. A Revista Do Linux traz 
até você um curso de Java, voltado aos que já conhecem alguma linguagem de 
programação, como C ou C++, dividido em várias edições e escrito por um dos autores 
do livro “Aprendendo Java 2”, Rodrigo Fernandes de Mello. Aproveite para iniciar o ano 
novo que se aproxima aprendendo uma nova linguagem 
A linguagem de programação Java nasceu como parte do The Green Project, um projeto da Sun 
iniciado em 1990 por Patrick Naughton, Mike Sheridan e James Gosling, que tinha como objetivo 
tentar descobrir qual seria a “nova onda” da computação e como seria possível desenvolvê-la. 
Em Abril de 1991, com uma mudança de endereço do escritório do projeto, Chris Warth, Ed Frank 
e Craig Forrest uniram-se ao grupo. Ed Frank trouxe a idéia de um dispositivo baseado na 
plataforma SPARC com um sistema operacional embarcado. Dava-se início ao protótipo do Star7, 
um novo handheld wireless baseado na arquitetura SPARC, com um display LCD colorido de 5" 
com touchscreen. 
Para desenvolver a interface do Star7 foi criada uma nova linguagem de programação independente 
de processador. A linguagem foi desenvolvida por James Gosling e recebeu o nome de Oak 
(carvalho), por causa das árvores que podiam ser vistas através de sua janela. Esta linguagem mais 
tarde se tornaria a linguagem Java. A equipe de desenvolvimento tentava encontrar um mercado 
para a venda do Star7 e as companhias de TV a cabo, interessadas em projetos de set-top-boxes e de 
vídeo sob demanda pareciam fazer mais sentido. A equipe desenvolveu então um novo protótipo 
chamado MovieWood, mas, infelizmente, estas indústrias estavam começando a aparecer e ainda 
tentavam investir em modelos de negócios mais viáveis para se fixarem no mercado. 
Quando perceberam que a tecnologia desenvolvida pelo grupo era bastante boa, mas que não havia 
clientes para ela, tentaram visualizar o que poderia ser feito com a criação da equipe, agora 
conhecida como FirstPerson. Foi então que John Gage, James Gosling, Bill Joy, Patrick Naughton, 
Wayne Rosing e Eric Schmidt resolveram apostar na internet. 
A grande rede mundial era exatamente o cenário que o grupo esperava para a tecnologia 
desenvolvida. Em 1994, a FirstPerson disponibiliza para download o WebRunner, um clone do 
navegador Mosaic feito com tecnologia baseada em Java, que mais tarde foi oficialmente chamado 
de HotJava. O WebRunner foi o primeiro navegador a apresentar objetos se movendo e o conteúdo 
dinâmico sendo executado em uma página da Internet. 
Em 1995, John Gage e James Gosling apresentaram o WebRunner na conferência de tecnologia, 
entretenimento e design em Monterey e impressionaram o público com a possibilidade de ter 
animações em um navegador, fazendo com que os presentes no auditório repensassem seus 
conceitos sobre as capacidades da internet. 
Em março de 1995 o grupo liberou uma versão pública do código fonte do Java para download na 
internet. O sucesso foi grande, em alguns meses os downloads chegavam à casa dos milhares e a 
linha T1 compartilhada que o grupo possuía não era suficiente para a crescente demanda de 
mercado que o software estava causando. 
Após algum tempo a tecnologia foi incorporada ao navegador Netscape, então onipresente no 
mercado de browsers e, mais tarde, também em alguns produtos da Microsoft. Desde então, o Java é 
utilizado pelas mais diversas empresas, possibilitando a criação desde simples gráficos animados 
em um website a complexos sistemas de análise meteorológica. 
Programação Orientada a Objetos 
A programação orientada a objetos é um paradigma de programação baseado no conceito de classes 
e objetos. As classes são elementos onde dados e procedimentos podem ser agrupados, segundo sua 
função para um determinado sistema. Essas classes são codificações no formato de arquivos; 
quando uma destas classes é utilizada como um tipo de dado para a criação de uma variável, essa 
variável é chamada de objeto. 
O que é uma Classe? 
Uma classe é definida como uma estrutura de dados que contém métodos e atributos. No paradigma 
da orientação a objetos, os procedimentos ou funções (presentes em linguagens estruturadas, tais 
como C e Pascal) são chamados de métodos de uma classe. As variáveis, que são declaradas dentro 
de uma classe, são chamadas de atributos. Exemplo de uma classe em Java: 
// declaração inicial da classe cliente 
public class cliente 
{ 
 // atributos da classe cliente 
 String nome; 
 String endereco; 
 
 // métodos da classe cliente 
 public void setNome (String novo_nome) 
 { 
 nome = novo_nome; 
 } 
 public void setEndereco (String novo_endereco) 
 { 
 endereco = novo_endereco; 
 } 
 public String getNome() 
 { 
 return nome; 
 } 
 public String getEndereco() 
 { 
 return endereco; 
 } 
} // fim da declaração da classe Cliente 
O que é um Objeto? 
Enquanto uma classe é somente a codificação na forma de um arquivo texto, um objeto é uma 
instância de uma classe, ou seja, uma porção de memória que é reservada para armazenar os dados e 
os métodos declarados na classe. Enfim, um objeto é a instanciação de uma classe na memória. A 
classe é o código-fonte escrito em um arquivo texto, enquanto o objeto é uma parte de uma 
aplicação durante o processo de execução. No objeto, pode-se executar os métodos que foram 
definidos além de acessar e alterar dados. 
O que é uma Mensagem? 
Define-se mensagem como o ato de chamar ou requisitar a execução de um método. Portanto, um 
objeto do tipo Cliente apresenta diversos métodos, e o ato de requisitar a execução de um desses 
métodos é conhecido como mensagem. 
O que é Encapsulação? 
É a capacidade de restringir o acesso a elementos de uma classe por meio de qualificadores. Um 
qualificador é uma palavra reservada em uma linguagem orientada a objetos, que define a 
visibilidade de determinado atributo ou método. Veja na tabela 1.1 as características dos 
qualificadores na linguagem C++ e Java. 
A seguir, um exemplo de uma classe em Java, que utiliza qualificadores: 
// declaração inicial da classe Clientes 
 
public class Clientes { 
 
 // atributos da classe Clientes - estes 
 // podem ser acessados somente dentro da classe 
 
 private String nome; 
 private String endereco; 
 
 // atributos da classe Clientes acessíveis 
 // por meio de código externo à classe 
 
 public String cidade; 
 public int idade; 
 
 // atributos da classe Clientes acessíveis 
 // por meio de código externo à classe, 
 // desde que pertença ao mesmo pacote desta 
 // classe - existe em Java, em C++, não. 
 
 float saldo; 
 String rg; 
 
 // métodos da classe Clientes 
 
 public void setNome (String novo_nome) 
 { 
 nome = novo_nome; 
 } 
 public void setEndereco (String novo_endereco) 
 { 
 endereco = novo_endereco; 
 } 
 public String getNome() 
 { 
 return nome; 
 } 
 public String getEndereco() 
 { 
 return endereco; 
 } 
} // fim da declaração da classe Clientes 
O que é Herança?A herança torna possível a reutilização de funcionalidades previamente definidas em uma classe. A 
finalidade é que a subclasse (aquela que herda as características de determinada classe) inclua o 
comportamento da superclasse (aquela que contém o comportamento a ser herdado) e adicione mais 
funcionalidades. Não seria interessante a herança, se não houvesse a possibilidade de adicionar 
funcionalidades à subclasse. 
Existem construções de hierarquia de classes que apresentam erros. A figura anterior apresenta um 
exemplo de hierarquia onde a superclasse Carro tem as subclasses Porta e Pneu. Essa técnica não 
expressa corretamente o conceito de hierarquia, onde as subclasses especializam, ou seja, afunilam 
o conceito da superclasse. Caso utilize o mesmo questionamento realizado anteriormente para essa 
hierarquia como: “Uma Porta é um Carro?”, a resposta é não. Portanto, o correto é definir uma 
subclasse que tenha a ver com a superclasse, onde a subclasse seja o conceito da superclasse, 
adicionando algum conteúdo que possa representar de forma mais específica o conceito apresentado 
pela superclasse. 
A herança pode ser múltipla onde uma subclasse herda características de diversas superclasses. A 
linguagem C++ suporta esse tipo de herança, enquanto a linguagem Java suporta somente a herança 
de uma única classe. 
A seguir, um exemplo de herança em Java: 
/*declaração da superclasse*/ 
class madeira { 
 // atributo da classe madeira 
 String cor; 
 
 // métodos da classe madeira 
 public String getCor() 
 { 
 return cor; 
 } 
 public void setCor(String nova_cor) 
 { 
 cor = nova_cor; 
 } 
} // fim da declaração da superclasse 
/*declaração da subclasse*/ 
class cadeira extends madeira 
{ 
 // atributos adicionais à superclasse 
 int peso; 
 // métodos adicionais à superclasse 
 public void escreve_tela() 
 { 
 System.out.println(this.getCor()); 
 } 
} // fim da declaração da subclasse 
O que é Sobrecarga de Métodos e de Operadores? 
Sobrecarregar um método ou operador é permitir que se utilize o mesmo nome de chamada para 
operar sobre uma variedade de tipos de dados. A seguir, um exemplo de classe em Java que tem o 
método setValor sobrecarregado: 
// declaração da classe vetor 
public class vetor 
{ 
 // atributos da classe vetor 
 private float X; 
 private float Y; 
 // métodos da classe vetor 
 // ocorre sobrecarga no método setValor, pois 
 // ele manipula uma ou duas variáveis do 
 // tipo float 
 public void setValor(float novo_x) 
 { 
 X = novo_x; 
 } 
 public void setValor(float novo_x, float novo_y) 
 { 
 X = novo_x; 
 Y = novo_y; 
 } 
} // fim da declaração da classe vetor 
A sobrecarga de operadores é oferecida para classes que desejem manipular adição, subtração e 
outras operações. A seguir, um exemplo na linguagem C++ onde existe a sobrecarga do operador 
adição (+) para que manipule objetos do tipo Vetor2D. 
// declaração da classe em C++ 
class Vetor2D 
{ 
 // atributos 
 float x, y; 
 public: 
 // construtor 
 Vetor2D(Vetor2D v2); 
 // métodos 
 void EscreveVideo(char texto[]); 
 Vetor2D operator + (Vetor2D v2); 
} // fim da classe Vetor2D 
No exemplo anterior, é declarado um método: Vetor2D operator + (Vetor2D v2). 
Existe nesse método a sobrecarga do operador + (adição). Esta sobrecarga torna possível a soma de 
dois objetos do tipo Vetor2D, como abaixo: 
Vetor2D v1 = new Vetor2D; 
Vetor2D v2 = new Vetor2D; 
 
// uso do operador adição entre instâncias 
// do tipo Vetor2D 
Vetor2D v3 = v2 + v1; 
No caso apresentado acima, o objeto v2 é responsável por executar de forma implícita uma 
chamada para o operador adição sobrecarregado (+), o qual executa uma determinada função sobre 
os dados. Na chamada para execução do operador sobrecarregado, o objeto v1 é enviado como 
parâmetro. Na declaração da classe Vetor2D, observa-se que o operador adição sobrecarregado 
recebe somente um parâmetro, que é do mesmo tipo da classe. 
O que é Polimorfismo? 
É a troca de mensagens entre métodos de uma subclasse com sua superclasse, e assim 
sucessivamente. O polimorfismo pode ser observado através de métodos virtuais de uma classe 
como representado a seguir: 
/*declaração da superclasse*/ 
class Madeira 
{ 
 // atributo da classe Madeira 
 String cor; 
 // métodos da classe madeira 
 public void escreve_na_tela() 
 { 
 escreve(); 
 } 
 public void escreve() 
 { 
 System.out.println(“estou na classe Madeira!”); 
 } 
} // fim da declaração da superclasse 
/*declaração da subclasse*/ 
class Cadeira extends Madeira 
{ 
 // métodos adicionais à superclasse 
 public void escreve() 
 { 
 System.out.println(“estou na classe Cadeira!”); 
 } 
} // fim da declaração da subclasse 
Na prática, o que acontece é que cada classe procura os métodos sempre da classe cujas chamadas 
estão sendo feitas em direção às superclasses. Na linguagem Java, todos os métodos são virtuais, 
portanto, suportam polimorfismo. Basta serem redeclarados nas subclasses. Em C++, o mesmo não 
ocorre, a superclasse deve permitir que determinado método seja reescrito nas subclasses. 
O que são Construtores e Destrutores? 
Construtores são métodos especiais que são chamados no processo de instanciação de um objeto no 
sistema. A execução de tais métodos garante que os identificadores serão inicializados de forma 
correta. Todo construtor tem o mesmo nome que a classe. O exemplo a seguir tem dois 
construtores, um que não recebe parâmetro algum e outro que recebe o nome de um cliente. 
Observe o exemplo em Java abaixo: 
// declaração inicial da classe cliente 
public class cliente 
{ 
 // atributos da classe cliente 
 private String nome; 
 private String endereco; 
 
 // construtores 
 public cliente() 
 { 
 nome = “”; 
 endereco = “”; 
 } 
 public cliente(String novo_nome) 
 { 
 nome = novo_nome; 
 endereco = “”; 
 } 
 // métodos da classe cliente 
 public void setNome (String novo_nome) 
 { 
 nome = novo_nome; 
 } 
 public void setEndereco (String novo_endereco) 
 { 
 endereco = novo_endereco; 
 } 
 public String getNome() 
 { 
 return nome; 
 } 
 public String getEndereco() 
 { 
 return endereco; 
 } 
} // fim da declaração da classe Cliente 
Todo construtor recebe o mesmo nome da classe. No exemplo anterior, existem dois construtores 
sobrecarregados, um que não recebe nenhum parâmetro e outro que recebe uma string novo_nome. 
Quando um objeto do tipo classe cliente é criado, isto pode ser feito de duas formas, pois existem 
dois construtores. Primeira forma: 
// utilizando o construtor sem parâmetros que 
// inicia o objeto do tipo cliente. É executado o 
// código contido nesse construtor 
cliente c1 = new cliente(); 
Segunda Forma: 
// utilizando o construtor que recebe como parâmetro 
// uma string que identifica o nome do cliente. É 
// executado o código contido nesse construtor. 
cliente c2 = new cliente(“o cliente”); 
O construtor é chamado somente durante o processo de instanciação do objeto. Nos construtores, 
são definidos comportamentos de início do objeto. Quando um objeto, por exemplo,do tipo Cliente 
é instanciado espera-se que o comportamento inicial do cliente seja satisfeito pelos construtores. 
Quais tipos de comportamento são esperados na instanciação de um cliente? Existem parâmetros 
como nome do cliente, endereço, cidade, estado, etc. Por meio desta análise de comportamento, são 
implementados os construtores. 
Destrutores são métodos especiais chamados na finalização do objeto. Quando as posições de 
memória que um objeto ocupa devem ser liberadas, o destrutor é chamado. Na linguagem C++, 
todo destrutor tem o nome da classe precedido por ~ (til). Observe o exemplo em C++ a seguir: 
// declaração da classe em C++ 
class Vetor2D 
{ 
 // atributos 
 float x, y; 
 public: 
 // construtor 
 Vetor2D(Vetor2D v2); 
 // destrutor 
 ~Vetor2D(); 
 // métodos 
 void EscreveVideo(char texto[]); 
 Vetor2D operator+ (Vetor2D v2); 
} // fim da classe Vetor2D 
Quando um objeto do tipo Vetor2D estiver sendo removido da memória, o destrutor é chamado e 
nele devem conter chamadas que liberem a memória que está sendo utilizada pelo objeto. 
Quando uma instância é criada utilizando a palavra new, ela é alocada na memória heap. As demais 
instâncias, tais como int, long e outras, são alocadas na stack (pilha do sistema). A stack é liberada 
automaticamente quando um programa ou objeto morre, entretanto a memória heap não é liberada 
automaticamente. Portanto, deve-se liberar a memória que foi alocada na heap utilizando a chamada 
delete sobre as instâncias que foram declaradas com o uso da palavra reservada new. Por exemplo: 
// para instanciar 
cliente c1 = new cliente(); 
// para liberar a memória heap 
delete c1; 
Portanto, o objetivo do destrutor é liberar a memória heap, alocada usando new, que não é liberada 
automaticamente. A stack é liberada automaticamente. 
A Plataforma e a Linguagem Java 
Tendo tudo isso em mente, pode-se dizer que a plataforma Java é composta de duas partes básicas: 
1. A Máquina Virtual Java (Java Virtual Machine - JVM): como se sabe, a Máquina Virtual 
Java tem como objetivo executar os bytecodes Java, traduzindo-os para código-nativo. Ela 
pode ser implementada em hardware (processadores dedicados que interpretam os 
bytecodes) ou software (tal como o J2SDK que inclui a Máquina Virtual, disponível em 
www.javasoft.com). 
2. A Interface para Programação de Aplicações em Java (Java Application Programming 
Interface - Java API): oferece um conjunto de pacotes de classes (packages) com 
funcionalidades semelhantes às bibliotecas de C ou C++. Ou seja, na Java API encontram-se 
classes que tratam de acesso a redes de computadores, manipulação de strings, 
gerenciamento de interfaces gráficas, threads etc. 
Java API 
A Java API é composta por vários pacotes (packages) que agrupam classes em torno de uma 
funcionalidade específica. Os pacotes básicos da Java API são mostrados na tabela 1.2. 
Estes são apenas alguns pacotes. A Java API tem muitos outros, inclusive subpacotes dos citados 
anteriormente. É muito importante que, na hora em que estiver programando, você tenha sempre à 
mão uma referência da Java API. Esta referência pode ser encontrada no site 
www.javasoft.com/docs. Sem ela, é praticamente impossível criar algum programa na linguagem 
Java. 
Coleta de lixo 
A maioria das linguagens tem alguma instrução que permite que o programador requisite memória 
dinamicamente, ou seja, enquanto o programa está sendo executado. Da mesma forma, existe um 
comando que permite que o programador libere esta memória quando ela não for mais utilizada. 
Na próxima edição da Revista do Linux, continuaremos com nosso curso de Java, abordando 
aspectos como tipos de dados, operadores, expressões, fluxo de execução e os passos para a 
compilação do nosso primeiro programa em Java. Até lá! 
Por quê Star7? 
Já no novo escritório da equipe, os telefones possuíam uma função útil: Quando um telefone estava 
tocando, podia-se atender a chamada a partir de outro aparelho pressionando as teclas * e 7. Então, 
quando alguém não podia atender uma ligação telefônica, este alguém gritava “Star Seven” para 
que outra pessoa pudesse atender a chamada. Quando surgiu a necessidade de “batizar” o projeto, o 
nome Star7 acabou sendo o escolhido 
Duke 
O mascote da linguagem Java se chama Duke, e foi criado como um 'agente' destinado a ajudar o 
usuário a navegar pela interface do projeto Star7, funcionando mais ou menos da mesma forma que 
o infame “clipe” de papel do Word'. E se você acha que já o viu em algum lugar, pode estar certo de 
que viu mesmo: seu formato foi inspirado no emblema da federação, do seriado de TV Star Trek. 
Tabela 1.1 - Qualificadores nas linguagens Java e C++ 
Qualificadores Java C++ 
private O método ou atributo somente pode ser acessado dentro de sua própria classe. 
O método ou 
atributo 
somente 
pode ser 
acessado 
dentro de sua 
própria 
classe. 
public O método ou atributo pode ser acessado externamente por outro 
código 
O método ou 
atributo pode 
ser acessado 
externamente 
por outro 
código 
protected O método ou atributo pode ser acessado pela própria classe ou por 
classes filhas (aquelas que herdam desta classe). 
O método ou 
atributo pode 
ser acessado 
pela própria 
classe ou por 
classes filhas 
(aquelas que 
herdam desta 
classe) 
package O método ou atributo pode ser acessado pela própria classe ou por 
classes que pertençam ao mesmo pacote 
Não existe 
em C++ 
 
Tabela 1.2 - Java API 
Pacote Descrição 
java.applet Contém as classes necessárias para se criar applets 
java.awt Classes para se criar interfaces gráficas e para manipulação de imagens 
java.io Provê o sistema básico de entrada e saída (I/O) e de manipulação de arquivos 
java.lang Contém classes que são fundamentais no projeto da linguagem de programação Java 
java.math Classes para cálculos com números de precisão arbitrária 
java.net Provê classes que são utilizadas na programação de aplicações para redes 
java.sql Contém classes que permitem o acesso a banco de dados 
java.util 
Tem classes que são muito úteis no dia-a-dia da programação como, por exemplo, 
uma classe chamada Vector que implementa um vetor cujo tamanho vai sendo 
alocado dinamicamente. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O geek que sabia Java Parte II 
No capítulo anterior de nosso curso de Java (veja a edição 36 da Revista do Linux, 
página 34), apresentamos um pequeno histórico da linguagem Java e uma introdução aos 
seus principais conceitos. Nesta edição, começamos a lidar com a linguagem em si, 
abordando tipos de dados, operadores, escopo de variáveis, expressões e controle de 
fluxo. Mostramos também os ajustes que devem ser feitos para começar a usar as 
principais ferramentas de desenvolvimento: o compilador javac e o interpretador java. 
Mãos à obra! 
Programando em Java 
Para utilizar a linguagem Java, é preciso ter acesso ao compilador e à máquina virtual, que podem 
ser obtidos no site oficial da linguagem, www.javasoft.com. Uma vez instalado o pacote J2SDK 
(Java 2 Standard Development Kit), devemos configurar algumas variáveis de ambiente para poder 
usar as ferramentas: 
CLASSPATH 
Abaixo, um exemplo de como configurar a variável de ambiente CLASSPATH no Windows e 
Unix: 
Windows: 
set CLASSPATH=%CLASSPATH%;c:\jdk1.3\src.jar; 
c:\j dk1.3\lib\tools.jar;c:\jdk1.3\lib\dt.jar;.; 
Unix (usando Bash): 
export CLASSPATH=$CLASSPATH:/usr/jdk1.3/src.jar: 
/usr/jdk1.3/lib/tools.jar:/usr/jdk1.3/lib/dt.jar:.: 
PATH 
Windows: 
set PATH=%PATH%;c:\jdk1.3\bin; 
Unix (usando Bash): 
export PATH=$PATH:/usr/jdk1.3/bin 
Usando o comando JAVAC 
O javac é o compilador da linguagem Java.Executando esse comando sobre um arquivo que 
contém código nessa linguagem, é gerado um segundo arquivo contendo código-binário. Esse 
arquivo de código-binário é utilizado para a execução do programa. O comando básico para 
compilar seu código é: javac NomeDoArquivo.java. Um arquivo contendo um programa na 
linguagem Java deve ter a extensão .java. No exemplo de compilação apresentado acima, o nome do 
arquivo que contém o código-fonte em Java chama-se NomeDoArquivo.java. 
Usando o comando JAVA 
O executável java é a Máquina Virtual Java, ou seja, é o programa responsável pela execução do 
código compilado pelo javac. Para executar um programa, o comando é: java NomeDoArquivo. 
Com isso, você está instruindo o interpretador java a executar o código contido no arquivo 
NomeDoArquivo.class. Note que a extensão .class deve ser omitida. 
Tipos de dados 
Veja na tabela 3.1 os tipos de dados primitivos da linguagem Java. 
Tabela 3.1 
Inteiros 
Tipo Tamanho/Formato Descrição 
byte 8 bits Inteiro do comprimento de um byte 
short 16 bits Inteiro curto 
int 32 bits Inteiro 
long 64 bits Inteiro longo 
 
Reais 
Tipo Tamanho/Formato Descrição 
float 32 bits IEEE 754 Ponto flutuante de precisão simples 
double 64 bits IEEE 754 Ponto flutuante de precisão dupla 
 
 
Outros 
Tipo Tamanho/Formato Descrição 
char 16 bits (Unicode) Um caractere 
boolean true ou false Valor booleano (verdadeiro ou falso) 
 
 
Tabela 3.1 - Qualificadores nas linguagens Java e C++ 
Escopo 
O escopo define onde uma variável é acessível durante a execução de um sistema e quando a 
variável é criada e destruída. A localização de uma variável dentro do programa estabelece seu 
escopo. Existem quatro categorias de escopo de variáveis na linguagem Java, são elas: 
1. Variável membro. 
2. Variável local. 
3. Parâmetro de métodos. 
4. Parâmetro do manipulador de exceções. 
Tabela 3.2 
Operador Uso Descrição 
+ op1 + op2 Soma op1 e op2 
 
 
- op1 - op2 Subtrai op2 de op1 
* op1 * op2 Multiplica op1 por op2 
/ op1 / op2 Divide op1 por op2 
% op1 % op2 Módulo (resto da divisão) de op1 por op2 
 
Tabela 3.2 - Tabela de operadores binários na linguagem Java 
Escopo.java 
public class Escopo extends Object 
{ 
 private int atributo_classe = 10; 
 public Escopo() 
 { 
 int variavel_metodo = 9; 
 System.out.println(“A variável da classe fica acessível na execução do 
objeto”); 
 System.out.println(atributo_classe); 
 System.out.println(“\nA variável de método morre após a execução do 
método”); 
 System.out.println(variavel_metodo); 
 } 
 public void escopo1() 
 { 
 System.out.println(“Não foi declarada a variável x portanto não posso 
acessá-la”); 
 int x = 67; 
 System.out.println(“Agora a variável x fica ativa até o final do método 
=> “+x); 
 } 
 public void escopo2() 
 { 
 // mesmo nome do atributo de classe 
 int atributo_classe = 4; 
 System.out.println(“Se quiser acessar o atributo de classe deve-se 
utilizar”); 
 System.out.println(“ this.atributo_classe => “+this.atributo_classe); 
 System.out.println(“Sem usar this acesso a variável deste método”); 
 System.out.println(atributo_classe); 
 } 
 public static void main(String args[]) 
 { 
 Escopo e = new Escopo(); 
 e.escopo1(); 
 e.escopo2(); 
 } 
} 
 
A tabela 3.3 apresenta os operadores unários da linguagem Java. Esses operadores atuam sempre 
sobre um único operando, tal como a adição de uma unidade sobre um operando. 
Tabela 3.3 
Operador Uso Descrição 
++ op++ Incremente op em 1; utiliza o valor de op antes de realizar o incremento 
 
 
++ ++op Incrementa op em 1; utiliza o valor de op após realizar o incremento 
 
 
-- op-- Decrementa op em 1; utiliza o valor de op antes de fazer o decremento 
 
 
-- --op Decrementa op em 1; utiliza o valor de op após realizar o decremento 
 
 
 
Tabela 3.3 - Tabela de operadores unários na linguagem Java 
A tabela 3.4 apresenta os operadores relacionais e condicionais da linguagem Java. Esses 
operadores podem ser utilizados em estruturas condicionais tal como “se a > b então execute algo”. 
Tabela 3.4 
Operador Uso Retorna verdadeiro se... 
> op1 > op2 op1 é maior que op2 
>= op1 >= op2 op1 é maior ou igual a op2 
< op1 < op2 op1 é menor que op2 
<= op1 <= op2 op1 é menor ou igual a op2 
== op1 == op2 op1 e op2 são iguais 
!= op1 != op2 op1 e op2 não são iguais 
 
Tabela 3.4 - Tabela de operadores condicionais e relacionais na linguagem Java 
A tabela 3.5 apresenta os operadores binários condicionais da linguagem Java. Esses operadores são 
utilizados em estruturas condicionais onde se deve verificar se um ou mais operandos são 
verdadeiros ou falsos. 
Tabela 3.5 
Operador Uso Retorna verdadeiro se... 
&& op1 && op2 op1 e op2 são verdadeiros, avalia condicionalmente op2 
|| op1 || op2 op1 ou op2 é verdadeiro, avalia condicionalmente op2 
! !op op é falso 
& op1 & op2 op1 e op2 são ambos verdadeiros, sempre avalia op1 e op2 
| op1 | op2 op1 ou op2 é verdadeiro, sempre avalia op1 e op2. 
 
Tabela 3.5 - Tabela de operadores binários condicionais na linguagem Java 
A tabela 3.6 apresenta os operadores de bits da linguagem Java. Esses operadores atuam sobre o 
conteúdo binário dos operandos. 
Tabela 3.6 
Operador Uso Operação 
>> op1 >> op2 Gira os bits de op1 para a direita na distância de op2 
<< op1 << op2 Gira os bits de op1 para a esquerda na distância de op2 
>>> 
op1 >>> 
op2 
Gira os bits de op1 para a direita na distância de op2 (unsigned - sem 
sinal) 
& op1 & op2 Operação lógica AND 
| op1 | op2 Operação lógica OR 
^ op1 ^ op2 Operação lógica XOR 
~ ~op2 Complemento dos bits 
 
Tabela 3.6 - Tabela de operadores sobre bits na linguagem Java 
A tabela 3.7 apresenta os operadores de equivalência da linguagem Java. Esses operadores podem 
ser utilizados como recurso opcional da linguagem. 
Tabela 3.7 
Operador Uso Equivalente a... 
+= op1 += op2 op1 = op1 + op2 
-= op1 -= op2 op1 = op1 - op2 
*= op1 *= op2 op1 = op1 * op2 
/= op1 /= op2 op1 = op1 / op2 
%= op1 %= op2 op1 = op1 % op2 
&= op1 &= op2 op1 = op1 & op2 
|= op1 |= op2 op1 = op1 | op2 
^= op1 ^= op2 op1 = op1 ^ op2 
<<= op1 <<= op2 op1 = op1 << op2 
>>= op1 >>= op2 op1 = op1 >> op2 
>>>= op1 >>>= op2 op1 = op1 >>> op2 
 
Tabela 3.7 - Tabela de operadores de equivalência na linguagem Java 
Operacoes.java 
public class Operacoes extends Object 
{ 
 public void calculos() 
 { 
 int x = 10; 
 int y = 9; 
 
 double resultado = ((((x + y) * y) / x) - y) % 3; 
 System.out.println(“Resultado => “+resultado); 
 } 
 public void operadoresUnarios() 
 { 
 int x = 1; 
 int y = 1; 
 int k = 10; 
 int z = 10; 
 
 for (int m = 0; m < 5; m++) 
 } 
 public void operadoresRelacionais() 
 { 
 int x = 10; 
 int y = 9; 
 
 if (x > y) 
 { 
 System.out.println(“X maior que Y”); 
 } 
 
 if (x != y) 
 { 
 System.out.println(“X diferente de Y”); 
 } 
 // outra forma de if 
 // se x > y então k recebe 3 senão k recebe 7 
 float k = x > y ? 3 : 7; 
 
 System.out.println(“Valor de K =>” +k); 
 
 if (4 == 4) 
 { 
 System.out.println(“4 igual a 4”); 
 } 
 } 
 
 public void operacoesAtribuicao() 
 { 
 int x = 10; 
 
 System.out.println(“Valor original => “+x); 
 x += 10; 
 System.out.println(“Valor após soma com atribuição => “+x); 
 x -= 5; 
 System.out.println(“Valorapós subtração com atribuição => “+x); 
 x *= 5; 
 System.out.println(“Valor após multiplicação com atribuição => “+x); 
 x /= 5; 
 System.out.println(“Valor após divisão com atribuição => “+x); 
 } 
 
 public static void main (String args[]) 
 { 
 Operacoes o = new Operacoes(); 
 o.calculos(); 
 o.operadoresUnarios(); 
 o.operadoresRelacionais(); 
 o.operacoesAtribuicao(); 
 } 
} 
 
 
Fluxo.java 
public class Fluxo extends Object 
{ 
 public static void main(String args[]) 
 { 
 int x = 5; 
 int k = 0; 
 
 if (x > 10) 
 { 
 x = 50; 
 } 
 else 
 { 
 x = 40; 
 } 
 
 switch (x) 
 { 
 case 10: { 
 System.out.println(“DEZ”); 
 break; 
 } 
 case 40: { 
 System.out.println(“QUARENTA”); 
 break; 
 } 
 case 50: { 
 System.out.println(“CINQÜENTA”); 
 break; 
 } 
 } 
 
 for (k = 0; k < 10; k++) 
 { 
 if (k > 5) 
 { 
 // volta para o for 
 continue; 
 } 
 System.out.println(“valor => “+k); 
 } 
 while (k > 0) 
 { 
 System.out.println(“valor do while => “+k); 
 k~W; 
 } 
 
 do { 
 System.out.println(“valor no do-while => “+k); 
 k++; 
 } while (k < 5); 
 
 // tratamento de exceções tenta executar o código se não funcionar trata o 
erro 
 // com (catch) ou executa um finally (executa no final do trecho de código) 
 try { 
 System.out.println(“dentro do try”); 
 } 
 catch(Exception e) 
 { 
 
 System.out.println(“Se não funcionar por algum motivo entra aqui!”); 
 } 
} 
Tabela 3.8 
Operadores pós-fixados [] . (params) expr++ expr- 
Operadores unários ++expr -expr +expr -expr ~ ! 
Cast ou criação new (type)expr 
Multiplicação * / % 
Adição + - 
Rotação << >> >>> 
Relacional < > <= >= instanceof 
Igualdade = = != 
Operador de bits AND & 
Operador de bits OR exclusivo ^ 
Operador de bits OR inclusivo | 
AND lógico && 
OR lógico || 
Condicional ?:: 
Atribuição = += -= *= /= %= &= ^= |= <<= >>= 
>>>= 
 
Tabela 3.8 - Tabela de expressões na linguagem Java 
Tabela 3.9 
Tipo do Fluxo Palavra-chave 
Tomada de decisão If-else, switch-case 
Laços (loops) for, while, do-while 
Tratamento de exceções try-catch-finally, throw 
Outros break, continue, label:, return 
 
Tabela 3.9 - Tabela de fluxo de execução na linguagem Java 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O Geek que sabia Java Parte III 
Na terceira parte de nosso curso de Java, abordamos o conceito de hierarquia 
entre classes. Esta é uma aula essencialmente prática, portanto preste muita 
atenção ao código fonte e aos blocos de comentário entre ele, que dão dicas do 
que está sendo feito. 
Código fonte: http://www.revistadolinux.com.br/ed/039/RdL39-Curso_de_Java.tar.gz 
Exemplo de uma Hierarquia de Classes 
Compile o exemplo a seguir da seguinte forma: 
$ javac Livro.java 
$ javac LivroTecnico.java 
$ javac LivroInfantil.java 
As classes LivroTecnico e LivroInfantil apresentam o método main. Esse método define 
que uma classe pode ser acessada pela Máquina Virtual Java para iniciar a execução de 
uma aplicação. Toda a classe que tem declarada esse método pode ser passada como 
parâmetro para o executável java, tal como a seguir: 
$ java LivroTecnico 
$ java LivroInfantil 
Livro.java 
class Livro extends Object 
{ 
 // atributos acessados somente 
 // dentro da classe 
 private int codigo = 0; 
 
 // atributo acessado dentro da classe 
 // e pelas classes 
 // que herdam desta classe 
 protected String nome = null; 
 
 // acessível por outros objetos diretamente 
 public String editora = null; 
 
 // acessível por classes pertencentes 
 // a este pacote 
 int ano = 0; 
 
 public Livro() 
 { 
 codigo = 0; 
 nome = “default”; 
 editora = “default”; 
 ano = 2001; 
 } 
 
 public Livro(int codigo, String nome) 
 { 
 this.codigo = codigo; 
 this.nome = nome; 
 editora = “default”; 
 ano = 2001; 
 } 
 
 public Livro(String nome, int codigo) 
 { 
 this.codigo = codigo; 
 this.nome = nome; 
 } 
 
 public Livro(int codigo, String nome, String editora, int ano) 
 { 
 this.codigo = codigo; 
 this.nome = nome; 
 this.editora = editora; 
 this.ano = ano; 
 } 
 
 public void setCodigo(int codigo) 
 { 
 this.codigo = codigo; 
 } 
 
 public void setNome(String nome) 
 { 
 this.nome = nome; 
 } 
 
 public void setEditora(String editora) 
 { 
 this.editora = editora; 
 } 
 
 public void setAno(int ano) 
 { 
 this.ano = ano; 
 } 
 
 public int getCodigo() 
 { 
 return codigo; 
 } 
 
 public String getNome() 
 { 
 return nome; 
 } 
 
 public String getEditora() 
 { 
 return editora; 
 } 
 
 public int getAno() 
 { 
 return ano; 
 } 
 
 public void imprime() 
 { 
 System.out.println(“Livro => “+codigo+”, “+nome+”, “+editora+”, “+ano); 
 } 
} 
 
LivroTecnico.java 
{ 
 protected String palavras_chave = null; 
 public LivroTecnico() 
 { 
 // chama o construtor da classe 
 // pai (superclasse)sem parâmetros 
 super(); 
 palavras_chave = “sem palavras-chave”; 
 } 
 
 public LivroTecnico(int codigo, String nome, String editora, int ano, String 
palavras_chave) 
 { 
 super(codigo, nome, editora, ano); 
 this.palavras_chave = palavras_chave; 
 } 
 
 public void testeMensagens() 
 { 
 
Comentário: acessar private int código da classe-pai gera erros, pois um 
atributo private somente é acessível pela própria classe. Mesmo herdando da 
classe que tem o atributo private, não é possível acessá-lo diretamente. Todo 
atributo protected é acessível pela própria classe e pelas classes que herdarem 
da classe que os contém. 
 
System.out.println(“valor de protected String nome -> “+nome); 
 
Comentário: acessando public String editora. Quando um atributo ou método é 
public ele pode ser acessado diretamente por qualquer objeto. 
 
System.out.println(“valor de public String editora -> “+editora); 
 
Comentário: acessando int ano. Neste caso não há modificadores, qualquer classe-
filha ou pertencente ao mesmo pacote pode acessá-la. 
 
System.out.println(“valor de int ano-> “+ano); 
 
 // acessando protected String palavras_chave 
 
 System.out.println(“protected String palavras_chave -> 
“+palavras_chave); 
 } 
 
 public void imprime() 
 { 
 System.out.println(“LivroTecnico”); 
 System.out.println(nome+”, “+editora+”, “+ano+”, “+palavras_chave); 
 } 
 
 public static void main(String args[]) 
 { 
 LivroTecnico lt = new LivroTecnico(1, “Linguagens”, “Novatec”, 2001, “c, 
c++, java, orientação a objetos”); 
 lt.testeMensagens(); 
 
 Livro lv = new Livro(5, “O Livro Externo”, “A Editora”, 1930); 
 
Comentário: acessando de forma externa, ou seja, o envio da mensagem para o 
objeto não é feito dentro da classe System.out.println(“Acessando o atributo 
private int codigo => “+lv.codigo); Isto não funciona, pois private somente é 
acessível dentro da classeque declara o atributo. 
 
 System.out.println(“Acessando o atributo protected String nome => 
“+lv.nome); 
 System.out.println(“Acessando o atributo public editora => 
“+lv.editora); 
 
 // é acessível pois está no mesmo pacote! 
 
 System.out.println(“Acessando atributo int ano => “+lv.ano); 
 } 
} 
LivroInfantil.java 
 
public class LivroInfantil extends Livro 
{ 
 private String colecao = null; 
 
 public LivroInfantil(int codigo, String nome, String editora, int ano, 
String colecao) 
 { 
 super(codigo, nome, editora, ano); 
 this.colecao = colecao; 
 } 
 
 public void imprime() 
 { 
 System.out.println(“LivroInfantil”); 
 System.out.println(nome+”, “+editora+”, “+ano+”, “+colecao); 
 } 
 
 public static void main (String args[]) 
 { 
 LivroTecnico lt = new LivroTecnico(1, “Tutorial Java”, “Sun 
Microsystems”, 1992, “java, orientação a objetos, pacotes”); 
 LivroInfantil li = new LivroInfantil(2, “Branca de Neve”, “Editora 
Infantil”, 1931, “princesa, anões”); 
 
 System.out.println(“Criando um objeto LivroTecnico e outro 
LivroInfantil”); 
 lt.imprime(); 
 li.imprime(); 
 
 // o \n dentro do System.out.println 
 // faz pular uma linha 
 System.out.println(“\n\nFazendo um Cast do Objeto LivroTecnico para 
Livro”); 
 Livro lv1 = (Livro) lt; 
 lv1.imprime(); 
 
 System.out.println(“\n\nFazendo um 
 //Cast do Objeto LivroInfantil para Livro”); 
 Livro lv2 = (Livro) li; 
 lv2.imprime(); 
 
 // System.out.println(“\n\nForçando 
 // um Cast de LivroInfantil 
 // para Livro Tecnico”); 
 // System.out.println(“Este Cast é fora da // 
hierarquia de classes”); 
 // System.out.println(“Portanto não 
 // funciona!”); LivroInfantil li1 = new 
 // LivroInfantil(1, “livro infantil”, 
 // “editora de livros”, 1998, 
 // “coleção infantil”); 
 // LivroTecnico tc1 = (LivroTecnico) li1; 
 
 System.out.println(“\n\nFazendo um cast do Pai para o Filho...”); 
 try 
 { 
 LivroTecnico _lt = (LivroTecnico) new Livro(7, “o livro”, “a editora”, 
2001); 
 _lt.imprime(); 
 } 
 catch(Exception e) 
 { 
 System.out.println(“Não foi possível fazer o cast...”); 
 } 
 
Comentário: Este cast de Pai para Filho não funciona, pois o que existe no filho 
não existe no pai, entretanto o que existe no pai existe no filho. Assim, pode-
se converter um filho no pai, mas não o contrário. Isto é possível, pois na 
herança todo o código do pai foi passado para o filho. Entretanto converter o 
pai no filho gera erros, pois o pai não contém todo o código do filho. 
 
 } 
} 
Hierarquia, palavra-chave this e Escopo 
No exemplo desta seção são aplicados conceitos de hierarquia de classes, uso da 
palavra-chave this para acesso aos identificadores membro da classe e apresentados 
conceitos de escopo de forma prática. Esse exemplo é formado pela superclasse Veiculo, 
que é genérica, como toda superclasse deve ser. As especializações da superclasse 
Veiculo são feitas na implementação das subclasses Moto e Carro. 
Para compilar o exemplo a seguir proceda da seguinte forma: 
$ javac Veiculo.java 
$ javac Moto.java 
$ javac Carro.java 
A classe Moto apresenta o método main que possibilita a execução do aplicativo da 
seguinte forma: 
$ java Moto 
No código-fonte desse exemplo apresentado a seguir existem diversas explicações sobre 
o uso de hierarquia, escopo e da palavra-chave this. 
Veiculo.java 
class Veiculo extends Object 
{ 
 private int ano = 0; 
 protected String marca = null; 
 
 public Veiculo() 
 { 
 // acessando variável ano da classe, pois 
 // não há nenhuma variável ano definida 
 // no escopo deste método 
 ano = 2001; 
 } 
 
 public Veiculo(int ano) 
 { 
 // this é o mesmo que um ponteiro para uma 
 // instância do objeto, o ponto (.) 
 
 this.ano = ano; 
 
Comentário: quando tentamos acessar uma variável ano o que ocorre? Se esta 
variável estiver definida dentro do método no qual se está chamando você estará 
se referindo à variável ano no escopo do método. Portanto, quando nos referimos 
a ano dentro deste construtor, estamos falando da variável ano definida dentro 
deste método, ou seja, aquela variável definida como parâmetro do construtor 
public Veiculo(int ano). Caso a variável ano do construtor não esteja definida 
estaremos acessando o atributo ano da classe, como no construtor vazio acima! 
 
 } 
 public void setAno(int ano) 
 { 
 // atribuindo o valor da variável ano para 
 // o atributo de classe ano 
 this.ano = ano; 
 } 
 public int getAno() 
 { 
 return ano; 
 } 
} 
Moto.java 
class Moto extends Veiculo 
{ 
 public int cilindradas = 0; 
 
 public Moto() 
 { 
 super(); 
 cilindradas = 125; 
 } 
 
 public Moto(int cilindradas) 
 { 
 super(); 
 this.cilindradas = cilindradas; 
 } 
 
 public Moto(int ano, String marca, int cilindradas) 
 { 
 super(ano); 
 
Comentário: O código abaixo acessa o atributo protected marca definido na 
classe-pai atribuindo-lhe o valor da variável marca definida neste construtor. 
 
 this.marca = marca; 
 this.cilindradas = cilindradas; 
 } 
 
 public static void main (String args[]) 
 { 
 Moto x = new Moto(); 
 System.out.println(x.cilindradas); 
 } 
} 
 
Carro.java 
 
class Carro extends Veiculo 
{ 
 protected int numero_portas = 0; 
 
 public Carro() 
 { 
 // chamando o construtor do pai com 
 // parâmetro vazio! 
 super(); 
 // atributo marca acessível, pois está 
 // definido com protected na classe-pai 
 marca = “sem marca”; 
 numero_portas = 2; 
 } 
 
 public Carro(int ano, String marca, int numero_portas) 
 { 
 // chamando construtor com parâmetro 
 // do ano do veículo 
 super(ano); 
 // atribuindo o valor da variável marca 
 // declarada no construtor para o atributo 
 // de classe this.marca 
 this.marca = marca; 
 // atribuindo variável numero_portas para 
 // o atributo this.numero_portas da classe 
 this.numero_portas = numero_portas; 
 } 
 
 public void setNumeroPortas(int numero_portas) 
 { 
 this.numero_portas = numero_portas; 
 } 
 
 public int getNumeroPortas() 
 { 
 return numero_portas; 
 } 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O Geek que sabia Java Parte IV 
Não basta sair escrevendo código feito louco. O planejamento é talvez a parte 
mais importante no desenvolvimento de um sistema. 
Desenvolvendo Aplicações usando Orientação a Objetos 
A primeira questão a ser feita ao desenvolver um software não é Como devo iniciar minha 
Aplicação?, mas: Qual é meu problema? Para iniciar o desenvolvimento de uma solução é 
preciso, primeiro, conhecer o problema e sua abrangência. Na detecção do problema 
pode-se, ao mesmo tempo, aplicar uma forma de “Levantamento de Requisitos para a 
Solução” a ser proposta para o cliente. Nesta seção, será vista uma forma de construir 
sistemas orientados a objetos. 
Entendendo o problema 
Antes de tudo, deve-se tentar entender o problema a ser resolvido. Para isto, pode-se 
utilizar o Diagrama de Atividades que faz parte da UML(Unified Modeling Language - 
mais informações em www.omg.org). É importante notar que a UML não é um método, ou 
seja, ela não mostra os passos a serem seguidos para construir uma aplicação. Em vez 
disso, ela mostra como se pode documentar as diversas partes que formam um sistema 
completo. 
Como exemplo, vamos construir um Sistema de Biblioteca com cadastramento e consulta. 
O Diagrama de Atividades mostra as atividades que estão envolvidas no problema a 
resolver. Assim, na construção de um sistema para uma biblioteca, devemos pensar nas 
atividades que estão envolvidas numa biblioteca real. Os exemplos a seguir mostram 
alguns casos para o nosso Sistema de Biblioteca. 
Levantamento de requisitos 
Entendido o problema, precisamos levantar todos os requisitos para a construção deste 
sistema, tais como: 
O que se tem em ma Biblioteca? (Livros, Jornais, Revistas, Usuários, Funcionários, etc.) 
Têm-se cadastros de que tipo? (Livros, Jornais, Revistas etc.) 
Têm-se consultas de que tipo? (Consulta pela descrição do item da biblioteca etc.) 
Têm-se quantos computadores disponíveis? 
Existe uma rede de computadores para interligar o sistema? 
Quantos usuários em média acessarão o sistema? 
Quantos itens existem para cadastramento? 
Análise dos requisitos 
Nesta fase, fazemos uma análise dos principais itens levantados no processo anterior e 
chegamos a um escopo mais determinado do que é o sistema. 
Estudo de caso do sistema 
Nesta etapa, realizam-se diversos estudos sobre o desenvolvimento do sistema. 
Utilizando o diagrama de Use Cases do UML (atores e os processos do sistema). 
Atenção: nesta fase devem ser gerados os demais estudos de atores e processos que 
envolvem o sistema. 
Estudo da Hierarquia de Classes 
Nesta etapa, iniciamos um estudo detalhado de quais classes, atributos e métodos devem 
existir no sistema para que ele funcione corretamente. Definimos, também, a hierarquia 
de classes que será implementada para oferecer as funcionalidades que se deseja para o 
nosso software. 
Hierarquia de classes 
Deve haver uma série de discussões em grupo, para definir a melhor estrutura hierárquica 
de classes no sistema, seus atributos, seus métodos, etc. 
Análise da arquitetura 
Definimos, nesta fase, a plataforma de implantação do sistema final. Perguntas que 
devem ser feitas nesta fase são: 
 Quantos computadores devem executar o sistema? 
 O sistema necessita de um hardware específico? 
 A aplicação necessita de alto desempenho devendo, assim, ser particionada? 
 Quais são os requisitos mínimos de hardware? 
Aqui cabem todas as questões relacionadas ao ambiente em que a aplicação irá executar. 
A implementação 
Com todo o sistema já definido, finalmente chega a hora de implementar o sistema. 
Apresentamos um exemplo do nosso sistema de biblioteca, com a inserção e consulta de 
livros funcionando. Deixo ao leitor a tarefa de implementar o restante das funções e 
aprendar mais sobre o processo de desenvolvimento usando Java! Antes de compilar, 
não se esqueça de configurar as variáveis PATH e CLASSPATH. Compile o programa 
com o comando javac Biblioteca.java, e execute com java Biblioteca. O código fonte pode 
ser baixado no site da Revista do Linux em: www.RevistaDoLinux.com.br/ed/domes. 
Tratamento de Exceções 
Uma exceção é um evento que ocorre durante a execução de uma aplicação e 
que interrompe o fluxo normal das instruções. Muitos tipos de erros podem 
causar exceções, tais como erros de hardware (um disco rígido com problemas) 
ou software (uso de um vetor sem posições adicionais, por exemplo). Em 
ambos os casos, a plataforma Java gera uma exceção que pode ser tratada em 
tempo de execução pelo software. 
Muitas classes da API Java apresentam um tratamento especial que disponibiliza as 
exceções para que sejam tratadas pelo desenvolvedor. Para saber mais sobre exceções, 
a forma mais simples é a observação, dentro de um help ou da documentação da API 
Java (www.javasoft.com/docs), se cada método de uma classe disponibiliza uma ou mais 
exceções para serem tratadas. Um exemplo disso é a classe System do pacote java.lang. 
Essa classe tem um atributo in (do tipo InputStream). Quando se executa um 
System.in.read*(), essa chamada disponibiliza uma exceção de entrada/saída conhecida 
como IOException, que pode ser tratada. 
Manipulando Exceções 
Excecao1.java 
public class Excecao1 extends Object 
{ 
 public static void main(String args[]) 
 { 
 byte dado[] = new byte[10]; 
 System.out.println("Digite um número"); 
 System.in.read(dado); 
 } 
} 
Ao tentar compilar o exemplo acima será gerado o erro de compilação abaixo: 
C:\jdk1.2.1\samples\excecao>javac Excecao1.java 
Excecao1.java:7: Exception java.io.IOException must be caught, or it must be 
declared in the throws clause of this method. 
 
 System.in.read(dado); 
 ^ 
1 error 
O erro de compilação acima demonstra haver uma exceção que precisa ser 
obrigatoriamente tratada. Trata-se, neste caso, de uma exceção de entrada e saída 
(IOException), como se pode observar pela linha gerada: ` 
Excecao1.java:7: Exception java.io.IOException must be caught, or it must be 
declared in the throws clause of this method. 
Para saber qual linha de código gerou o erro de compilação, basta analisar a saída 
gerada pela compilação. Essa saída apresenta o nome do arquivo que contém o erro, 
seguido de dois pontos e do número da linha de código que apresenta erro. 
Após descobrir qual linha apresenta erro, deve-se analisar qual a natureza do erro. Todo 
erro que diz "... must be caught, or it must be declared in the throws clause of this method" 
está se referindo a uma exceção que não foi manipulada corretamente. Na linha 7 do 
exemplo Excecao1.java há o código abaixo: 
System.in.read(dado); 
Após saber qual o código, a melhor forma de agir é recorrer à documentação do objeto 
utilizado. Ao encontrar a documentação, pode-se checar o método que está sendo 
chamado. A documentação dos pacotes disponíveis no J2SDK pode ser obtida no site 
JavaSoft (www.javasoft.com/docs). No caso acima demonstrado, ao acessar a 
documentação deve-se inicialmente procurar pela classe System, que se encontra 
disponível no pacote java.lang. Ao observar o atributo in (System.in), percebe-se que é 
um objeto do tipo InputStream. Nesse caso, deve-se acessar a documentação da classe 
InputStream. A lista de exceções geradas pelo método em caso de erros se encontra no 
método read dessa classe. A partir desse momento, basta tratar as exceções que o 
método gera. Neste exemplo, a exceção gerada é do tipo IOException. 
Como tratar esses erros? 
Para tratar as exceções, a linguagem Java disponibiliza a estrutura de controle try-catch-
finally, que é utilizada para o tratamento de exceções e fluxo de execução de sua 
aplicação. O try-catch-finally permite tratar determinado tipo de exceção gerada por um 
método qualquer. O exemplo a seguir mostra o tratamento de uma exceção de entrada e 
saída (IOException). Utilizaremos apenas o try-catch, sem o finally: 
Excecao1.java 
public class Excecao1 extends Object 
{ 
 public static void main(String args[]) 
 { 
 byte dado[] = new byte[10]; 
 System.out.println("Digite um número"); 
 try 
 { 
 // tenta executar o código contido no try, 
 // caso haja exceção chama o catch responsável 
 // pela exceção 
 System.in.read(dado); 
 } 
 catch (java.io.IOException erro_gerado) 
 { 
 // pode-se tratar a exceção aqui 
 } 
 } 
} 
No exemplo acima não são gerados erros de compilação, pois a classe System contém 
tratamento da exceção gerada pelo método read do indentificador in, que é do tipo 
InputStream. Tratar exceções é uma técnicade programação muito recomendada para 
oferecer uma boa interface para os usuários dos sistemas, por isso a linguagem Java 
obriga o desenvolvedor a adotar esta prática. 
Pode-se utilizar o finally na mesma estrutura do try-catch. Após tratar determinada 
exceção com o try-catch, o finally possibilita a execução de um bloco qualquer de código. 
O finally é sempre executado, mesmo que nenhuma exceção tenha sido gerada. Por 
exemplo, pode-se executar uma operação qualquer sobre o dado lido através da 
chamada System.in.read(). 
Exc1.java 
 
public class Exc1 extends Object 
{ 
 public Exc1() 
 { 
 System.out.println("Chamei o construtor vazio"); 
 } 
 public void lendo() 
 { 
 System.out.println("Digite um número e tecle ENTER" ); 
 try 
 { 
 int i = System.in.read(); 
 } 
 catch (Exception e) 
 { 
 // tratando a exceção 
 System.out.println("Entrando no tratamento de exceção"); 
 } 
 finally 
 { 
 // executa este bloco de 
 //código após tratar a exceção 
 System.out.println("O finally é sempre executado após try com ou 
sem catch"); 
 } 
 } 
 public static void main (String args[]) 
 { 
 Exc1 x = new Exc1(); 
 x.lendo(); 
 } 
} 
Exc2.java 
public class Exc2 extends Object { 
 
 public static void main(String args[]) 
 { 
 try 
 { 
 int a[] = new int[2]; 
 System.out.println(a[4]); 
 } 
 catch (ArrayIndexOutOfBoundsException e) 
 { 
 // tratamento da exceção imprime a 
 //mensagem que causou a exceção 
 System.out.println("Exceção gerada: " + e.getMessage()); 
 System.out.println("\nPilha de erros"); 
 // imprime a pilha de erros gerados 
 e.printStackTrace(); 
 } 
 finally 
 { 
 System.out.println("O finally é sempre executado"); 
 } 
} 
Com isso, chegamos ao fim do nosso curso introdutório à linguagem Java. Esperamos 
que tenham gostado! Mas o assunto ainda não está esgotado, e voltaremos a abordar 
esta fascinante linguagem de programação em futuras edições da Revista do Linux. Até a 
próxima! 
Pra saber mais: 
Java: www.javasoft.com