apostila formação programador java

PROGRAMAÇÃO APLICADA

JAVA EDIÇÃO Nº 1 - 2007

LAÉRCIO DA CRUZ LOUREIRO

___________________________________________________________________

Apoio Gestão e Execução Conteúdo e Tecnologia

• •

Programação Aplicada - Java 2

SOCIESC – Sociedade Educacional de Santa Catarina

Apresentação

a) Este livro didático contém a disciplina de Programação Aplicada em Java. b) A programação em Java é um assunto muito rico, com centenas de livros já publicados, em vários idiomas, desde o seu lançamento. Este material foi elaborado para que você conheça as propostas tecnológicas da plataforma Java e obter sua primeira experiência com a linguagem de programação. c) Você verá que a convergência dos assuntos que você estudou até agora, irão ser aplicados nas próximas páginas, principalmente sobre a programação orientada a objetos, método utilizado para o desenvolvimento de sistemas usando Java. d) O método de estudo para este material é evolutivo, à medida que você avançar nos estudos, as informações irão complementando as conclusões do tópico anterior. Diante do grande volume de informações e das infinitas possibilidades da plataforma Java, este material procura apresentar os aspectos mais relevantes para o seu início na construção de aplicações em Java. Mas com certeza, não esgota o assunto. e) É importante ressaltar que o livro foi desenvolvido com o objetivo de proporcionar-lhe um aprendizado independente, inerente aos estudos do EAD, e o conteúdo foi revisado com o intuito de oferecer-lhe uma linguagem simples, objetiva e estimulante. f) Lembre-se de que a sua passagem por esta disciplina será também acompanhada pelo Sistema de Ensino Tupy Virtual, seja por correio postal, fax, telefone, e-mail ou Ambiente Virtual de Aprendizagem. g) Entre sempre em contato conosco quando surgir alguma dúvida ou dificuldade. h) Toda a equipe terá a maior alegria em atendê-lo, pois a sua aquisição de conhecimento nessa jornada é o nosso maior objetivo. i) Acredite no seu sucesso e bons momentos de estudo!

Equipe Tupy Virtual.



SUMÁRIO

CARTA DO PROFESSOR...........................................................................................4

CRONOGRAMA DE ESTUDOS..................................................................................6

PLANO DE ESTUDOS ................................................................................................7

AULA 1 - CONHECENDO A PLATAFORMA JAVA...................................................9

AULA 2 - SINTAXE, DADOS E OOP EM JAVA.......................................................29

AULA 3 - ESTRUTURAS DE PROGRAMAÇÃO......................................................58

AULA 4 - HERANÇA.................................................................................................76

AULA 5 - USANDO SWING E CRIANDO APPLETS................................................84

AULA 6 - TRABALHANDO COM OBJETOS..........................................................106

AULA 7 - JAVA COM BANCO DE DADOS............................................................123

Carta do Professor



“ O Java pode estar supervalorizada, mas ela também poderá

ser tão significativa para o mundo da computação, como a

televisão foi para a comunicação em massa.”

(U.S. News and World Report, 1995)

Caro(a) aluno(a),

Java é um dos assuntos mais instigantes no mundo da programação de

computadores. Surgida na década de 90, já nasceu com uma curiosidade (e até hoje

nunca confirmada): a palavra Java vem da marca de café que os programadores

tomavam quando iniciaram o seu projeto. Algumas versões, na Internet, afirmam que

era na verdade o nome da cafeteria próxima do escritório de trabalho da equipe.

Nada surpreendente, pois já dizem os praticantes da “velha arte” da programação de

computadores: o “combustível” para os profissionais manterem altas horas de

produção era (e talvez ainda seja) o café.

A linguagem Java nasceu com outra curiosidade ainda mais forte: fora criada

para programar eletrodomésticos, pois em 1990 a Sun, desenvolvedora do projeto,

tinha a intenção de fabricar eletrônica de consumo com algumas capacidades extras.

Então, veja prezado(a) aluno(a), é com esta primeira percepção que eu

desejo motivá-lo(a). A linguagem Java é um assunto que, desde o seu projeto, é

polêmico e influencia os profissionais da Tecnologia da Informação a, no mínimo,

refletir sobre suas possibilidades.

Em apenas alguns meses, o Java saiu dos laboratórios de pesquisa e

desenvolvimento da Sun para o centro da era da World Wide Web. Foi “a linguagem

certa, no momento certo, com a tecnologia certa”. De todas as tecnologias e

recursos oferecidos pela linguagem Java, talvez a sua característica mais importante

é a portabilidade. A Internet e seu serviço WWW ofereciam um mundo de

possibilidades e a portabilidade era o elemento que o Java oferecia para que as

aplicações pudessem explorar este novo ambiente para se fazer negócios. Além

disso, como a linguagem Java foi construída com base nas famosas e largamente

utilizadas linguagens C e C++, ela “arregimentou” um grande exército de

programadores. Para fechar, explorou de forma nativa a programação orientada a



objetos, que até então era um método exclusivo de linguagens pouco absorvidas,

como o Smalltalk.

Aprender a programar em Java, hoje, é muito mais fácil. A versão atual da

linguagem está muito poderosa. Há um grande número de ambientes de

programação para auxiliar o programador no trabalho com a linguagem e o grande

volume de informações na Internet sobre o tema, favorecem a um aprendizado mais

rápido, sem contudo deixar de ser uma experiência profissional das mais procuradas

da atualidade.

Cabe aqui ainda destacar que a Sun criou o Java com uma mentalidade

totalmente nova sobre o licenciamento e uso. Todo o entorno da tecnologia foi

transformado em “especificação” e publicada na Internet, e agora é mantida por um

comitê chamado “Java Community Process (JCP)”, que reúne profissionais de

renome em Java e a própria Sun, seguindo um modelo demoncrático para a

condução da melhorias das tecnologias.

Então, é com este clima de atualidade e de grande potencial de crescimento

que convido você para mais esta aventura do conhecimento na informática. Desejo-

lhe um estudo rico e cheio de surpresas positivas, já que você estará adentrando

para um grande mundo de tecnologias, serviços, recursos e possibilidades de

negócios, que o Java oferece a todos.

Bons estudos!

Professor Laércio da Cruz Loureiro



Cronograma de Estudos

Acompanhe no cronograma abaixo os conteúdos das aulas, e atualize as

possíveis datas de realização de aprendizagem e avaliações.

Semana Carga horária Aula Data / Avaliação

1

6

Conhecendo a Plataforma

Java

_/_ a _/_

18

Sintaxe, dados e OOP

_/_ a _/_

2

24

Estruturas de Progamação

_/_ a _/_

3

12

Herança

_/_ a _/_

16

_/_ a _/_

4

16

Usando Swing e criando

Applets

5

14

Trabalhando com Objetos

_/_ a _/_

6

16

Java com Banco de Dados

_/_ a _/_



Plano de Estudos

EMENTA

• Conhecendo a plataforma Java

• Instalando o Java

• Sintaxe da linguagem e convenções

• Usando dados em um programa

• Métodos, classes e objetos

• Conceitos avançados de objetos

• Trabalhando com estruturas de dados

• Strings e Arrays

• Applets – Web e Swing

• Programação orientada a eventos

• Modificadores e Associação

• Introdução à herança

• Distribuindo pacotes

• Usando Javabeans e o Java em Rede

• Programação no lado servidor – Java Server Pages

• Introdução ao JDBC

Objetivos da Disciplina

• Geral

Implementar os princípios da orientação a objetos usando a linguagem

Java e aprender como implementar aplicações Java usando os principais

recursos da plataforma.

• Específicos

o Descrever os componentes da plataforma Java;

o Construir programas orientados a objetos usando a linguagem Java;

o Conhecer e desenvolver programas usando a sintaxe de comandos da

linguagem Java;



o Aprender a utilizar recursos de banco de dados em Java.

Carga Horária: 120 horas



Aula 1

CONHECENDO A PLATAFORMA

JAVA

Objetivos da aula

Ao final desta aula, você deverá ser capaz de:

• Identificar os componentes da plataforma e suas variações;

• Diferenciar os tipos de programas Java;

• Identificar a versão do Java a ser utilizada em determinadas

aplicações;

• Preparar o ambiente de um computador para o

desenvolvimento em Java.

Conteúdos da aula

Acompanhe os conteúdos desta aula. Se você preferir,

assinale os conteúdos na medida em que for estudando.

• A plataforma Java;

• O ambiente Java;

• Tipos de programas;

• As versões do Java;

• Instalando o ambiente para programação.



Prezado(a) aluno(a),

Tem um ditado nos Estados Unidos assim: “Você precisa comer antes de

cozinhar. Você precisa ouvir antes de ver. Você precisa viajar antes de

dirigir. E você precisa executar programas em um computador, antes de programar”.

Eis o objetivo desta aula. Você saberá como a plataforma Java foi construída para

executar programas e quais os componentes disponíveis que ajudam o programador

na elaboração de soluções de tecnologia. Você também aprenderá como instalar o

Java para programação e qual a instalação necessária para execução de programas

feitos em Java.

Finalmente, você conhecerá as várias versões que o Java possui e os

direcionamentos tecnológicos que a plataforma está seguindo.

Boa Aula!

1 A PLATAFORMA JAVA

A tecnologia Java foi desenvolvida pela Sun Microsystems para que fosse

uma linguagem de programação orientada a objetos, como também uma plataforma

de desenvolvimento.

Uma plataforma é um ambiente de hardware e software no qual um programa

é executado. Algumas das plataformas mais populares são o Windows, Linux,

Solaris e o Macintosh. Algumas das plataformas existentes podem ser descritas

como uma combinação de sistema operacional com hardware.

Java difere da maioria das plataformas de mercado, pois se posiciona como

uma plataforma apenas de software, que é executada SOBRE as plataformas

baseadas em hardware.

A tecnologia Java pode ser utilizada para a construção de sistemas

convencionais de negócios, como também para o desenvolvimento de sistemas

bseados na Internet. Algumas das vantagens que a linguagem de programação Java

oferece aos programadores desses dois tipos de aplicações é a sua segurança e a

sua capacidade de ser independente de arquitetura, o que significa permitir ao

programador a capacidade de construir programas em Java que poderão ser

executados em qualquer plataforma ou sistema operacional.

A plataforma Java possui dois componentes:



• A Java Application Programming Interface (API), é uma grande coleção

de componentes de software “prontos para uso” que fornecem

capacidades importantes para reuso. A API Java é organizada em

bibliotecas de classes e interfaces relacionadas. As bibliotecas são

conhecidas como packages (pacotes – java.*, javax.* e extensões);

• A Java Virtual Machine (JVM), é a base da plataforma Java, utilizada para

a execução dos programas escritos e compilados em Java. Foi construída

para várias plataformas de hardware e software do mercado.

2 O AMBIENTE JAVA

Um programa Java pode ser executado em vários tipos de computadores por

que ele não executa instruções diretamente no computador. Na verdade, executa o

programa em um computador virtual conhecido como Java Virtual Machine (JVM).

Você pode escrever um programa Java usando qualquer editor de textos. O

arquivo contendo as instruções de programação em Java é também conhecido como

código-fonte. O compilador Java converte o código-fonte em um tipo de arquivo

chamado bytecode, independente de plataforma. Um programa chamado

Interpretador Java verifica o bytecode e executa as instruções do bytecode, linha a

linha, dentro da JVM. Considerando que o programa Java executa de forma isolada

do sistema operacional, permite que possa ser executado em qualquer computador

que possua uma versão JVM. Dessa forma, com a JVM sendo a responsável pela

execução do programa, recursos de segurança são disponibilizados para o

programador, que estão acima das fragilidades que possam existir no sistema

operacional (figura 1.



Figura 1 – O ambiente Java (JRE – Java Runtime Environment)

Ao contrário do Java, o uso de outras linguagens de programação, os

fornecedores de software precisam ter diferentes versões do programa para cada

plataforma que deseja executá-lo. No Java uma única versão do programa é

executada em todas as plataformas. O Bytecode Java permite que se realize a

promessa de “escrever uma vez e executar em qualquer lugar”(figura 2). Você pode

compilar seu programa em bytecode para qualquer plataforma que possua um

compilador Java. Então o bytecode poderá ser executado em qualquer

implementação da JVM. Isso significa que um programa construído em Windows,

terá o mesmo comportamento em Linux, em Unix, etc.



Figura 2 – O método Java “escrever uma vez, executar várias vezes”

Além disso, duas tecnologias de implementação fazem parte do JRE: Java

Plug-in, a qual permite que applets sejam executados nos navegadores para a

Internet, e o Java Web Start, que permite a instalação de aplicações “stand alone”

através de uma rede.

3 TIPOS DE PROGRAMAS

Três tipos de programas podem ser construídos usando Java:

• Aplicações – executadas em uma JVM instalada no sistema operacional do

computador local;

• Applets – executadas através de uma JVM no navegador, usando um plug-in;

• Servlets – são aplicações executadas em uma JVM instalada em um servidor

Web.

Enquanto os applets e as aplicações são usualmente um tipo de interface

gráfica com o usuário e um conjunto de funcionalidades embutidas, os servlets

fornecem funcionalidades para serem consumidas por páginas Web, ou seja, através

dos servlets o programador constrói recursos a serem executados em back-end no

servidor Web. Desta forma, a interface com o usuário de um servlet é normalmente



uma página HTML com um formulário, que “chama” o servlet. Mas também é

importante observar que um applet ou uma aplicação Java, que são executadas

através de HTTP (Hypertext Transfer Protocol) podem chamar um servlet.

As aplicações Java (figura 3) podem ser subdivididas em:

• Aplicações Console: são as aplicações com o foco em apresentação e

interface com o usuário usando apenas caracteres, por exemplo no

Windows, são executadas em uma sessão do Prompt do MS-DOS;

• Aplicações gráficas com Janelas: possuem uma interface gráfica com

elementos visuais, como por exemplo menus, barras de ferramentas e

caixas de diálogo.

Figura 3 – Os tipos de aplicações Java

4 AS VERSÕES DO JAVA

Desde 1995 a Sun vêm lançando várias versões do Java que é resultado das

melhorias tecnológicas e inovações recebidas por profissionais do mundo todo e

também como consequência de sua larga adoção.

• Java 2 Platform Standard Edition (J2SE): é o kit necessário para o

desenvolvimento de todas as aplicações em Java, exceto aquelas



desenhadas para dispositivos de consumo. O J2SE já vem com um

compilador, o ambiente de execução e as APIs principais do núcleo da

plataforma Java;

• Java 2 Platform Enterprise Edition (J2EE): esse pacote inclui um

servidor de aplicações, um servidor Web, APIs específicas para a J2EE,

suporte à Enterprise JavaBeans, Java Servlets API e a tecnologia Java

Server Pages (JSP). O J2EE utiliza o J2SE;

• Java Server Pages Development Kit (JSWDK): se você está interessado

em construir e testar páginas JavaServer ou servlets, este kit fornece os

componentes fundamentais para execução, incluindo o J2SE, mas se você

estiver trabalhando com JavaBeans, será necessária a instalação do

J2EE;

• Java Platform, Micro Edition (J2ME): direcionada para os

programadores que estão construindo programas para dispositivos

móveis, como Palm Pilots, celulares e dispositivos de consumo, esse kit

fornece as ferramentas para a compilação, disponibilização e

configurações de dispositivos, incluindo as APIs específicas para cada tipo

de dispositivo.

A J2SE oferece um ambiente completo para suportar o desenvolvimento de

sistemas, inclusive para desktop e servidores e ela é a base para todas as demais

plataformas, como a J2EE.

j) A plataforma J2SE versão 1.6 está distribuída em blocos que determinam sua especialidade e recursos, de acordo com a necessidade do programador. Uma visão clara sobre os componentes da plataforma está na figura 4.



k)

Figura 4 – A plataforma J2SE

A versão do Java 1.0, lançada em 1995, forneceu a estrutura básica para o

desenvolvimento de programas, basicamente as bibliotecas necessárias para

escrever e compilar programas simples.

A versão 1.1 do Java incorporou grandes avanços, lançada em 1997, com

sua maior implementação para uma interface grágica (GUI), usando um pacote de

bibliotecas (package) chamada AWT. Sua abordagem usando AWT foi uma grande

evolução nas interfaces gráficas, já que suportava Netscape e Internet Explorer com

o mesmo código. Também nesta versão foram lançados recursos para auxiliar na

construção de programas com acesso a banco de dados (JDBC) e à comunicação

em rede (RMI).

O Java 2.0, lançado em 1998, na verdade internamente, é considerada como

versão 1.2 do JDK. O principal objetivo de batizá-la como 2.0 para amplificar as

mudanças significativas que ocorreram na plataforma, onde esta versão agregou

mais de 500 novas classes, o dobro da versão anterior. Também nessa versão,

novas adições foram incorporadas à plataforma, trazendo cada vez mais a

abordagem de uso de “plu-ins” à linguagem. Uma nova capacidade de criação



usando interfaces gráficas foi liberada, chamada SWING. As versões da J2SE

começaram a ser lançadas, estando hoje na versão 6 (J2SE 1.6).

O site oficial da plataforma Java e para obter maiores informações sobre as

versões estão no seguinte endereço:

http://java.sun.com

5 INSTALANDO O AMBIENTE PARA PROGRAMAÇÃO

Antes de você iniciar os trabalhos de programação, é necessário preparar o

seu computador para permitir que os programas sejam interpretados e compilados.

Conforme já foi tratado anteriormente, a linguagem Java não exige que o

programador utilize uma ferramenta particular para a construção de seus programas

em Java. Na verdade, a linguagem nasceu com um apelo de uso livre, ou seja,

incentivar o programador a escolher qual a melhor forma que deseja trabalhar,

quebrando, com isso, paradigmas de algumas linguagens que demonstravam uma

amarração a um ambiente de produção, o que era comercialmente aceitável.

Historicamente, as linguagens compiladas não exigem necessariamente uma

ferramenta para construir programas, mas a sua adoção facilita o trabalho do

programador e aumenta a sua produtividade.

Por isso, surgiram as IDEs (acronismo de Integrated Development

Environment, ou Ambiente de Desenvolvimento Integrado) com o objetivo de auxiliar

o programador na construção dos sistemas e acelerando o processo de construção,

integrando em um único lugar, todos os recursos necessários para a composição de

uma aplicação em Java.

Nesse sentido, como a especificação Java busca estabelecer, vários

fabricantes de software liberaram suas versões de IDE, sendo algumas muito

conhecidas, como a Borland, a IBM e a Oracle. Outras iniciativas surgiram, de forma

gratuita como o modelo de software livre, para atender aos programadores que

desejavam manter uma linha de iniciativa sem custos. O produto gratuito mais

utilizado no mundo Java é o Eclipse (www.eclipse.org) (figura 5).



Figura 5 – O ambiente do Eclipse

Segundo pesquisa (figura 6), o resultado do Java IDE Market Survey

