-- CURSO TÉCNICO DE INFORMÁTICA -- MÓDULO III LÓGICA … · A apostila foi produzida com base no software de desenvolvimento Eclipse, disponível ... de programadores em COBOL

Colégio Tableau – Curso Técnico de Informática – Lógica e Técnicas de Programação Todos os direitos reservados

-- CURSO TÉCNICO DE INFORMÁTICA --

MÓDULO III

LÓGICA E TÉCNICAS DE PROGRAMAÇÃO

Bem vindo!

Chegamos ao terceiro e último módulo de nosso curso, na disciplina de Lógica e

Técnicas de Programação, onde iremos abordar os conceitos do paradigma de

orientação a objetos, aplicada a linguagem Java. O objetivo é iniciar o desenvolvimento

de sistemas simples envolvendo o cotidiano. A disciplina contém 40 horas de duração,

divididas em 9 capítulos, como dispostos nesta apostila.

PRÉ-REQUISITOS

É fundamental que você conheça ou tenha noção de lógica de programação, estruturas

de controle, de repetição e coleções de dados para que haja um melhor

aproveitamento do aprendizado em Java.

SOFTWARES

A apostila foi produzida com base no software de desenvolvimento Eclipse, disponível

gratuitamente no endereço http://www.eclipse.org. Porém há citações também ao

JCreator e ao NetBeans

Bons estudos!

2


1. CONCEITOS DE ORIENTAÇÃO A OBJETOS E INTRODUÇÃO

A LINGUAGEM JAVA

Programadores são profissionais curiosos. Desenvolvem seus próprios métodos de escrever

códigos e, por vezes, não há quem os mude. E há quem

diga que eles são ditados pela “moda” em desenvolvimento

de software. Ao longo da história computacional, as

linguagens de programação comportaram-se maneiras

distintas e foram, com isso, evoluindo. Houve uma época

de programadores em COBOL. Formaram-se aos montes.

Outrora, houve os adeptos de CLIPPER. Houve quem

gostasse de programação estruturada. Houve (?) quem

gostasse de Assembly. A ‘onda’ agora (aliás, faz tempo)

aponta para a orientação a objeto.

A orientação a objeto nos induz a pensar na relação dos objetos do mundo real para podermos

representa-los exatamente igual ao mundo computacional. Mas que objetos? Ora, qualquer

coisa. Tudo para nós, no mundo real passa a ser tratado como objeto. Pessoas, animais,

móveis, imóveis, veículos. Então objeto são todas as coisas ‘físicas’ do mundo real? Nem

sempre. Uma conta de banco pode ser um objeto. Uma mensagem na tela de computador

também pode ser objeto. Enfim, tudo!

Mas porque devo usar orientação a objeto? Primeiro porque é intuitivo. Pensar em objetos do

mundo real, ajuda a entender melhor o problema computacional. Segundo e principalmente,

porque a manutenção do código fica extremamente mais fácil, haja vista que o código

responsável por cada ação fica organizado em apenas um arquivo fonte. E terceiro... porque

está na moda!

1.1. Classe

Quando agrupamos objetos com características, criamos uma classe. Pensamos por exemplo,

em cachorros (que para nós são objetos). Faça-se a pergunta: eu consigo generalizar um

cachorro? Claro! Todo cachorro tem cor de pelo, nome, raça e sexo. Além disso, latem, abanam

o rabo e pulam. Portanto, cachorro pode tornar-se uma classe em que todos os objetos desta

classe (no caso, os cachorrinhos) teriam e fariam as mesmas coisas.

Vamos a outro exemplo para fixar. Pense na conta de um banco. Como generalizar contas?

Bem, todas possuem um dono, um número, um saldo e um limite. Também podemos realizar

saques, tirar extratos, depositar e transferir. Quer dizer que conta também é uma classe? Sim!

Definindo então, classe é a generalização de objetos! Por uma convenção de código, as classes

são sempre escritas com as letras iniciais de cada palavra em maiúsculo.

3


1.2. Atributo

Todos os objetos possuem características. A essas características damos o nome de atributo.

Pense em um objeto qualquer: um carro. Quais as características de um carro? Chassi, motor,

cor, velocidade máxima, etc. Pois estes são os atributos de qualquer objeto carro. Perceba que

em nossa programação, os atributos ficaram descritos nas classes, que são como um modelo

para os objetos. Por convenção de código, os atributos são escritos com a primeira letra da

palavra em minúsculo e caso haja mais palavras as letras são em maiúsculo.

1.3. Método

Toda ação dentro do de nosso código (cadastrar, excluir, alterar) é caracterizado como método.

Um objeto também pode ter métodos ou comportamentos que influencia seus atributos. Por

exemplo, um carro pode acelerar ou frear (um comportamento), o que faz com que sua

velocidade atual (um atributo) seja alterada. Outro exemplo é a conta bancária que pode sofrer

um saque (uma ação) que irá modificar seu saldo (um atributo). Os métodos são sempre

identificados com sinal de parênteses. Há ainda alguns tipos de métodos especiais.

1.3.1. Método construtor

É o método responsável por criar o objeto propriamente dito a partir de uma determinada

classe. A maioria das classes irá conter o método construtor, exceto claro, as que não forem

gerar objetos no sistema. É obrigatório o método construtor ter o mesmo nome da classe que

está representando. Além disso, pode-se utilizar um método construtor padrão ou realizar uma

sobrecarga no método construtor padrão. O método construtor padrão, gera um objeto com

todos os atributos vazios, para mais tarde, na execução do código, os valores serem

adicionados. Isto significa construir um objeto carro sem cor, sem chassi, sem motor. Apenas o

objeto vazio. Gerar o objeto por gerar.

Já na sobrecarga, nós escrevemos além do método construtor padrão, outro método construtor,

porém com valores iniciais para o objeto. Dessa forma, o usuário informa o valor antes de o

objeto ser gerado. No exemplo do objeto carro, ao acionar o método construtor sobrecarregado,

o sistema irá requerer uma cor, um chassi e um motor e, somente após os valores informados,

o objeto é gerado. Veja um exemplo comparativo.

MÉTODO CONSTRUTOR PADRÃO SOBRECARGA DE MÉTODO CONSTRUTOR

public Carro ( ){

cor = “ ”;

chassi = “ ”;

motor = “ ”; }

public Carro( a, b, c ){

cor = “a”;

chassi = “b”;

motor = “c”;

}

4


1.3.2. Método acessor (get)

Métodos assessores são, como o nome sugere, os que acessam determinando atributo com o

objetivo de saber seu valor. Na forma mais comum, todos os atributos devem ter um método

acessor correspondente, exceto claro, aqueles cujo você não quer usuários acessem. A única

função de um método acessor é responder valores e essa resposta (chamada de retorno) deve

obrigatoriamente ter sempre um tipo (mais no capítulo Tipos Primitivos). Por exemplo, se

criarmos um método para acessar a cor de um carro, a resposta deverá ser... a cor do carro!

1.3.3. Método mutante (set)

Os métodos mutantes são os que mudam (ou cadastram) o valor de um atributo. Também é

ideal que todos os atributos tenham um método mutante correspondente, exceto claro, aqueles

que você não deseja permitir alterações. Um método pintar ou um método acelerar são

exemplos de métodos mutantes, pois alteram atributos do objeto carro (cor e velocidade

respectivamente). Diferentemente dos métodos acessores, os mutantes não respondem nada,

isto é, ao ser acionado ele não retorna valores, apenas realizam a ação e se encerram. Sendo

assim, por não retornarem valor, dizemos que são do tipo void. Ao acionar um método mutante

para alterar um atributo, obviamente você deve informar o novo valor ao método. Veja um

exemplo abaixo (não se preocupe com a palavra String, nem com public por enquanto).

MÉTODO ACESSOR MÉTODO MUTANTE

public String getCor()

{

return cor;

}

public void setCor(x)

{

cor = x;

}

1.3.4. Método main

Dentre os diversos métodos presentes em um programa Java, o método main, como o nome

sugere, é o principal deles pelo fato de, na execução do código, é sempre ele o primeiro a ser

acionado. Do ponto de vista do usuário, o método main é a tela inicial do sistema, funcionando

como principal interface de “conversa” com as outras classes do sistema. É comum no método

main conter menus iniciais, botões, janelas, ícones, etc. Veja um exemplo de método main (no

próximo subcapítulo, explicaremos as palavras estranhas, não se preocupe).

MÉTODO MAIN

public static void main (String args[])

{

<instruções>

}

5


1.4. Herança

Um dos grandes pilares da orientação a objeto é a herança de código. Sua principal vantagem é

o reaproveitamento de um método ou atributo já escrito anteriormente e precisa ser reutilizado.

Imagine por exemplo, uma classe Carro onde tenha um atributo motor e um método acelerar

com seu código já escrito. Você concorda que se criássemos uma classe Moto, teríamos que

escrever novamente o método e o atributo anteriores? E também para uma classe Caminhão?

Entra então a herança, onde é possível criar uma “classe-mãe” (chamada de superclasse) com o

nome de Veículo, contendo o atributo motor e o método acelerar e “repassar” esses elementos

para as outras classes. Dessa forma, escreveríamos o código apenas uma vez. É importante

ressaltar que na herança, todos os atributos e métodos são repassados para as “classes-filha”

(chamada de subclasses), porém outros atributos e métodos podem ser acrescentados. Na

classe Carro, por exemplo, além de receber a herança de Veículo, podemos acrescentar o

atributo portas, o que não faria sentido incluirmos em Veículos, já que motos (que também

recebem herança não tem portas).

1.5. Polimorfismo

É outra importante propriedade da orientação a objeto que permite uma mesma classe ou

método tenha diferentes significados dentro de um contexto sem que seu código seja alterado.

Vamos tomar como exemplo a classe Veículo, onde a mesma pode gerar objetos diferentes

(carro, moto ou caminhão) para casos distintos, embora seus métodos possam ser os mesmos.

Em casos de polimorfismo de métodos, a ação de acelerar pode causar diferentes efeitos em

cada objeto, isto é, apesar de ser herdado igualmente para todas as subclasses, o método pode

se “transformar” e comportar-se de maneira diferente ao ser usado em cada objeto.

1.6. Encapsulamento

É talvez o mais importante conceito. Encapsular em orientação a objeto significa esconder o

funcionamento interno de métodos, classes e atributos do sistema, com o objetivo de proteger

de acesso externo, de modo que possa somente ser utilizado através do “lado usuário”. Vamos

exemplificar com os veículos do mundo real. Para os motoristas, o que é importa é acelerar,

frear, trocar marchas e virar o volante, não importando a forma como tudo isso acontece. E

isso funciona tanto para motos, carros e caminhões. Trazendo para orientação a objetos,

podemos (e devemos) proteger o acesso aos métodos e atributos de uma classe e até mesmo a

própria classe para evitar que estes sejam modificados ou utilizados sem controle (sem antes

passar pela ‘cápsula’). Este controle pode ser feito com uso de modificadores, no qual veremos

próximo item.

6


1.7. Modificadores

Os modificadores do Java são palavras que utilizamos para alterar o funcionamento de classes e

atributos. As alterações podem afetar significativamente a lógica de seu programa, portanto é

necessário fazer uso consciente dos modificadores. Incluem entre as mudanças, modos de

acesso aos elementos, bloqueio no reaproveitamento do código, entre outras.

1.7.1. static

Quando o modificador static é aplicado aplicada a métodos, significa que aquele método pode

ser acionado sem um objeto específico da classe onde está inserido. Como vimos nos exemplos

acima, o método main é do tipo static, o que faz com que consigamos executá-lo sem

necessidade de criar um objeto da classe onde o método main foi criado. O modificador static

faz com que o elemento fique em uma posição única e reservada na memória, diferente de

outros elementos (variáveis, classe, métodos). Isto significa que um elemento static não

consegue “enxergar” outro elemento que não seja static. Costumamos então utilizar o

modificador em atributos e classes quando queremos agrupá-lo com métodos para serem

usados em conjunto.

1.7.2. abstract

Aprendemos na escola que uma coisa abstrata é algo que não existe fisicamente, algo

imaginário (por exemplo, o vento). O contrário de abstrato é concreto. Trazendo para nossa

orientação a objetos, um elemento abstrato é algo que está no código, mas não pode ser

utilizado diretamente sem antes ser complementado por outro código. Quando aplicado a

classes, significa que aquela classe não pode gerar objetos. Para métodos, indica que aquele

método é incompleto e precisa ser reescrito ou sobrecarregado (assim como um método

construtor). Por que estes elementos existem se não há utilidade? Simplesmente para permitir

o polimorfismo. Por exemplo, em sistema bancário, uma classe Conta poderia ser abstrata já

que não faz sentido criarmos objetos (contas) sem antes especificarmos um tipo para este

objeto (conta corrente ou conta poupança, por exemplo). Em outras palavras, um objeto que