(http://www.qa-systems.com/products/qstudioforjava/ide_marketshare.html), o

Eclipse permanece como o líder de mercado de IDE para Java.

Figura 6 – Resultados da Pesquisa

É importante ainda ressaltar que o grau de maturidade dessas ferramentas

fez com que elas não ficassem exclusivas para uma determinada linguagem, como é



o caso do Eclipse, que permite a construção de programas usando linguagem C++ e

Java. Outro aspecto começou a incomodar a comunidade Java: à medida que as

IDEs ficavam poderosas, maior era a capacidade exigida de processamento e

recursos do computador, gerando um certo desconforto para os profissionais. Essa

situação gerou uma nova onda de IDEs alternativos com finalidades específicas e

com o objetivo de oferecer ambientes equivalentes a cada condição do profissional.

Neste módulo,o utilizaremos um IDE muito simples chamado Jcreator

(www.jcreator.com).

Para que você possa construir programas usando o Jcreator, primeiramente

você precisa efetuar a instalação do JDK (Java Development Kit) da Sun. O JDK é o

pacote que fornece todas as bibliotecas principais da linguagem, o compilador e o

ambiente de execução de aplicações, ou runtime, conhecido como JRE (Java

Runtime Environment). Para apenas executar aplicações, basta o JRE.

Em hardware Intel, o Java 2 SDK suporta as seguintes plataformas:

• Windows 98, Windows NT 4.0, Windows ME, Windows XP, Windows 2000

e 2003. A versão 6 já suporta Windows Vista.

A documentação da plataforma sugere que um hardware com processador

Pentium 166 Mhz e 32 Mbytes de RAM são suficientes para executar aplicações

com interfaces gráficas. Além disso, recomenda-se 48 Mbytes de RAM para a

execução de applets a serem executados em navegadores. São necessários 120

Mbytes de disco rígido para a instalação do SDK.

Efetue o download do SDK correspondente à sua plataforma no seguinte

endereço oficial da Sun (figura 6):

https://sdlc1a.sun.com/ECom/EComActionServlet;jsessionid=3F79837846CC

3A56F4F03527F746C218



Figura 6 – Página de download do JDK

Após a conclusão do download, execute os seguintes passos:

1. Verifique se o arquivo baixado corresponde corretamente ao tamanho do

arquivo informado na página (é aproximadamente 50 Mbytes) (figura 7);

Figura 7 – Tamanho do arquivo de instalação do JDK

2. Desinstale uma versão anterior do JDK;

3. Execute o programa de instalação, efetuando um duplo clique sobre o

arquivo baixado. É importante lembrar que, nas versões do Windows XP,

NT, 2000, 2003 e Vista, você precisa ter privilégios como administrador

para realizar a instalação;

a. O programa de instalação, quando executado, apresenta um

assistente de instalação, que auxilia o usuário no processo de

configuração do JDK no computador. É uma abordagem que facilita

para o usuário iniciante;

b. A primeira tela solicita a sua concordância com os termos do

contrato de licença de uso;



c. A segunda tela, permite determinar quais os componentes do JDK

você deseja instalar. É comum para o JDK, instalar todos os seus

componentes;

d. Após ter determinado os componentes a instalar, o programa de

instalação iniciará a cópia dos arquivos do JDK para o computador;

e. Ao terminar a instalação, será apresentada uma janela de

confirmação de que o processo está concluído, conforme mostra a

figura 8:

Figura 8 – Janela de conclusão da instalação

4. Verifique a pasta de instalação do JDK. A instalação criará duas subpastas

na pasta “Arquivos de Programas” do Windows: jdk1.6.0_01 e jre1.6.0_01;

5. Definindo a variável PATH no Windows XP;

Você pode desenvolver em Java sem preocupar-se com a variável de

ambiente PATH do Windows. Mas se deseja ter um ambiente mais

conveniente para trabalhar, pode determinar o caminho onde estão as

bibliotecas e o compilador do Java.

a. Para configurar a variável no Windows, acesse a janela de

propriedades do ícone “Meu Computador” ou através do Painel de

Controle;

b. Acesse guia Avançado;

c. Clique no botão variáveis de ambiente, tal qual mostra a figura 9;



Figura 9 – Janela de variáveis de ambiente

d. Localize no grupo inferior de variáveis (Variáveis do sistema) a

palavra TEMP e efetue um duplo clique sobre ela. Essa variável

determinará onde está o compilador, a máquina virtual (JVM) e os

demais utilitários da plataforma Java;

e. Digite ao final do texto já existente na variável:

;C:\Arquivos de programas\Java\jdk1.6.0_01\bin

Lembre-se de que a pasta Arquivos de Programas pode alterar de

acordo com o idioma do Windows e a instrução inicia com o sinal de

ponto-e-vírgula, para separar a instrução atual da instrução já

existente na variável. Veja a figura 10.



Figura 10 – Variável PATH

f. Clique no botão OK;

g. Repita os passos para a variável CLASSPATH, mas o conteúdo

que deverá ser adicionado é:

;.

h. Feche todas as janelas.

Agora que o JDK está instalado e configurado, vamos instalar o JCreator LE,

a ferramenta IDE que vamos utilizar neste móduloo. Efetue o download do arquivo

do site do fabricante (http://www.jcreator.com/download.htm), de acordo com o que

mostra a figura 11.

Figura 11 – Página de download do Jcreator LE

Repare que existem várias versões do produto e a que vamos utilizar é

“freeware”, ou seja, podemos utilizar a ferramenta sem pagarmos nada e podemos

inclusive replicar o produto para outras pessoas.



Após baixar o arquivo, execute-o para entrar no programa de instalação, que

é o mesmo das demais aplicações para Windows, usando um assistente de

instalação. Siga os passos do programa para conduzir a instalação do JCreator.

l) Ao terminar, o programa de instalação irá executar o JCreator LE. A primeira vez que você executa o JCreator, após a sua instalação, o software apresenta uma caixa de diálogo (figura 12) com o objetivo de determinar: 1) Associação dos tipos de arquivos específicos para o programa;

2) O Java Home Directory, que já definimos nas variáveis;

3) E o JavaDoc, que é a documentação da plataforma Java.

Figura 12 – Configurações iniciais do JCreator

O JCreator tem por finalidade oferecer caminhos rápidos e fáceis

,principalmente para o programador iniciante. O ambiente do produto já está

orientado para esta particularidade. Quando você inicia o programa, uma janela

central apresenta a documentação das principais opções de execução de comandos

no produto (figura 13). Além disso, o produto segue os padrões gráficos das

aplicações Windows, com menus, janelas, barra de ferramentas e barra de status.



Figura 13 – Janela de início do JCreator

Vamos agora testar se realmente nosso ambiente de programação está

configurado adequadamente. Vamos criar uma aplicação simples e compilá-la para

avaliar os resultados que teremos.

1. Clique no menu File, depois aponte para o item de menu New e no

submenu apresentado, clique sobre o item File;

2. Na janela que será apresentada, selecione a opção Java Class (figura 14);



Figura 14 – File Wizard

3. Clique no botão Next;

4. Na caixa Name, digite: Exemplo e clique no botão Finish;

5. Repare que será apresentada a estrutura inicial de uma classe Java:

/**

/**

* @(#)Exemplo.java

*

*

* @author

* @version 1.00 2007/6/3

*/

public class Exemplo {

/**

* Creates a new instance of <code>Exemplo</code>.

*/

public Exemplo() {

}

/**

* @param args the command line arguments

*/

public static void main(String[] args) {



// TODO code application logic here

}

}

6. Digite a seguinte instrução de código Java na área indicativa com o texto

“TODO code application logic here”:

System.out.println(“Exemplo de teste para o ambiente Java”);

7. Clique no botão Execute(figura 15) da barra de ferramentas;

Figura 15 – Resultados do programa



Síntese

Nesta aula você aprendeu o que é a plataforma Java, sua importância e seus

componentes. Agora você já consegue identificar quais as versões do Java e como

cada uma de suas versões estão orientadas para determinadas necessidades. Você

também conheceu um pouco da história da plataforma, extremamente resumida,

mas que lhe oferece uma visão de como as tecnologias envolvidas chegaram até a

versão atual da plataforma.

Um dos aspectos relevantes que você pôde aprender foi entender como se

iniciam os trabalhos no desenvolvimento de progamas em Java.

Na próxima aula, você começará a conhecer a linguagem Java, suas regras e

padrões. Será trabalhado no seu primeiro programa em Java.

Até lá.

Exercícios Propostos

1) Qual a principal característica da linguagem Java que a diferenciou das

demais linguagens na época em foi lançada? Explique porque.

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

2) Descreva as versões do Java e identifique qual é a base para todas as outras.

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

3) Qual a importância do uso de um IDE para programar em Java?

______________________________________________________________

______________________________________________________________

__________________________________________________



Aula 2

SINTAXE, DADOS E OOP EM JAVA

Objetivos da aula


• Descrever as regras de sintaxe da linguagem;

• Identificar os arquivos envolvidos no processo de

programação Java;

• Utilizar variáveis, tipos de dados e operadores;

• Aplicar os conceitos de OOP na linguagem Java.

Conteúdos da aula



• Sintaxe;

• Usando dados e variáveis;

• Métodos, classes e objetos.




Nesta aula você aprenderá os elementos básicos da linguagem Java,

especificamente suas regras de sintaxe e como um programa é

organizado. Você já estudou sobre Lógica de Programação e os conceitos sobre

Orientação a Objetos, agora você irá colocar em prática os assuntos, utilizando a

linguagem Java.

Boa Aula!

1 SINTAXE

A sintaxe de uma linguagem determina a forma como os programas devem

ser construídos. A linguagem Java possui um grande conjunto de regras, mas não é

muito diferente das demais linguagens orientadas a objetos. Também é importante

observar que alguns IDEs mais avançados já facilitam na digitação das instruções, já

que fornecem ajuda e autocomplementação de código, de acordo com um

determinado contexto.

A linguagem Java, quanto à sintaxe, é similar às linguagens C e C++, mas

com uma série de melhorias e agregações, principalmente no que se refere aos

recursos orientados a objetos.

A maioria dos autores consideram que o melhor caminho para aprender a

sintaxe do Java é avaliando um programa simples. Vamos utilizar o programa

apresentado na aula anterior para testarmos o ambiente de desenvolvimento Java

que configuramos.

1 /**

2 /**

3 * @(#)Exemplo.java

4 *

5 *

6 * @author

7 * @version 1.00 2007/6/3

8 */

9

10 public class Exemplo {

11

12 /**



13 * Creates a new instance of <code>Exemplo</code>.

14 */

15 public Exemplo() {

16 }

17

18 /**

19 * @param args the command line arguments

20 */

21 public static void main(String[] args) {

22 System.out.println(“Exemplo de teste para o ambiente

Java”);

23 }

24 }

As linhas que estão iniciadas com */ ou * ou // são comentários e serão

desconsideradas quando o compilador realizar o trabalho de geração de código

compilado. Esta condição também é aplicada para as linhas em branco no código. A

combinação */...*.../* permite que você implemente comentários em múltiplas linhas.

Já o uso de duas barras comuns no início da linha, aplica a condição de comentário

apenas na linha corrente aonde as barras foram inseridas.

A linha que contém “public class Exemplo {“ determina a declaração da

classe, sendo as palavras public e class reservadas e a palavra Exemplo é o nome

da classe que está sendo criada. As palavras reservadas da linguagem determinam

que não podem ser utilizadas como identificadores em seu código de programação.

A lista de palavras reservadas na linguagem estão na tabela 1.



Tabela 1 – Palavras reservadas da linguagem Java

O sinal de abertura de chaves, ao final da linha 10, é obrigatória e determina o

início do bloco de instruções que fazem parte da classe. Todo bloco de instruções é

“margeado” por chaves. Repare que há um sinal de fechamento de chaves ao final

do código na linha 24.

Logo em seguida, repare que a linha 15 possui uma declaração public

Exemplo() {. É a criação de um método membro da classe. Nesse caso, não possui

funcionalidades, já que entre as chaves de abertura e fechamento (linha 16) não

exite qualquer instrução de código em Java.

Depois, na linha 21, há a declaração mais importante de uma aplicação Java.

Na verdade, o método Main é o ponto de entrada no programa, quando é

executado. Além disso, dentro de uma aplicação Java só pode haver um método

Main. A linha de código possui uma série de detalhes que veremos nas aulas

seguintes, mas vamos adiantando alguns detalhes:


A palavra reservada public determina um modificador de acesso. A palavra

static implementa ao método main a capacidade de ser acessível, mesmo que não

existam objetos para a classe. Isso também indica que todo membro criado para a

classe irá ter um método idêntico de main( ). Na linguagem Java, a palavra static

também indica unicidade, ou seja, somente um método main ( ) da classe poderá



ser armazenado na memória, mas obviamente outras classes poderão ter seus

próprios métodos main ( ).

A palavra void, basicamente, significa vazio. Quando a palavra void é

utilizada na declaração do método main ( ), não significa que o método esteja vazio,

mas que não retornará nenhum valor quando for chamado. Não significa que não

poderá produzir saída de dados, na verdade, o método não enviará qualquer valor

de retorno para o outro ponto de código que o chamou.

Nem todas as classe possuem um método main ( ), a grande maioria não

possui, porém, todas as aplicações Java precisam conter um método main( ), já que

o compilador ou a JVM irá executar primeiro o método main( ) da aplicação.

Finalmente, avaliando o método, existem parâmetros estabelecidos no

método main( ). O conteúdo entre parênteses determina os argumentos que

deverão ser passados para o método, quando for chamado. A palavra String

representa uma classe Java que pode ser usada para representar strings de

caracteres, e os símbolos de colchetes ([ ]) que acompanham a palavra, significam

que a string é um array. O identificador args é usado para controlar qualquer valor

String que seja enviado para o método Main. Essa palavra não é obrigatória, mas é

tradicional na implementação do método main( ).

A linha executável de fato no programa é a correspondente ao número da

linha 21. Seu conteúdo é:

System.out.println(“Exemplo de teste para o ambiente Java”);

Note que a instrução foi finalizada com o sinal ; (ponto-e-vírgula). Todas as

instruções na linguagem Java precisam terminar com ponto-e-vírgula. A frase

“Exemplo de teste para o ambiente Java” é um argumento para o parâmetro do

método println. Todo argumento para um método deve ser informado entre

parênteses e quando o argumento for texto, ele deverá ser informado também entre

aspas.

Argumentos são informações que os métodos exigem para realizar uma

determinada tarefa. No caso, o método Println imprime uma linha de texto na tela de

saída e posiciona o curso para a próxima linha, mantendo o programa pronto para

receber outras saídas. Os métodos são sempre acompanhados de parênteses para

distingui-los de nomes de variáveis.



A palavra out refere-se a um objeto de uma classe base do Java, que tem por

finalidade apoiar as operações de tela. No caso, o método println é membro do

objeto out, mas outros objetos também podem conter um método com o mesmo

nome e finalidade.

A palavra System é uma classe. O objeto out faz parte da classe system,

que é parte integrante no núcleo de classes do Java. Um ponto importante a

observar é que a linguagem Java é case sensitive, ou seja, textos digitados em

maiúsculas e minúsculas são diferentes. Por isso, é fundamental que você observe

as regras de digitação de determinado membro da linguagem.

Finalmente, os pontos que se apresentam entre os elementos da instrução

definem a hierarquia dos elementos na estrutura de classes do Java, que, nesse

caso, segue: nome da classe, ponto, nome do objeto, ponto, nome do método.

1.1 Classes Java

Tudo o que você utiliza em Java faz parte de uma classe. Quando você está

declarando uma classe, conforme vimos no exemplo do tópico anterior, a linha

public class Exemplo representa a criação de uma classe. A palavra “Exemplo”

define o identificador da classe e precisa seguir as seguintes regras:

• Um nome de uma classe precisa começar com um caractere alfanumérico,

símbolo de sublinhado ou o sinal de cifrão;

• O nome da classe somente pode conter caracteres, dígitos, sublinhados e

cifrão;

• Um nome de uma classe não pode conter qualquer uma das palavras

listadas como reservadas da linguagem;

• Um nome de uma classe não pode ser uma das seguintes palavras: true,

false ou null;

• O nome de uma classe não pode conter espaços.



1.2 Comentários

Como você pôde observar, um simples programa Java recebe um grande

número de linhas de código. Grandes programas que executam diversas tarefas

incluem um grande volume de código, o que dificulta ainda mais a sua clareza.

Os comentários nos programas são instruções que você insere no seu

programa e servem para a sua documentação. Os programadores utilizam

comentários para inserir informações relevantes sobre o que está sendo realizado

nas próximas linhas ou na linha atual, facilitam a clareza do programa, ajudando-o a

registrar detalhes que muitas vezes ficam apenas na cabeça do programador.

Como melhores práticas de mercado, colocar comentários no início de uma

classe, descrevendo o próposito da classe, documentação sobre seus parâmetros, o

nome do autor e o controle de versão, são muito comuns. Além disso, também como

prática comum, inserir no início de cada membro da classe (métodos, propriedades e

eventos) uma breve descrição de sua finalidade.

Existem três tipos de comentários na linguagem Java:

• Comentários de linha: iniciam com duas barras (//) e aplicam-se até o

final da linha corrente. Pode ser inserido no início de uma linha ou na

mesma linha de uma instrução, ao seu final;

• Comentários de bloco: iniciam com uma barra e um asterisco (/* e

finalizam com um asterisco e uma barra (*/). Também pode ser utilizado

em uma única linha, mas sua aplicação correta é para comentários que

envolvam várias linhas contíguas;

• Comentários Javadoc: são blocos especiais de comentários que iniciam

com uma barra e dois asteriscos (/**) e finalizam com um asterisco e uma

barra (*/). Você pode utilizar os comentários Javadoc para gerar

documentação com um utilitário do JDK chamado javadoc.

Os comentários javadoc, quando colocados imediatamente antes de uma

declaração (de uma função ou variável), indica que poderão ser incluídos

automaticamente em uma página HTML (gerado pelo comando javadoc). No

conteúdo dos comentários javadoc, você pode utilizar descritores, que fornecem

uma informação automática durante a geração da documentação. Veja esses

descritores na tabela 2.



Tabela 2 – Exemplos de descritores javadoc

Para criar a documentação de um programa Java, usando os comentários

javadoc, utilize o utilitário javadoc, incluído no pacote JDK do Java. O comando

poderia ser assim:

javadoc arquivo.java, arquivo2.java

Exemplos de comentários:

// Exemplo de comentário de uma linha

System.out.println(“Teste”); //Exemplo de comentário de linha

/*

Exemplo de comentário de bloco

*/

/**

* Programa para exemplificar o javadoc.

*/

public class HelloInternet

{

/**

* Método <code>main</code>. Determina o início da execução.

* @param args Recebe um array de elementos do tipo String que

* será passado na linha de comando.

*/

public static void main (String args[])

{



System.out.println("Hello Internet!");

}

}

1.3 Executando um programa e conhecendo os arquivos da aplicação

Quando você salva um arquivo de classe Java, ele deve possuir a extensão

java. Este é o arquivo que deverá ser compilado usando o utilitário de compilação do

J2SE, javac. Caso a compilação ocorrer sem erros, um novo arquivo será gerado

com a extensão class, que é o bytecode do seu programa. O utilitário de execução

de programas, ou runtime, do J2SE é o java e para executar o seu programa,

simplesmente digite java nome-do-arquivo.class.

Toda a operação acima é realizada em segundo plano por uma ferramenta

IDE, como é o caso do JCreator. Quando você solicita ao JCreator para executar o

programa, ele realiza as operações automaticamente, usando os utilitários do J2SE

instalados no computador.

Um arquivo bytecode é o formato binário que a JVM interpreta e converte

para o código de máquina da plataforma corrente, onde o programa está sendo

executado. Um bytecode contém instruções para a máquina virtual, uma tabela de

símbolos e outras informações específicas para execução do programa.

1.4 Depurando um programa

Se você insere instruções com erros de sintaxe em seu programa, o

compilador Java irá apresentar uma mensagem de erro durante o processo de

compilação e não fará a geração do bytecode correspondente. A mensagem de erro

depende da origem do problema que a está gerando e o responsável pela validação

e apresentação da mensagem é o compilador Java. O compilador detecta que houve

uma violação das regras da linguagem e recusa a tradução para o bytecode (figura

16).

Após entender e corrigir o problema indicado pelo compilador, você deverá

realizar uma nova tentativa de compilação.



Figura 16 – Ciclo de desenvolvimento

Também existem os tipos de erros de lógica que não apresentam erros pelo

compilador, já que as regras de sintaxe foram atendidas. O problema somente será

apresentado quando o usuário testar a aplicação e o resultado apresentado não foi o

esperado. Esse tipo de erro de lógica é o mais difícil de estabilizar, já que o

compilador não pode nos ajudar neste tipo de problema.

É nesse contexto que novamente se reforça a necessidade do uso de uma

ferramente IDE. Primeiro, porque, na maioria delas, há um validador de código

durante a digitação do seu programa, indicando quando existe uma quebra de regra

da linguagem e liberando o programador do método “tentativa e erro” de compilar e

testar o programa.

2 USANDO DADOS E VARIÁVEIS

Os dados podem ser categorizados em variáveis e constantes. Temos uma

constante quando não podemos alterar o conteúdo de uma variável, depois que o



programa foi compilado. Já uma variável permite ser alterada dinamicamente,

quando o progama está em execução. Esse assunto já foi bastante trabalhado em

Lógica de Programação.

Como você já aprendeu, as variáveis são áreas de memória nomeadas que

seu programa pode utilizar para armazenar informações. Você aplica nomes às

variáveis em Java, usando as mesmas regras usadas para identificadores de

classes. As variáveis precisam começar com uma letra e não se pode utilizar uma

palavra reservada da linguagem. Em Java, é obrigatória a declaração de todas as

variáveis que serão utilizadas no programa.

A declaração de uma variável em Java inclui:

• O tipo de dados que identificará o tipo de informação a ser armazenada na

variável;

• Um identificador como nome da variável;

• Um valor opcional de atribuição, quando você deseja que uma variável já

possua um valor inicial;

• O sinal de ponto-e-vírgula ao final da linha de declaração.

A linguagem Java não exige padronização de nomes de classes e variáveis,

porém, há convenções para a forma de nomeá-los de maneira que outros

programadores tenham maior facilidade em entender o sistema. Vejamos algumas

delas:

• O nome de classes deve começar com letra maiúscula (por exemplo: class

Banco);

• O nome de métodos, atributos e variáveis deve começar sempre com letra

minúscula (por exemplo: comprar( ));

• O nome de constantes deve utilizar todas as letras maiúsculas;

• Utilizar nomes compostos para melhorar a clareza dos nomes, por

exemplo, MeuCarrinhoCompras;

• As variáveis locais deverão utilizar a primeira letra referente ao tipo

primitivo de dados que está sendo utilizado, por exemplo, byte b, char c,

etc.) e as palavras subseqüentes usando nomes compostos.

Sintaxe para a declaração de variáveis:

[Tipo de Dados] Nome da variável = [Valor Inicial];

A declaração de uma variável sem valor inicial é:



int TempoCompra;

E a declaração da variável com valor inicial é:

int TempoCompra = 25;

Há também a declaração de múltiplas variáveis que, nesse caso, pode

agrupar variáveis do mesmo tipo em uma única declaração.

int TempoCompra = 25, Identificador = 1;

Se você desejar declarar variáveis de tipos diferentes, é obrigatório utilizar

uma instrução para cada declaração.

int TempoCompra = 25;

double ResultadoCalculo;

2.1 Constantes

Constante é uma varíavel com valor fixo, que não se altera durante a

execução do programa. Por isso, toda constante, quando declarada, precisa receber

imediatamente um valor no código de programação, caso contrário nunca receberá

um valor durante a execução do programa. Para declarar uma constante, utilize a

palavra reservada final na seguinte sintaxe:

static [Tipo de Dados] final Nome da variável = [Valor];

2.2 Tipos de dados

Como vimos anteriormente, o uso de variáveis e constantes precisa ser

acompanhado do uso do tipo de dados que será armazenado. O compilador Java

fornece oito tipos de dados NATIVOS, que ficam automaticamente disponíveis para

o programador, sem a necessidade de realizar qualquer parametrização para utilizá-

los. São eles:

• int: usado para armazenar números inteiros. Quando atribuir valores, não

utilizar aspas e pode utilizar o sinal de menos para especificar números

negativos;

• byte, short e long: são variações do tipo de dados inteiro. Os tipos byte e

short são utilizados quando há conhecimento claro dos limites menores



que deverão ser utilizados, com isso, há capacidade de redução do

consumo de memória. Já o tipo de dados long é usado quando há

conhecimento do tamanho maior dos dados que poderão ser

armazenados, com isso, ocupando maior espaço na memória;

• boolean: o tipo de dados booleano, como o próprio nome descreve,

somente pode armazenar os valores verdadeiro ou falso. Seu uso é

comum quando precisamos realizar algum teste condicional e este deve

ser armazenado para futuro uso;

• float e double: esses tipos de dados são relacionados a manter o

armazenamento de valores de ponto flutuante, incluindo quatro valores

especiais: infinito positivo, infinito negativo, zero negativo e valores not-a-

number (NaN). São valores que contêm posições decimais. O float possui

a capacidade de precisão de 6 a 7 dígitos, enquanto o double permite a

precisão de 14 a 15 dígitos;

• char: este tipo de dados permite o armazenamento de caracteres no

padrão Unicode.

Tipos de dados também chamados de primitivos, por participarem do núcleo

da plataforma Java. Além disso, servem de base para tipos mais complexos,

chamados tipos referência.

Um dos maiores obstáculos para conseguirmos independência de plataforma

e com isto obter a portabilidade das aplicações é a ausência de padrões para

armazenamento de dados na memória. Cada equipamento e cada CPU possui seus

próprios padrões e formatos para o armazenamento de tipos básicos. A linguagem

Java determina um padrão de tamanho e formato para cada tipo de dados nativo e

deixa para o “interpretador” implementar o tamanho e formato particular para a

arquitetura em que o programa Java está em execução. Veja os tipos de dados na

tabela 3.



Tabela 3 – Tipos de dados e seus limites

É importante destacar que escolher os tipos de dados apropriados, permite

que o seu programa ocupe menos espaço na memória. Além disso, o compilador irá

apresentar um erro para qualquer valor fora do intervalo permitido pela variável,

servindo, dessa forma, também como um validador da lógica implementada no

programa.

2.3 Operadores Aritméticos

Os operadores aritméticos (tabela 4) permitem a manipulação de valores em

sua aplicação. Eles seguem as mesmas regras de outras linguagens.

Tabela 4 – Operadores aritméticos

Ao combinar operadores em uma expressão em Java, você precisa conhecer

a precedência de cada operador. A precedência determina em que ordem as

operações de uma expressão serão realizadas. O parêntese pode ser usado para

sobrepor a precedência.

Nesse contexto, a ordem de precedência é:

1. Operadores multiplicativos: * / %



2. Operadores aditivos: + -

public class ExemploVariaveis

{

public static void main(String[] args)

{

int oneInt = 315;

short oneShort = 23;

long oneLong = 1234567876543L;

System.out.println(“O inteiro é ” + oneInt);

System.out.println(“O tipo Short é “ + oneShort);

System.out.println(“O tipo long é “ + oneLong);

int valor1 = 43, valor2 = 10, soma, diferenca, produto �

coeficiente, modulo;

soma = valor1 + valor2;

diferenca = valor1 – valor2;

produto = valor1 * valor2;

coeficiente = valor1 / valor2;

modulo = valor1 % valor2;

System.out.println(“A soma é “ + soma);

System.out.println(“O produto é “ + produto);

System.out.println(“O coeficiente é “ + coeficiente);

System.out.println(“O módulo é “ + modulo);

}

}

2.4 Conversão de tipos numéricos

Quando você está trabalhando com variáveis e constantes do mesmo tipo, o

resultado da operação aritmética mantém o mesmo tipo de dados. Por exemplo,

quando você divide dois números de tipo int, o resultado será um número também

do tipo int. Ás vezes, porém, você precisa realizar operações aritméticas com tipos

de dados diferentes. Nessas condições, o Java escolhe um tipo unificando o

resultado. O Java converte automaticamente os operandos para o tipo unificado,

mas sempre que existir a garantia que não haverá perda de de dados (tipos menos

para tipos maiores, tipos de menor precisão em tipos de maior precisão e inteiros em

ponto-flutuante). A lista seguinte apresenta, em ordem de precedência, os tipos de

dados dos operandos e qual o resultado unificado que deverá apresentar entre duas

variáveis:



1. double;

2. float;

3. long;

4. int;

5. short;

6. byte.

Você pode explicitamente sobrepor a unificação dos tipos impondo ao

compilador Java executar uma operação chamada cast (coerção). Com o Type

casting o programador assume o risco da conversão dos tipos de dados envolvidos

na expressão. O operador cast possui maior precedência sobre os demais

operadores.

public class ExemploCast

{

public static void main(String[] args){

boolean t = true;

byte b = 2;

short s = 100;

char c = 'C';

int i = 200;

long l = 24000;

float f = 3.14f;

double d = 0.000000000000053;

String g = "Texto";

System.out.println("Os valores comuns das variáveis ");

System.out.println("t = " + t );

System.out.println("b = " + b );

System.out.println("s = " + s );

System.out.println("c = " + c );

System.out.println("i = " + i );

System.out.println("l = " + l );

System.out.println("f = " + f );

System.out.println("d = " + d );

System.out.println("g = " + g );

System.out.println();

//Convertendo de booleando para byte

b = (byte)(t?1:0);

System.out.println("Valor de b após conversão: " + b);



//Convertendo de booleano para short

s = (short)(t?1:0);

System.out.println("Valor de s após conversão: " + s);

//Convertendo de booleano para inteiro

i = (int)(t?1:0);

System.out.println("Valor de i após conversão: " + i);

//Convertendo de booleano para char

c = (char)(t?'1':'0');

System.out.println("Valor de c após conversão: " + c);

c = (char)(t?1:0);

System.out.println("Valor de c após conversão para Unicode: �

" + c);

//Conversão de booleano para long

l = (long)(t?1:0);

System.out.println("Valor de l após conversão: " + l);

//Conversão de booleando para float

f = (float)(t?1:0);

System.out.println("Valor de f após conversão: " + f);

//Convertendo booleano para double

d = (double)(t?1:0);

System.out.println("Valor de d após conversão: " + d);

//Convertendo booleano para string

g = String.valueOf(t);

System.out.println("Valor de g após conversão: " + g);

g = (String)(t?"1":"0");

System.out.println("Valor de g após conversão: " + g);

int sum = (int)(b + i + l + d + f);

System.out.println("Valor da soma após conversão: " + sum);

}

}



3 MÉTODOS, CLASSES E OBJETOS

3.1 Métodos

Um método é uma série de instruções que tem por objetivo realizar uma

determinada tarefa (figura 17). Qualquer classe em Java pode conter um número

ilimitado de métodos. Em resumo, são operações que manipulam o estado de um

objeto e podem fazer parte da interface do objeto (pode ser utilizado por outras

classes) ou realiza uma atividade interna na classe. Sua composição é similar a uma

função, onde o principal objetivo é o reuso e sua sintaxe é a seguinte:

Figura 17 – Exemplo de método

Como você pôde perceber, as regras são as mesmas. A declaração do

método pode conter:

• Modificadores de acesso (opcional), por exemplo, public (tabela 5). Além

disso, pode ser private, protected ou static. Na maioria das vezes, o

método é acessível externamente, tornando sua natureza pública e

permitindo que outras classes o utilizem;



Tabela 5 – Modificadores possíveis usando métodos

• Tipo de retorno do método, por exemplo, void, que significa que não

retorna valor;

• O nome do método;

• A lista de parâmetros do método, entre parentêses e separados por ponto-

e-vírgula. No exemplo, não existem parâmetros e por isso a declaração

apresenta apenas os parênteses sem conteúdo;

• Finalmente, no corpo do método estão as instruções para realizar uma

determinada tarefa que, nesse caso, irá imprimir três linhas de texto.

Para “chamar” o método criado, você deve utilizar o nome declarado. No

exemplo, o nome do método é Apresenta (figura 18). Simplesmente digitando

Apresenta( ) em qualquer ponto do código, irá disparar o método criado.



Figura 18 – Chamando o método

Vamos ver agora como trabalhar com parâmetros nos métodos. O objetivo de

aplicar parâmetros é permitir que ocorra uma troca de informações entre o código

que chamou o método e o próprio método. Através dos parâmetros é possível que

seja enviado um determinado valor para ser processado pelo método e esse, por

sua vez, possui rotinas internas que manipulam o valor, transformam e podem

retornar o resultado para o código que o chamou.

Não há limite para a inserção de parâmetros. Realizando uma comparação

com o mundo real, imagine que você precisa escrever um método para “calcular o

risco de um empréstimo”. Esse cálculo envolve um conjunto de parâmetros que são

elementos fundamentais para um bom ou mau resultado do risco. Informações como

tempo em que o contratante possui relacionamento com a instituição, qual o valor do

empréstimo, remuneração atual da pessoa e histórico de empréstimos anteriores,

são parâmetros para que uma determinada tarefa seja realizada. Essa é a mesma

abordagem dos métodos.

Um princípio importante na programação orientada a objetos é a noção de

implementação de encapsulamento. Quando você faz a chamada para um método,

não sabe os detalhes de como foi executado. No exemplo anterior, a fórmula de

cálculo do risco do empréstimo não é de seu conhecimento e você apenas se

preocupa em utilizar bem o método, como passando parâmetros adequados para o

resultado esperado (figura 19).



Quando você realiza a chamada para um método, essa instrução deve conter

o nome do método e os seus parâmetros, na ordem que foram estabelecidos e

separados por ponto-e-vírgula.

Figura 19 – Passando parâmetros e usando no método

Lembre-se de que os parâmetros não são obrigatórios, bem como não há

limite para a quantidade de parâmetros que um método pode conter. Perceba

também que um parâmetro é usado no corpo do método, como uma variável e por

isso, é necessária a declaração do parâmetro incluindo o tipo de dados.

Finalmente vamos tratar sobre mais um elemento que estende as

capacidades de um método: o retorno de valor (figura 20). Um método pode retornar

valor para o ponto de código que o chamou. Pode ser de qualquer tipo de dados

suportado pela linguagem Java, bem como, pode retornar nada usando a declaração

void.



Figura 20 – Valor de retorno do método

Para que possamos utilizar um método e seu retorno, é necessário que o

código que o chamou tenha condições de “receber” o valor retornado. Por exemplo,

o método da figura 20pode ser armazenado em uma varíavel.

Resultado = CalcularRisco(5000.00);

Reforço aqui o uso de métodos: é a forma mais eficiente para o uso de

encapsulamento e reuso na linguagem Java. Abuse na sua utilização, mas faça

sempre um planejamento para que sua construção tenha sentido e possa ser

claramente entendido pelo programador, usuário de sua classe.

3.2 Classes

Quando você pensa em orientação a objetos, tudo é uma classe e todo objeto

é membro de uma classe. Como você já aprendeu, é comum o uso de comparações

com o mundo real para exemplificar classes e objetos. Novamente o conceito de

classes é muito útil para obter reuso. Os objetos “herdam” atributos da classe e

todos recebem atributos, já que são membros. Os componentes de dados de uma

classe são, às vezes, referenciados como variáveis instanciadas. Os atributos do

objeto derivados de uma classe também são chamados de “campos”, com o objetivo

de disntigui-los das demais variáveis que possam existir no mesmo contexto. Além

de seus atributos, os objetos derivados de uma classe possuem métodos que lhe



são associados e todo objeto, que é uma instância de uma classe, assume-se que

possui os mesmos métodos.

As classes definem a estrutura e o comportamento de um determinado tipo de

objeto. Na verdade, podemos considerá-las como “modelos” de objetos e sua

composição pode ser reutilizada por objetos derivados, o que são chamados de

instâncias do objeto.

Ao criar uma classe, você precisa atribuir um nome para ela e determinar os

métodos e os dados que farão parte da classe, também conhecidos como membros.

Para criar uma classe, a declaração pode conter:

• Um modificador de acesso (opcional);

• A palavra reservada class;

• Qualquer identificador válido para o nome da classe.

public class Funcionario();

A palavra public (tabela 6) refere-se ao modificador de acesso. Você pode

utilizar, por exemplo, os seguintes modificadores de acesso na declaração de uma

classe: public, final ou abstract. Se você não especificar nenhum modificador, a

classe naturalmente receberá o modificador public.

Tabela 6 – Modificadores possíveis usando classes

As classes públicas são acessíveis por todos os objetos, significa que podem

ser estendidas ou utilizadas como base para outras classes. O acesso mais liberal

para uma classe é o public. Os demais modificadores implementam certas restrições



no uso da classe e somente são utilizados em circunstâncias especiais. O

modificador public é o mais comum utilizado.

Após declarar a classe, você deve construir o corpo de instruções da classe,

que devem ser incluídos dentro de sinais de chaves.

public class Funcionario()

{

//Instruções em código Java

}

Você pode inserir variáveis de instâncias, ou campos, declarando-as dentro

do bloco de instruções da classe. A declaração das variáveis, por uma boa prática,

sempre é realizada usando um modificador que pode ser: private, public, static e

final.

A maioria dos campos de uma classe são private, que fornece o mais alto

nível de segurança. O uso de private determina que nenhuma outra classe poderá

acessar o valor armazenado na variável e somente os métodos da mesma classe

poderão utilizá-la. Esse é um recurso na OOP, que determina o encapsulamento, ou

seja, o usuário não tem acesso ao conteúdo da classe.

public class Funcionario()

{

private int CodFuncionario;

}

3.3 Trabalhando com objetos

Segundo a teoria de OOP, objetos possuem estado, comportamento e

identidade. O estado de um objeto é mantido por um ou mais atributos (que são as

variáveis membro do objeto), o comportamento é implementado por métodos e a

identidade é a referência exclusiva que cada instância tem. Enquanto os atributos

são variáveis, contendo alguma informação pertinente ao objeto, um método é uma

função associada a ele.

Declarar uma classe não cria objetos. Uma classe é uma abstração do que

um objeto é ou será quando for instanciada a classe. Todas as características de um

item a ser produzido em uma fábrica, primeiro é projetado. A classe é um projeto de



objeto, pois contém informações sobre como o objeto possui informações, como

deve ser utilizado e como deve ser identificado.

O processo de criação de um objeto, ou instanciação de uma classe, é

conduzido através de dois passos. Ao declarar uma variável, você determina o tipo

de dados que ela deverá conter e um identificador, referência nomeada da memória

que possuirá o dado armazenado. Quando você declara uma variável do tipo inteiro

(int), o compilador está sendo notificado de que um valor inteiro será armazenado na

área de memória.

A mesma operação é realizada quando estamos criando um objeto. Na sua

declaração, a primeira informação que precisa ser passada ao compilador é o nome

da classe que será utilizada para compor o objeto.

Funcionario exemploFunci = new Funcionario();

No exemplo, a palavra Funcionario é o tipo do objeto, ou seja, a classe que

irá originar o objeto e a palavra exemploFunci é o nome do objeto. O operador new

determina para o compilador a reserva de memória para o objeto e depois seguido

da declaração do método Funcionario( );. Essa declaração é chamada de o

construtor da classe, o que veremos mais adiante. Quando você não escreve

explicitamente um construtor para a classe, o Java escreve uma para você e o nome

do método construtor é sempre o nome da própria classe.

public class Automovel

{

String modelo,cor;

int ano;

boolean estadoMotor = false;

public void ligaMotor()

{

estadoMotor = true;

}

public void informaDados()

{

String motorString;

if (estadoMotor){

motorString = " ligado";

}

else{



motorString = " desligado";

}

System.out.println("Automovel:" + modelo + " " �

+ ano + " " + cor + motorString);

}

}

public class AgenciaAutomoveis

{

public static void main(String args[])

{

// Criando os objetos (instancias) da classe Automovel:

Automovel fusca = new Automovel();

Automovel gol = new Automovel();

fusca.modelo = "Fusca";

fusca.cor = "Preto";

fusca.ano = 69;

gol.modelo = "Gol";

gol.cor = "Vermelho";

gol.ano = 96;

// Ligando o motor de um automoveis:

fusca.ligaMotor();

// Mostrando informações dos automóvel

fusca.informaDados();

gol.informaDados();

}

}

3.4 Construtores

Quando você cria uma classe e uma instância dessa classe, ou cria um

objeto, como vimos, você está chamando um método construtor que possui o

mesmo nome da classe que, por sua ausência, o compilador Java cria

automaticamente. Um método construtor é o responsável pela criação do objeto,

mas é comum a necessidade de interferir no processo de criação, principalmente

para reforçar determinadas regras que a classe pode precisar manter.



Para realizar essa definição na classe, você pode declarar explicitamente um

método com o mesmo nome da classe e inserir em seu bloco de instruções (entre as

chaves), um conjunto de regras que deverão ser seguidas durante a instanciação da

classe, ou seja, após o objeto ter sido criado, o conjunto de instruções contidas no

construtor serão executadas.

public class Pessoa

{

private String nome;

private int idade;

public Pessoa(String nome, int idade)

{

this.nome = nome;

this.idade = idade;

}

}

3.5 Garbage Collection

Nesse momento, você pode imaginar que um programa Java pode conter

inúmeras classes e vários objetos em memória, instanciando-as. À medida que você

instancia classes, a alocação de memória ocorre naturalmente, fazendo com que

seja ocupada por um grande número de armazenamentos e, por sua vez, precisa ser

liberada quando não for mais necessário.

Para auxiliar o programador na tarefa de gerenciamento de memória da

aplicação, a plataforma Java oferece um processo chamado “Garbage Collection”,

executado em segundo plano, como um sistema operacional, que registra toda

memória alocada e mantém contagem do número de referências para cada ponto da

memória. A JVM, periodicamente, verifica se há na memória alguma referência com

valor 0, procedendo então a desalocação.

Em resumo, esse processo é responsável por liberar parte da memória

alocada que não é mais referenciada. Essa condição é necessária, garantindo que

os objetos não mais necessários para o programa em execução sejam lixos e

possam ser excluídos da memória.



Essa funcionalidade faz parte do núcleo do ambiente de execução Java, com

o objetivo de liberar os programadores da necessidade de liberar memória alocada,

o que, em linguagens mais antigas era exigido e gerava mais um trabalho para o

progamador (quando não esquecia de fazê-lo). Além disso, com o uso do Garbage

Collection, há garantia da integridade do programa, deixando a responsabilidade do

que deve ou não ser descarregado da memória a cargo do processo do JRE, não

gerando com isso risco de uma exclusão indevida na memória.

Síntese

Nesta aula tivemos a grande oportunidade de conhecer a aplicação da OOP

em Java. É a união dos conceitos que você já aprendeu com a prática da

implementação de classes e objetos em Java.

Na próxima aula você aprenderá mais detalhes para a construção do corpo de

instruções em linguagem Java, com o uso de estruturas de dados.

As peças vão se encaixando cada vez mais, na direção de aplicações mais

complexas em Java.

Até lá.




1) .Por que devemos utilizar modificadores na declaração campos em uma