seja simplesmente do tipo Conta, não acrescenta em nada ao sistema, devendo, portanto ser

abstrata para evitar que sejam gerados objetos desnecessários. Para métodos, imagine um

método na classe Conta que sirva para cobrar uma taxa. Você concorda que para cada tipo de

conta, temos uma taxa diferente. Portanto, esse método deve também ser abstrato para que

seja reescrito em cada caso.

1.7.3. sealed

Em tese, qualquer classe pode transformar-se em superclasse, permitindo gerar filhos que

reaproveitem seus métodos e atributos. Mas com o modificador sealed, podemos “trancar” uma

classe, isto é, impedir que ela seja herdada e que seu código seja reutilizado.

7


1.7.4. Tipo de acesso (privado, público e protegido)

Qualquer elemento no código possui um escopo que deve estar claramente definido. O escopo é

a abrangência ou alcance do elemento e está diretamente ligado ao encapsulamento. Podemos

controlar o escopo através das palavras public, private e protected. Quando um elemento é

public, seu acesso é permitido a partir de qualquer outro elemento, sem restrições. Já no

modificador private, o atributo é restrito apenas ao local original onde foi criado, não permitindo

nenhum tipo de manipulação externa, um exemplo exato de encapsulamento. Um atributo

private, por exemplo, não pode ser acessado ou modificado diretamente por objetos de outra

classe, que não seja a própria classe onde o atributo foi criado. Já o modo protected permite o

acesso e modificação do elemento apenas por herança ou por elementos do mesmo pacote.

Pacote? Sim, pacote. Um pacote é uma coleção de classes. Por exemplo, um sistema de uma

multinacional poderia separar suas filiais em pacotes e neles, as classes (pacote SP, com

classes Funcionário e Cliente; pacote RJ, com classes Fornecedor e Cliente). As classes que

pertencem ao mesmo pacote podem então, acessar elementos protected de outras classes.

1.8. Assinatura de método

A assinatura do método é a linha de código que especifica sua criação. A assinatura contém o

tipo de acesso, os modificadores, o tipo de retorno e o nome e parâmetros adicionais. Por

convenção de código, os métodos são escritos com a primeira letra da primeira palavra em

minúsculo e caso haja outras palavras, as letras iniciais destas em maiúsculo.

O tipo de retorno especifica se o método irá retornar valores ou não. No exemplo acima, o tipo

está especificado como um valor inteiro. Quando o método não retornar valor algum, indicamos

com a palavra void. No próximo capítulo iremos conhecer os tipos de valores da linguagem

Java.

8


2. TIPOS DE DADOS

Como em qualquer linguagem, no Java também temos os tipos de dados, para que haja uma

reserva de memória compatível com a informação que será armazenada. A linguagem Java tem

uma tipagem de dados forte e estática, isto é, o tipo de dado deve ser expresso antes da

execução do código e os valores armazenados devem ser compatíveis com o tipo declarado.

Isso garante consistência ao sistema evitando erros de estouro de memória, quando um valor é

armazenado em um espaço menor do que o reservado. No Java, podemos especificar tipos de

dados primitivos ou por referência, que ficam em lugares diferentes na memória.

2.1. Tipos primitivos (primitive)

Os tipos primitivos ficam em um lugar na memória chamada stack e representam valores

básicos, a maioria, numéricos. Por uma convenção de código, os tipos primitivos são sempre

escritos em minúsculo.

TIPO PRIMITIVO VALORES

int Números inteiros gerais

byte Números inteiros de -128 a 128

short Números inteiros pequenos

long Números inteiros longos

float Números decimais, com precisão de 7 casas

double Números decimais, com precisão de 14 casas

char 1 caracter (letra, número ou símbolo)

boolean Valores lógicos (true ou false)

Alguns tipos possuem uma classe correspondente que vem inclusa na instalação do Java

(chamada de API), utilizada para operações mais complexas através dos métodos desta classe.

O tipo int, por exemplo, possui a classe Integer (em maiúsculo), o tipo double possui a classe

Double, etc.

2.2. Tipos por referência (references)

Além dos tipos primitivos, o Java permite os tipos por referência, através de classes inclusas na

API do Java. Para utilizá-las, não é necessário criar um objeto da classe pretendida. Por

convenção de código, os tipos primitivos são escritos com a primeira letra maiúscula, pois se

9


referem a uma classe Java. As classes mais usadas são String, Array e Object. O tipo String é

usado para conjuntos de caracteres (um nome, um endereço). O tipo Array cria uma coleção de

dados do mesmo tipo, que pode ser tanto por referência quanto primitivo. Por exemplo, uma

lista de nomes ou de endereço, uma coleção de números inteiros, etc. Os Arrays são

identificados por colchetes. Veja o exemplo abaixo.

Já o tipo Object é genérico para qualquer objeto e pode ser usado quando precisamos gerar um

objeto no sistema, mas não sabemos de qual classe ele virá, isto é, não sabemos qual método

construtor será acionado.

2.3. Conversões entre tipos

É possível converter valores entre os tipos primitivos através da operação chamada de cast.

Colocamos o tipo final entre parênteses, na frente do valor final. Veja o exemplo abaixo.

CAST

Int x = (int)5;

No exemplo acima, o valor de x está sendo convertido para inteiro. Para tipos por referência, a

conversão é feita com a operação parse, presente em cada classe. Veja o exemplo abaixo da

conversão de um tipo String para um tipo Integer.

PARSE

int x = Integer.parseInt(5);

10


3. OPERADORES

Operadores são símbolos que podem representar uma ação ou cálculo dentro da linguagem

Java. Vamos conhecer alguns deles.

3.1. Operadores Unários

São os que representam apenas uma operação, utilizando símbolos específicos. Os principais

operadores unários do Java são:

3.1.1. Negação

Representado pelo símbolo de exclamação (!), o operador de negação, como o nome sugere,

nega o que estiver na frente do operador. Em outras palavras, o operador inverte o resultado

de um cálculo ou expressão lógica. Ex: !true vira false,

3.1.2. Incremento e Decremento

Incrementar (representado por ++) ou decrementar (representado por --) um atributo significa

alterar seu valor positiva ou negativamente em 1 unidade. Esta operação pode ser pré-fixada

ou pós-fixada. Quando realizamos uma operação pré-fixada, a variável é

incrementada/decrementada antes de ser utilizada. Por exemplo, considere o valor de x = 5 e

y=++x. Neste caso, qual o valor de y? A resposta seria 6, pois a variável x foi incrementada

antes de ser utilizada na operação. Já no exemplo y=x++, o valor de y permanece 5, pois a

variável x foi incrementada depois de ser utilizada.

3.1.3. Aritmético

Realizam as operações aritméticas mais comuns como Soma (+), Subtração (-), Divisão (/),

Multiplicação (*) e Resto (%).

3.2. Operadores de Atribuição

Atribuição é o ato de inserir valores nas variáveis e atributos do sistema. Podem ser atribuições

simples ou compostas.

3.2.1. Atribuição simples

É representada pelo sinal de igual (=). A variável ou atributo fica à esquerda do sinal e o valor à

direita. Ex: idade = 20; nome = “Joãozinho”;

11


3.2.2. Atribuições compostas

São as que, antes de inserirem valores nos atributos, fazem alguma operação aritmética com

um operador próprio. Observe o exemplo abaixo.

ATRIBUIÇÃO COMPOSTA

X += 5;

No exemplo acima, o valor de x ao final da operação será x+5. O mesmo acontece com os

outros operadores (-=, *=, /=, %=).

3.3. Operadores Relacionais

Também chamado de operadores de comparação, são os que comparam valores de variáveis ou

atributos. Podemos fazer várias comparações, como por exemplo, se um valor é menor (<) que

outro, se é maior (>), se é menor ou igual (<=), se é maior ou igual (>=), se é igual (==) ou

diferente (!=). Veja o exemplo abaixo

OPERADOR RELACIONAL

X != 5;

Neste exemplo acima, estamos comparando se x é diferente de 5.

3.4. Operadores Lógicos

Operadores lógicos envolvem mais de uma sentença e pode uni-las ou dividi-las. O resultado de

uma operação lógica será sempre verdadeiro ou falso. Temos dois operadores, de conjunção

(&&) e de disjunção (||). Na conjunção, as sentenças são unidas, isto é, o resultado somente

será verdadeiro quando todas as sentenças forem também verdadeiras. Veja o exemplo abaixo.

OPERADOR DE CONJUNÇÃO

(x>5) && (x!=10)

No exemplo acima, o resultado somente será verdadeiro se x for maior que 5 e, ao mesmo

tempo, x for diferente de 10. O mesmo ocorre se houver mais de 2 sentenças, ou seja, todas

devem ser verdadeiras. Já na disjunção, qualquer sentença que seja verdadeira já é suficiente

para o resultado ser verdadeiro. Veja o exemplo abaixo.

OPERADOR DE DISJUNÇÃO

(x>5) || (x!=10)

12


3.5. Métodos Matemáticos

No pacote de instalação do Java está incluso uma classe chamada Math, onde estão contidos

alguns métodos para operações matemáticas.

3.5.1. Método pow()

O método pow() calcula operações de potência, recebendo como argumentos a base e o

expoente, nesta ordem. O resultado retornado é sempre um double.

MÉTODO POW (base, expoente)

Math.pow(2,3);

3.5.2. Método sqrt()

O método sqrt(), de square root, calcula raiz quadrada de um argumento. Assim como o

método pow(), o resultado é sempre um double.

MÉTODO SQRT (argumento)

Math.sqrt(25);

3.5.3. Método cbrt()

O método cbrt(), de cube root, calcula raiz cúbica de um argumento. Também retorna um valor

double como resultado.

MÉTODO CBRT (argumento)

Math.cbrt(81);

3.5.4. Método ceil() e floor()

São métodos de arredondamento de valores. O método ceil() arredonda “para cima” e floor()

arredonda “para baixo”. Assim, o resultado abaixo seria 3 e 2, respectivamente.

MÉTODO CEIL (argumento) MÉTODO FLOOR (argumento)

Math.ceil(2.3); Math.floor(2.8);

Além de métodos, a classe Math possui também constantes como o Math.PI e o Math.E (número

de Euler). Outros métodos da classe Math são o log() para logaritmos, sin() para senos, cos()

para cossenos e tan() para tangentes.

13


4. DIAGRAMA DE CLASSES UML

A UML (Unified Modeling Language) é um modelo de linguagem,

com grande base em diagramas. E um dos diagramas ajuda a

especificar as classes de um sistema baseado em orientação a

objetos, representando inclusive os métodos e atributos. Veja ao

lado uma representação gráfica de uma classe em UML. Nela, o

nome da classe vem no alto do desenho. Na parte imediatamente

abaixo, vem descritos os atributos da classe com seus respectivos

tipos. O sinal de menos (-) indica que o atributo deve ser privado (private). Na última parte,

vêm descrito os métodos da classe com o tipo de retorno. O sinal de mais (+) indica que os

métodos são públicos (public). O símbolo # é usado para indicar elementos protegidos

(protected). Se o nome da classe estiver em itálico, significa que ela é estática (static).

4.1. Relacionamentos

O relacionamento entre as classes descrevem como os objetos criados no sistema irão

influenciar uns sobre os outros. Vamos conhecer alguns tipos e suas representações.

4.1.1. Generalização / Especialização

Caracteriza o conceito de herança entre classes, onde temos classes

específicas (subclasse) que herdam de uma classe geral (superclasse).

É importante frisar que na linguagem Java, não temos herança

múltipla, isto é, uma classe pode herdar métodos e atributos de apenas

uma única outra classe. É representada por uma linha e uma seta

branca apontando para a superclasse. Veja um exemplo da

representação gráfica de especialização.

4.1.2. Agregação

Na relação de agregação, os objetos específicos de

uma classe se relacionam com os objetos específicos

de outra classe, de modo que um faça parte do

outro. É representada por um losango branco na

extremidade da linha. A principal característica está

na exclusão de um objeto. Quando isto ocorre, a

outra parte não é excluída junto e continua existindo

no sistema. No exemplo ao lado, imagine que uma

vacina contra a raiva seja aplicado em um cachorro.

14


Caso este cachorro (que é um objeto) venha a ser “destruído” no sistema, a vacina contra a

raiva (que também é um objeto) deve continuar a existir pois pode ser aplicado em outro

cachorro (outro objeto). Além disso, o objeto agregado pode estar presente várias vezes na

outra parte. A palavra “contém” especifica um nome para a relação.

4.1.3. Composição

Tem o mesmo conceito de uma relação de agregação. Porém, ao destruir um objeto, todos os

outros objetos relacionados também são destruídos. É representado graficamente por uma linha

com um losango preto na extremidade. Além disso, o objeto composto pode constar em apenas

uma única outra parte. Um exemplo são objetos Capítulos e Seções. Um capítulo é composto de

seções, onde uma seção específica consta em apenas um capítulo específico. Quando um