classe?

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

2) Qual a necessidade do Garbage Collection?

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

3) O que é um método construtor?

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________



Aula 3

ESTRUTURAS DE PROGRAMAÇÃO

Objetivos da aula


• Trabalhar com lógica condicional em Java;

• Utilizar os operadores lógicos;

• Implementar blocos de repetição em Java;

• Descrever com detalhes o uso de strings e arrays.

Conteúdos da aula



• Trabalhando com estruturas de dados;

• Controle de fluxo;

• Operadores lógicos;

• Blocos de repetição (loops);

• Strings;

• Arrays




Nesta aula você aprenderá a trabalhar com blocos de programação em

Java. Vamos inicialmente falar sobre as princípais características para

trabalhar com blocos de código e suas particularidades. Depois vamos tratar das

estruturas convencionais de lógica, como controle de fluxo e loops. Finalmente,

vamos dar uma atenção especial nos trabalhos com strings e arrays.

Perceba que na maioria do conteúdo desta aula, vamos aplicar os conceitos de

lógica de programação e OOP, que você já aprendeu, usando a linguagem Java e

entendendo suas regras e sintaxe.

Boa Aula!

1 TRABALHANDO COM ESTRUTURAS DE DADOS

O conteúdo de instruções de código Java entre chaves é considerado um

bloco de código. É comum encontrarmos blocos de código dentro de outro bloco

como também blocos de código separados em uma mesma classe (figura 21). O

principal objetivo de compreender os limites de um bloco é entender como funciona

o escopo de dados na linguagem Java.

Figura 21 – Blocos de código em uma classe

A regra principal é: ao declarar uma variável em um programa, você não pode

utilizar o valor armazenado nela em outro programa. Quando a variável está dentro

de um bloco, você não pode referenciá-la em outro bloco. A este tipo de limitação



chamamos escopo. Isso também determina que um mesmo nome de variável não

pode ser declarado duas vezes no mesmo bloco.

Novamente o uso de modificadores de acesso (tabela 7) são fundamentais

para o uso adequado de variáveis de acordo com seu escopo. Quando não é

especificado o modificador na declaração da variável, ela é considerada friendly

(amigável) e poderá ser acessada por todas as classes que pertencem ao pacote.

Tabela 7 – Modificadores de escopo

1.1 Sobrecarga de métodos

À medida que implementamos métodos em nossas classes, é comum termos

um grande número de métodos para atender determinadas necessidades. O

conceito de sobrecarga de métodos é a capacidade de implementar métodos com o

mesmo nome em uma mesma classe. O compilador consegue diferenciá-los pela

assinatura do método, composta do identificador do método, o tipo de retorno, os

tipos de dados dos parâmetros e a quantidade de parâmetros.

Esse recurso é muito útil na criação de classes cujos métodos utilizam

parâmetros opcionais, exigindo a criação de métodos com diferentes quantidades e

tipos de parâmetros. A sobrecarga de métodos é uma das formas de implementação

do polimorfismo em Java.

class ContaBancaria

{

int numeroDeConta;

int nomeDoCorrentista;

int saldo;



// Método original para realizar depósito

public void deposito ( double valorDeposito )

{

saldo = saldo + valorDeposito;

}

// Método sobrecarregado, permitindo um novo

// conjunto de parâmetros

public deposito ( double valor, double nivel )

{

saldo = saldo + val;

if ( saldo > nivel ) {

System.out.println( "Saldo atual" + saldo );

}

}

public void saque ( double valorSaque )

{

if ( saldo - valor < 0 ) {

System.out.println("Saldo insuficiente");

} else {

saldo = saldo - valorSaque;

}

}

}

1.3 Referência this

Quando você está criando classes a partir de objetos que instanciou, as

classes podem tornar-se muito grandes rapidamente. Além dos campos, cada classe

pode conter muitos métodos, inclusive várias versões de métodos sobrecarregados.

Se você instanciar muitos objetos de uma classe, a memória do computador pode

tornar-se um limitador, já que há um trabalho desnecessário em armazenar cópias

separadas de cada variável e método para cada instanciação da classe.

Ao instanciar uma classe, você deseja que cada instância possua seus

próprios campos, por exemplo: cada classe de Empréstimo, deve conter as



informações de risco, valor, cliente e data, de forma individualizada, ou seja, cada

classe deverá conter informações particulares para cada campo.

Já no caso de um método, é utilizado da mesma forma em cada instância da

classe. Assim, você só precisa de um único armazenamento do método para todas

as instâncias da classe.

Quando você está usando um membro de um objeto, é necessário sempre

referir-se ao nome do objeto, mais o sinal de ponto, mais o nome do método ou do

campo. Por exemplo:

aEmprestimo.Valor = 105.000,00;

aEmprestimo.Cliente = “Marcos de Oliveira”;

dblEmprestimo.CalcularRisco();

O compilador Java identifica cada membro da classe de forma simples e

clara. Em classes com múltiplos construtores, que realizam tarefas semelhantes,

this() pode ser usado para chamar outro construtor local (figura 22), identificado pela

sua assinatura (número e tipo de argumentos).

Figura 22 – Uso do método this()

2 CONTROLE DE FLUXO

As declarações de controle de fluxo em Java são usadas para alterar o fluxo

seqüencial das instruções de um programa. Como você já aprendeu, as condições

lógicas impostas para os programas têm por finalidade determinar resultados lógicos

e executar determinadas ações de acordo com a condição apresentada. A



linguagem Java oferece todo o suporte às práticas mais comuns para a construção

de lógica condicional nos programas.

2.1 IF, IF...ELSE e IF...ELSE-IF...ELSE

O processo de decisão no programa envolve a avaliação de um determinado

elemento e, de acordo com seu resultado lógico, pode conduzir a caminhos

diferentes de execução do programa. A instrução IF, em Java, permite que você

avalie uma determinada condição e, de acordo com o resultado, o bloco de código

será executado ou não. Esse é o exemplo de uma condição simples.

Você pode ainda acrescentar o tratamento da condição FALSA, usando a

palavra chave ELSE. Com esse tipo de implementação você terá dois blocos de

código: um para o caso do resultado verdadeiro da condição lógica aplicada e outro

para o resultado falso.

Por exemplo:

public class UsoIF

{


{

int a = 10;

int b = 20;

int c;

if (a > b)

c = a;

else

c = b;

System.out.println("O maior valor = " + c);

}

}

Você pode ainda aplicar condições previstas de acordo com o resultado

obtido do teste lógico, usando a instrução else if.

if ( ano < 0) {

System.out.println("Não é um ano!");

} else if ( (ano%4==0 && ano%100!=0) || (ano%400==0) ) {

System.out.println("É bissexto!");

} else {



System.out.println("Não é bissexto!");

}

2.2 Switch

O uso da condição IF é muito comum, mas em grande quantidade,

principalmente quando há declarações IF dentro de outras declarações IF

(chamados de condições aninhadas), o seu código pode ficar mais complexo e de

difícil entendimento.

Uma alternativa para utilizar um grande número de condições IF é o uso da

instrução SWITCH, declaração muito útil quando necessitamos realizar um único

teste lógico e seu resultado poderá ser uma série de resultados possíveis. A

estrutura da instrução SWITCH é a seguinte:

• Switch: inicia a estrutura de código e é implementada junto com a expressão

lógica a ser testada;

• Case: é a palavra chave que avalia o resultado da expressão para um

determinado valor;

• Break: é uma declaração opcional e permite que o bloco de código do Switch

seja terminado no ponto em que o break foi declarado;

• Default: também seu uso é opcional, e é usado para que uma determinada

instrução (ou conjunto de instruções) seja executada em caso de nenhuma

condição ter sido atendida.

Por exemplo:

public class UsoSwitch

{


{

for (int i = 1; i<5; i++)

{

switch (i)

{

case 1: System.out.println ("Numero UM");

break;

case 2: System.out.println ("Numero DOIS");

break;



case 3: System.out.println ("Numero TRES");

break;

default: System.out.println ("NUMERO INVALIDO");

}

}

}

}

2.3 Operadores Relacionais

Os operadores relacionais são aplicados em expressões utilizadas nas

condições IF e Switch. Aplicam-se apenas a números (todos os tipos primitivos são

tratados por seus valores numéricos). São eles (tabela 8) : maior que(>), maior ou

igual a (>=), menor que (<), menor ou igual a (<=), igualdade (==) e diferença (!=).

O sinal de == é utilizado para avaliar se duas variáveis primitivas são iguais

(possuem o mesmo conteúdo/valor). Em Java, da mesma forma que na linguagem

C, o símbolo == é utilizado também para diferenciar do símbolo = que identifica

atribuição.

Tabela 8 – Operadores relacionais

3 OPERADORES LÓGICOS

Os operadores lógicos são utilizados nas expressões aplicadas aos testes

lógicos, responsáveis pela avaliação condicional em um bloco de instruções. A

linguagem Java oferece vários operadores lógicos.



3.1 Operadores AND e OR

Uma alternativa no uso de instruções IF aninhadas, é o operador AND, usado

em uma expressão lógica que determine que DUAS condições são verdadeiras. O

operador AND é representado por dois símbolos &&.

É importante ressaltar que a utilização do operador AND exige que uma

expressão booleana completa seja inserida em cada lado do operador &&. Por

exemplo:

if (Emprestimo > 1000 && TempoConta < 5) risco = 6;

No exemplo, a condição valida se a variável empréstimo for maior que 1000 E

a variável tempo conta for menor que 5. Caso positivo em AMBOS os casos, o valor

da variável risco será 6.

Você pode utilizar o operador OR, escrito como ||, quando espera que uma

das condições na expressão seja verdadeira. Neste caso, uma e somente uma

condição poderá ser verdadeira.

// Usando dois Ifs

if (ValorItemVenda > 100)

comissao = 5;

else if (totalVenda > 5000)

comissao = 5;

//Usando o operador OR

If(ValorItemVenda > 100 || totalVenda > 5000) comissao = 5;

Os operadores lógicos atuam conforme a descrição da tabela verdade, mas

para obter melhores desempenhos, o Java utiliza a técnica do curto-circuito, ou seja,

quando a análise do primeiro elemento da expressão já define o resultado, não se

avalia o segundo termo.

4 LOOPS

Um loop é uma estrutura na qual você pode utilizar repetidamente a execução

de um bloco de instruções, de acordo com uma condição determinada. Como você

já viu, os blocos de repetição (ou loops) testam uma expressão lógica, caso seja



verdadeira, executam o bloco de instruções e, ao terminar a execução, realiza um

novo teste lógico na expressão.

4.1 While

Permite que um bloco de instruções seja executado enquanto uma expressão

for verdadeira. O teste lógico é realizado ANTES do bloco de instruções ser

executado.

Por exemplo:

public class UsoWhile

{


{

int i = 0;

while (i < 11)

{

if ( (i % 2) == 0)

{

System.out.println("Número " + i + " e' par !");

}

i = i + 1;

}

}

}

Você pode utilizar o loop While para implementar uma tarefa que deve ser

executada um determinado número de vezes, segundo uma expressão lógica.

Nesse caso, a expressão lógica se utiliza de uma variável contadora, que delimitará

o limite de execuções que o bloco de instruções deverá realizar.

4.2 Do...While

O uso do loop Do…While é similar à declaração While. A diferença é apenas

o teste lógico realizado ao final da primeira execução do bloco de código, muito útil

para os casos em que se deseja que pelo menos uma vez o bloco de código seja



executado, já que, utilizando o loop while, se a expressão não for verdadeira, o bloco

de instruções pode nunca ser executado.

public class UsoDoWhile

{


{

int i = 0;

do

{

if ( (i % 2) == 0)

{

System.out.println("Número " + i + " e' par !");

}

i = i + 1;

}

while (i < 11);

}

}

4.3 For

O loop for é um método especial usado para determinar um número finito de

iteracões necessárias. É muito mais elegante trabalhar com loops com seqüências

limitadas de execuções ao invés do loop while. Ao trabalhar com o loop for, você

pode indicar o valor inicial para a variável de controle, que faz parte do teste de

controle do loop.

Para construir um loop for, você precisa iniciar o código com a palavra

reservada “for”, seguida de um par de parentêses. O trecho entre parênteses possui

três seções separadas por ponto-e-vírgula:

• A inicialização da variável de controle para execução do bloco de

instruções;

• A variável de teste de controle do loop;

• A atualização da variável do loop de controle.

public class UsoFor

{


{



for (int i=1;i<=15;i++)

{

System.out.println ("O quadrado de "

+ i + " = " + i * i );

}

}

}

5 STRINGS

Uma seqüência de caracteres entre aspas é considerada uma string. No

Java, as strings são tratadas através de uma classe String e uma grande variedade

de métodos é fornecida para ajudá-lo(a) a trabalhar com cadeias de caracteres.

5.1 Classe Character

O tipo de dados char é usado para armazenar qualquer tipo de caractere.

Além desse tipo primitivo de armazenamento, a linguagem Java oferece uma classe

chamada Character, contendo métodos padrões para testar os dados contidos na

variável (tabela 9). Essa classe é um Wrapper do tipo de dados primitivo char. O

uso de wrapper é um meio prático com que o Java trabalha para adicionar

funcionalidades a um objeto. Nesse caso, a classe Character é um wrapper do tipo

de dados char e adiciona-lhe várias funcionalidades.

Tabela 9 – Métodos da classe Character



public class ExemploCharacter

{

public static void main(String[] args) throws Exception

{

char aChar;

System.out.println("Por favor entre com algum caractere");

aChar = (char)System.in.read();

System.in.read(); System.in.read();

if(Character.isDigit(aChar))

System.out.println(aChar + "é um número");

else

System.out.println(aChar + "não é um número");

if(Character.isLetter(aChar))

System.out.println(aChar + "é uma letra");

else

System.out.println(aChar + "não é uma letra");

if(Character.isWhitespace(aChar))

System.out.println("é um espaço em branco");

else

System.out.println("não é um espaço em branco");

if(Character.isLetter(aChar))

if(Character.isLowerCase(aChar))

System.out.println(aChar + "está em letras minúsculas");

else

System.out.println(aChar + "não está em letras minúsculas");

}

}

5.2 Objeto String

Uma variável String é um objeto da classe String que faz parte das

bibliotecas-base da linguagem Java e é importada automaticamente para todo

programa escrito em Java. Essa classe é a única com tratamento especial e não

pode ser instanciada sem o uso da palavra new. Na verdade, quando se atribui um

valor a uma variável do tripo String (tabela 10), usando apenas as aspas, a JVM

criará uma instância nova por meio de um comando new. Isso ocorre para que o seu

conteúdo seja sempre lido, se alterado, sua performance cai. Uma das



características importantes é que todos os métodos associados a essa classe não

alteram o conteúdo do objeto armazenado.

Essa classe também tem por finalidade o armazenamento de uma seqüência

de caracteres e possui um amplo conjunto de métodos. Por exemplo:

String str = "abc";

char data[] = {'a', 'b', 'c'};

String str = new String(data);

Tabela 10 – Métodos da classe String

public class TesteString

{

public static void main(String args[])

{

String str1 = "Hello";

String str2 = str1;

str2 = str2 + " world!";

System.out.println("str1 = " + str1);

System.out.println("str2 = " + str2);

}

}



5.3 Conversão de strings

Se uma String contém um conteúdo apenas de números, você pode convertê-

la para um número permitindo que se realizem operações aritméticas com os dados.

Para converter uma String para um inteiro, você utiliza a classe Integer, a qual faz

parte das bibliotecas-base do Java e é automaticamente importada para o seu

programa. O método parseInt() é parte da classe Integer e recebe o parâmetro em

forma de string e retorna um valor inteiro.

int eInt = Integer.parseInt(“100034”);