capítulo é apagado do sistema, todas as suas seções também são apagadas em conjunto.

4.2. Multiplicidade

A multiplicidade ou cardinalidade define a quantidade de objetos que estará presente nos lados

de uma relação. A quantidade é sempre definida como 1 ou várias (representada por asterisco

[*]) e pode ser diferente de um lado para outro. Acompanhe os exemplos abaixo, envolvendo

as classes Musica, CD e Gravadora.

MULTIPLICIDADE CD-GRAVADORA

Uma gravadora pode ter vários CD’s (1-*)

Um CD pode pertencer a apenas uma gravadora (1-1)

MULTIPLICIDADE MUSICA-CD

Uma CD pode ter várias músicas (1-*)

Uma música pode estar em vários CD’s (1-*)

MULTIPLICIDADE MUSICA-GRAVADORA

Uma gravadora pode ter várias músicas (1-*)

Uma música pode pertencer a apenas uma gravadora (1-1)

15


5. ESTRUTURAS DE SELEÇÃO EM JAVA

Na linguagem Java, temos algumas estruturas ou blocos de comandos que auxiliam a realizar

tarefas de modo facilitado. As estruturas de seleção, também chamadas de desvio condicional,

permitem selecionar uma alternativa dentre várias para determinar um resultado (seja ele

verdadeiro ou falso). Vamos conhecer as estruturas de seleção.

5.1. IF..ELSE

A estrutura IF/ELSE é utilizada quando queremos selecionar um resultado dentre 2 possíveis

(verdadeiro ou falso), fazendo comparações entre sentenças, testando-as. Para realizar

comparações, utilizamos os operadores da linguagem Java. Vamos a um exemplo.

Imagine que queremos deteminar se uma pessoa pode ou não obter a carteria de habilitação no

Brasil. Faremos isso testando a idade e exibindo uma mensagem na tela. Acompanhe os

códigos abaixo.

ESTRUTURA IF EM JAVA

int idade;

if (idade>=18){

System.out.print (“Apto a dirigir”);

}

else{

System.out.print (“Inapto a dirigir”);

}

Na primeira linha da estrutura, testamos se a idade é maior ou igual a 18. Se for (resultado

verdadeiro), o Java irá executar a primeira opção, escrevendo na tela “Apto a dirigir”. Em Java,

utilizamos para exibir mensagens o método print() do pacote System.out (veremos mais sobre

os pacotes adiante). Caso a idade não seja maior ou igual a 18 (resultado falso), o Java irá

executar a linha ELSE, escrevendo na tela “Inapto a dirigir”. Note que cada bloco é separado

por chaves {}.

5.2. SWITCH

A estrutura SWITCH funciona de modo semelhante a estrutura IF/ELSE, fazendo a seleção de

uma solução dentre várias possíveis. A principal diferença é que as comparações com SWITCH

só podem ser feitas com operador de igualdade, enquanto que com a estrutura IF/ELSE

podemos fazer outras comparações (maior, menor, maior ou igual, menor ou igual). É indicado

usar a estrutura SWITCH quando temos um grande número de possibilidades e, claro, estas

puderem ser comparadas com sinal de igualdade. Vamos a um exemplo.

16


Imagine que em uma loja, a vendedora deve digitar um código para determinar o modo de

pagamento, seguindo a regra: 1 – CARTÃO, 2 – DINHEIRO e 3 – CHEQUE. Veja o exemplo de

código para esta situação:

ESTRUTURA SWITCH EM JAVA

int codigo;

switch(codigo)

{

case 1:

System.out.print(“Cartão”);

break;

case 2:

System.out.print(“Dinheiro”);

break;

case 3:

System.out.print(“Cheque”);

break;

}

No exemplo acima, a estrutura de seleção escolha primeiramente uma variável para “testar”

(código). Lembre-se que a estrutura SWITCH só permite operações de igualdade, isto é, só é

possível testar se o código é igual a alguma coisa. A variável testada precisa necessariamente

não ser do tipo FLOAT ou DOUBLE ou então perderemos a precisão do código. A variável irá

então passar por testes e caso seja igual a algum valor (1, 2 ou 3), o código correspondente

será executado. Note que ao final de cada execução temos a instrução break, utilizada para

interromper a execução dos testes, ou seja, quando a mensagem for exibida na tela, O Java

para de testar e encerra imediatamente a estrutura.

17


6. ESTRUTURAS DE REPETIÇÃO EM JAVA

Como o nome sugere, as estruturas de repetição, também chamada de laços, auxiliam o Java

na tarefa de repetir linhas de código de modo finito, a fim de evitar a redigitação de algum

trecho. Cada estrutura tem sua repetição de modo particular, podendo ser usada livremente de

acordo com a lógica do programa. É importante notar que uma estrutura de repetição pode

conter, dentro dela, uma ou mais estrutura de seleção e vice-versa. Vamos conhecer as

estruturas de repetição.

6.1. FOR

A estrutura FOR repete linhas de código em número de vezes definido, isto é, devemos usá-la

quando sabemos exatamente quantas vezes o código irá se repetir. Geralmente, para a

estrutura FOR, usamos uma variável auxiliar para contar a quantidade de repetições, de modo

que o programa não execute nem mais, nem menos vezes do que o necessário (vamos chamar

essa variável nesta apostila de “i”). Esta variável obrigatoriamente deve ser do tipo INT. Vamos

a um exemplo.

Imagine que desejamos escrever na tela 10 vezes a frase “Aprenda Java”. Caso fizessemos no

modo tradicional, escreveríamos 10 vezes o comando System.out.print() para exibir a frase.

Como sabemos o número exato de repetições, podemos escrever apenas 1 uma vez o comando

e usar a estrutura FOR para repetir 10 vezes. Acompanhe o código de exemplo abaixo.

ESTRUTURA FOR EM JAVA

int i;

for (i=0;i<10;i++){

System.out.print(“Aprenda Java”);

}

Na início da estrutura, é declarada que a variável “i” que irá contar a quantidade de repetições.

Quando abrimos a estrutura, definimos os limites da contagem, começando em 0 e indo até 9

(menor do que 10). A instrução i++ indica que a cada repetição, a variável “i” deve ser

incrementada. Dentro do bloco, é colocado um único código onde aparece a mensagem na tela

que irá se repetir 10 vezes (de 0 a 9).

6.2. WHILE

Para os casos em que não sabemos a quantidade de vezes que o código deverá ser repetido,

temos a estrutura WHILE. Para repetir, testamos uma sentença e se o resultado for