Para converter uma String para um double, você utiliza a classe Double, a

qual também faz parte das bibliotecas-base do Java e é automaticamente importada

para o seu programa. O método parseDouble() é parte da classe Doublé, recebe o

parâmetro em forma de string e retorna um valor double.

double doubleValor = Double.parseDouble(“100.35”);

Toda classe implementa o método toString, porque a implementação padrão

está na classe Object. Esse recurso também permite que se convertam dados de

qualquer tipo primitivo para String.

// Conversão: int para String

int i = 10;

Integer intObj = new Integer(i);

String str1 = intObj.toString();

// Conversão: String para int

String str = “10”;

Integer intObj = new Integer(str);

int i = intObj.intValue();

// ou

String str = “10”;

int i = Integer.parseInt(str);



6 ARRAYS

Como você já aprendeu, um array é uma lista de dados que possuem o

mesmo tipo de dados e estão associados a um mesmo nome na memória. Você cria

um array da mesma maneira que declara uma variável em Java, apenas adicionando

os sinais de abertura e fechamento de colchetes.

A declaração de um array em Java deve ser feita usando a seguinte sintaxe:

double[] Vendas = new Double[20];

Essa declaração reserva 20 alocações de memória para a variável Vendas.

Os elementos do array em Java são numerados a partir do 0 e, nesse caso, o índice

correspondente a cada elemento do array é usado entre 0 e 19, para o exemplo

acima.

Os trabalhos com array seguem as mesmas regras das variáveis em Java e

você também pode utilizar um array, com a definição do elemento a ser utilizado, da

mesma maneira que uma variável. Por exemplo:

System.out.println(Vendas[15]);

Para inicializar um array, e estabelecer um valor padrão para cada elemento,

você deve utilizar uma lista de valores separados por vírgulas e acompanhados de

chaves, por exemplo:

int[] Idade = {20,15,14,32,45};

Abaixo um exemplo de código Java usando array.

public class Arrays

{


{

int[] array1 = { 1, 2, 3, 4, 5 };

int[] array2;

array2 = array1;

for(int i = 0; i < array2.length; i++)

array2[i]++;

for(int i = 0; i < array1.length; i++)



System.out.println("array1["+i+ "] = "+array1[i]);

}

}

Você pode declarar arrays que contenham dados dos tipos inteiros e duplos e

também pode declarar conteúdos de qualquer tipo de dados, incluindo objetos.

Síntese

Nesta aula você avançou um pouco mais e passou a desenvolver programas

Java com o controle de fluxo de execução. Além disso, você aprendeu como

trabalhar com alguns aspectos particulares da OOP com Java, como a sobrecarga

de métodos.

Você também aprendeu como trabalhar com dados do tipo String e as várias

formas de trabalho com classes especiais no Java.

Estes dois assuntos também participam do núcleo essencial de

conhecimentos para a programação Java, e tenha certeza de que você irá utilizá-los

muito ainda neste módulo.

Na próxima aula vamos aprender mais alguns detalhes de implementação de

rotinas orientadas a objetos usando Java. Continuamos a nossa jornada na sua

formação.

Até a próxima aula.


1) O que é um Wrapper?

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________



2) Quais os tipos de loops suportados pela linguagem Java? Descreva cada um

deles.

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

3) Qual a vantagem em utilizar o modificador protected para uma variável?

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________



Aula 4

HERANÇA

Objetivos da aula


• Compreender como a herança em OOP funciona na

linguagem Java;

• Implementar herança, usando os vários elementos da

linguagem Java.

Conteúdos da aula



• Herança;

Herança de métodos.




Nesta aula você aprenderá um pouco mais sobre orientação a objetos

usando a linguagem Java. O foco principal da aula é tratar um pouco

sobre o relacionamento entre classes em Java. Quando falamos de herança,

estamos tratando de um assunto que muitas vezes parece assunto complexo, mas

na verdade é uma evolução natural dos assuntos até aqui tratados. Você verá ainda

que a similaridade com o mundo real é muito grande, já que os conceitos de herança

seguem as orientações com base nas interpretações que temos hoje sobre o

assunto.

Boa Aula!

1 HERANÇA

Herança é um recurso poderoso da linguagem Java que permite que novas

classes possam ser derivadas de classes existentes. As classes derivadas “herdam”

a interface da classe base e podem adicionar novos métodos ou alterar os

existentes, para atender um propósito particular. Qualquer quantidade de classes

pode ser adicionado a um esquema para produzir uma hierarquia de tipos

relacionados. A implementação de herança no Java é a base para o polimorfismo, o

qual permite que objetos de diferentes tipos possam ser tratados como se fossem do

mesmo tipo.

1.1 Introdução à Herança

Os programadores, trabalhando com linguagens orientadas a objetos,

visualizam classes e seu relacionamento com as demais,usando uma hierarquia de

tipos de relacionamentos. Dessa forma, os programadores generalizam as

características comuns de tipos similares em uma superclass. Na verdade, como

veremos mais adiante, toda clase base utilizada para a criação de outras classes é

considerada uma superclasse. Muitas das principais classes da plataforma Java

estão relacionadas através de herança. Veja a figura 23.

Toda classe Java, existente na plataforma ou criada pelo usuário, faz parte da

hierarquia usando herança, a menos que você explicitamente programe ao contrário,



as suas classes são derivadas de uma classe participante do núcleo da plataforma

Java: a classe Object. A classe object é o ancestral comum de todas as classes

Java e é a raiz da hierarquia das classes na plataforma. Isso é correto dizer porque

todas as classes Java, inclusive as criadas por você, herdam um conjunto padrão de

características da classe Object.

Figura 23 – Herança

1.2 Estendendo uma classe

O processo de definição de uma nova classe, que herda características de

uma classe existente, é chamado de extensão de uma classe. Você adiciona

campos e métodos em sua nova subclasse e lhe fornece novas capacidades ou

substitui métodos herdados da superclasse pela sobreposição, para customizar ou

implementar recursos adicionais. A linguagem Java possui recursos fáceis de serem

implementados para se obter herança múltipla, através do uso de interfaces. Uma

interface, assim como uma classe, é um tipo de dado. Definir uma interface é similar

à definição de uma classe, exceto que a interface poderá conter somente constantes

e métodos abstratos. Além disso, uma interface não pode ser instanciada.

Você pode definir uma classe para ser abstrata. Assim como as interfaces, as

classes abstratas não podem ser instanciadas, mas podem ser estendidas. O uso de

classes abstratas está direcionado para quando você desejar implementar um

método padrão em uma superclasse.



Na programação Java, a implementação de uma extensão da classe é feita pela

palavra chave extends. Toda classe Java implicitamente é estendida da classe

Object. Um exemplo da declaração da classe estendida:

class Fruta

{

int gramas;

int caloriasPorGrama;

}

class Citros extends Fruta

{

int acidoCitrico;

}

1.3 Classes abstract e final

Para prevenir que uma classe possa ser usada como superclasse, utilize a

palavra reservada final, com isso você irá garantir que a classe nunca será

estendida e seus métodos nunca sobrepostos. Algumas classes da plataforma Java

são final, como por exemplo algumas classes wrapper dos tipos primitivos de dados

do Java.

Há uma forma de você declarar uma classe para que ela sempre seja uma

superclasse e não possa ser instanciada: use a palavra reservada abstract. A partir

desse tipo de classe, você pode estendê-la ou criar outras subclasses a partir dela,

mas não poderá utilizar os meios para instanciar uma classe naturalmente. A única

forma de utilizar uma classe com esta característica é estendendo-a.

1.4 Implementando interfaces

Uma interface é como um documento de desenho com as características

externas da classe. Definindo uma interface, você determina métodos públicos que

precisam ser fornecidos pela classe quando estiver implementando-a. Uma interface

pode conter métodos, mas algumas restrições precisam ser observadas:

• Todos os métodos são abstratos;

• Você não pode definir a implementação de métodos em uma interface;



• Todos os métodos são públicos.

Uma interface pode conter campos, mas eles precisam ser static ou final,

somente dessa os dados contidos em uma interface podem ser constantes.

Para que uma classe possa estabelecer o vínculo com a interface criada, é

necessário utilizar a palavra chave implements. Quando uma classe implementa

uma interface, dizemos que a classe instanciou a interface.

public interface ControleRemoto

{

public void ligaTV();

public void desligaTV();

public void mudaCanalTV(int canalNovo);

}

public class TV implements ControleRemoto

{

public void ligaTV() {...}

public void desligaTV() {...}

public void mudaCanalTV(int canalNovo) {...}

}

2 HERANÇA DE MÉTODOS

Só há um caminho para chamar métodos herdados, é fazendo referência a

um objeto com a chamada vinculação dinâmica, para garantir que o método

chamado pelo objeto seja implementado ou herdado pela classe que o objeto

instanciou.

2.1 Usando construtores

Um objeto superclasse é criado na memória antes de um objeto subclasse em

todos os níveis da hierarquia.

Por padrão, o JVM chama o construtor da superclasse e não passa qualquer

parâmetro para o construtor. Isso significa que a superclasse possui um construtor

sem parâmetros. A linguagem Java realiza a inicialização de uma superclasse com



um método especial chamado super. Funciona como um construtor da superclasse

e permite que, a partir da subclasse, possamos utilizar membros da superclasse.

2.2 Efeitos da Herança

Em Java, métodos privados da classe base não são herdadas por suas

subclasses, mas todos os demais membros sim.

Além do uso das palavras reservadas public, private e default, para acessar

membros da classe base, existem mais dois modificadores de acesso que se

aplicam apenas às classes derivadas: Qualquer membro da superclasse declarado

como protected é acessível somente pelas classes que que são derivadas da

classe atual. Qualquer membro que foi declarado com private protected é acessível

somente pela classe que é derivada de uma classe que contém o membro. Vamos

considerar o seguinte exemplo:

public Class A

{

protected int x;

private protected int y;

}

O membro X é acessível em qualquer classe que for derivada da classe A,

bem como qualquer classe em um mesmo pacote da classe A. Já o membro Y

somente é acessível por qualquer classe que deriva diretamente da classe A

2.3 Sobreposição de métodos

Quando uma subclasse possui um método com a mesma assinatura de um

método da superclasse, essa situação é conhecida como sobreposição de

métodos.

class Fruta {

int gramas;

int calorias_por_grama;

Fruta()



{

gramas=55;

calorias_por_grama=0;

}

Fruta(int g, int c)

{

gramas =g;

calorias_por_grama =c;

}

void descascar ()

{

System.out.println(“Aqui eu descasco frutas”);

}

}

Síntese

Nesta aula você aprendeu mais uma parte importante da orientação a objetos,

usando a linguagem de programação Java. Você conheceu os conceitos que estão

associados a este recurso da linguagem e aprendeu como implementar a herança

em código Java.

Conforme nós vimos, a herança é parte fundamental do polimorfismo e está

amplamente utilizada na comunicação entre os objetos e classes de um programa

em OOP.

Na próxima aula vamos aprender como trabalhar com Interfaces Gráficas

usando Java. Esse é um assunto com uma riqueza visual que nos permite construir

soluções visualmente confortáveis para nossos usuários.

Até lá.




1) Qual a necessidade do uso dos modificadores final e abstract?

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

2) Qual a vantagem no uso da palavra super?

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

3) Qual a finalidade da palavra extends?

_________________________________________________________________

_________________________________________________________________

_________________________________________________________________

_________________________________________________________________



Aula 5

USANDO SWING E CRIANDO

APPLETS

Objetivos da aula


• Conhecer os conceitos sobre o desenvolvimento de

aplicações com interfaces gráficas;

• Identificar os componentes da plataforma Java para a

construção de aplicações gráficas;

• Detalhes os componentes Swing;

• Construir um applet.

Conteúdos da aula



• Interfaces Gráficas em Java;

• Componentes Swing;

• Gerenciadores de Layout;

• Applets.




Nesta aula você aprenderá um assunto muito exigido nas aplicações

atuais: as interfaces gráficas com o usuário. Na verdade, é um assunto

antigo mas foi através do advento do Macintosh e do Windows que realmente esse

método de envolvimento com o usuário recebeu toda sua potencialidade. Hoje são

raras as aplicações que não possuem uma interface gráfica, já que a grande maioria

dos computadores estão executando sistemas operacionais Windows ou Linux, além

do próprio Macintosh. A plataforma Java oferece uma ampla cobertura de recursos

para o suporte na construção de aplicativos com interface gráfica, inclusive, com as

últimas versões do JDK, os programadores receberam mais atenção em tecnologias

atuais que auxiliam na construção de interfaces.

A grande vantagem do Java é que a Sun implementou os mesmos

conceitos de portabilidade também para as bibliotecas que suportam a construção

de interfaces gráficas, o que permite uma aplicação gráfica ser executada e

apresentada da mesma forma em várias plataformas.

Boa Aula!

1 INTERFACES GRÁFICAS EM JAVA

Trabalhar com uma interface gráfica do sistema operacional, como é o caso

do Windows e das diversas interfaces disponíveis para Linux, é uma operação cada

vez mais comum hoje em dia. O principal apelo é a facilidade em realizar tarefas que

antes, em modo caractere, era muito mais trabalhoso. Concluímos, então, que o uso

de recursos gráficos nas suas aplicações será algo comum nos seus trabalhos como

programador. Antes de aprender como construir aplicações com recursos gráficos,

você precisa entender algumas orientações essenciais para esse tipo de

programação. É comum encontrarmos programadores que são exímios profissionais

da lógica booleana e de complexos algoritmos, mas com grandes dificuldades em

explorar as potencialidades das interfaces gráficas. O objetivo deste tópico é

despertar em você uma visão ampla sobre o assunto e compreender a importância

em seguir orientações e melhores práticas, com o objetivo de obter um resultado

superior em suas aplicações.



Um programa com interface gráfica está baseado em um modelo específico

de programação, chamada “orientada a eventos”. O usuário executa a maioria dos

eventos movimentando e clicando o mouse ou pressionando as teclas do teclado

(muitas vezes combinando as duas). Observe a figura 24.

Figura 24 – Aplicação Java com interface gráfica

Cada elemento visual é considerado um componente que pode ser

gerenciado a partir de um objeto particular. O termo controle é usado para

determinar os componentes que possuem interfaces gráficas e estão inseridos em

um contexto visual e de negócio. Controles como caixas de verificação, labels,

barras de rolagem, caixas de texto e caixa de listas são exemplos de componentes.

Alguns componentes, como o botão, são usados individualmente, outros são

chamados de “containers”, componentes que armazenam outros componentes. As

janelas, os painéis e as caixas de diálogo são containers.

Você pode utilizar uma das bibliotecas principais – chamadas gerenciadores

de layout – para controlar os arranjos dos componentes em um container. Para cada

container, você pode selecionar um gerenciador de layout que controlará o tamanho

e a posição dos componentes dentro do container. O obetivo da separação é

fornecer liberade para escolher o container que deseja e então selecionar o

gerenciador de layout em particular.

As bibliotecas Swing e AWT possuem a responsabilidade de como realizar o

desenho das interfaces gráficas.



Existem dois tipos de aplicações gráficas que podem ser criadas em Java:

• Componentes iniciados a partir de um navegador (applets);

• Aplicações locais iniciadas a partir do sistema operacional.

Ambas capturam eventos do sistema e são desenhadas sobre um contexto

gráfico que é fornecido pelo sistema e pela JVM.

1.1 Component

A classe Component representa um objeto que tenha uma representação

gráfica, como botões, campos de textos, choices, etc. (tabela 11). Essa classe define

o comportamento básico para a maioria dos componentes visuais do pacote AWT

(todos os métodos definidos nesta classe estarão disponíveis para todos os

componentes visuais do AWT, bem como todos os recipientes).

Tabela 11 – Métodos da classe Component

1.2 Container

Um container é uma categoria especial de componente gráfico que pode

conter outros componentes ou mesmo outros containers (figura 25). Todos os

containers são componentes, mas nem todos os componentes são containers. Um

applet, uma janela e um painel são exemplos de container. Um container (painel)

pode ser inserido dentro de outro. Cada container possui associado um gerenciador



de layout para controlar a maneira pela qual seus componentes serão mostrados

(tamanho e posição).

Figura 25 – Containers do pacote AWT

1.3 Window

Uma Window é uma janela sem barra de título e borda, necessariamente tem

que estar associada com outro objeto da classe Frame (janela) para que possa

existir. A classe Window especializa a classe container, logo, poderá conter outros

componentes internamente. A classe Window normalmente é utilizada para

implementar janelas pop-up e, quando um objeto da classe Window é criado,

automaticamente é associado a ele o gerenciador de layout BorderLayout (tabela

12).

O construtor Window é responsável por construir um objeto da classe Window

invisível que estará vinculado ao objeto Frame (janela) previamente instanciado.



Tabela 12 – Métodos da classe Window

1.4 A biblioteca AWT

Inicialmente, a Sun criou um pacote de classes visuais chamado Abstract

Window Toolkit (AWT), que possui as classes representativas dos objetos de um

programa visual (figura 26). Esse é o antigo conjunto de ferramentas para o

desenvolvimento de interfaces gráficas na linguagem Java. A criação de interfaces

gráficas AWT consiste:

• Na instanciação de objetos do tipo Component (botões, textos etc.);

• Na criação de recipientes ou objetos da classe Container (janelas, painéis

etc.) para receber os componentes criados;

• Na adição dos componentes aos recipientes, com base num sistema de

coordenadas (especificando a localização da inserção) ou via utilização de

gerenciadores de layouts que se encarregam de definir a localização e

aspecto visual dos componentes inseridos nos recipientes.



Figura 26 – Hierarquia de eventos AWT

1.5 JFC

O Java Foundation Classes (JFC) fornece um poderoso e flexível suporte

para a criação de aplicações gráficas. O objetivo da JFC é simplificar o

desenvolvimento de programas 100% Java para ambientes de rede e estações

locais. Através das classes, você pode desenhar aplicações para refletir o sistema

operacional que está armazenando à JVM, ou criar sua própria interface gráfica, ou

utilizar o visual dos recursos da plataforma Java e das implementações da JVM.

São cinco APIs (Application Programming Interface) que compõem a JFC: a

API AWC e a Swing API são os elementos fundamentais para a criação de

interfaces gráficas. A Java2D API fornece um conjunto de recursos para, através da

AWT, permitir que aplicações avançadas sejam criadas, especificamente para a

manipulação de imagens e desenho em 2D. A Accessibility API fornece uma

interface de programação necessária para apoio às aplicações voltadas para

tecnologias assistidas, para pessoas com alguma deficiência física. A Drag and

Drop API fornecem suporte à transferência de dados entre duas aplicações Java e

entre uma aplicação Java e uma aplicação nativa do sistema operacional (figura 27).

Para programar uma aplicação gráfica ou um applet, você precisa referenciar

pacote java.awt em sua aplicação. Dentro desse pacote, a AWT encapsula as



características específicas da plataforma para a implementação de uma aplicação

gráfica Java. Essa classe é a ponte entre as particularidades de cada plataforma e

as primitivas gráficas da plataforma Java, responsáveis pelo desenho das interfaces

gráficas.

Figura 27 – Java Foundation Classes

1.6 Swing API

O conjunto de componentes fornecidos pela AWT é adequado para tarefas

simples, mas possui algumas limitações. Por exemplo, a dificuldade na criação de

um novo tipo de componente a partir de uma implementação de subclasse

Component, porque ele exige que seja criado por objeto.

Na versão 1.1 da plataforma Java, a AWT introduziu, para a criação leve de