verdadeiro, o código se repete. No momento que a sentença passar a ser falsa, o laço é

18


interrompido (o que pode ocorrer a qualquer momento, não sabemos quando). A estrutura

WHILE tem uma particularidade extremamente importante de notar. O teste da sentença é feito

no início do laço, portanto, pode ocorrer de o laço não ser executado nenhuma vez, caso a

sentença não seja verdadeira logo de início. Vamos a um exemplo.

Imagine que o usuário deva adivinhar um número. Para isso deve ir tentando digitar números e

quando acertar o sistema mostrará uma mensagem avisando-o do acerto. Acompanhe o código

abaixo.

PASCAL

int sorteado, numero;

sorteado=23;

while(sorteado!=numero){

System.out.print(“Tente adivinhar: “)

numero=x.nextInt();

}

System.out.prin(“Parabéns”);

Nos código acima, o número sorteado é 23. O teste do WHILE é feito no início resultando em

verdadeiro (23 é diferente de 0), portanto o laço é iniciado. A partir daí, o código irá se repetir

eternamente nas duas linhas de baixo até o número ser adivinhado. Quando isso ocorrer, a

condição inicial passa a ser falsa (23 é igual a 23) e o laço é interrompido, executando por fim,

a linha com a mensagem de parabéns. Note dentro da estrutura o código x.nextInt(). O “x” é

um objeto da classe Scanner utilizado para leitura de dados via teclado (veremos adiantes mais

sobre a classe Scanner).

6.3. DO WHILE

A estrutura DO WHILE possui o mesmo principio de funcionamento da estrutura WHILE, isto é,

repete um trecho de código por um número de vezes indefinido, após testar uma sentença.

Porém há uma diferença importantíssima. O teste da sentença é feito apenas no final do

código, isto significa que as instruções serão executadas ao menos uma vez (na estrutura

WHILE o código corre o risco de não ser executado nenhuma vez, pois o teste é feito no início

da estrutura). A sentença testada deve ser verdadeira para o laço funcionar, assim como na

estrutura WHILE. Em suma, devemos usar a estrutura DO WHILE quando há a necessidade do

código ser executado ao menos uma vez.

Vamos refazer o mesmo exemplo anterior, utilizando a estutura DO WHILE. O usuário tentará

adivinhar o número escolhido pelo programa.

19


ESTRUTURA DO WHILE EM JAVA

int sorteado, numero;

sorteado=23;

do{

System.out.print(“Tente adivinhar: “)

numero=x.nextInt();

}while (sorteado!=numero)

System.out.prin(“Parabéns”);

Após inserir o número 23 na variável “sorteado”, entramos na estrutura de repetição DO. Note

que neste ponto não há nenhum teste de sentença, o que faz com que o código continue sendo

executado normalmente. Após as linhas System.out.print() e a leitura de dados através da

classe Scanner (mais nos capítulos adiante) dentro da estrutura, há o teste com o comando

WHILE. Se o resultado do teste for verdadeiro, o código irá se repetir até que este seja falso,

isto é, até que o usuário acerte o número. Ao sair da estrutura, é exibida a linha com os

“parabéns”.

Podemos também forçar a saída de um laço de repetição por algum motivo. Para isso usamos o

comando BREAK (semelhante a estrutura SWITCH) que interrompe o laço e executa a próxima

instrução.

20


7. ARRAYS

Alguns capítulos antes, vimos o tipo de variável por referência Array. Vamos conhecê-lo melhor.

Em qualquer linguagem de programação, as variáveis guardam apenas um valor. Algumas

linguagem implementam o conceito de coleção, onde é possível armazenar vários valores em

apenas uma variável. Na linguagem Java, podemos ter vários tipos de coleções dos quais

destacamos os vetores, as listas, filas, pilhas e árvores, estudadas na área de Estrutura de

Dados. Vamos nos focar nos vetores. Mas como localizamos os dados em uma coleção?

Em vetores, os dados vão sendo armazenados e organizados em uma sequencia lógica e

numerada, como um índice de um livro. Cada informação fica armazenada em um número

ordenado de acordo com a quantidade de espaços ou posições disponíveis. Imagine que

desejamos armazenar vários nomes de clientes em um sistema. Ao invés de criar várias

variáveis do tipo String, podemos criar um vetor. Veja um exemplo gráfico:

João José Juca Maria Benedita Mário Ana

Acima temos a representação gráfica de uma coleção de dados do tipo String. Note os índices

identificando cada informação que é gravada, ficando fácil para localizar ou manipular as

informações dentro da coleção. Algumas linguagens de programação, como o Java, definem por

padrão o número 0 (zero) como o primeiro índice da coleção, o que pode alterar a lógica de seu

programa.

7.1. PERCORRENDO COLEÇÕES

Frequentemente, as coleções precisam ser percorridas, isto é, todos os seus espaços precisam

ser conferidos e analisados. A forma mais comum de realizar essa operação é utilizando as

estruturas de repetição. Como as coleções sempre possuem um número definido de espaços

para guardar as informações, a estrutura FOR é quase sempre a mais indicada, pois

precisaremos definir um o início e o fim da coleção de modo explícito. A estrutura FOR evita

também um erro clássico de lógica que é tentar acessar um índice inexistente na coleção

(algumas linguagens definem o erro de Null Pointer Exception), já que a contagem dos índices é

explícita. Lembre-se que representamos as coleções com o símbolo de colchetes ([ ]). Primeiro

definimos o nome da coleção, seguindo pela palavra VETOR/ARRAY. Dentro dos colchetes

colocamos as dimensões da coleção, isto é o número de seus índices. Por fim, definimos o tipo

de dado que a coleção irá guardar, no caso literal/string. Como fazemos então para percorrer a

coleção?

1 2 3 4 5 6 7

21


Vamos utilizar como exemplo, uma coleção de nome. Imagine que desejamos imprimir na tela

os nomes contidos em todas as posições. Acompanhe o código.

VETORES EM JAVA

int i:

String[] nomes = new String[10];

for (i=0;i<10;i++){

System.out.print(nomes[i]);

}

Vamos entender o código acima. Declaramos um vetor de String chamado “nomes”, com 10

espaços para armazenar nossas informações. Note que há uma variável inteira (“i”) responsável

por controlar os índices da coleção. Iniciamos então a estrutura FOR, contando de 0 até 9

(menor do que 10), isto é, repetindo o código 10 vezes. Para cada repetição, iremos escrever

na tela o valor da coleção na posição que estiver valendo a variável “i”, isto é, de 0 a 9, um de

cada vez. Desse modo, conseguimos passar por todas as posições da coleção, imprimindo o

valor na tela de cada índice.

22


8. IMPORTANDO CLASSES

No pacote de instalação do Java, temos algumas classes inclusas que não contém métodos

static, significando que é preciso importá-las para seu código e criar objetos dessas classes para

habilitar seu uso (diferentemente da classe Math que pode ser usada diretamente). Vamos

conhecer 3 classes importadas.

8.1. Scanner

A classe Scanner é responsável pela entrada de dados via teclado. Qualquer valor ao ser

digitado pode ser lido com objetos da classe Scanner e armazenado em variáveis. Como dito

anteriormente, essa classe precisa ser importada. Para isso, adicione a seguinte linha no início

do seu código.

IMPORTANDO A CLASSE SCANNER

import java.util.Scanner;

Após importar, é necessário criar um objeto Scanner para utilizar os métodos da classe.

Chamaremos então o método construtor da classe Scanner, criando um objeto “x”. Segue o

código:

CRIANDO UM OBJETO SCANNER

Scanner x = new Scanner (System.in);

Agora o objeto “x” nos dá acesso aos métodos da classe Scanner. São métodos básicos para

leitura de dados via teclado. Os métodos são implementados de acordo com cada tipo de dado.

Suponhamos que desejamos ler o nome de uma pessoa digitado no teclado e armazenar na

variável “nome”. Acompanhe o código:

LENDO VALORES PELO SCANNER

String nome = x.nextLine();

A linha acima diz que a variável “nome” irá receber o próximo valor String digitado. De posse

do objeto x, acionamos o método nextLine() usado para ler valores de texto. Da mesma forma

seria para ler uma idade.

LENDO VALORES PELO SCANNER

int idade = x.nextInt();

23


Como a idade é uma informação numérica inteira, o método acionado é o nextInt(). Da mesma

forma podemos acionar o nextDouble(), nextFloat(), nextByte() ou nextBoolean() de acordo

com cada tipo de dado.

8.2. Abstract Windowing Toolkit (AWT)

Trata-se na verdade de um pacote de classes que permite manipulação de ambientes gráficos

(GUI – Graphical User Interface) no Java. É possível construir botões, janelas, elementos de

cor, entre outras opções. O pacote AWT utiliza a biblioteca do próprio sistema operacional para

renderizar os elementos gráficos na tela, isto é, se você estiver no Windows, os elementos irão

aparecer com o tema do Windows e assim por diante. Para usar o pacote, é preciso importar

com a linha abaixo:

IMPORTANDO PACOTE AWT

import java.awt.*;

Note o asterisco (*), ele indica que TODO o pacote AWT será importado. Dentro do pacote AWT,

dispomos de várias classes que modelam as regras dos componentes gráficos. A classe Frame,

por exemplo, serve como superclasse para a maioria das janelas. A classe Component modela

atributos e comportamentos de componentes comuns como botões, setas, barras, etc. A classe

Container é uma subclasse de Component e permite organizar os componentes gráficos,

posicionando-os na tela. Por não ter um padrão de exibição e buscar recursos nativos do

sistema operacional para renderização dos elementos, o pacote AWT é por vezes substituído

pelo pacote SWING.

8.3. Swing

Contém diversos elementos em comum com o pacote AWT, porém com recursos próprios para

renderização, o que garante certa padronização na exibição dos elementos, independente da

plataforma ou sistema operacional. É preciso também importá-la com a linha abaixo:

IMPORTANDO PACOTE AWT

import javax.swing.*;

Vamos conhecer algumas classes de elementos gráficos do pacote SWING.

JButton - Botão padrão;

JLabel - Rótulo de texto;

JTextField - Campo de texto de uma linha (para várias linha, há o JTextArea);

JCheckBox - Caixa de seleção;

JChoice - Caixa drop-down.

24


Cada uma das classes faz-se necessária a criação de um objeto da mesma para que seja

possível utilizar seus métodos e mostrar o objeto na tela. Vamos tomar como exemplo a classe

JButton para criarmos um objeto (um botão) e utilizar seus métodos de manipulação.

CRIANDO UM OBJETO BOTÃO

JButton botao = new JButton();

Agora temos um objeto da classe JButton (botao) e podemos acessar seus métodos para

manipulação, como colocar uma legenda no botão, tamanho, cor, visibilidade, etc. Vamos

conhecer alguns exemplos.

MÉTODO DE EXEMPLO ACÃO

botao.setLabel(“Salvar”); Colocar uma legenda no botão.

botao.setSize(100,200); Define largura e altura em pixels.

botao.setBackground(vermelho); Define uma cor de fundo do botão.

botao.setVisible(true); Define se o botão será visível ou não.

botao.setForeground(branco); Define a cor do texto do botão.

No caso dos métodos setBackground() e setForeground(), os argumentos passados (vermelho e

branco) são, na verdade, objetos da classe Color com valores que representam a cor em

questão. Na linguagem Java, as cores são definidas seguindo o padrão RGB (Red, Green e Blue)

cujos valores vão de 0 a 255. A combinação entre os 3 valores resulta em uma grande variação

de cores. A ausência de todas (0,0,0) resulta em preto enquanto a presença máxima de todas

(255,255,255) resulta em branco. Para criar o objeto da classe, use a linha abaixo.

CRIANDO UM OBJETO COLOR

Color vermelho = new Color(255,0,0);

Da mesma forma, os outros elementos podem ser criados e manipulados através dos métodos

da classe correspondente. Para caixas de texto (JTextField) por exemplo, pode-se definir a cor

de fundo, a formatação de texto (negrito, itálico).

Uma das classes mais úteis do pacote SWING é o JOptionPane quer permite criar caixas de

diálogo e de entrada de dados. Vamos conhecer métodos dessa classe.

8.4. JOptionPane

Contida no pacote SWING, é útil quando desejamos criar caixas gráficas para exibir mensagens

ou para entrada de dados via teclado. Vamos exemplificar dois métodos desta classe:

25


8.4.1. showInputDialog()

O método showInputDialog() permite criar caixas para entrada de dados via teclado. Para

utilizá-lo, basta chamar o método passando um texto de enunciado, se necessário. Acompanhe

o exemplo abaixo:

MÉTODO showInputDialog()

String nome = JOptionPane.showInputDialog(“Qual seu nome?”);

Irá aparecer uma caixa com a mensagem acima e com um campo para digitação. Uma

característica ‘desvantajosa’ é que o JOptionPane captura apenas tipos String, sendo necessário