componentes gráficos, um framework que estende as classes java.awt.Component

e a java.awt.Container, sem a necessidade de criar componentes nativos. A Swing

API está contruída sobre essa framework e fornece um conjunto de componentes

que são completamente independentes de plataforma e sem a necessidade de gerar

código para uma plataforma em particular.

A Swing API (tabela 13) possui 100% dos componentes da AWT, mais

componentes adicionais que também são 100% Java, ou seja, a biblioteca não



possui nenhum código dependente de plataforma, é composta de mais de 250

classes e 75 interfaces agrupadas nas seguintes categorias:

• Um componente chamado JComponent, que estende a classe de container

da AWT e o conjunto de componentes que são subclasses

• do JComponent. Todos esses componentes possuem em seu nome a letra

inicial J;

• Classes de suporte não visíveis, que fornecem serviços importantes, como

classes de eventos e o modelo de implementação, parte do Swing

responsável pelo modelo de Design;

• Um conjunto de interfaces relacionadas, implementadas pelos componentes

Swing, e classes de suporte da API.

Tabela 13 – Componentes Swing

As aplicações Java que possuem interface gráfica, utilizam componentes

Swing e componentes AWT, juntos, em uma mesmoa direção (figura 28). Os

componentes Swing utilizam os mesmos gerenciadores de layout, eventos dos

objetos e interfaces, assim como os componentes AWT.



Figura 28 – Hierarquia de classes AWT e Swing

2 Componentes Swing

2.1 JComponent

Fornece uma aparência que pode ser especificada pelo programador ou

(opcionalmente) selecionada pelo usuário, em tempo de execução, além disso,

permite a criação de componentes personalizados. Uma borda que implicitamente

define os limites do componente e possui a habilidade para definir o tamanho

máximo, mínimo e preferido de um componente. Fornece o recurso de ToolTips --

descrições curtas quando o cursor passa sobre um componente. Também fornece o

recurso de Autoscrolling, quando ocorre a rolagem automática em lista, tabelas ou

árvore, ao arrastar o mouse sobre eles, com o botão pressionado (tabela 14).

Todos os componentes possuem dois modos de cores associados: a de fundo

(background) e a de frente (foreground). A JFC introduz o conceito de um

componente “lightweight”, com um fundo transparente que permite ver o que está

atrás do componente. O componente transparente não faz uso de cores de fundo. A

classe JComponent possui os métodos isOpaque, que retorna false, se o

componente for transparente, e setOpaque(boolean b), que permite alterar essa

propriedade.



Tabela 14 – Métodos da classe JComponent

2.2 Frame e JFrame

Uma Frame é uma janela com uma barra de título e uma borda. A classe

Frame especializa a classe Window que, por sua vez, especializa a classe container.

A classe Frame implementa a interface MenuContainer, logo, uma frame pode ter

uma barra de menu associada a ela.

Frames são geralmente usadas para construir aplicações, mas também

podem ser usadas com applets. Se uma aplicação tem uma janela dependente de

outra (que desaparece quando a outra é iconificada, por exemplo), então deve-se

utilizar Dialog ou Window para essa janela. A classe Frame, por padrão, não fornece

ao usuário mecanismos para ser fechada com o clique do mouse no botão para

fechar a janela (x).

Quando um programa Java inicia com uma Interface Gráfica, vemos a janela

onde a aplicação irá fazer as interações com o usuário, usando o teclado e o mouse.

No Swing, a interface principal da aplicação é implementada pelo componente

javax.swing.JFrame. Assim como outros componentes, o JFrame é derivado do

controle da AWT e segue a estrutura hierárquica dos componentes AWT e Swing.

Quando criado, o JFrame possui um único filho, o container, uma instância da

classe JRootPane que pode gerenciar outros 4 componentes: um JLayeredPane, um

ContentPane, um MenuBar e um GlassPane tabela 15).

JRootPane é gerenciado de forma a cobrir a superfície inteira da JFrame,

exceto a barra de título e o tamanho da barra. A classe MenuBar class encapsula os



conceitos da plataforma para os limites da barra de menu para uma janela. O

objetivo é associar a barra de menu com um objeto Frame, chamando o método

setMenuBar (figura 29).

Tabela 15 – Métodos da classe JFrame

import javax.swing.*;

public class BasicFrame extends JFrame {


BasicFrame bf = new BasicFrame �

("Exemplo de Janela Java");

}

BasicFrame (String title) {

super(title);

setSize(250, 200);

setVisible(true);

}

}

Figura 29 – Janela JFrame



2.3 JPanel

A classe JPanel (painel) é uma sub-classe de JComponent. Tem o propósito

de agrupar componentes para serem posteriormente inseridos em outro container e

permitem a criação de layouts sofisticados. Podem conter componentes incluindo

outros painéis e utiliza o gerente de layout FlowLayout como padrão.

import java.awt.*;


public class PanelDemo {

private JPanel painelAzul;

private JPanel painelVermelho;

private JFrame janelaDemo;

public PanelDemo() {

painelAzul = new JPanel();

painelVermelho = new JPanel();

janelaDemo = new JFrame();

painelAzul.setBackground(Color.blue);

painelVermelho.setBackground(Color.red);

painelAzul.setSize(50,50);

painelVermelho.setSize(100,100);

janelaDemo.getContenPane().setLayout(null);

janelaDemo.setSize(200,200);

janelaDemo.getContentPane().add(painelAzul);

janelaDemo.getContentPane().add(painelVermelho);

painelAzul.setLocation(10,10);

painelVermelho.setLocation(10,70);

janelaDemo.setVisible(true);

}


PanelDemo p = new PanelDemo();

}

}



2.4 JDialog

Um JDialog é uma janela com uma barra de título. As caixas de diálogos são em

geral usadas para obter/mostrar informações do/para o usuário.

O swing fornece um rico conjunto de diálogos que permite interações básicas

com o usuário, sem a necessidade de escrever muito código (tabela 16).

Alguns aspectos importantes sobre caixas de diálogo:

• Caixas de diálogos podem ser modais ou não-modais;

• Caixas modais não permitem que outras janelas sejam acessadas até que a

caixa de diálogo seja fechada;

• Caixas não-modais permitem que outras janelas sejam manipuladas

simultaneamente à janela de diálogo;

• BorderLayout é o gerente de layout usado implicitamente por caixas de

diálogos.

Tabela 16 – Construtores JDialog

JDialog utiliza uma estrutura de camadas como a classe JFrame (tabela 17. Assim,

ao adicionarmos um componente, devemos utilizar o ContentPane:



dialog.getContentPane().add(comp1);

Tabela 17 – Métodos da classe JDialog

2.5 JLabel

JLabel é uma área onde textos não editáveis e imagens podem ser

mostrados. São rótulos usados para informações ou instruções textuais na interface

gráfica, mostrando um texto não editável na posição selecionada. Uma vez criado

um rótulo, programas raramente modificam seu conteúdo.

Os construtores da classe JLabel são:

public JLabel()

public JLabel (String s)

public JLabel (String s, int alignment)

public JLabel(String text,

Icon icon,int horizontalAlignment)

public JLabel(Icon icon, int horizontalAlignment)

Para avaliarmos como implementar uma classe JLabel, avalie o código Java

abaixo:

import java.awt.*;


public class TesteLabel

{


{

JFrame fr = new JFrame();

JLabel lb = new JLabel(“Texto em baixo”,

new ImageIcon(“duke.gif”),

SwingConstants.LEFT);

lb.setHorizontalTextPosition(SwingConstants.CENTER);

lb.setVerticalTextPosition(SwingConstants.BOTTOM);

fr.getContentPane().add(lb);



fr.pack();

fr.setVisible(true);

}

}

2.6 JTextComponent

A classe JTextComponent (tabela 18) é uma abstração de um componente

que recebe inserções de textos do usuário. É a super-classe abstrata de duas

classes com funcionalidades em comum: JTextField e JTextArea e seus métodos e

atributos são compartilhados.

Tabela 18 – Métodos da classe JTextComponent

3 GERENCIADORES DE LAYOUT

Embora seja possível posicionar objetos em coordenadas fixas (x, y), deve-se

evitar essa prática em Java. Isso causa problemas de portabilidade: outras JVMs,

GUIs e Window Managers terão fontes e outros elementos em tamanhos e



proporções diferentes. Baseados em regras, os Layout Managers calculam as

coordenadas automaticamente.

Há 6 gerenciadores de layout pré-definidos no pacote java.awt.*:

• FlowLayout;

• GridLayout;

• BorderLayout;

• CardLayout;

• GridBagLayout;

• BoxLayout.

Implicitamente, cada container possui um gerenciador de layout default

associado. Assim, se não for declarado nenhum gerenciador de layout para o

container, será usado o layout default. Um programador pode também criar novos

gerenciadores de layout.

Para escolher um gerenciador de layout adequado para suas necessidades,

considere o seguinte:

• Se você precisa mostrar alguns componentes utilizando os seus tamanhos

naturais em uma linha, use o FlowLayout. Se você precisa mostrar

componentes de mesmo tamanho em linhas e colunas, use o GridLayout;

• Se você precisa mostrar painéis alternativamente, use o CardLayout;

• Se você precisa mostrar componentes e espalhá-los utilizando todo

espaço disponível, utilize o BorderLayout ou GridBagLayout.

Cada container tem um gerenciador de layout default:

• JPanel (incluindo JApplet) � FlowLayout

• WindowBorderLayout � BorderLayout

• JmenuBar � BoxLayout

Para utilizar um gerenciador de layout diferente do default, você precisa criar

uma instância do gerenciador de layout desejado e avisar ao container para usá-lo:

aContainer.setLayout(new CardLayout());

// ou

CardLayout meuCardLayout = new CardLayout();

aContainer.setLayout(meuCardLayout);

// ou



aContainer.setLayout(null); //sem gerenciador

Os métodos add, remove e removeAll (que adiciona e removem

componentes) podem ser utilizados a qualquer momento, mas se você muda o

tamanho de um componente indiretamente (por exemplo, mudando a sua Font),

invocar o método invalidate para o componente e, logo após, invocar o método

validate para o container.

Os métodos getPreferredSize e getMinimumSize podem retornar valores

sem significado (os seus valores são válidos somente após o componente ter sido

mostrado a primeira vez).

4 EVENTOS

Quando o usuário interage com uma interface de aplicativo final (teclado,

mouse etc), provoca o disparo de alguma ação: o evento. Eventos são objetos que

descrevem a ação ocorrida. Qualquer objeto pode ser notificado de um evento.

Existem vários tipos de classes de eventos para tratar as diversas categorias

de ações desencadeadas pelo usuário final.

É necessário incluir a instrução import java.awt.event.* .

4.1 Como os eventos são processados?

Através de um modelo de delegação de eventos, os componentes da AWT

implementam rotinas de manipulação de eventos (listener) com o objetivo de recebê-

los. O componente que gera o evento é chamado de fonte do evento (event

source). O componente que trata o evento é chamado de manipulador de evento

(event handler) ou ouvinte de evento (event listener).

Normalmente, a manipulação do evento é delegada para uma classe separada do

componente-fonte desse evento.

import java.awt.*;

import java.awt.event.*;


public class TesteEvento {




{

JFrame j = new JFrame("Teste de evento");

JButton b = new JButton("Pressione-me!");

b.addActionListener(new ActionDemo());

j.getContentPane().add(b, BorderLayout.CENTER);

j.pack();

j.setVisible(true);

}

}

class ActionDemo implements ActionListener {

public void actionPerformed (ActionEvent e){

System.out.println("Acao executada");

}

}//classe externa de tratamento do evento

5 APPLETS

Java Applets são mini-programas gráficos que executam em um contexto de

outro programa, também são conhecidos como containers. A Internet foi a grande

alavancadora da tecnologia, considerando que seu uso ficou mais explorado em

páginas Web. Um applet não é uma aplicação convencional em Java. Na verdade é

um mini-programa chamado a partir de um programa maior, como um visualizador

de applets ou um navegador compatível com a tecnologia Applet. Por isso, um

applet precisa de um outro programa, sempre, para que possa ser executado. Isso

significa que o visualizador ou o navegador implementam as funções mais comuns

para applets e fornecem estas funções para o applet, através da Java API. É o

container que controla a execução do applet.

Um applet é gráfico por natureza. Ocupa um painel retangular na janela de

visualização do container. Os applets podem ser vinculados em uma página Web,

assim como uma imagem é vinculada a uma página.

import java.applet.*;

import java.awt.*;

public class exemploApplet extends Applet

{



public void paint (Graphics g)

{

g.drawString (“Exemplo de Applet”, 25, 50);

}

}

Todo applet é uma extensão da classe java.applet.Applet. A classe base

Applet fornece métodos que derivam da classe Applet e que, por sua vez, mantém a

comunicação entre o container e a aplicação.

Os métodos associados à instanciação dentro de um navegador:

• Obter parâmetros do applet;

• Obter a localização de rede de um arquivo HTML que contém o applet;

• Obter a localização de rede de um applet em um diretório de classes;

• Imprimir na barra de status do navegador;

• Preencher e apresentar uma imagem;

• Preencher e tocar um arquivo de áudio;

• Alterar o tamanho do applet.

Além disso, a classe Applet fornece uma interface na qual o container, no

caso o navegador, obtém informações sobre o applet, controlando-lhe a execução.

Dessa forma, quando instanciado no container:

• Requisita informações sobre o autor, versão e copyright do applet;

• Requisita uma descrição dos parâmetros que o applet reconhece;

• Inicializa o applet. Nesse caso, o evento init executado quando o applet é

carregado ou recarregado;

• A execução do applet é iniciada. Nesse momento o evento start será

executado após o método init ou quando a página é recarregada;

• Pára a execução do applet. É quando o evento stop é executado. Quando

o usuário muda de página, continuando na memória, ou quando a

execução do browser é encerrada;

• Finalmente, há o evento destroy executado quando a applet for removido

da memória.

Para chamar um applet de uma página Web, o código deve ser o seguinte:



<html>

<title>Exemplo de uso de applet em página HTML</title>

<hr>

<applet code=”exemploApplet.class” width=320 height=120>

Se o seu navegador é compatível com Java, uma mensagem “Exemplo de

Applet” deverá aparecer aqui.

</applet>

<hr>

</html>

Síntese

Nesta aula você aprendeu como construir programas com interfaces gráficas.

Não é uma tarefa simples, mas a versão mais atual do Java, oferece um grande

conjunto de melhorias e as instruções necessárias para a construção de aplicações

gráficas está muito facilitado.

Você viu também como trabalhar com Applets. Tipo de aplicação que tem

muita procura a ser atendida, já que através deles é possível gerar uma interação

entre um programa convencional Java e recursos de uma página Web.

Na próxima aula, vamos falar mais sobre como utilizar objetos com Java para

expandir ainda mais as capacidades de nossas aplicações.

Até lá.


1) Qual a vantagem do uso de gerenciadores de layout nos trabalhos de

construção de interfaces gráficas em Java?

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________



2) Diferencie uma aplicação Java de um applet Java?

_________________________________________________________________

_________________________________________________________________

_________________________________________________________________

_________________________________________________________________



Aula 6

TRABALHANDO COM OBJETOS

Objetivos da aula


• Compreender os desafios do desenvolvimento

corporativo e as soluções baseadas em Java que fornecem

suporte às soluções;

• Identificar a construção de componentes de software

usando Java;

• Fazer aplicações Java, operando em ambientes

distribuídos, inclusive na Internet.

Conteúdos da aula



• Introdução ao J2EE;

• Usando Java Beans;

• Java em rede;

Java Server Pages e Servlets.




À medida que as aplicações Java cresceram em amplitude de uso e

possibilidades de negócios, novas demandas foram surgindo para a

plataforma. O uso do Java em ambiente corporativo gerou exigências como,

capacidade de gerenciamento de grande volume de dados, regras de negócios

complexas e dinâmicas e grande volume de usuários simultâneos. O ambiente

transacional de hoje espera tecnologias que atendam questões como segurança,

distribuição, velocidade e resiliência.

Nesta aula, vamos conhecer os componentes da plataforma Java que

oferecem respostas para as mais diversas finalidades nas aplicações corporativas.

No centro desta aula estará o conceito de objetos distribuídos no Java, como

também o conceito de aplicações empresariais que necessitam de alta capacidade

de processamento.

Finalmente, vamos falar um pouco de como a linguagem Java oferece

suporte ao desenvolvimento Web.

Tenha uma boa aula.

1 J2EE

J2EE, ou Java 2 Enterprise Edition, é uma plataforma para desenvolvimento

de aplicações distribuídas. Apresenta facilidades para a utilização dos recursos

computacionais e distribuídos tais como acesso a banco de dados, componentes

Web, utilização de mensagens assíncronas, execução de processos transacionais,

persistentes e outros.

Apresenta uma API, especificada pela Sun MicroSystems, que proporciona

um padrão para a implementação dos diversos serviços que oferece. Pode ser feito

diferentemente por várias empresas, de formas distintas, mesmo oferecendo as

mesmas facilidades, por estarem de acordo com as especificações impostas para a

sua construção. Um programador que já tenha tido contato com a linguagem Java e

suas APIs na J2SE (Java 2 Standart Edition), não terá muitas dificuldades no

entendimento e na utilização de J2EE. O que precisa é entender os detalhes da

arquitetura e onde se encontra cada componente e seus recursos. É necessário

ambientarmo-nos nesse contexto para fazermos uso correto da plataforma.



1.1 Arquitetura J2EE

A arquitetura J2EE se apresenta em várias camadas, cada uma é composta

por componentes e serviços providos por um container.

Um exemplo é o uso de páginas HTML em um Web Browser numa simples

navegação, em um site qualquer. Podemos entender como container, o próprio

navegador que fornece recursos e facilidades para o componente, no caso, as

páginas HTML. O componente, por sua vez, pode oferecer diversos serviços ao

usuário, pelo suporte do container, proporcionando facilidades visuais como: botões,

hiperlinks, figuras e tabelas, e o próprio serviço de navegação.

Em um servidor J2EE (figura 30), podemos ter diversos containers interagindo

entre si.

Figura 30 – Arquitetura J2EE (fonte: Sun)

• Camada cliente: acesso por meio de interfaces standalone (aplicações Java),

páginas HTML ou Applets. Nessa camada, os componentes residem em um

Applet Container, em um HTML container (Web browser) ou em um



Application Client Container. O Applet container, fornece recursos para um

componente Applet executar e se tornar funcional para o usuário. O Web

Browser apresenta recursos e funcionalidades para o uso de páginas HTML.

Por fim, o Application Client container fornece recursos para a execução da

classe standalone utilizados pelos usuários para interagirem no sistema;

• Camada Web: implementada por JSPs e Servlets, fornecem a lógica para a

camada cliente ( ou de apresentação ) do negócio. JSPs e Servlets residem

no Web Container. JSPs oferecem a facilidade de utilizar algumas lógicas de

apresentação em uma página web sem muitas dificuldades tecnológicas. O

Servlet apresenta-se como um controlador das ações executadas pelos

usuários nas páginas de apresentação e fornece recursos para obter dados

dessas ações e realizar as operações desejadas. Os componentes Web

residem no Web Container que pode ser um servidor TomCat ou outro similar;

• Camada de Negócios: trata da lógica de negócio da aplicação. É nela que

implementamos todas as regras de negócio, alocação de recursos,

persistência de dados, validação de dados, gerência de transações e

segurança, providos por componentes conhecidos por EJBs, que residem no

EJB Container;

Camada EIS Enterprise Information System, ou Sistema de informações

empresariais: nessa camada se encontram os sistemas de banco de dados,

sistemas legados, integração com outros sistemas não J2EE, etc.

2 USANDO JAVABEANS

O principal objetivo dos programadores é integrar componentes de software.

Tornando esssa façanha uma realidade, construiriam aplicações corporativas de

forma mais rápida e segura. O objetivo de criar componentes de software

reutilizáveis e intercambiáveis é um modelo definitivo na engenharia de software

para aplicações distribuídas. O modelo de componentes JavaBeans fornece um

framework para criar, reutilizar e empacotar componentes de software. Então, o

principal objetivo em utilizarmos JavaBeans é acelerar o processo de construção de

componentes reutilizáveis, usando métodos já disponíveis nas classes JavaBeans.

Normalmente, são pequenas aplicações visuais que têm por finalidade ampliar a

capacidade de construção de software com interface gráfica (GUI).



Para criar uma classe JavaBeans, você deve se utilizar dos pacotes

java.beans e java.beans.context, que estão incluídos no J2SE. É importante

observar que não existe uma superclasse que compreenda todas as extensões

JavaBeans e que também não apresenta um modelo centralizado de interfaces para

implementar JavaBeans.

Como o objetivo é a criação de componentes que serão utilizados em

interfaces gráficas, um JavaBean expõe membros de sua implementação através de

três elementos importantes:

• Métodos: um método representa alguma ação que pode ser executada

pelo JavaBean;

• Propriedades: uma propriedade representa um atributo de um JavaBean,

como a sua cor ou tamanho da fonte;

• Eventos: os objetos JavaBean utilizam eventos para notificar outros

objetos sobre algum evento ocorrido. Esses objetos são os mesmos

conceitos que já vimos em orientação a eventos usando Swing.

Para trabalhar com JavaBeans, é importante que você compreenda os

conceitos fundamentais sobre o modelo de desenvolvimento e sua terminologia

(tabela 19). Na verdade, os conceitos se utilizam de muitas informações sobre a

linguagem Java e por isso, você não terá muita dificuldade em conhecê-los.

Tabela 19 – Terminologia JavaBean



a) Além da terminologia, é importante também você entender como o processo de desenvolvimento de um JavaBean acontece e qual o seu uso. O principal usuário de um JavaBean é um programador. O objetivo é acelerar o processo de desenvolvimento para um programador, através de objetos pré-construídos que venham a atender uma finalidade específica (figura 31). Por isso, existem três profissionais programadores envolvidos no processo: aquele que cria ferramentas para o consumo de JavaBeans, aquele que cria um JavaBean e aquele que consome o JavaBean. b)

Figura 31 – Processo JavaBean

O importante no processo é que, uma vez criado o componente

JavaBean, poderá ser reutilizado por vários programadores e poderá ficar disponível

em qualquer ambiente IDE que seja compatível com o modelo JavaBean.

Para conhecer mais sobre a especificação JavaBean, acesse o seguinte

endereço:

http://splash.javasoft.com/beans/spec.html

2.1 Enterprise JavaBeans

A especificação Enterprise JavaBeans (EJB) descreve um modelo para

componentes Java que foram construídos para serem instalados e disponibilizados a

partir de um servidor. A conexão entre os componentes EJB e o JavaBeans referem-

se a um modelo de programação da linguagem Java. Exceto pela similaridade dos

nomes, são poucas as similaridades funcionais entre os dois modelos.



Apesar de estar baseada nos conceitos do JavaBeans, a especificação EJB

não inclui as mesmas regras de programação do JavaBeans. Os componentes EJB

são destinados para o uso em soluções três camadas e em ambientes de redes de

computadores, com a finalidade de compartilhamento de objetos através de vários

sistemas.

Os componentes EJB possuem somente a lógica necessária para um

processo de negócio, ou seja, você pode desenvolver componentes que possuam

apenas código de programação, que poderá ser armazenado em algum servidor da

rede e permitirá ser utilizado “remotamente” por aplicações nas estações da rede

local.

a) Normalmente, os componentes EJB são disponibilizados em um servidor por um software chamado “servidor de aplicações”. Os aplicativos em Java se comunicam com um servidor de aplicações na rede, que disponibiliza objetos a serem consumidos de acordo com determinadas condições. No servidor de aplicações, os componentes EJB ficam localizados em um container EJB que controla todos os detalhes para a criação, ativação e destruição das instâncias de um componente EJB. Ele também controla as complexas atividades de controle de transações e segurança, fazendo com que os componentes distribuídos possam receber funcionalidades essenciais, sem a necessidade de serem explicitamente implementadas no código do componente.

Para criar uma classe EJB, você deve definir uma classe que execute uma

determinada regra de negócio e adicionar os métodos para uma interface EJB. O

servidor precisa fornecer as implementações que estejam de acordo com a

especificação EJB para então disponibilizá-lo em um servidor de aplicações.

3 TRABALHANDO COM JAVA EM REDE

3.1 Trabalhando com URLs

Para muitos programadores, a necessidade para programar soluções para a

Internet, mais especificamente para a Web, foi uma das razões para aprender a

linguagem de programação Java. Diferente de muitas outras linguagens, o Java foi

desenhado para atuar com bastante facilidade nas tecnologias da Internet. O J2SE

SDK oferece um pacote java.net, específico para realizar conexões através de uma

rede de computadores e executar comandos de entrada e saída para os

computadores remotamente.



Uma aplicação para esse pacote é o uso em URLs. Os endereços de sites na

Web utilizam um protocolo de comunicação, que você já conhece, chamado HTTP

(Hypertext Transfer Protocol). O pacote java.net contém classes que foram

construídas ao redor dos padrões HTTP. As classes essenciais para esta operação

são a URL e a URLConnection. Basicamente, você obtém acesso ao arquivo que

está sendo transferido através do protocolo e pode processar o seu conteúdo de

acordo com a sua necessidade. Você também pode conectar-se a um servidor URL

e executar uma série de operações para a criação e leitura de conteúdo no site.

a) O caminho mais seguro para a comunicação com o servidor URL é pela classe URLConnection. Realizada a conexão, você poderá requisitar ou enviar informações, porém uma URLConnecetion é fechada automaticamente após a troca de dados ter sido concluída e você não pode manter uma conexão por um período longo. Dessa forma, você precisa restabelecer a comunicação com o servidor a cada necessidade de troca de informações.

package examples.network;

import java.net.*;

import java.util.Date;

public class ObjetosURL{

public static void main(String[] args){

try{

URL sunPage = new

URL(“http://www.sun.com”);

URLConnection sunPageConn=sunPage.openConnection();

Date lastModified=new Date(sunPageConn.getLastModified();

System.out.println(sunPage+” foi modificada pela �

última vez em “+lastModified);

catch(Exception x){

System.out.println(x);

}

}

}

3.2 Usando RMI

O RMI (Remote Method Invocation) é uma tecnologia utilizada pelos

programadores para chamar diretamente métodos de objetos Java, que residem em



outros sistemas. Nessa abordagem, você não precisa estabelecer uma referência

para um objeto que está em um sistema remoto. Ao invés disso, estabelece uma

referência para um stub object, substituto local para o objeto remoto. O stub retorna

um objeto local por um ORB (Object Request Broker), em resposta à sua solicitação

para localizar um objeto. Um stub object possui os mesmos métodos suportados

pelo objeto remoto, mas, ao invés de executar métodos independentemente,

encaminha os parâmetros para o objeto remoto e passa de volta qualquer retorno de

valor do método. A técnica utilizada para encaminhar os parâmetros para um objeto

remoto é chamada de marshaling. Após o marshaling, os parâmetros são

serializados em um arquivo de bytes e enviados para o sistema remoto, que possui o

objeto, recebe o arquivo e utiliza a técnica chamada unmarshaling para

desserializar o conteúdo dos parâmetros e, conseqüentemente, executar o método.

Caso tenha valor de retorno, ele é enviado de volta ao processo original, realizando

as mesmas operações no caminho inverso. Observe esse processo na figura 32.

Figura 32 – Processo RMI

a) Você pode utilizar uma combinação de classes servidora e cliente para colocar uma classe remota para funcionar. Essencialmente, o programa servidor criará um objeto remoto e irá registrá-lo como um serviço e o programa cliente irá localizar esses objetos, usando o serviço para obter as referências.

Por padrão, os objetos nomeados para os serviços são registrados e

disponibilizados através de um serviço no servidor. O serviço de registro abre um

canal de comunicação com os clientes através da porta 1099, padrão do RMI.



Exemplo de uma classe servidora RMI:


import java.rmi.Naming;

import java.rmi.RMISecurityManager;

/** Um programa server-side que cria e registra

* objetos StudentImpl com um registro RMI para uso pelos

* clientes

*/

public class StudentEnrollment {

public static void main( String[] args ) {

if ( System.getSecurityManager() == null ) {

System.setSecurityManager(

new RMISecurityManager() );

}

try {

StudentImpl[] students = {

new StudentImpl( 1001, "Elaine Jones" ),

new StudentImpl( 1002, "Patricia Hartswell" ),

new StudentImpl( 1003, "Darius Smith" ),

new StudentImpl( 1004, "Mary Bagshaw" ),

new StudentImpl( 1005, "Henry Miller" )

};

for ( int i = 0; i < students.length; i++ ) {

int id = students[i].getID();

Naming.rebind( "Student" + id , students[i] );

}

System.out.println( "Student objects bound." );

} catch ( Exception x ) {

x.printStackTrace();

}

}

}

Exemplo de uma classe cliente RMI usando a classe acima:


import java.rmi.Naming;

import java.rmi.RMISecurityManager;

/** Um programa cliente para acessar e atualizar os



* objetos no servidor

*/

public class StudentClient {

private static final String HOST_NAME = "localhost";

public static void main( String[] args ) {

if ( System.getSecurityManager() == null ) {

System.setSecurityManager(

new RMISecurityManager() );

}

try {

Student s1001

= (Student) Naming.lookup( "//" + HOST_NAME

+ "/Student1001" );

Student s1005

= (Student) Naming.lookup( "//" + HOST_NAME

+ "/Student1005" );

System.out.println( s1001.getName() );


System.out.println( s1001.getCredits() );

s1001.addCredits( 3 );

s1001.setName( "Elaine Goldman" );


System.out.println( s1001.getCredits() );

} catch ( Exception x ) {

x.printStackTrace();

}

}

}

3.3 Java Server Pages e Servlets

a) A Internet e a linguagem Java já estão muito maduras em seu relacionamento. A Internet já é uma realidade para a disponibilização de informações mundiais, através de um mecanismos simples e acessível à grande maioria das pessoas. Isso fez com que ocorresse uma mudança fundamental na forma como os programadores constróem aplicações, pois agora temos uma nova plataforma para o desenvolvimento das aplicações e com muitas tecnologias envolvidas. Isto faz com que o progamador Java precise conhecer um amplo conjunto de conhecimentos para desempenhar com competência a construção de aplicações para a Web. Neste tópico vamos falar exclusivamente das duas tecnologias Java que suportam o desenvolvimento Web: páginas JSP e Servlets.



3.4 O que é um servlet?

Servlets são classes Java, desenvolvidas de acordo com uma estrutura bem

definida, e que podem tratar requisições recebidas de clientes, quando instaladas

junto a um Servidor que implemente um Servlet Container (um servidor que permita

a execução de Servlets, muitas vezes chamado de Servidor de Aplicações Java)

(figura 33).

Veja um exemplo de um Servlet:

import java.io.*;

import java.util.Date;

import javax.servlet.*;

import javax.servlet.http.*;

public class TodayServlet extends HttpServlet {

public void doGet( HttpServletRequest request,

HttpServletResponse response )

throws IOException, ServletException {

response.setContentType( "text/HTML" );

response.setHeader( "Pragma", "no cache" );

response.setHeader( "Cache-Control", "no cache" );

response.setHeader( "Expires", "0" );

PrintWriter out = response.getWriter();

out.println( "<HTML>" );

out.println( "<head>" );

out.println( "<title>Today</title>" );

out.println( "</head>" );

out.println( "<body>" );

out.println(

"<h1>The current date and Time is:</h1>" );

Date today = new Date();

out.println( "<p>" + today + "</p>" );

out.flush();

out.println( "</body>" );

out.println( "</HTML>" );

}



Para executar um servlet você precisa de um servidor Web, que precisa ter o

mecanismo de interpretação de servlets. Existem vários servidores Web de

fabricantes diferentes.

Figura 33 – Processo de um Servlet

3.5 Java Server Pages

As páginas JSP, ou Java Server Pages, foram criadas para contornar

algumas das limitações no desenvolvimento com Servlets: se em um Servlet a

formatação da página HTML, resultante do processamento de uma requisição, se

mistura com a lógica da aplicação em si, dificultando a alteração dessa formatação,

em uma página JSP essa formatação se encontra separada da programação,

podendo ser modificada sem afetar o restante da aplicação.

Assim, um JSP consiste de uma página HTML com alguns elementos especiais, que

conferem caráter dinâmico à página. Esses elementos podem tanto realizar um

processamento por si, como podem recuperar o resultado do processamento

realizado em um Servlet, por exemplo, e apresentar esse conteúdo dinâmico junto à

página JSP. Existe também um recurso adicional bastante interessante na utilização

de páginas JSP: a recompilação automática, permitindo que alterações feitas no

código da página sejam automaticamente visíveis em sua apresentação. Assim, não

é necessário interromper o funcionamento da aplicação para incorporar uma

modificação de layout.



Exemplo:

<HTML>

<HEAD>

<META NAME="Pragma" CONTENT="no-cache">

<META NAME="Cache-Control" CONTENT="no-cache">

<META NAME="Expires" CONTENT="0">

<TITLE>Member Info Update</TITLE>

</HEAD>

<%@ page import="skiclub.*" %>

<BODY BGCOLOR="#FFFFFF" LINK="#0000FF" VLINK="#990099" >

<CENTER>

<IMG SRC="/skiclub/images/SkiClub.gif"

ALT="Near Hills Ski Club " >

<h2>Member Information Update</H2>

</CENTER>

<p>Please complete the form below and press

<strong>Update</strong> to change

the information on our records.

</p>

<CENTER>

<FORM METHOD=POST ACTION=

"http://localhost:8080/servlet/skiclub.UpdateServlet">

<TABLE BORDER=0 BGCOLOR="#DDDDFF" CELLPADDING=5 >

<TR>

<TD><strong>First name</strong></TD>

<TD><INPUT TYPE="text" NAME="FNAME"

VALUE="<%= ( (ClubMember)

session.getValue( "member" ) ).getFirstName() %>"

SIZE=30 MAXLENGTH=30 > </TD>

</TR>

<TR>

<TD><strong>Initials</strong></TD>

<TD><INPUT TYPE="text" NAME="MNAME"


session.getValue( "member" ) ).getMiddleName() %>"


</TR>

<TR>

<TD><strong>Last name</strong></TD>

<TD><INPUT TYPE="text" NAME="LNAME"




session.getValue( "member" ) ).getLastName() %>"


</TR>

<TR>

<TD><strong>Phone Number</strong></TD>

</TD>

<TD><INPUT TYPE="text" NAME="PHONE"


session.getValue( "member" ) ).getPhoneNumber() %>"

SIZE=10 MAXLENGTH=10 >

<em>digits only</em>

</TD>

</TR>

<TR>

<TD><strong>Address</strong></TD>

<TD><em>For demonstration purposes,

this field is a placeholder</em></TD>

</TR>

<TR>

<TD><strong>Skiing Ability</strong></TD>

<TD>

<%! String[] levels = { "Novice",

"Intermediate",

"Advanced",

"Expert" };

%>

<% String ability = ( (ClubMember)

session.getValue( "member" ) ).getAbility();

out.println( "<SELECT NAME=\"ABILITY\" >" );

for ( int i = 0; i < levels.length; i++ ) {

out.print( "<OPTION VALUE=\"" + levels[i] + "\"");

if ( ability.equals( levels[i] ) ) {

out.print( " SELECTED>" );

} else {

out.print( ">" );

}

out.println( levels[i] + "</OPTION>" );

}

out.println("</SELECT>");

%>



</TD>

</TR>

</TABLE>

<TABLE BORDER=0 CELLSPACING=20 >

<TR>

<TD><INPUT TYPE="submit" VALUE=" Update "></TD>

<TD><INPUT TYPE="reset" VALUE=" Reset " ></TD>

</TR>

</TABLE>

</CENTER>

<p>If this information is correct, you may:

<ul>

<li><a href="/servlet/skiclub.BookingServlet">

Update ski trip bookings</a></li>

<li><a href="/skiclub/skiclub/memberHome.jsp">

Return to your member home page</a></li>

</ul>

</FORM>

</p>

</BODY>

</HTML>

Síntese

Nesta aula você conheceu como as principais tecnologias Java se

apresentam para resolver problemas mais complexos, de aplicações corporativas e

baseadas em objetos distribuídos. A plataforma J2EE é a proposta mais ampla que a

Sun e seus colaboradores apresentaram para os programadores, considerando todo

o conjunto de tecnologias envolvidas.

Também nesse contexto, você pôde perceber que a Internet é uma grande

revolução para os programadores, já que novas necessidades e novos formatos de

aplicações estão sendo exigidas pelo mercado. Isso gera no progamador a

necessidade de conhecimentos essenciais sobre como as aplicações na Web

funcionam, incluindo conhecer a linguagem HTML, os protocolos de comunicação



envolvidos na Internet, o funcionamento em detalhes de um navegador, uso de

servidores de aplicações e outros.

Na próxima aula você aprenderá como implementar banco de dados em suas

aplicações.

Até lá.


1) Qual a diferença entre uma página JSP e um Servlet?

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

______________________________________________________________

2) Qual a principal finalidade do uso do J2EE?

_____________________________________________________________________

_____________________________________________________________________

_____________________________________________________________________

_____________________________________________________________________



Aula 7

JAVA COM BANCO DE DADOS

Objetivos da aula


• Implementar programas Java usando recursos de banco de

dados.

Conteúdos da aula

Acompanhe os conteúdos desta unidade. Se você

preferir, assinale os conteúdos na medida em que for

estudando.

• Introdução a bancos de dados relacionais;

• Linguagem SQL;

JDBC.




Nesta última aula você aprenderá como trabalhar com bancos de dados

em sua aplicação Java. A plataforma Java oferece um conjunto de

classes principais que você pode utilizar para acessar dados em um banco de dados

relacional, disponibilizado por um SGBD e instalado em seu computador local ou na

rede, e que possua um driver de conexão para que as classes Java possam acessá-

lo.

Desenvolver soluções corporativas usando Java, é muito comum à

necessidade de implementação de uma conexão com banco de dados e o Java

oferece todo o ferramental para que você possa construir suas aplicações.

Tenha uma boa aula.

1 INTRODUÇÃO A BANCOS DE DADOS RELACIONAIS

Um banco de dados é uma coleção organizada de dados e os sistemas

gerenciadores de banco de dados (SGBD) fornecem os mecanismos para organizar,

armazenar, recuperar e modificar os dados pelo usuário.

Em um Banco de Dados relacional, temos uma série de tabelas com um

conjunto de linhas e colunas. As colunas representam as informações pertinentes a

uma linha. Desta forma, as linhas devem ser identificadas univocamente por uma

chave primária para que possam ser recuperadas posteriormente suas informações.

A chave primária pode ser uma coluna que nunca terá seus dados repetidos ou um

conjunto de colunas que, juntas, nunca serão repetidas. Veja a tabela 20.