a conversão com métodos parse. Por exemplo, caso desejemos capturar uma idade (que é

numérica), devemos armazená-la numa String e convertê-la para int. Acompanhe o exemplo:

MÉTODO showInputDialog()

String idade = JOptionPane.showInputDialog(“Qual sua idade?”);

int x = Integer.parseInt(idade);

8.4.2. showMessageDialog()

Método que permite gerar caixas de mensagens na tela. Para utilizá-lo, basta chamar o método

passando alguns parâmetros, na ordem descrita. O primeiro parâmetro indica a posição e é

geralmente especificado como null, quando a caixa não está dentro de nenhuma outra janela. O

segundo parâmetro é o conteúdo da caixa de texto, podendo ser um texto ou uma variável. O

terceiro parâmetro é o título da caixa que irá aparecer na barra de título, devendo vir entre

aspas. O último parâmetro é o ícone indicativo da caixa, chamado através de uma constante da

classe JOptionPane que pode ser:

MÉTODO showMessageDialog()

JOptionPane.showMessageDialog(null, “Java”, “Curso:”, JOptionPane.INFORMATION_MESSAGE)

26


9. PERSISTÊNCIA DE DADOS

Ao desenvolver um sistema, é comum trabalharmos com dados simulados, geralmente

utilizando a memória RAM do computador como auxílio. Por esta razão, quando desligamos a

máquina ou fechamos o software em desenvolvimento, os dados que digitamos desaparecem.

Ao iniciar o programa novamente, precisamos redigitá-los. Esse cenário é bastante comum por

se tratar de um ambiente de desenvolvimento e testes. Claramente, ao finalizar o software e

colocá-lo em funcionamento, os dados não podem ser voláteis. Imagina ter que cadastrar um

cliente novamente toda vez que o programa ou o computador for reiniciado? Inviável! Por isso

os dados precisam ser “eternizados”.

A persistência de dados trata justamente do armazenamento permanente, isto é, os dados são

persistidos e continuam a existir após o encerramento do software. Entre vários meios de

armazenamento permanente, temos os bancos de dados. A linguagem Java é perfeitamente

comunicável com vários bancos de dados, através de um driver de conexão específico. Um

driver pode ser visto como um código contendo informações de acesso a um determinado

objetivo (seja um hardware ou um software). Por exemplo, para fazer funcionar uma

impressora é necessário um driver que contém informações para permitir o acesso do

computador a essa impressora. Num driver de conexão de banco de dados estão especificados

os dados de acesso como nome de usuário e senha, endereço do servidor e nome do banco de

dados a ser acessado. Na linguagem Java, esse driver é chamado de JDBC (Java Database

Connectivity). Cada banco de dados fornece um arquivo JDBC específico, baixado gratuitamente

na Internet, que deve ser incorporado ao código Java para fazer a comunicação entre a

aplicação e a base de dados. Vamos exemplificar a comunicação entre o Java e o banco de

dados MySQL da empresa Oracle Inc. No momento de desenvolvimento deste material didático,

o JDBC do MySQL pode ser baixado em http://dev.mysql.com/downloads/connector/j/5.0.html

Após baixar o arquivo, copie-o para a pasta jdk\jre\lib\ext localizada dentro da pasta de

instalação do Java (normalmente C:\Arquivos de Programas\Java). Após copiar, carregue o

conector para sua aplicação. Dependendo da ferramenta de desenvolvimento que você estiver

usando, pode haver diferentes formas para carregar o conector.

No JCreator, clique em CONFIGURE – OPTIONS. Na janela aberta, clique em JDK PROFILES do

lado esquerdo. Selecione o JDK que você está usando, clique em EDIT – ADD – ADD ARCHIVE.

Selecione agora o arquivo que baixamos na pasta ext. Dê OK nas janelas.

No Eclipse, clique com o botão direito em cima da pasta do projeto e escolha PROPERTIES. Na

janela que se abre, clique em JAVA BUILD PATH do lado esquerdo. Clique na aba LIBRARIES e

no botão ADD EXTERNAL JARS e escolha o arquivo JDBC que baixamos.

27


Após configurarmos o JDBC do MySQL, precisamos agora criar classes para efetuar nossas

ações no banco (gravar, excluir, etc) e também realizar a conexão com usuário e senha.

9.1. Classes de Persistência

Quando trabalhamos com persistência de dados, devemos criar códigos onde seja possível

realizar as operações mais comuns, chamadas de CRUD (Create, Read, Update, Delete). Estas

operações permitem cadastrar novas informações, visualizar dados existentes, atualizar

informações já cadastradas ou apagar registros. O código para estas operações são comumente

chamados de classes de persistência. Além dessas operações, é necessário também um código

para conectar-se ao banco. Para simplificar, vamos criar os métodos de conexão e persistência

em um mesmo arquivo. Vamos chamar essa classe de “ConexaoBD”.

CLASSE CONEXAOBD

import java.util.*;

import java.sql.*;

public class ConexaoBD

{

private String url;

private String login;

private String senha;

public ConexaoBD(String url)

{

this.url = url;

}

public crud(String comando)

{

Class.forName("com.mysql.jdbc.Driver").newInstance();

Connection conn = DriverManager.getConnection(url);

String sql = comando;

Statement stm = conn.createStatement();

stm.executeUpdate(sql);

}

}

Note que importamos uma classe extra, a classe SQL, própria para interação com banco de

dados. O método crud() irá carregar o JDBC do MySQL, abrir a conexão com a variável url

executar o comando digitado pelo usuário (variável sql). No método principal de seu programa,

basta criar um objeto da classe ConexaoBD passando a seguinte configuração;

ConexaoBD x = new ConexaoBD("jdbc:mysql://servidor/banco?user=root&password=");

Em servidor, insira o endereço de seu servidor de banco de dados, bem como o nome do banco,

o usuário e a senha. Após isso, basta chamar o método crud() passando o comando desejado.

28


10. REFERÊNCIAS

http://www.caelum.com.br/apostila-java-orientacao-objetos/

http://dev.mysql.org

http://www.guj.com.br

http://www.oracle.com/br/technologies/java/overview/index.html

========================================================

Apostila produzida pelo Prof. Esp. Jonas Willian R. Aureliano para o Curso Técnico de

Informática do Colégio Tableau de Guaratinguetá.

Documents

-- CURSO TÉCNICO DE INFORMÁTICA -- MÓDULO III LÓGICA … · A apostila foi produzida com base no software de desenvolvimento Eclipse, disponível ... de programadores em COBOL