Tabela 20 – Exemplo de tabela

Coluna 1 Coluna 2 Coluna 3

CPF Nome DataNascimento

4594545 Júnior da Silva 24-08-2005

9454001 Armort de Souza 31-05-2005

9345400 Tianak da Costa 12-02-2004



Vários autores apresentam vantagens no uso de um SGBD:

Vantagem Descrição

Eliminação da

inconsistência dos dados

Nos sistemas de arquivos, os dados ficavam

armazenados em locais isolados e só acessados pela

linguagem que lhes deu origem, com isso tínhamos a

mesma informação repetida em locais diferentes. Com

a chegada dos SGDBs, os dados puderam ser

centralizados, evitando esta duplicação e,

conseqüentemente, essa inconsistência.

Facilidade de acesso aos

dados

Devido à centralização dos, puderam ser facilmente

acessados por qualquer ponto da rede.

Provê eficiente segurança

aos dados

Através de critérios de permissões definidos pelo

administrador, podemos informar ao servidor quem

pode acessar o que e quais operações pode realizar.

Provê restrições de

integridade

Nos SGDBs você pode definir regras de integridade

sobre os campos de uma tabela, com isso, qualquer

valor inserido naquela coluna deverá respeitar a regra.

Provê ferramentas

eficientes para backup e

restore

Um dos aspectos importantes no uso de SGBDs é a

manutenção dos dados. Utilitários para cópia de

segurança e restauração de dados são fundamentais

para uma administração dos dados do SGBD.

Um Sistema Gerenciador de Base de Dados (SGBD) é uma coleção de

programas que permite aos usuários criarem e manipularem uma base de dados.

Um SGBD é, assim, um sistema de software de propósito geral que facilita o

processo de definir, construir e manipular bases de dados de diversas aplicações

(figura 34).

• Definir uma base de dados envolve a especificação de tipos de dados a

serem armazenados na base de dados;

• Construir uma base de dados é o processo de armazenar os dados em

algum meio que seja controlado pelo SGBD;

• Manipular uma base de dados indica a utilização de funções como a de

consulta, para recuperar dados específicos, modificação da base de dados



para refletir mudanças no mini-mundo (inserções, atualizações e

remoções), e geração de relatórios.

Figura 34 – Aplicação acessando banco de dados

2 LINGUAGEM SQL

Na história do desenvolvimento dos Bancos de Dados Relacionais, há o

momento em que foi necessário o desenvolvimento de linguagens destinadas à sua

manipulação. Então o Departamento de Pesquisas da IBM desenvolveu a SQL

(Search and Query Language) como forma de interface para o SGBD denominado

SYSTEM R no início dos anos 70. Somente em 1986 o American National Standard

Institute ( ANSI ), publicou um padrão SQL (Structured Query Language), que se

estabeleceu como linguagem padrão de Banco de Dados Relacional.

A SQL pode ser dividida em dois tipos de comandos:



• A DDL (Data Definition Language) - apresenta uma série de comandos

que permite a definição dos dados. É composta, entre outros, pelos

comandos Create, destinado à criação do Banco de Dados, das Tabelas

que o compõem, além das relações existentes entre as tabelas.

• Create, Alter e Drop.

Os comandos da série DML (Data Manipulation Language) - destinados às

consultas, inserções, exclusões e alterações em um ou mais registros de uma

ou mais tabelas de maneira simultânea.

Select, Insert, Update e Delete.

A linguagem SQL é um grande padrão de banco de dados, devido à

simplicidade e facilidade de uso. Opõe-se a outras linguagens, visto que uma

consulta SQL especifica a forma e não o caminho para chegar ao resultado. É uma

linguagem declarativa, em oposição a outras linguagens procedurais, reduzindo o

ciclo de aprendizado daqueles que se iniciam na linguagem.

Após estabelecer a comunicação de sua aplicação C# com um SGBD, a forma de

armazenamento, alteração e exclusão dos dados se dará com o uso da linguagem

SQL. Esse modelo de aplicação é conhecido, hoje, como arquitetura cliente/servidor,

pois as atividades de interface com o usuário (camada de aplicação) e SGBD

(camada de dados) estão fisicamente separados em uma rede de computadores. À

medida que o modelo evoluiu, novas camadas foram inseridas, com o objetivo de

aumentar a capacidade de processamento simultâneo que a aplicação pode

atender. Dessa forma, as arquiteturas 3-Camadas e N-Camadas, foram batizadas

com uma camada adicional chamada “aplicação”, ou seja, as classes, métodos e

funções de uma aplicação, responsáveis pela lógica do sistema, podem ficar

armazenadas também em um servidor separado. O conceito de N-Camadas surgiu

com o objetivo de representar a capacidade dos sistemas corporativos poderem

“escalar horizontalmente”, ou seja, para cada camada podemos ter um ou vários

computadores.



a) O processamento de consulta de dados de uma aplicação até o banco de dados, envolve uma série de passos, os quais envolvem software, tecnologia e informações. Veja os detalhes na figura 35.

Figura 35 – O processo de consulta ao banco de dados usando SQL

Comandos DDL:

Comando Descrição

CREATE Permite a criação de tabelas no banco de dados

ou mesmo de sua criação.

DROP Elimina a definição da tabela, seus dados e

referências.

ALTER Permite inserir/eliminar atributos nas tabelas já

existentes

Comandos DML:

Comando Descrição



SELECT Realiza a consulta em um banco de dados

INSERT Insere dados em uma tabela específica

DELETE Exclui dados de uma tabela segundo um critério

UPDATE Atualiza os dados em uma tabela

3 JDBC

JDBC (figura 36) é uma API (Application Program Interface) para acesso a

SGBD´s (Sistemas Gerenciadores de Banco de Dados) relacionais por meio de

comandos SQL (Structured Query Language).

Figura 36 – JDBC

A API para programação do sistema é a mesma para qualquer SGBD. Por

isso, não há necessidade de se desenvolverem aplicações voltadas para um SGBD

específico, pois elas não estão atreladas a uma arquitetura proprietária. Com isso,

fica assegurada a independência de plataforma de Java. A biblioteca JDBC também

permite a construção de páginas WWW dinâmicas que acessem banco de dados.

A grande vantagem do modelo JDBC é que nenhuma configuração é

requerida no lado cliente.

Os Passos para conexão JDBC são os seguintes:

a) Incluir no programa: import java.sql.*;

b) Carregar corretamente o driver desejado;

c) Conectar com o banco de dados;

d) Criar o comando JDBC;

e) Enviar comandos SQL.



Como você pode perceber, o primeiro passo para iniciar a comunicação com

o banco de dados é o uso de um driver, o software responsável pela comunicação

entre a aplicação, usando JDBC e o sistema de banco de dados envolvido. Cada

fabricante de banco de dados possui seu próprio driver e sempre é preferível utilizar

o driver nativo do fabricante. A linguagem Java suporta quatro tipos de drivers:

1. Ponte com ODBC: o tipo provido pela Sun. Apropriado para uso

experimental e para situações em que não haja outro driver disponível;

2. Driver independente de SGBD: converte chamadas JDBC em chamadas

à API do cliente para Oracle, Sybase, Informix, DB2 ou outro SGBD;

3. Acesso ao driver nativo: a API JDBC chama procedimentos do driver

nativo do SGBD instalado na máquina local ou no servidor para as

aplicações distribuídas;

4. Driver com protocolo proprietário escrito em Java: a comunicação

entre o cliente e o SGBD dá-se no protocolo do BD, contudo, como o

driver é escrito em Java, dispensa a instalação ou configuração do driver

no cliente.

A abertura da conexão (sessão) é feita pelo método getConnection da classe

DriverManager (o serviço básico para gerenciamento de um conjunto de drivers

JDBC) e o método retorna um objeto do tipo Connection. A URL de acesso é

composta de protocolo:subprotocolo:subnome e o DriverManager tenta conectar

com o primeiro driver carregado; se não consegue, tenta o driver seguinte e se não

localizar, é lançada uma exceção SQLException.

Vamos a um exemplo:

import java.sql.*;

java.util.Properties props = new Properties();

props.put("user", objAccessManager.getConta());

props.put("password", objAccessManager.getSenha());

String url = "jdbc:odbc:temp//"+ "fava" +":6024/" +

bancoDeDados;

try

{

// carrega o driver da ponte jdbc-odbc

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");



// abre conexao com o banco de dados

Connection con = DriverManager.getConnection(url, props);

// Este banco não aceita autocommit

//con.setAutoCommit( false ); //se o BD lida com transação

}

catch(ClassNotFoundException e) //Class.forName()

{

System.out.println("Classe do Driver JDBC não encontrada");

}

catch(SQLException e) //DriverManager.getConnection()

{

System.out.println(

"Falha na conexão com o banco de dados:" );

System.out.println(e.getMessage();

}

O envio de um comando SQL é feito por intermédio dos métodos

executeQuery(String s) e executeUpdate(String s) de um Statement, da seguinte

forma:

executeQuery:

ResultSet rs = stmt.executeQuery (“SELECT * FROM Alunos”);

executeUpdate:

stmt.executeUpdate (“CREATE TABLE Alunos(nome VARCHAR(32), �

idade INTEGER);”);

stmt.executeUpdate (“INSERT INTO Alunos VALUES(‘Jonas’, 18);”);

Vamos avaliar um exemplo completo de conexão com banco de dados

usando JDBC.

package skiclub;

import java.sql.*;

import java.util.*;

public class SkiClubDB {

static Connection connection = null;



static final String dbDriver =

"COM.ibm.db2.jdbc.app.DB2Driver";

static final String dbUrl= "jdbc:DB2:SKICLUB";

static final String dbName = "SKICLUB";

// Definindo o usuário para criar o banco de dados

static final String dbOwner = "USERID";

// associando o usuário no Windows

static final String dbUser = "USERID";

// Informando a senha do usuário

static final String dbPassword = "PASSWORD";

static final String memberTable = "MEMBERS";

static final String tripTable = "SKITRIPS";

static final String bookTable = "BOOKINGS";

synchronized static Connection getConnection()

throws DBopException

{

if ( connection == null ) {

try {

Class.forName( dbDriver );

connection = DriverManager.getConnection(

dbUrl, dbUser, dbPassword);

} catch ( ClassNotFoundException e ) {

throw new DBopException (

"Cannot load database driver: for DB2, " +

"your classpath must include " +

"SQLLIB\\JAVA\\DB2JAVA.ZIP." );

} catch ( SQLException e ) {


"Cannot connect to database: for DB2, " +

"check that DB2 is running and the SKICLUB "

+ "database exists." );

}

}

return connection;

}

synchronized static ResultSet getAllColumns(

String[] tables, String condition )


{



String[] columns = {"*"};

return getSelectedColumns( columns, tables,

condition );

}

synchronized static ResultSet getSelectedColumns(

String[] columns, String[] tables,

String condition )


{

String select = "SELECT ";

try {

Statement query = getConnection().

createStatement();

for ( int i = 0; i < columns.length; i++ ) {

select += columns[i];

select += i + 1 < columns.length ? "," : " ";

}

select += "FROM ";

for ( int i =0; i < tables.length; i++ ) {

if ( dbOwner.length() > 0 ) {

select += dbOwner + ".";

}

select += tables[i];

select += i + 1 < tables.length ? "," : " ";

}

select += condition;

System.out.println( select );

return query.executeQuery( select );



"Cannot extract data with SQL statement:\n "

+ select );

}

}

synchronized static public int getNextId( )

throws SQLException, DBopException

{

Statement query = getConnection().createStatement();



ResultSet result = query.executeQuery(

"SELECT MAX(ID) FROM " +

( dbOwner.length( ) > 0 ? dbOwner + "." : "" ) +

memberTable );

int newId = 1;

if(result.next()==true) {

newId = result.getInt(1) + 1;

}

return newId;

}

synchronized static public void addMember(

ClubMember member )


{

int rowInserted = 0;

Statement insert = getConnection().

createStatement();

String addrecord = "INSERT INTO " +


memberTable + " VALUES (" + member.getId() +

",'" + member.getFirstName() + "','" +

member.getMiddleName() + "','" +

member.getLastName() + "','" +

member.getPhoneNumber() + "','" +

member.getAbility() + "')" ;

System.out.println( addrecord );

rowInserted = insert.executeUpdate(addrecord);

if ( rowInserted != 1 ) {

throw new DBopException(

"Unable to add new member to database" );

}

return;

}

synchronized static public void updateMember(

ClubMember member )


{

Statement update = getConnection().createStatement();

String changeRecord = "UPDATE " +




memberTable + " SET " +

"FNAME = '" + member.getFirstName() + "'," +

"MNAME = '" + member.getMiddleName() + "'," +

"LNAME = '" + member.getLastName() + "'," +

"PHONENUM = '" + member.getPhoneNumber() + "'," +

"ABILITY = '" + member.getAbility() + "'" +

"WHERE ID = " + member.getId();

System.out.println( changeRecord );

int changed = update.executeUpdate( changeRecord );

if ( changed < 1 ) {


"No changes made to databare" );

} else if ( changed > 1 ) {


"More than one member's data was affected: "

+ changed + "records changed." );

}

return;

}

synchronized static public ClubMember

getMemberByID ( int id )

throws SQLException, DBopException,

BadDataException

{

String[] tables = { memberTable };

ResultSet result = getAllColumns( tables,

"WHERE ID = " + id );

if ( ! result.next() ) {

return null;

}

ClubMember member = new ClubMember();

member.setId( result.getInt( "ID" ) );

member.setFirstName(

result.getString( "FNAME" ).trim() );

member.setMiddleName(

result.getString( "MNAME" ).trim() );

member.setLastName(

result.getString( "LNAME" ).trim() );

member.setPhoneNumber(



result.getString( "PHONENUM" ).trim() );

member.setAbility(

result.getString( "ABILITY" ).trim() );

if ( result.next( ) ) {


"Duplicate Member ID: " + id );

}

return member;

}

synchronized static public ClubMember getMemberByName (

String firstName, String lastName )

throws SQLException, DBopException, BadDataException

{

String[] tables = { memberTable };


" WHERE FNAME = '" + firstName +

"' AND LNAME = '" + lastName + "'" );

if ( ! result.next() ) {

return null;

}

ClubMember member = new ClubMember();

member.setId( result.getInt( "ID" ) );

member.setFirstName(

result.getString( "FNAME" ).trim() );

member.setMiddleName(

result.getString( "MNAME" ).trim() );

member.setLastName(

result.getString( "LNAME" ).trim() );

member.setPhoneNumber(

result.getString( "PHONENUM" ).trim() );

member.setAbility(

result.getString( "ABILITY" ).trim() );

if ( result.next( ) ) {


"Duplicate member name: "

+ firstName + " " + lastName );

}

return member;

}



synchronized static public Vector retrieveTrips( )


{

Vector trips = new Vector();

try {

String[] tables = { tripTable };


"ORDER BY ID" );

while( result.next() ) {

SkiTrip trip = new SkiTrip();

trip.setId( result.getInt( "ID" ) );

trip.setWeek( result.getInt( "WEEK" ) );

trip.setDay( result.getString( "DAY" ).trim() );

trip.setCapacity( result.getInt( "CAPACITY" ) );

trip.setBooked( result.getInt( "BOOKED" ) );

trips.addElement(trip);

}



"Error reading Table: " + tripTable);

}

return trips;

}

synchronized static public Vector getSkierTrips(

int skierID )


{

String[] tables = { tripTable, bookTable };

String condition = "WHERE " +


tripTable + "." + "ID" + "=" +


bookTable + "." + "TRIPID" +

" AND " +


bookTable + "." + "MEMBERID=" + skierID;


try {



ResultSet result = getAllColumns(

tables, condition );


SkiTrip trip = new SkiTrip();

trip.setId( result.getInt( "ID" ) );

trip.setWeek( result.getInt( "WEEK" ) );

trip.setDay( result.getString( "DAY" ).trim() );

trip.setCapacity( result.getInt( "CAPACITY" ) );

trip.setBooked( result.getInt( "BOOKED" ) );

trips.addElement(trip);

}



"Error reading Table: " + tripTable);

}

return trips;

}

synchronized static public Vector retrieveBookings(

int skierID )


{


try {

String[] tables = { bookTable };

String[] columns = { "TRIPID" };

ResultSet result = getSelectedColumns( columns,

tables, " WHERE MEMBERID = " + skierID +

" ORDER BY TRIPID" );


trips.addElement( new Integer

( result.getInt( "TRIPID" ) ) );

}



"Error reading Table: " + bookTable);

}

return trips;

}



synchronized public static void updateTrip(

SkiTrip trip )

throws DBopException, SQLException

{

Statement update =

getConnection().createStatement();

String doChange = "UPDATE " +


tripTable + " SET " +

"BOOKED = " + trip.getBooked() +

" WHERE ID = " + trip.getId();

System.out.println( doChange );

int changed = update.executeUpdate( doChange );

if ( changed != 1 ) {


"Error updating booked count for trip "

+ trip.getId() );

}

return;

}

synchronized public static void addBooking(

Booking booking)


{

int rowInserted = 0;

Statement insert = getConnection().createStatement();

String addrecord = "INSERT INTO " +


bookTable + " VALUES (" + booking.getMemberId() +

"," + booking.getTripId() + ")";


rowInserted = insert.executeUpdate(addrecord);

if ( rowInserted != 1 ) {


"Problem adding booking for trip" +

booking.getTripId() );

}

return;



}

synchronized public static void dropBooking(

Booking booking)


{

int rowDeleted = 0;

Statement delete = getConnection().

createStatement();

String addrecord = "DELETE FROM " +


bookTable + " WHERE MEMBERID="+

booking.getMemberId() +

" AND TRIPID=" + booking.getTripId();


rowDeleted = delete.executeUpdate(addrecord);

if ( rowDeleted != 1 ) {


"Problem dropping booking for trip" +

booking.getTripId() );

}

return;

}

public static void main( String [] args )

throws SQLException, DBopException,

ClassNotFoundException

{

System.out.println( "Getting Database driver" );

Class.forName( dbDriver );

System.out.println( "Getting Database connection" );

getConnection();

System.out.println( "Database ready" );

return;

}

}



Síntese

Nesta aula você aprendeu como trabalhar com banco de dados em suas

aplicações e quais os principais componentes da plataforma Java que suportam as

operações de banco de dados.

Com esta aula terminamos o módulo de Programação Aplicada usando Java. Espero

que você tenha obtido resultados satisfatórios com o conteúdo apresentado e que

esteja motivado para continuar a construir aplicações usando a plataforma Java.

Desejo-lhe boa sorte e não pare seus estudos em Java, pois é um “mundo de

oportunidades” que está em constante crescimento e hoje, está cada vez, permite

que profissionais realizem melhor o seu trabalho.

Um grande abraço!


1) Qual a função do JDBC no Java?

______________________________________________________________

______________________________________________________________

______________________________________________________________

2) É possível executar um comando SQL através de uma conexão SQL? Caso

positivo, explique os componentes Java envolvidos nesta operação.

______________________________________________________________

______________________________________________________________

______________________________________________________________



REFERÊNCIAS

MORGAN, M..; Java 2 para programdores profissionais. Sams Books, 2000.

RODRIGUES FILHO, Renato; Desenvolva aplicativos com Java 2. Érica, 2005.

GOSLING, James; A linguagem de programação Java. Bookman, 2007.

CADENHEAD, Rogers; Aprenda em 21 dias Java 2. Campus, 2005.

LINDEN, Peter; Simplesmente Java2. Alta Books, 2005.

apostila formação programador java

Documents