programação orientada a objetos com java

PROGRAMAÇÃO ORIENTADA A OBJETOS

COM JAVA

https://www.facebook.com/alvarofpinheiroaulas/br.linkedin.com/in/alvarofpinheiro/

www.alvarofpinheiro.eti.br

JAVAApresentação

*www.alvarofpinheiro.eti.br

Java Apresentação

Eclipse●Se trata de um Ambiente de Desenvolvimento Integrado ou Integrated Development

Environment (IDE). É um software livre e permite suporte a algumas linguagens de

programação, a exemplo, Java, PHP, C e C++. Possui portabilidade paras as plataformas

Linux, Windows e Mac OS. Uma das características dessa IDE é a flexibilidade na

personalização, o que faz muitos o classificarem como um Framework, justamente devido

a esse poder de customização. Podendo assim ser utilizado um dos pacotes disponíveis

na Web ou você mesmo montar o seu pacote. Outra característica marcante dessa IDE é

que ela é portable, ou seja, não precisa de instalação, bastando extrair os arquivos na

pasta e executá-lo.

●Existem várias versões , as que estão disponíveis como é mostrado abaixo:

●* 3.7 – Indigo (Cor entre azul e violeta) – lançado em 28 de Junho de 2011;

●* 3.6 – Helios (Sol para os gregos) – lançado em 23 de Junho de 2010;

●* 3.5 – Galileo (Conjunto de quatro luas de Jupiter) – lançado em 24 de Junho de 2009;

●* 3.4 – Ganymede (Lua de Jupiter) – lançado em 25 de Junho de 2008;

●* 3.3 – Europa (Lua de Jupiter) – lançado em 29 de Junho de 2007;

●* 3.2 – Callisto (Lua de Jupiter) – lançado em 30 de Junho de 2006;

●* 3.1 – sem codinome – lançado em28 de Junho de 2005;

●* 3.0 – sem codinome – lançado em 28 de Junho de 2004.*


Java Apresentação

Eclipse●Além das versões acima existem os pacotes. Esses existem para agrupar por

linguagem e plugins direcionados para um tipo de desenvolvimento. Para Java

usa-se normalmente o Eclipse IDE for Java EE Developers (JEE), pois é a mais

completa ou o Eclipse IDE for Java and Report Developers (Reporting), que

tem os mesmos componentes da primeira mais o Birt, que é um recurso para

desenvolver relatórios. Os plugins, além os do pacote, existem diversos

disponíveis na Web e para instalar é normalmente só baixá-los e descompactá-

los dentro da pasta eclipse.

●Para baixar as versões e pacotes segue link:

●http://www.eclipse.org/downloads/

●Para baixar os plugins segue link:

●http://www.eclipse.org/modeling/mdt/?project=uml2


Java Apresentação

http://www.eclipse.org/downloads/

http://www.eclipse.org/modeling/mdt/?project=uml2

JDK / JRE / JVM●JDK é um Pacote de Desenvolvimento de Aplicativos ou Java Developers Kit e servem

para que desenvolvedores tenham condições de interagir com o software,

disponibilizando para isso documentação, código e utilitários. Basicamente o JDK contém

diversas ferramentas entre as quais estão as de compilação e execução do programa

Java. JDK e SDK são as mesmas coisas.

●JRE significa Ambiente de Tempo de Execução ou Java Runtime Environment e é

utilizado para executar as aplicações da plataforma Java. Basicamente ele é composto

de bibliotecas ou Application Program Interface (API) e da Máquina virtual Java ou Java

Virtual Machine (JVM). Ele é utilizado como um interpretador de código de bytes em

código de máquina, assim o JRE é o interpretador do programa Java. JRE contém o

ambiente de execução, como JVM e outras classes Java (AWT, SWING), mas não

contém todas as ferramentas de desenvolvimento tais como um compilador ou um

depurador.

●JVM é a Máquina Virtual Java e é usada para interpretar o programa em Java para

plataforma para corrente. Ambos JDK e JRE contém a JVM .


Java Apresentação

JDK / JRE / JVM●O Java Developers Kit (JDK) inclui a JVM, bibliotecas de

classe standard, e muita outras ferramentas que um

desenvolvedor utiliza para desenvolver um programa

Java

●O Java Runtime Environment (JRE) inclui a JVM,

bibliotecas de classe standard, desta forma pode-se

executar um programa Java, mesmo não possuindo

todas as ferramentas.

●O Java Virtual Machine (JVM), é o responsável em

carregar os arquivos da classe para a sua execução.*


Java Apresentação

JAR●O Java Archive (JAR) é um arquivo compactado usado para distribuir classes

compiladas, metadados associados que podem constituir um programa,

imagens, XMLs, etc. Mas, normalmente é usada para distribuir uma aplicação

Java que contém tudo que foi citado.

●Os arquivos JAR podem ser criados e extraídos usando o utilitário "jar" da

JDK. Esse tipo de arquivo possui um manifesto localizado no caminho META-

INF/MANIFEST.MF. As entradas do arquivo manifesto determinam como o ele

será usado. O que é normalmente usado como um executável, desta forma ele

terá uma de suas classes especificada como a classe principal.

●O arquivo manifesto terá uma entrada do tipo:

●Main-Class:meusProgramas.MinhaClasse.

●As aplicações contidas neste tipo de arquivo são tipicamente executadas com

o comando java -jar exemplo.jar


Java Apresentação

História●O Java foi concebido inicialmente como uma ferramenta de programação para um

projeto da empresa Sun Microsystems, denominado de O Projeto Verde, pelos

desenvolvedores Patrick Naughton, Mike Sheridan e James Gosling, no ano de 1991.

Esse projeto tinha o objetivo criar uma nova plataforma para a computação interativa,

desta forma, a linguagem de programação não era o principal objetivo desse projeto. Um

ano após o início foi concluído o sistema que permitia controle remoto e possuía interface

sensível ao toque interativa, sendo o sistema denominado de *7 (star seven). Com esse

sistema era possível controlar uma grande variedade de dispositivos de uso doméstico,

além de possuir interface com alta usabilidade e gráfica.

●A linguagem utilizada nesse sistema foi batizada de Oak o que significa carvalho em

inglês, em referência a árvore que James Gosling via todos os dias de sua janela no

período de desenvolvimento. Em 1995, John Gage, diretor da Sun Microsystems, e Marc

Andreessen, um executivo da Netscape, anunciaram o lançamento da plataforma Java,

que era composta do Java Virtual Machine (JVM) e do Application Programming Interface

(API) Java. Essa plataforma foi inserida no Netscape Navigator, um dos principais

browsers nessa época.


Java Apresentação

Biografia●Patrick Naughton, americano nascido em 1965 é um desenvolvedor de software

conhecido como sendo um dos criadores originais da linguagem de programação Java,

pois trabalho na Sun Microsystems no Projeto Verde a origem do Java. Em 1994, saiu da

Sun e foi para Starwave de propriedade de Paul Allen para desenvolver um servidor Java.

É autor do livro O Manual do Java, Osborne, 1995 e co-autor do Java: The Complete

Reference, com Herbert Schildt, Osborne , 1996. Em 1998, torna-se vice-presidente

executivo da Infoseek.

●James Gosling, nasceu em Calgary no Canadá em 1955 é conhecido como o pai da

linguagem de programação Java. Em 1977, formou Bacharel em Ciência da Computação

pela Universidade de Calgary, e em 1983 tornou-se PhD em Ciência da Computação pela

Universidade Carnegie Mellon. Enquanto estudava no doutorado, Gosling programou a

versão original do editor de texto Emacs para UNIX, e antes de se juntar a Sun

Microsystems ele construiu uma versão de UNIX para máquinas multi-processadas,

assim como diversos compiladores e sistemas de mensagens eletrônicas. Trabalhou de

1984 até 2010 na Sun Microsystems, atualmente está na Google.


Java Apresentação

Independência●O código é armazenado em arquivos com extensão

.java; Um programa .java compilado se transforma em

.class; Bytecodes são interpretados em tempo de

execução.


Java Apresentação

Applets●Utilizado em páginas HTML; Pode incluir formulários,

áudio, imagens, vídeo, etc.; Aparece nos browsers e

pode se comunicar com o servidor.


Java Apresentação

Aplicação●Instalação no lado do cliente: JVM é executado; Não faz

carga das classes na rede;

●Instalação do lado do servidor; Pode servir múltiplos

clientes; Faz uso dos modelos multi-camada.


Java Apresentação

Java●Código é compilado para bytecodes;

●Código bytecodes é independentes de plataforma;

●Os bytecodes são interpretados por uma JVM;

●As applets são executados em um browser no cliente;

●As aplicações Java são executadas de forma autônoma.


Java Apresentação

JAVAIntrodução


Java Introdução

Convenções●Nomes dos arquivos = palavras capitalizadas:

●Ex.: ArquivoX.java, NomeComposto.java

●Nomes das Classes = palavras capitalizadas:

●Ex.: Classe, NomeComposto

●Nomes dos Métodos = verbo + palavras capitalizadas:

●Ex.: getCampoNome(), setCampoNome()


Java Introdução

Definição de Classe●Modificador de acesso: public, private

●A palavra-chave class

●Campos das instâncias

●Construtores

●Métodos das instâncias

●Campos da classe

●Métodos da classe

*

public class ClasseExemplo {

// campos das instâncias

private int campoExemplo1;

private String campoExemplo2;

// construtores

public ClassExemplo() {

this.campoExemplo1 = 0;

this.campoExemplo2 = "";

}

public ClassExemplo(int paramExemplo1; String paramExemplo2) {

this.campoExemplo1 = paramExemplo1;

this.campoExemplo2 = paramExemplo2;

}

// métodos das instâncias

private int getCampoExemplo1() {

return campoExemplo1;

}

private void setCampoExemplo1(int campoExemplo1) {

this.campoExemplo1 = campoExemplo1;

}

private String getCampoExemplo2() {

return campoExemplo2;

}

private void setCampoExemplo2(String campoExemplo2) {

this.campoExemplo2 = campoExemplo2;

}

}


Java Introdução

Bloco de código●Em java se usa chaves “{ }” para: Agrupar todas as

declarações de classe; Agrupar todas as declarações de

métodos; e Agrupar outros segmentos de código

relacionado entre si.


Java Introdução

Instruções●Os comandos terminam sempre com ponto-e-vírgula “;”

●Todos os comandos devem estar entre chaves “{}”


Java Introdução

Variáveis / Constantes●A declaração de variáveis basta especificar o escopo, o tipo de

dado o nome da variável e se for desejado o valor que será

inicializado, caso contrário usará o default do tipo.

● int v1;

● static int v2;

● static int v3 = 9;

●A declaração de constantes segue a mesma especificação com

a adição da palavra final.

● final float PI = 3.14159265f;

● static final float PI = 3.14159265f;

●Obs: com o uso da palavra static temos uma especificação de

escopo global, sem ela local.


Java Introdução

Tipos de Dados●boolean: lógico - boolean b = true;

●byte: inteiros entre -128 e 127 - byte b = 111;

●char: caracter - char letra = ‘A’;

●double: números reais de precisão dupla - double d = 123.4;

●float: números reais de precisão simples - float f = 12.3;

●int: inteiro entre -2.147.483.648 e 2.147.483.647 - int i =0;

●long: inteiro entre -9.223.372.036.854.775.808

● e 9.223.372.036.854.775.807

●short: inteiro entre -32.768 e 32.767 - short s = 1;

●void: método sem retorno ou vazio.


Java Introdução

Declaração de Variáveis●Variáveis de instância pertencem as classes.

●Variáveis locais pertencem aos métodos e devem ser

inicializadas antes de serem usadas.

●class Exemplo {

● private int exVar; // variável de instância

● public void exMetodo() {

● float exVarLoc = 1.0; // variável local

● }

●}


Java Introdução

Tipo Literal●Se declarado como char usar aspas simples.

●Se declarado como String usar aspas duplas.

●class Exemplo {

● public void exMetodo() {

● char exVar1 = ‘A’;

● String exVar2 = “A”;

● }

●}


Java Introdução

Atribuição●São possibilidades de atribuição:

●int var1 = 1;

●int var1, var2, var3 = 2;

●var1 = var2 = var3 = 3;


Java Introdução

Aritmética●int a, b, c, d, e;

●a = 8 + 7; // adição

●b = 6 - 5; // subtração

●c = 4 * 3; // multiplicação

●d = 2 / 1; // divisão que retorna o quociente

●e = 2 % 1; // divisão que retorna o resto


Java Introdução

Conversões implícitas●Java converter um tipo menor para um maior

automaticamente, mas não faz o contrário (downcast).

● byte -> short -> int -> long (FAZ)

● byte <- short <- int <- long (NÃO FAZ)

●


Java Introdução

Incrementador / Decrementador●Exemplos:

●int var1 = 3, var2 = 0;

●var2 = ++var1; // Pré: Incrementa var1 primeiro para depois

atribuir para var2.

●var2 = var1++; // Pós: Atribui para var2 primeiro para depois

incrementar var1.

●var2 = --var1; // Pré: Decrementa var1 primeiro para depois

atribuir para var2.

●var2 = var1--; // Pós: Atribui para var2 primeiro para depois

decrementar var1.


Java Introdução

Relacionais●== igual

●!= diferente

●> maior que

●>= maior ou igual

●< menor que

●<= menor ou igual

●Exemplos:

● int var1 = 1, var2 = 2;

● boolean res = true;

● res = (var1 == var2); // falso

● res = (var2 > var1); // verdadeiro*


Java Introdução

Lógicos●&& e lógico

●|| ou lógico

●^ ou exclusivo

●! Negação

●Exemplos:

● int var1 = 1, var2 = 2, var3 = 3;

● boolean res = true;

● res = (var2 > var1) & (var3 == 3); // falso


Java Introdução

Atribuição Composta●int x = 0;

●x = x + 1; // x passa a ser 1

●é o mesmo que

●x += x; // x passa a ser 2

●outras possibilidades

●x -= 1; // x passa a ser 1

●x *= 2; // x passa a ser 2

●x /= 2; // x passa a ser 1


Java Introdução

Concatenação●String var1 = “Álvaro”;

●String var2 = “Pinheiro”;

●var1 = var1 + var2; // resulta em “ÁlvaroPinheiro”

●Var1 += var2 // resulta em “ÁlvaroPinheiro”


Java Introdução

Array● public static int obterVetorInteito() {

● int[] vI = new int[3];

● vI[0]=0;

● vI[1]=1;

● vI[2]=2;

● return (vI[2]);

● }

● public static String obterVetorString() {

● String[] vS = new String[3];

● vS[0] = "a";

● vS[1] = "b";

● vS[2] = "c";

● return (vS[2]);

● }


Java Introdução

Array● public static float obterMatrizFloat() {

● float[][] mF = new float[1][2];

● mF[0][0] = 0.0f;

● mF[0][1] = 0.1f;

● return (mF[0][1]);

● }

● public static double obterMatrizDouble() {

● double[][][] mD = new double[1][2][3];

● mD[0][0][0] = 0.0;

● mD[0][0][1] = 0.001;

● mD[0][0][2] = 0.002;

● mD[0][1][0] = 0.01;

● mD[0][1][1] = 0.011;

● mD[0][1][2] = 0.012;

● return (mD[0][1][2]);

● }


Java Introdução

Array● public static int obterArrayListInteiro() {

● ArrayList<Integer> al = new ArrayList<Integer>();

● al.add(10);

● al.add(11);

● al.add(12);

● return (al.get(2));

● }

● public static String obterArrayListString() {

● ArrayList<String> al = new ArrayList<String>();

● al.add("a");

● al.add("b");

● return (al.get(1));

● }*


Java Introdução

if

*

if ( cond )

cmd1;

[else]

cmd2;


Java Introdução

If else if else

*

if (cond1)

if (cond2)

cmd1;

else

cmd2;

else

cmd3;


Java Introdução

( ? : )

*

(expr1 ? expr2 : expr3)

int var1;

var1 = (val1 > val2) ? ret_verdadeiro : ret_falso;


Java Introdução

while

*

while ( cond )

cmd;


Java Introdução

do...while

*

do

cmd;

while ( cond );


Java Introdução

for

*

for ( início; cond; passo )

cmd;


Java Introdução

break

*

● Interrompe um ciclo ou uma instrução

switch;

● Transfere o controle para a primeira

instrução depois do corpo do ciclo ou

instrução switch; e

● Pode simplificar o código.


Java Introdução

continue

*

● Apenas pode ser usado em ciclos;

● Abandona a iteração em curso e salta para a

próxima iteração do ciclo


Java Introdução

Labeled break, continue

*

Pode ser usado para saltar fora de ciclos

encaixados ou continuar um ciclo exterior ao

ciclo corrente

lacoexterno:

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

for (int j = 0; j < 5; j++) {

System.out.println(i, j);

if (i + j > 7)

break lacoexterno;

}

}www.alvarofpinheiro.eti.br

Java Introdução

JAVAEntrada e Saída de Dados


Java Entrada/Saída

Saída

*

Para sair com dados no dispositivo corrente

basta usar System.out.print() ou

System.out.println(), onde o primeiro imprime e

fica com o controle na mesma linha e o

segundo imprime e o controle vai para a

próxima linha.


Java Entrada/Saída

Saída

*

Para sair com dados no dispositivo corrente

basta usar System.out.print() ou

System.out.println(), onde o primeiro imprime e

fica com o controle na mesma linha e o

segundo imprime e o controle vai para a

próxima linha.public class Principal {

public static void main(String[] args) {

System.out.print("Imprime e não muda de linha");

System.out.println("-Veja a saída no console! Percebeu?");

System.out.println("Imprimiu a cadeia anterior e mudou de

linha");

System.out.print("-Olhe o console! Percebeu?");

}


Java Entrada/Saída

Entrada

*

Para entrar com dados usar a classe Scanner.

import java.util.*;

public class Principal {


int codigo = 0;

String nome = "";

Scanner scanner = new Scanner(System.in);

System.out.println("Código:");

codigo = scanner.nextInt();

System.out.println("Nome:");

nome = scanner.next();

System.out.println("Código:" + codigo + " e Nome:" + nome + " informados!");

}

}


Java Entrada/Saída

Stream

*

Trata-se de uma abstração para a entrada ou

saída de dados. Os bytes trafegam do input

para o output por stream. E esse pode

representar múltiplas fontes de dados, como

arquivos em disco, outros computadores em

rede, páginas da web, dispositivos de entrada

como teclado, pendrive, ...


Java Entrada/Saída

Stream Hierarquia

*

java.io.InputStream

AudioInputStream

FileInputStream

ObjectInputStream

java.io.OutputStream

ByteArrayOutputStream

FileOutputStream

ObjectOutputStream


Java Entrada/Saída

Input Stream

*

Métodos comuns a todas as input streams:

// para ler um um caracter

int read() throws IOException

// inicia a stream para que os seus

// bytes possam ser lidos novamente

void reset() throws IOException

// notifica a stream de que ela vai

// ser fechada

void close() throws IOException


Java Entrada/Saída

Output Stream

*

Métodos comuns a todas as output streams:

// escreve um caracter

void write(int n) throws IOException

// escreve os bytes que estavam

// à espera para ser escritos

void flush() throws IOException

// notifica a stream de que de que ela

// vai ser fechada

void close() throws IOException


Java Entrada/Saída

Exemplo de Stream

*

try {

InputStream ler = new FileInputStream(“arq.txt”);

char caracter = (char)ler.read();

String cadeia = “exemplo”;

OutputStream gravar = new FileOutputStream(“arq.txt”);

for (int i = 0; i < cadeia.length(); i++)

gravar.write(cadeia.charAt(i));

gravar.close();

}

catch (IOException excecao) {

System.out.print(excecao.getMessage());

}


Java Entrada/Saída

Thread

*

É uma execução sequencial de um programa. Cada

programa tem pelo menos um thread. Cada thread tem

a sua própria pilha, prioridade e conjunto de registos

virtuais. Os threads subdividem o comportamento de

um programa

em subtarefas independentes.

São usados virtualmente em todos os computadores:

Em muitas aplicações (imprimir); Em programas como

browsers Internet; Em bases de dados; No sistema

operacional; e Assim os Threads são normalmente

usados, mas não são percebidos pelo usuário.


Java Entrada/Saída

Thread

*

Se usa threads para melhor aproveitar as

capacidades do computador e assim utilizar a

CPU enquanto se faz entrada/saída de dados.

Para maior produtividade do usuário, através

de uma interface mais interativa. E pelas

vantagens na simplificação da lógica

algoritmica.


Java Entrada/Saída

Thread

*

A Classe Thread: Mantém o estado de um

thread; Fornece diversos construtores; Fornece

diversos métodos; São escalonados pela JVM;

e Utiliza o sistema operacional.

Thread.currentThread()

Thread.sleep()

Thread.setName()

Thread.isAlive()


Java Entrada/Saída

Thread

*

Cada programa corre numa thread e em

seguida adormecer, assim uma thread é uma

técnica que permite que outras threads possam

ser executadas.

public static void main (args[] s) {

System.out.println(“thread " + Thread.currentThread().getName());

try {

Thread.sleep(5000)

}

catch (InterruptedException e) {

}

…

}


Java Entrada/Saída

Thread

*

// criar um thread

public class Dormir extends Thread {

public void run () {

Date inicio = new Date();

try {

Thread.currentThread().sleep

((int) (1000 * Math.random()));

}

catch (Exception es) {}

long lapso = new Date().getTime() - inicio.getTime();

System.out.println(Thread.currentThread().getName() +

": lapso de " + lapso + "milisegundos");

}

}


Java Entrada/Saída

Thread

*

// instanciar a Dormir


new Dormir().start();

new Dormir().start();

System.out.println(“2 threads iniciadas:");

}

// Saída

2 threads iniciadas:

Thread-1: lapso de 78 milisegundos

Thread-2: lapso de 428 milisegundos


Java Entrada/Saída

Thread

*

Ciclo de vida:


Java Entrada/Saída

Thread

*

Se uma thread invocar um método

synchronized, nenhuma outra thread pode

executar um método sincronizado no

mesmo objeto até a primeira thread completar

a sua tarefa.

public class Moldura extends JFrame {

public synchronized void Atualiza() {

…

}

…

}


Java Entrada/Saída

Thread

*

Cada thread tem uma prioridade que vai de 1

até 10 e o escalonamento é dependente do

sistema operacional. Uma thread de alta

prioridade pode interromper uma de baixa

prioridade, assim threads de alta prioridade

podem dominar o processador e de prioridades

idênticas podem ser escalonados de forma

Circular, então cuidado ao usar synchronized.


Java Entrada/Saída

Model-View-Controller (MVC)

*

Arquitetura para construção de aplicações OO

em que se separam três dimensões, as quais

são: Modelo, que mantém dados usando os

algoritmos apropriados e fornece métodos de

acesso; Visão, que constrói uma representação

visual de parte ou todos os dados do modelo; e

Controlador, que trata das regras de negócio.

Quando o modelo altera os seus dados, gera

eventos que fazem com que a visão atualize a

sua representação, segundo as ordens do

controlador.www.alvarofpinheiro.eti.br

Java MVC/JDBC


*

Podem existir várias visões e controladores

para o mesmo modelo, o qual pode

permanecer inalterado quando este evolui.

Uma alteração no modelo provoca um evento

de alteração que é difundido para todos os

objetos que estão à escuta desse evento e

desencadeia as alterações, assim facilita

manter o sincronismo entre visões diferentes

de um mesmo modelo. Atuar numa visão pode

provocar alterações no modelo que são

refletidas nas outras visões.www.alvarofpinheiro.eti.br

Java MVC/JDBC


*

A arquitetura de desenvolvimento em três camadas

divide um aplicativo permitindo que a lógica de

negócio resida no meio das três camadas (camada

intermediária ou camada de negócios), como a maior

parte do código que normalmente é escrito fica na

camada de negócio, deixando-a no meio, torna mais

prática a construção e manutenção.

A arquitetura Modelo Visualização Controle (MVC)

permite dividir a funcionalidade da apresentação dos

dados. Assim torna mais fácil mapear os conceitos no

domínio de aplicações.

MVC -


Java MVC/JDBC


*

Na arquitetura MVC o modelo representa

os dados da aplicação que governam o

acesso e a modificação dos dados.

O modelo mantém o estado persistente do negócio e fornece

ao controlador a capacidade de acessar as funcionalidades da

aplicação encapsuladas pelo próprio modelo. É a camada de

lógica da aplicação e é o coração da aplicação. Modela os

dados e o comportamento por atrás do processo de negócios

e se preocupa apenas com o armazenamento, manipulação e

geração de dados É um encapsulamento de dados e de

comportamento independente da apresentação.


Java MVC/JDBC


*

Um componente de visualização renderiza

o conteúdo de uma parte particular do

modelo e encaminha para o controlador as

ações do usuário e acessa também os

dados do modelo via controlador definindo

como esses dados devem ser

apresentados.A Camada de apresentação ou visualização, não esta

preocupada em como a informação foi obtida ou onde ela foi

obtida apenas exibe a informação. inclui os elementos de

exibição no cliente, tipo HTML, XML, ASPX, JSP, JFC,

Applets, ... É a camada com o interface com o usuário. E é

usada para receber a entrada de dados e apresentar o

resultado.


Java MVC/JDBC


*

Um controlador define o comportamento da

aplicação, é ele que interpreta as ações do

usuário e as mapeia para chamadas do

modelo.

Em um cliente de aplicações Web essas ações do usuário

poderiam ser cliques de botões ou seleções de menus. As

ações realizadas pelo modelo incluem ativar processos de

negócio ou alterar o estado do modelo. Com base na ação do

usuário e no resultado do processamento do modelo , o

controlador seleciona uma visualização a ser exibida como

parte da resposta a solicitação do usuário. Há normalmente um

controlador para cada conjunto de funcionalidades

relacionadas.


Java MVC/JDBC


*

Em um cliente de aplicações Web essas ações do

usuário poderiam ser cliques de botões ou seleções de

menus. As ações realizadas pelo modelo incluem

ativar processos de negócio ou alterar o estado do

modelo. Com base na ação do usuário e no resultado

do processamento do modelo , o controlador seleciona

uma visualização a ser exibida como parte da resposta

a solicitação do usuário. Há normalmente um

controlador para cada conjunto de funcionalidades

relacionadas.


Java MVC/JDBC


*

Algumas vantagens do uso do modelo MVC: gerenciar

múltiplos visualizadores usando o mesmo modelo e é fácil

manter, testar e atualizar sistemas múltiplos; É muito simples

incluir novos clientes apenas incluindo seus visualizadores e

controles; Torna a aplicação escalável; É possível ter

desenvolvimento em paralelo para o modelo, visualizador e

controle pois são independentes.

Algumas desvantagens do uso MVC: Requer uma quantidade

maior de tempo para analisar e modelar o sistema; Requer

pessoal especializado; Não é aconselhável para pequenas

aplicações.


Java MVC/JDBC

Java DataBase Connective (JDBC)

*

Etapas de uso de JDBC:

1. Carregar o driver JDBC;

2. Estabelecer a ligação à base de dados;

3. Criar um objeto SQL;

4. Executar uma consulta;

5. Processar os resultados; e

6. Fechar a ligação.


Java MVC/JDBC


*

Para usar um driver JDBC, é necessário carregar o

driver através do método Class.forName(), através do

código Class.forName("jdbc.DriverXYZ") em que o

jbdc.DriverXYZ é o driver JDBC que se pretende

carregar. Se usarmos um driver JDBC-ODBC, o

código será algo como:

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");


Java MVC/JDBC


*

Digitar o

mysql-connector-java-5.1.18-bin.jar; e para isso é

necessário clicar sobre o projeto e acionar a opção do

menu Build Path executando a subopção Add External

Archives...

Depois é só digitar o código que cria o objeto de

conexão e que estabelece a mesma.


Java MVC/JDBC


*

O objeto JDBC Statement envia comandos SQL para a

base de dados. Os objetos Statement são criados a

partir de objetos Connection ativos.

Exemplo:

Statement cmd = con.createStatement();

Com um objeto Statement, pode-se enviar chamadas

SQL diretamente à base de dados.


Java MVC/JDBC


*

executeQuery() - executa uma query SQL e retorna os

dados numa tabela (ResultSet). A tabela resultante

pode estar vazia mas nunca null.

String sCmd = "SELECT campo FROM tabela"

ResultSet oResultado = cmd.executeQuery(sCmd);


Java MVC/JDBC


*

executeUpdate() - utilizado para executar instruções

Data Definition Language (DDL). O resultado é o

número de linhas que foram afetadas na base de

dados.


Java MVC/JDBC


*

getMaxRows/setMaxRows - Determina o número de

linhas que um ResultSet pode conter. Por omissão, o

número de linhas é ilimitado (return 0).

getQueryTimeout/setQueryTimeout - Especifica o

tempo que um driver deve esperar pela execução de

um STATEMENT antes de lançar a exceção

SQLException.


Java MVC/JDBC


*

A ResultSet contém os resultados da query SQL.

Métodos úteis:

● close - Liberta os recursos alocados pelo JDBC;

● getMetaDataObject - Retorna um objeto;

● ResultSetMetaData - que contém informação sobre

as colunas do ResultSet;

● next - Tenta mover para próxima linha do ResultSet,

se bem sucedido é devolvido true; senão, false; A

primeira invocação de next posiciona o cursor na

primeira linha.


Java MVC/JDBC


*

● findColumn - Retorna o valor inteiro correspondente

à coluna especificada por nome, os números das

colunas nos resultados não mapeiam

necessariamente para as mesmas colunas na base

de dados;

● getXxx - Retorna o valor da coluna especificada

pelo nome ou índice como um tipo Xxx do Java,

retorna 0 ou null.


Java MVC/JDBC


*

Excepções SQL - Quase todos os métodos JDBC

podem originar uma SQLException em resposta a um

erro de acesso a dados. Se mais do que um erro

ocorrer, eles são encadeados. As excepções SQL

contêm: Descrição do erro, getMessage. O SQLState

(Open Group SQL specification) identificado a

excepção, getSQLState. Um código de erro específico

do vendedor da base de dados, getErrorCode. Uma

referência para a próxima SQLException,

getNextException


Java MVC/JDBC


*

import java.sql.*;


public static void main(String[] args) throws Exception {

String comandoSQL;

try {

Connection conexao = BD.obtemConexao("127.0.0.1", "exemplo", "root",

“***");

comandoSQL = "CREATE TABLE EXEMPLO COD INTEGER";

BD.executaDDL(conexao, comandoSQL);

comandoSQL = “INSERT INTO EXEMPLO (COD) VALUES (1) ";

BD.executaDDL(conexao, comandoSQL);

comandoSQL = “SELECT * FROM EXEMPLO";

BD.executaDML(conexao, comandoSQL);

}

catch (Exception excecao) {

System.out.print(excecao.getMessage());

}

}

}


Java MVC/JDBC


*

import java.sql.*;

public class BD {

public static Connection Conexao(

String servidorNome,

String bancoNome,

String bdUsuario, String bdSenha) throws Exception {

Connection cnx = null;

try {

String driverNome = "com.mysql.jdbc.Driver";

Class.forName(driverNome);

String bdCaminho = "jdbc:mysql://" + servidorNome + "/" + bancoNome;

cnx = DriverManager.getConnection(bdCaminho, bdUsuario, bdSenha);

return (cnx);

}

catch (ClassNotFoundException e) {

throw new Exception("O driver expecificado não foi encontrado");

}

catch (SQLException e) {

throw new Exception("Não foi possível conectar ao Banco de Dados");

}

}

}


Java MVC/JDBC


*

public static void executaDDL(Connection conexao, String comandoSQL) throws SQLException {

Statement comando;

try {

comando = conexao.createStatement();

comando.executeUpdate(comandoSQL);

comando.close();

conexao.close();

}

catch(SQLException excecao) {

throw (excecao);

}

}


Java MVC/JDBC

Garbage Collection

● Quando todas as referência para um objeto são

eliminadas, o objeto é marcado para ser destruído. O

Garbage Collection (GC) liberta a memória utilizada

pelo objeto. Não existe necessidade de intervenção do

programador, mas não possui qualquer controle sobre

quando o objeto é realmente destruído.


Java Outros Recursos

finalize()

*

Se um objeto utilizar um recurso de acesso a base de

dados, esse deve ser liberado através do método

finalize(). Esse é invocado antes do objeto ser destruído.

public class Classe {

…

public void finalize() {

System.out.println(“Tchau");

}

}



Collections

*

Java Collection Framework (JCF)

Permite interoperabilidade entre APIs diferentes; Reduz

o esforço de aprendizagem de APIs; Reduz o esforço de

desenho e implementaçao de APIs; e Promove

reutilização de software.

Interfaces

• Comparator

• Iterator

Classes

• Collections

• Arrays



Métodos de Collections

*

int size();

boolean isEmpty();

boolean contains(Object);

Iterator iterator();

Object[] toArray();

boolean add(Object);

boolean remove(Object);

void clear();



Set

*

Herdado de Collection; Trata-se de uma coleção de

objetos não ordenados; Não permite elementos

duplicados; São os mesmos métodos de Collection; A

semântica é diferente, pois obriga a utilizar uma interface

diferente; e é implementada por AbstractSet, HashSet,

TreeSet.



List

*

Herdado de Collection; Uma coleção de objetos não

ordenados; Permite elementos duplicados; e

Implementada por AbstractList, ArrayList, LinkedList,

Vector.

Os principais métodos:

Object get(int);

Object set(int, Object);

int indexOf(Object);

int lastIndexOf(Object);

void add(int, Object);

Object remove(int);

List subList(int, int);



List

*

ArrayList - Uma implementação sem métodos legados,

baseada num array de tamanho dinâmico;

LinkedList - Uma implementação baseada numa lista

duplamente ligada, podendo ter melhor performance do

que a ArrayList se os elementos forem frequentemente

inseridos/apagados no meio da lista. Útil para queues e

double-ended queues (deques); e

Vector - Uma implementação baseada num array de

tamanho dinâmico e com métodos legados adicionais.



Iterator

*

Representa um iterador para um ciclo; Criado por

Collection.iterator(); Similar à Enumeration; Permite a

operação remove() no item corrente.

Principais métodos:

boolean hasNext();

Object next();

void remove();




*

public static void executaDML(Connection conexao, String comandoSQL) throws SQLException {

try {

Statement comando = conexao.createStatement();

ResultSet retorno = comando.executeQuery(comandoSQL);

int codigo;

while (retorno.next()) {

codigo = retorno.getInt("COD");

System.out.println("Código: " + codigo);

}

retorno.close();

comando.close();

conexao.close();

}

catch(SQLException excecao) {

throw (excecao);

}

}



*

Java é uma linguagem de programação que usa o paradigma

orientado a objetos e que foi criada na década de 90 por James

Gosling da Sun Microsystems, que não gera código nativo, mas sim

um bytecode que é executado por uma máquina virtual.

A linguagem Java possui diversas características muito úteis para o

desenvolvimento Web, as quais são: Orientação a objetos baseado

no Simula67; portabilidade; APIs para rede; segurança; sintaxe

semelhante a linguagem C; e desalocação de memória automática.

BYTECODE é um código intermediário que serve para ser

interpretado pela Máquina Virtual Java (MVJ), essa característica faz

com que os os programas Java sejam independentes de sistemas

operacionais. Cada opcode tem o tamanho de um byte, por isso é

chamado de bytecode.


Java Conceitos Gerias

*

MVJ é um programa que carrega e executa códigos Java,

convertendo os bytecodes em código executável do sistema

operacional instalado, sendo responsável pelo gerenciamento dos

aplicativos, à medida que são executados. A arquitetura de uma MVJ

permite um controle sofisticado sobre o código que está sendo

executado.

APPLETS são códigos que rodam dentro de uma VM incorporada ao

browser do usuário, executando código baixado de um servidor

HTTP remoto. O código remoto roda em uma sandbox, que protege

o usuário de códigos maliciosos. O autor do applet pode aplicar um

certificado para assinar digitalmente o applet como "seguro", dando a

ele permissão de sair do sandbox e acessar livremente a máquina

onde está rodando.



*

J2SE (Java 2 Standard Edition) é uma ferramenta de desenvolvimento para a

plataforma Java. Ela contém todo o ambiente necessário para a criação e

execução de aplicações Java, incluindo a máquina virtual Java (JVM), o compilador

Java, as APIs do Java e outras ferramentas utilitárias.

J2EE (Java 2 Enterprise Edition) inclui toda a funcionalidade existente na

plataforma Java SE mais todas as funcionalidades necessárias para o

desenvolvimento e execução de aplicações em um ambiente corporativo,

adicionando de bibliotecas que fornecem funcionalidade para implementar software

Java distribuído, tolerante a falhas e multi-camada, baseada amplamente em

componentes modulares executando em um servidor de aplicações.

J2ME (Java 2 Micro Edition) é uma tecnologia que possibilita o desenvolvimento de

software para sistemas e aplicações embarcadas, ou seja, toda aquela que roda

em um dispositivo de propósito específico, desempenhando alguma tarefa que seja

útil para o dispositivo. É a plataforma Java para dispositivos compactos, como

celulares, PDAs, controles remotos, e uma outra gama de dispositivos. Java ME é

uma coleção de APIs do Java definidas através da JCP (Java Community

Proccess).



*

Os containers Java são:

● JDBC (Java Database Connectivity), utilizado no acesso a bancos de dados;

● Servlets, são utilizados para o desenvolvimento de aplicações Web com

conteúdo dinâmico. Ele contém uma API que abstrai e disponibiliza os

recursos do servidor Web de maneira simplificada para o programador.

● JSP (Java Server Pages), uma especialização do servlet que permite que

conteúdo dinâmico seja facilmente desenvolvido.

● JTA (Java Transaction API), é uma API que padroniza o tratamento de

transações dentro de uma aplicação Java.

● EJBs (Enterprise Java Beans), utilizados no desenvolvimento de

componentes de software. Eles permitem que o programador se concentre

nas necessidades do negócio do cliente, enquanto questões de infra-

estrutura, segurança, disponibilidade e escalabilidade são responsabilidade

do servidor de aplicações.

● JCA (Java Connector Architecture), é uma API que padroniza a ligação a

aplicações legadas.

● JPA (Java Persistence API), é uma API que padroniza o acesso a banco de

dados através de mapeamento Objeto/Relacional dos Enterprise Java

Beans.www.alvarofpinheiro.eti.br


JAVAOrientação a Objetos


Java Orientado a Objetos

Objeto

*

É uma abstração de um objeto do mundo real,

que no mundo computacional se traduz numa

estrutura de dados (propriedades ou campos) e

funções (comportamentos ou métodos)

associados no qual cada comportamento

consiste em uma operação e cada propriedade

numa característica.



Encapsulamento

*

Permite ocultar como as coisas funcionam.

Violar o encapsulamento em programação

orientada por objetos é impossível.

As variáveis de instância devem ser

declaradas como private. Apenas métodos de

instância podem ter acesso a variáveis de

instância. Assim o encapsulamento permite

isolar a interface de uma classe da sua

implementação interna.



Hieráquias

*

Os objetos são compostos por outros objetos.

E os objetos podem fazer parte de outros

objetos. E esta relação entre objetos é

conhecida por agregação ou composição.



Classes

*

Uma classe é uma especificação de objetos.

Uma definição de uma classe especifica as

operações e atributos para todas as instâncias

de uma classe. Assim uma classe descreve o

tipo de um objeto e define o comportamento

(operações) e estrutura (atributos) de um grupo

de objetos. Reduzindo-se a complexidade

utilizando classes.



Classes versus Objetos

*

As classes são definições estáticas que nos

permitem compreender todos os objetos de

uma classe. Os objetos são as entidades

dinâmicas que existem no mundo real e em

suas simulações.



Herança

*

Podem existir semelhanças entre classes

distintas. Assim se deve definir as

propriedades comuns (atributos, operações)

entre classes numa superclasse comum. As

subclasses utilizam herança para incluir as

propriedades comuns entre elas.



Polimorfismo

*

O polimorfismo é a capacidade de um único

nome poder referir objetos de classes

diferentes, se relacionadas por uma

superclasse comum. O polimorfismo surge

quando a linguagem de programação

simultaneamente suporta herança e a

associação dinâmica de tipos (late binding).

O polimorfismo permite que uma operação

possa existir em diferentes classes. Cada

operação tem um mesmo significado mas é

executada de forma particular.www.alvarofpinheiro.eti.br


Pacote

*

Servem para agregar as classes comuns em

uma estrutura única, agrupando por afinidade.



Modificadores

*

private

Só a classe proprietária visualiza.

public

Todos visualizam.

protected

A classe proprietária e suas subclasses.

package

Dentro do pacote.



Instanciamento

*

Os objetos são criados pelo operador new.

Exemplo:

Classe objeto1 = new Classe();

Classe objeto2 = new Classe();

O operador ‘new’ aloca memória para o novo

objeto, invoca um método especial da classe

para inicialização de objetos, o construtor e

retorna uma referência para o novo objeto.



null

*

As referências para objetos têm o valor null até

serem inicializadas. É possível comparar

referências de objetos a null. E pode-se apagar

um objeto pela atribuição do valor

null a uma referência.



Atribuição de Referências

*

A atribuição de uma referência a outra resulta

em duas referências para o mesmo objeto.



Variáveis de Instância

*

As variáveis de instância são declaradas na

classe.


public String campo1;

public String campo2;

}

As variáveis públicas de instância podem ser

acessadas através do operador ‘.’ , mas viola o

paradigma OO.



Variáveis de Classe

*

As variáveis de classe pertencem a uma classe

e são comuns a todas as instâncias dessa

classe. As variáveis de classe são declaradas

como ‘static’ na definição da classe.


private static String campo1; // var classe

private String campo2; // var instância

}



Variáveis de Classe

*

A inicialização de variáveis de classe podem

ser na declaração. A inicialização é realizada

quando a classe é carregada.


private static String campo1 = “ex”;

private String campo2;

private int campo3 = 0;

}



Métodos

*

Um método é equivalente a uma função ou

subrotina no paradigma procedural. Um

método apenas pode ser definido na definição

de uma

classe.

public void mostraDetalhes() {

System.out.println(“Exemplo”);

}



Métodos de Classe

*

Os métodos de classe são partilhados por

todas as instâncias. São úteis para manipular

variáveis de classe. Um método de classe

pode ser invocado utilizando o nome da classe

ou uma referência para um objeto.



Passagem de Parâmetros

*

Quando um valor primitivo é passado a um

método, é gerada uma cópia do valor:

public void exMetodo(int arg) { }

Quando um objeto é passado a um método, o

argumento refere o objeto original:

public void exMetodo(Classe objeto) {}



Overloading

*

Métodos de uma mesma classe podem ter o

mesmo nome, mas os métodos devem ter

diferentes assinaturas.



Assinatura

*

Garante a unicidade de um método na classe e

é composto por:

1. nome do método;

2. quantidade de parâmetros existentes;

3. tipo de cada parâmetro; e

4. ordem desses parâmetros.

O tipo de retorno de um método e os nomes

dos parâmetros não fazem parte de sua

assinatura.



Construtores

*

Servem para uma inicialização adequada,

assim a classe deve fornecer construtores. O

construtor é invocado automaticamente quando

o objeto é criado e deve ter o mesmo nome da

classe, não especifica nenhum tipo de retorno

e

normalmente é declarado como ‘public’. O

compilador automaticamente fornece um

construtor por default sem argumentos.



Definição de Construtores

*


private String campo1;

private String campo2 = “exemplo2”;

public Classe() {

campo1 = “exemplo1";

} // construtor

public Classe(String parametro1) {

campo1 = parametro1;

} // construtor sobrecarregado

}

Classe objeto1 = new Classe();www.alvarofpinheiro.eti.br


this

*

Os métodos de instância recebem um

argumento com o nome ‘this’, que indica o

objeto corrente.



this()

*

Um construtor pode invocar outro através de

this(). Partilha de código entre construtores.


private String campo;

public Classe() {

this(“exemplo”);

}

public Classe(String parametro) {

campo = parametro;

}



Classes



*

Para iniciarmos o estudo da programação Java vamos começar com

o entendimento do conceito de classe.

O diagrama de classes na Programação Orientada a Objetos (POO),

os problemas são pensados e expressados como objetos, ao

contrário da análise tradicional os quais eram em rotinas e dados,

que aqui foram substituídos por métodos (comportamento) e

atributos (propriedades). Assim, quando é colocado o problema de

desenvolver um sistema acadêmico na análise orientada a objetos,

deve-se pensar como dividir esse problema em objetos.



*

Assim teríamos Alunos, Administradores, Professores, Cursos,

Turmas, etc... E a melhor maneira de conceituar estes termos é

considerar um objeto do mundo real e mostrar como podemos

representá-lo em termos conceitos em POO. Assim, um objeto é um

conceito que usamos para representar uma entidade do mundo real.

Exemplificando, um Aluno possui nome, data de nascimento,

identidade, etc... E além dessas características (propriedades),

possuem ações (métodos) como freqüentar as aulas, fazer as

avaliações, etc... Em termos de POO para podermos tratar os

objetos temos que criar classes. Assim, uma classe representa um

conjunto de objetos que possuem comportamentos e características

comuns.



*

Na UML em primeiro lugar denomina-se uma classe e recomenda-se

nomeá-la capitalizando-a e deixando no singular. E em segundo

lugar denominam-se as propriedades, informações específicas

relacionadas a uma classe de objeto, isto é características dos

objetos que as classes representam.

Em terceira e última parte, métodos, que são ações que os objetos

de uma classe podem realizar. Assim tem-se um modelo para

instanciar quantos objetos forem necessários. Dessa forma os

objetos instanciados possuirão todas as características e

comportamentos definidos pela classe. Então as classes especificam

a estrutura (propriedades) e os comportamentos (operações) dos

objetos, que são instâncias das classes.



*

Geralmente em um sistema de médio porte serão identificadas

diversas classes que compõem o sistema. Neste contexto a UML

surgiu como uma proposta de ser uma linguagem para modelagem

de dados que usava diversos artefatos para representar o modelo de

negócio; um destes artefatos é o diagrama de classes.



*

Os diagramas de classes registram atributos e operações de uma

classe e as restrições de como os objetos podem ser conectados,

descrevendo também os tipos de objetos no sistema e os

relacionamentos entre eles e esse podem ser associações e

abstrações. Para poder representar a visibilidade dos atributos e

operações, a UML usa os seguintes símbolos: + público, visível em

qualquer classe; - privado, visível somente dentro da classe; #

protegido, na classe e suas subclasses.

O relacionamento entre classes retrata as relações entre os objetos.

Exemplo: um professor ministra uma disciplina para alunos numa

sala. A UML reconhece três tipos mais importantes de relações:

dependência, associação e generalização ou herança. Geralmente

as classes não estão isoladas (coesas) e se relacionam entre si

(acoplamento). O relacionamento e a comunicação entre as classes

se definem em 3 tipos: Associações que podem ser de Agregação ou

Composição; Generalização ou herança; e Dependências.



*

As associações são relacionamentos estruturais entre instâncias e

especificam que objetos de uma classe estão ligados a objetos de outras

classes, podendo ser unária, binária, etc... As associações podem existir

entre classes ou entre objetos. Uma associação entre a classe Professor e

a classe Disciplina (um professor ministra uma disciplina) significa que uma

instância de Professor (um professor específico) vai ter uma associação

com uma instância de uma Disciplina. Esta relação significa que as

instâncias das classes são conectadas, seja fisicamente ou

conceitualmente.

Dependências são relacionamentos de utilização no qual uma mudança na

especificação de um elemento pode alterar a especificação do elemento

dependente. A dependência entre classes indica que os objetos de uma

classe usam serviços dos objetos de outra classe. Generalização ou

herança, que pode ser simples ou múltipla (composta), serve para

relacionar um elemento mais geral e um mais específico, onde o elemento

mais específico herda as propriedades e métodos do elemento mais geral.

Como a relação de dependência, ela existe só entre as classes. Um objeto

particular não é um caso geral de outro objeto, apenas classes podem

receber esse conceito. www.alvarofpinheiro.eti.br


*

Agregação é um tipo de associação (é parte de ou todo-parte) onde o

objeto parte é um atributo do todo, onde o objeto parte somente são criados

se o todo ao qual estão agregados seja criado. Pedidos é composto por

itens de pedidos. Composição é o relacionamento entre um elemento (o

todo) e outros elementos (as partes) onde as partes só podem pertencer ao

todo e são criadas e destruídas com ele.

O diagrama de classes lista todos os conceitos do domínio que serão

implementados no sistema e as relações entre os conceitos. Ele é muito

importante, pois define a estrutura do sistema a desenvolver. O diagrama

de classes é conseqüência do prévio levantamento de requisitos, definição

de casos de usos e classes. Como exemplo tem os passos de elicitação de

requisitos com os stakeholders do sistema a ser desenvolvido, usando a

técnica de entrevista com os administradores, professores, etc... que a

partir desses os objetos do sistema são definidos: Alunos, Professores,

Turmas, Cursos, etc... Definição dos atores do sistema: aluno, professor,

administrador, etc... Definição e detalhamento dos casos de uso: Matricular

Aluno, Pagar Matrícula, etc... Definição das classes: alunos, professor,

etc...www.alvarofpinheiro.eti.br


*

Atributo representa uma propriedade que todos os objetos da classe têm,

porém cada objeto terá valores particulares para seus atributos. A UML, o

nome de um atributo é um texto que deve capitalizar todas as primeiras

letras de cada palavra no nome menos a primeira palavra. Todos os

métodos têm que respeitar exatamente a assinatura que é composta pelo

nome, número de parâmetros, tipos de dados e ordem. Um método não

pode acrescentar ou cortar um parâmetro. Para mandar a mensagem

corretamente, devesse saber qual é a classe do objeto, já que cada classe

tendo método com assinatura diferente.



*

/*** Classe de domínio ClassPessoa* * @author (Álvaro Pinheiro) * @version (01/03/2011)*/public class ClassPessoa {

// variáveis de instânciaprivate int codigo;private String nome;/*** Construtor da classe ClassPessoa*/

public ClassPessoa() {// inicialização das variáveis de instânciacodigo = 0;nome = "";

}/*** Método para atribuir valor ao campo código* * @param pcodigo* @return codigo*/

public void setCodigo(int pCodigo) {codigo = pCodigo;

}

/*** Método para retornar valor do campo código* * @param nulo* @return codigo*/

public int getCodigo() {return codigo;

}/*** Método para atribuir valor ao campo nome* * @param pnome* @return nome*/public void setNome(String pNome)

nome = pNome;}/*** Método para retornar valor do campo nome* * @param nulo* @return nome*/

public String getNome() {return nome;

}}

Entendido o conceito de classe, segue uma codificação básica em Java.



Objetos



*

Agora que sabemos o conceito e como codificar uma classe, vamos

entender sobre objeto.

Segundo os pais da UML (Rumbaugh, Jacobson e Booch) um objeto

é uma instância de uma classe, isto é, trata-se de uma cópia da

classe na memória em tempo de execução (runtime), sendo assim,

um elemento específico que possui valores (estados) nos atributos

(campos).

A UML representa um objeto usando um retângulo que o representa,

onde o nome da instância do objeto é seguido de dois pontos,

seguido do nome da classe, com essa formação sublinhada.



*

/**

* Classe de domínio ClassCliente

*

* @author (Álvaro Pinheiro)

* @version (01/03/2011)

*/

public class ClassCliente {

/**

* Construtor da classe ClassCliente

*/

public ClassCliente() {

}

/**

* Método da classe cliente que exemplifica o instân-

* ciamento de dois objetos da classe Pessoa

*/

public void exemplo() {

ClassPessoa objCliente1 = new ClassPessoa();

ClassPessoa objCliente2 = new ClassPessoa();

objCliente1.setCodigo(1);

objCliente1.setNome("abc");

objCliente2.setCodigo(2);

objCliente2.setNome("xyz");

}

} www.alvarofpinheiro.eti.br


Métodos



*

Vamos aprender agora a chamar as classes e os métodos escritos em Java a partir de um ponto principal.

/**

* Classe Principal:

*

*/

class Principal {

/**

* Método que será chamado pelo método principal

*/

public void exemplo() {

System.out.println("Método chamado!");

}

/**

* Método principal

*/


Principal principal = new Principal();

principal.exemplo();

}

}

Nessa classe principal temos um método principal "main" que por default recebe um array de caracteres que

poderá ser preenchido quando o programa principal for carregado. Ao carregá-lo uma mensagem irá aparecer na

tela "Método chamado!" pois quando um objeto da classe é instanciada o método exemplo é invocado.



Pacotes



*

Um pacote em Java é a forma que se tem para permitir a

organização de classes em módulos, isto é, colocar todas as classes

de funcionalidades semelhantes e/ou equivalentes em um mesmo

lugar físico, chamado de package.

Os pacotes Java podem ser armazenados em arquivos compactados

denominados arquivos JAR, permitindo assim que classes com

mesmas funcionalidades possam se utilizadas de um maneira mais

rápida e fácil, já que todas as classes estão agrupadas em um

mesmo arquivo.

Outra vantagem do uso de pacotes é a utilização do modificador

package que disponibiliza para todas as propriedades e

comportamentos das classes agrupadas a sua visibilidade. Além de

normalmente os pacotes serem utilizados para conter Classes,

Interfaces e Tipos Enumerados - agrupando-os pelas suas

similidades.



*

Para se usar um pacote em uma classe Java deve-se importá-lo e isso

é feito com a seguinte declaração import javax.swing.*; Com essa

declaração é importado para a classe corrente todas as classes que

estão dentro do pacote javax.swing. Mas, se for desejado pode-se

importar somente a classe que se quer usar de um pacote específico,

como no exemplo import java.awt.event.ActionEvent;

Para se criar um arquivo JAR se faz necessário utilizar um utilitário de

linha de comando que se segue JAR arquivo.class meupacote.jar, esse

comando compacta todos os arquivos .class dentro do arquivo JAR

denominhado meuPacote.jar.

Um característica importante na criação dos pacotes é a utilização de

uma hierarquia baseada na separação dos nomes por ponto (.). Apesar

de pacotes inferiores na hierarquia de nomeação são muitas vezes

referidos como "subpacotes" dos pacotes correspondentes superior na

hierarquia, não há nenhuma relação semântica entre pacotes.



*

O Java Language Specification estabelece pacote de convenções de

nomenclatura para evitar a possibilidade de dois pacotes publicado com

o mesmo nome. As convenções de nomenclatura descrevem como criar

nomes de pacote exclusivo, para que os pacotes que são amplamente

distribuídos. Isso permite que os pacotes sejam separadamente, de

forma fácil e automaticamente instalado e catalogadas.

Segue o Core dos pacotes no Java SE 6:

● java.lang - Funcionalidades básicas da língua e tipos fundamentais;

● java.util - Utilitário;

● java.io - Operações de entrada e saída;

● java.math - Funções matemática;

● java.net - Operações de rede;

● java.security - Geração de chave de criptografia e descriptografia;

● java.sql - Drivers JDBC para acessar bancos de dados;

● java.awt - GUI nativa;

● javax.swing - GUI genérica;

● java.applet - Classes para a criação de applets;www.alvarofpinheiro.eti.br


*

Observe o exemplo abaixo, temos a importação do pacote javax.swing

que permite entro outras classes, usar a JOptionPane, que disponibiliza

os métodos showMessageDialog(null, "texto", "título", ícone) para

mostrar uma mensagem na tela e o showInputDialog("texto") para

entrar com um valor.



*

/**

* Classe Principal com pacote swing:

*

*/

import javax.swing.*;

class Principal

{

/**

* Método que será chamado pelo método principal

*/

public void exemplo()

{

System.out.println("Método chamado!");

String sVar1 = JOptionPane.showInputDialog("Entre com um número:");

String sVar2 = JOptionPane.showInputDialog("Entre com outro número:");

int nVar3 = Integer.parseInt(sVar1);

int nVar4 = Integer.parseInt(sVar2);

int nVar5 = nVar3 + nVar4;

JOptionPane.showMessageDialog(null, "A soma é " + nVar5, "Operação", JOptionPane.PLAIN_MESSAGE);

}

/**

* Método principal

*/

public static void main(String[] args)

{

Principal principal = new Principal();

principal.exemplo();

}



Relacionamentos



*

O que vamos estudar agora é como em Java se codifica os

relacionamentos, isto é as associações e heranças. Também iremos

codificar os três tipos de classes: Concreta, Abstrata e Interface.

Observe o diagrama de classes abaixo:



*

Temos a seguinte modelagem. A classe principal está associada a

classe cliente, esta por sua vez está associada as classes

departamento e função. A classe função estende a classe abstrata

cargo. A classe cliente é uma subclasse da classe pessoa-física que

também é pai da classe filha fornecedor. Ambas classes, cliente e

fornecedor são concretas, assim permitindo que se instâncie objetos

dessa classes. Já as classes pessoa-física e pessoa-jurídica são

abstratas, assim sendo possuem métodos não implementados e por

consequencia não permitindo que se instancie objetos diretamente

dessas classes. Essas duas últimas classes são filhas da classe

concreta pessoa que estende a classe abstrata configurações-básica e

implementa (realiza) as interface configurações-especiais e

configurações-avançadas.



Polimorfismo



*

É a capacidade de classes mais abstratas possuírem comportamentos

diferentes das classes concretas, isto é, duas ou mais classes derivadas de

uma mesma superclasse podem invocar métodos que têm a mesma

identificação (assinatura) mas comportamentos distintos, especializados para

uma das classes derivadas. A decisão sobre qual o método que deve ser

selecionado, de acordo com o tipo da classe derivada, é tomada em tempo de

execução, através do mecanismo de ligação tardia.

Mas para ser considerado polimorfismo, é necessário que os métodos tenham

exatamente a mesma identificação, quer dizer, o mesmo nome de método,

sendo utilizado o mecanismo de redefinição de métodos, isto é, sobrescrita dos

métodos.

Override ou Sobreescrita, a redefinição ocorre quando um método cuja

assinatura já tenha sido especificada recebe uma nova definição ou seja, uma

nova implementação em uma classe derivada. O mecanismo de redefinição,

juntamante com o conceito de ligação tardia, é a chave para a utilização do

polimorfismo. É importante observar que, quando polimorfismo está sendo

utilizado, o comportamento que será adotado por um método só será definido

durante a execução.www.alvarofpinheiro.eti.br


*

Temos a seguinte modelagem. A classe principal está associada a classe

cliente, esta por sua vez está associada as classes departamento e função. A

classe função estende a classe abstrata cargo. A classe cliente é uma

subclasse da classe pessoa-física que também é pai da classe filha fornecedor.

Ambas classes, cliente e fornecedor são concretas, assim permitindo que se

instâncie objetos dessa classes. Já as classes pessoa-física e pessoa-jurídica

são abstratas, assim sendo possuem métodos não implementados e por

consequencia não permitindo que se instancie objetos diretamente dessas

classes.

Essas duas últimas classes são filhas da classe concreta pessoa que estende

a classe abstrata configurações-básica e implementa (realiza) as interface

configurações-especiais e configurações-avançadas.



*

Overload ou Sobrecarga, um método aplicado a um objeto é selecionado para

execução através da sua assinatura e da verificação a qual classe o objeto

pertence. Dois ou mais métodos de uma mesma classe podem ter o mesmo

nome, desde que suas listas de parâmetros sejam diferentes, constituindo

assim uma assinatura diferente. Tal situação não gera conflito pois o

compilador é capaz de detectar qual método deve ser escolhido a partir da

análise dos tipos de argumentos do método.

Early Binding ou Ligação Prematura, quando um método é invocado durante a

compilação do programa, o mecanismo de ligação é prematura.

Late Binding ou Ligação Tardia, quando a definição do método que será

efetivamente invocado só ocorre durante a execução do programa, o

mecanismo de ligação usado é o de tardia também conhecido pelos termos

dynamic binding ou run-time binding. Em Java, todas as determinações de

métodos a executar ocorrem através de ligação tardia exceto em dois casos:

métodos declarados como final não podem ser redefinidos e portanto não são

passíveis de invocação polimórfica da parte de seus descendentes e

métodos declarados como private são implicitamente finais.



*

Para melhor entender o polimorfismo, veja o diagrama abaixo e sua implementação.



*

public interface IPrincipal

{

void verificaAcesso();

boolean verificaCpf(String pCpf);

}

public abstract class ClsSecundaria implements IPrincipal

{

public abstract void verificaAcesso();

public boolean verificaCpf(String pCpf)

{

if (true) {

return true;

}

else

{

return false;

}

}



*

public class ClsPessoa extends ClsSecundaria

{

private String cpf;

private String nome;

public ClsPessoa()

{

cpf = "";

nome = "";

}

public ClsPessoa(String pCpf) // exemplo de overload (sobrecarga)

{

cpf = pCpf;

nome = "";

}

public ClsPessoa(String pCpf, String pNome) // exemplo de overload (sobrecarga)

{

cpf = pCpf;

nome = pNome;

}

public void verificaAcesso()

{

System.out.print("Acesso tipo 1");

}

}



*

public interface IPrincipal

{

void verificaAcesso();

boolean verificaCpf(String pCpf);

}

public abstract class ClsSecundaria implements IPrincipal

{

public abstract void verificaAcesso();

public boolean verificaCpf(String pCpf)

{

if (true) {

return true;

}

else

{

return false;

}

}



*

public class ClsPessoaJuridica extends ClsPessoa

{

public ClsPessoaJuridica()

{

}

}

public class ClsPessoaFisica extends ClsPessoa

{

public ClsPessoaFisica()

{

}

public void verificaAcesso() // exemplo de override (sobreescrita)

{


}

}



*

public class ClsFornecedor extends ClsPessoaJuridica

{

public ClsFornecedor()

{

}

}

public class ClsCliente extends ClsPessoaFisica

{

public ClsCliente()

{

}

// exemplo de herança e encapsulamento

}

public class ClsTecnico extends ClsPessoaFisica

{

public ClsTecnico()

{

}

public void verificaAcesso() // exemplo de override (sobreescrita)

{


}

public void verificaAcesso(int p1) // exemplo de overload (sobrecarga)

{


}



*

public class ClsPrincipal

{

public ClsPrincipal()

{

}

public static void main(String Args[])

{

ClsFornecedor objFornecedor = new ClsFornecedor();

ClsCliente objCliente = new ClsCliente();

ClsTecnico objTecnico = new ClsTecnico();

objFornecedor.verificaAcesso(); // executa System.out.print("Acesso tipo 1")

objCliente.verificaAcesso(); // executa System.out.print("Acesso tipo 2")

objTecnico.verificaAcesso(); // executa System.out.print("Acesso tipo 3")

objTecnico.verificaAcesso(1); // executa System.out.print("Acesso tipo 4")

}

}



Super



*

É um recurso para se invocar um construtor da classe pai. A palavra super disponibiliza

o acesso a partes da classe pai a partir da classe filha, e é útil no polimorfismo da

sobreposição de métodos. Veja o exemplo a seguir.

public class ClsPessoa

{

public ClsPessoa() {} // construtor

public void verificaAcesso() {

System.out.print("Acesso tipo 1"); }

public void verificaAcesso(String pUsuario, String pSenha) {

System.out.print("Acesso tipo especial"); }

}

public class ClsPessoaJuridica extends ClsPessoa

{

public ClsPessoaJuridica() {} // construtor

// herda verificaAcesso do pai sem sobreescrever executando Acesso tipo 1

}



*

public class ClsPessoaFisica extends ClsPessoa

{

public ClsPessoaFisica() {} // construtor

public void verificaAcesso() {

System.out.print("Acesso tipo 2"); // sobreescreve o tipo de acesso do pai

(override) }

public void verificaAcesso(String p1) {

super.verificaAcesso(); // executa System.out.print("Acesso tipo 1") da classe pai }

}

public class ClsTecnico extends ClsPessoaFisica

{

public ClsTecnico() {} // construtor

public void verificaAcesso(int p1) {

System.out.print("Acesso tipo 3"); // exemplo de sobreescrita (override) }

public void verificaAcesso(int p1, int p2) {

System.out.print("Acesso tipo 4"); // exemplo de sobrecarga (overload) }

}



*

public class ClsPrincipal

{

public ClsPrincipal() {} // construtor

public static void main(String Args[]) {

ClsTecnico objTecnico = new ClsTecnico();

objTecnico.verificaAcesso("x"); // executa System.out.print("Acesso tipo 1")

objTecnico.verificaAcesso(); // executa System.out.print("Acesso tipo 2")

objTecnico.verificaAcesso(1); // executa System.out.print("Acesso tipo 3")

objTecnico.verificaAcesso(1,2); // executa System.out.print("Acesso tipo 4")

objTecnico.verificaAcesso("x","y"); // executa System.out.print("Acesso tipo

especial") }

}



JAVA

Tratamento de Exceções



Exceções

Permitem tratar (“catch”) de forma agradável os erros

que podem acontecer durante a execução de um

programa;

Permitem especificam diferentes formas de tratamento

de exceções distintas;

Oferecem uma forma padronizada de levantar (“throw”)

exceções;

Permitem representar como objetos os erros de um

programa que podem ser recuperados (“exceptions”); e

Permitem criar uma hierarquia extensível de classes de

exceções para um tratamento de erros preciso.



Tipos de Exceções

*

I/O (teclado/ floppy / disco / entrada de dados);

Rede (internet, LAN);

Casting;

Desreferenciação de objectos;

Matemática;

Índice de array (colecção fora dos limites);

Falta de memória;

Crash na Java Virtual Machine; e

Classes Java requeridas pelo programa corruptas.



Hierarquia de Exceções

*

java.lang.Throwable

Error

ThreadDeath

OutOfMemoryError

VirtualMachineError

Exception

AWTException

IOException

FileNotFoundException

MalformedURLException

RemoteException

SocketException

RuntimeException

ArithmeticException

ClassCastException

IllegalArgumentException

IndexOutOfBoundsException

NullPointerException

UnsupportedOperationException



checked versus unchecked

*

checked - Podem ter sido causadas por algo fora do controle do

nosso programa; Devem ser tratadas pelo nosso código, senão

o

programa não compila.

unchecked (runtime) - Poderiam ter sido evitadas se fossem

devidamente analisadas e tratadas no código; Não precisam de

ser tratadas, mas farão com que o programa crash no caso de

ocorrerem em runtime.



Exceções em runtime

*

Podem ser geradas em qualquer parte do código pelo

programador e não precisam de ser tratadas (handled) pelas

chamadas que as apanham.

public Object metodo(int param) {

// verificar se parâmetro é válido

if (param < 0)

throw new IndexOutOfBoundsException(“param < 0!”);

return dados[index];

}



Exceções checked

*

No cabeçalho do método devem ser especificados os tipos de

exceções que ele pode originar (“throws”); Quem invocar um

método que possa originar exceções deve tratá-las ou então

passar essas exceções a quem o invocou.

public void metodo(String param) throws IOException {

if (condição)

throw new IOException(“mensagem”);

}



Exceções sintaxe

*

try {

// bloco de comandos

}

catch (Exception objeto) {

// tratamento da exceção

}

finally {

// bloco de comandos opcional no final do tratamento

}



Multiplas Exceções sintaxe

*

try {

// bloco de comandos

}

catch (IndexOutOfBoundsException ioobe) {

// tratamento de exceção

}

catch (IOException ioe) {


}

catch (Exception e) {


}

finally {

// tratamento de finalização

}



JAVAExemplo de Aplicação com POO / MVC / JDBC



PACOTES (CAMADAS)



PACOTE DEFAULT (PRINCIPAL)



*

import Visual.Pessoa;



Visual.Pessoa pessoa = new Pessoa();

pessoa.setVisible(true);

}

}



PACOTE VISUAL (VIEW)



*

package Visual;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JTextField;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import org.dyno.visual.swing.layouts.Constraints;

import org.dyno.visual.swing.layouts.GroupLayout;

import org.dyno.visual.swing.layouts.Leading;

public class Pessoa extends JFrame {

private static final long serialVersionUID = 1L;

private JLabel jLabel0;



private JTextField jTextField0;

private JTextField jTextField1;

private JButton jButton0;




...



*

…

public Pessoa() {

initComponents();

}

private void initComponents() {

setTitle("Pessoa");

setLayout(new GroupLayout());

add(getJLabel0(), new Constraints(new Leading(12, 12, 12), new Leading(12, 12, 12)));


add(getJButton0(), new Constraints(new Leading(12, 12, 12), new Leading(84, 10, 10)));


add(getJTextField0(), new Constraints(new Leading(55, 47, 12, 12), new Leading(12, 12, 12)));




add(getJTextField1(), new Constraints(new Leading(55, 194, 12, 12), new Leading(44, 12, 12)));

setSize(381, 201);

}

…



*

…

private JButton getJButton0() {

if (jButton0 == null) {

jButton0 = new JButton();

jButton0.setText("Incluir");

jButton0.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent event) {

jButton0MouseMouseClicked(event);

}

});

}

return jButton0;

}




jButton1.setText("Consultar");




}

});

}

return jButton1;

}

…



*

…




jButton2.setText("Alterar");

jButton2.setEnabled(false);




}

});

}

return jButton2;

}




jButton3.setText("Excluir");





}

});

}

return jButton3;

}

…



*

…

private JLabel getJLabel0() {

if (jLabel0 == null) {

jLabel0 = new JLabel();

jLabel0.setText("Código");

}

return jLabel0;

}




jLabel1.setText("Nome");

}

return jLabel1;

}




jLabel2.setText("Mensagem");

}

return jLabel2;

}

…



*

…

private JTextField getJTextField0() {

if (jTextField0 == null) {

jTextField0 = new JTextField();

}

return jTextField0;

}

private JTextField getJTextField1() {

if (jTextField1 == null) {

jTextField1 = new JTextField();

}

return jTextField1;

}

…



*

…


installLnF();

SwingUtilities.invokeLater(new Runnable() {

@Override

public void run() {

Pessoa frame = new Pessoa();

frame.setDefaultCloseOperation(Pessoa.EXIT_ON_CLOSE);

frame.setTitle("Pessoa");

frame.getContentPane().setPreferredSize(frame.getSize());

frame.pack();

frame.setLocationRelativeTo(null);

frame.setVisible(true);

}

});

}

…



*

…

private void inicializarTela() {

jTextField0.setText("");

jTextField1.setText("");



}

private void jButton0MouseMouseClicked(MouseEvent event) {

try {

Modelo.Pessoa pessoa = new Modelo.Pessoa();

pessoa.setCodigo(Integer.parseInt(jTextField0.getText()));

pessoa.setNome(jTextField1.getText());

Controle.Pessoa.validarInclusao(pessoa);

jLabel2.setText("Inclusão realizada com sucesso!");

inicializarTela();

} catch (Exception excecao) {

jLabel2.setText(excecao.getMessage());

}

}


try {

jTextField1.setText(Controle.Pessoa.validarCodigo(jTextField0.getText()));

jButton2.setEnabled(true);

jButton3.setEnabled(true);



}

}

…



*

…


try {

Modelo.Pessoa pessoa = new Modelo.Pessoa();

pessoa.setCodigo(Integer.parseInt(jTextField0.getText()));

pessoa.setNome(jTextField1.getText());

Controle.Pessoa.validarAlteracao(pessoa);

jLabel2.setText("Alteração efetuada com sucesso!");

inicializarTela();



}

}


try {

Controle.Pessoa.validarExclusao(jTextField0.getText());

jLabel2.setText("Exclusão efetuada com sucesso!");

inicializarTela();



}

}

}



PACOTE MODELO (MODEL)



*

package Modelo;

public class Pessoa {

private int codigo;

private String nome;

public void setCodigo(int codigo) {

this.codigo = codigo;

}

public int getCodigo() {

return codigo;

}

public void setNome(String nome) {

this.nome = nome;

}

public String getNome() {

return nome;

}

}



PACOTE CONTROLE (CONTROL)



*

package Controle;


public static String validarCodigo(String codigo) throws Exception {

try {

if (codigo.isEmpty()) {

throw new Exception("Código é de preenchimento obrigatório!");

} else {

int aux = 0;

try {

aux = Integer.parseInt(codigo);


throw new Exception("Formato inválido");

}

if ((aux<1) || (aux>100)) {

throw new Exception("Código válido entre 0 e 100!");

} else {

return (Dado.Pessoa.realizarConsulta(aux));

}

}

}


throw (excecao);

}

}

...



*

...

public static void validarInclusao(Modelo.Pessoa pessoa) throws Exception {

try {

if ((pessoa.getCodigo()<1) || (pessoa.getCodigo()>100)) {


} else {

if (pessoa.getNome().isEmpty()) {

throw new Exception("Nome é de preenchimento

obrigatório!");

}

}

Dado.Pessoa.realizarInclusao(pessoa);

}


throw (excecao);

}

}

...



*

...

public static void validarAlteracao(Modelo.Pessoa pessoa) throws Exception {

try {

if ((pessoa.getCodigo()<1) || (pessoa.getCodigo()>100)) {


} else {

if (pessoa.getNome().isEmpty()) {

throw new Exception("Nome é de preenchimento

obrigatório!");

}

}

Dado.Pessoa.realizarAlteracao(pessoa);

}


throw (excecao);

}

}

...



*

...

public static void validarExclusao(String codigo) throws Exception {

try {

if (codigo.isEmpty()) {

throw new Exception("Código é de preenchimento obrigatório!");

} else {

try {

int aux = Integer.parseInt(codigo);

if ((aux<1) || (aux>100)) {

throw new Exception("Código válido entre 0 e

100!");

} else {

Dado.Pessoa.realizarExclusao(aux);

}


throw new Exception("Formato inválido");

}

}

}


throw (excecao);

}

}

}



PACOTE DADOS (PERSISTÊNCIA)



*

package Dado;

import java.sql.*;


public static String realizarConsulta(int codigo) throws Exception {

String aux = "";

try {

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

String bd = "jdbc:mysql://localhost/exemplo";

Connection conexao = DriverManager.getConnection(bd, "root", “******");


ResultSet retorno = comando.executeQuery("SELECT VC_PES_NOME FROM

PESSOA WHERE NU_PES_CODIGO = " + codigo);

boolean bExiste = true;

while (retorno.next()) {

aux = retorno.getString("VC_PES_NOME");

}

if ((aux.isEmpty()) || (aux.equals(""))) {

bExiste = false;

}

retorno.close();

comando.close();

conexao.close();

if (!bExiste) {

throw new Exception("Código não cadastrado!");

}

}


throw (excecao);

}

return (aux);

}

...www.alvarofpinheiro.eti.br


*

...

public static void realizarInclusao(Modelo.Pessoa pessoa) throws Exception {

try {





comando.executeUpdate("INSERT INTO PESSOA (NU_PES_CODIGO,

VC_PES_NOME) VALUES ("+pessoa.getCodigo()+",'"+pessoa.getNome()+"')");

comando.close();

conexao.close();

}


throw (excecao);

}

}

...



*

...

public static void realizarAlteracao(Modelo.Pessoa pessoa) throws Exception {

try {





comando.executeUpdate("UPDATE PESSOA SET VC_PES_NOME = '"+

pessoa.getNome() +"' WHERE NU_PES_CODIGO = "+pessoa.getCodigo());

comando.close();

conexao.close();

}


throw (excecao);

}

}

...



*

...

public static void realizarExclusao(int codigo) throws Exception {

try {





comando.executeUpdate("DELETE FROM PESSOA WHERE NU_PES_CODIGO =

"+codigo);

comando.close();

conexao.close();

}


throw (excecao);

}

}

}




Java Aulas


POO com Java Exercícios1) Considere uma classe ContaBancária e suas duas subclasses ContaCorrente e

ContaPoupança, cada uma das três com o método AplicarJuros. A redefinição do método

AplicarJuros nas duas subclasses, cada uma com detalhes de implementação diferentes com a

mesma interface, caracteriza o princípio denominado na orientação a objetos como

1. abstração.

2. encapsulamento.

3. herança.

4. unificação.

5. polimorfismo.

2) Na orientação Objeto, quando uma rotina precisar ser modificada, basta o código do programa

que define o objeto ser mudado que o comportamento da rotina é imediatamente atualizado. Esta

característica é conhecida como:

1. ocultamento de informação;

2. polimorfismo;

3. herança;

4. sobrecarga;

5. encapsulamento.


POO com Java Exercícios3) No tocante à linguagem Java, a principal utilização da variável de classe STATIC com uma única

cópia de dados é:

1. compartilhamento de código;

2. economia de memória;

3. ocultamento de informação;

4. minimização de manutenção;

5. controle de acesso (modificador de acesso).

4) Analise as seguintes afi rmações relacionadas à Programação Orientada a Objetos:

I. Em um Programa Orientado a Objetos as instâncias de uma classe armazenam tipos diferentes

de informações e apresentam comportamentos distintos.

II. Em uma Aplicação Orientada a Objetos podem existir múltiplas instâncias de uma mesma

classe.

III. Em Programação Orientada a Objetos deve existir um e somente um objeto de uma mesma

classe.

IV. Os serviços que podem ser solicitados a um objeto são definidos pelos métodos.

Indique a opção que contenha todas as afirmações verdadeiras.

1. II e IV

2. II e III

3. III e IV

4. I e III

5. I e II


POO com Java Exercícios5) Na Programação Orientada a Objetos podem-se definir as visibilidades dos métodos e atributos.

Quanto a essa característica é correto afirmar que:

1. o acesso aos atributos e aos métodos privados só pode ser feito a partir dos métodos membros

da classe.

2. os métodos protegidos podem ser acessados a partir dos métodos de qualquer classe, desde

que instanciada na mesma aplicação.

3. os métodos públicos e os atributos protegidos só podem ser acessados a partir dos métodos da

própria classe ou de classes derivadas.

4. os métodos privados e os atributos protegidos podem ser acessados a partir dos métodos de

qualquer classe.

5. o acesso aos atributos privados e aos métodos públicos só pode ser feito a partir dos métodos

membros da classe.


POO com Java Exercícios6) Analise as seguintes afirmações relacionadas à Orientação a Objetos:

I. Os atributos podem ser de instância ou de classe.

Quando os atributos são de instância, cada objeto

guarda a sua própria cópia de tais atributos.

II. Os atributos compartilhados entre objetos de uma classe são chamados de atributos de objetos.

Em Java, por exemplo, esses atributos são identifi cados com a palavra static.

III. Existem métodos cujo código apenas acessa atributo de classe ou os parâmetros passados.

Esses métodos são chamados de métodos de classe.

IV. Um mesmo nome de objeto pode ser usado para

identificar diferentes objetos em uma mesma classe

ou diferentes objetos em classes diferentes, evitando assim, que seja necessário usar nomes

diferentes para objetos diferentes que realizam a mesma operação. A esta característica da

Orientação a Objetos dá-se o nome de Polimorfismo.


1. I e II

2. II e III

3. III e IV

4. II e IV

5. I e III


POO com Java Exercícios7) Analise as seguintes afirmações relacionadas à Orientação a Objetos:

I. As exceções que podem ser lançadas por um método são definidas na criação da classe

abstrata que contém o método. As exceções normalmente provocam o encerramento indesejado

do programa.

II. Quando uma classe é definida, nem sempre é possível definir todos os seus métodos. Para

resolver esta situação pode-se definir métodos abstratos, que podem ser instanciados a qualquer

momento após a criação da classe.

III. Da mesma forma que é necessário especificar o código a ser executado na criação de um

objeto, pode ser necessário especificar um código para ser executado na destruição de um objeto.

Isso é feito com a utilização de um método chamado destrutor ou finalizador. Nesses métodos é

comum, por exemplo, inserir código para fechar arquivos ou encerrar conexões.

IV. Em uma classe podem existir métodos que não devem ser redef nidos em classes derivadas.

Esses métodos são chamados métodos finais e uma tentativa de redefini-los resulta em um erro de

compilação.


1. I e II

2. II e III

3. I e III

4. III e IV

5. II e IV


POO com Java Exercícios8) Na Programação Orientada a Objetos,

1. a definição dos objetos deve ser obrigatoriamente definida no corpo do construtor.

2. o código construtor é responsável por criar e inicializa os atributos dos objetos.

3. o construtor é uma função que tem um nome qualquer e, quando instanciada, faz referência aos

atributos da classe a ser definida.

4. o código construtor é responsável por criar os método da classe.

5. quando se instancia uma classe diversas vezes, o código construtor é responsável por

armazenar e compartilhar os atributos das instâncias e os de classe utilizados ao longo de todo o

processo.

9) Uma pizzaria fez uma ampliação de suas instalações e o gerente aproveitou para melhorar o

sistema informatizado, que era limitado e não atendia a todas as funções necessárias. O gerente,

então, contratou uma empresa para ampliar o software. No desenvolvimento do novo sistema, a

empresa aproveitou partes do sistema antigo e estendeu os componentes de maneira a usar

código validado, acrescentando as novas funções solicitadas.

Que conceito de orientação a objetos está descrito na situação hipotética acima?

1. sobrecarga

2. herança

3. sobreposição

4. abstração

5. mensagem


POO com Java Exercícios10) Com relação a conceitos de orientação a objetos, julgue os seguintes itens.

I As variáveis ou métodos declarados com modificador de acesso private só são acessíveis a

métodos da classe em que são declarados.

II Uma classe deve possuir uma única declaração de método construtor.

III Uma instância de uma classe abstrata herda atributos e métodos de sua superclasse direta.

IV O polimorfismo permite substituir a lógica condicional múltipla (lógica switch ou faça caso).

Estão certos apenas os itens

1. I e II

2. I e III

3. I e IV

4. II e III

5. II e IV.


POO com Java Exercícios11) A orientação a objetos é uma forma abstrata de pensar um problema utilizando-se conceitos do

mundo real e não, apenas, conceitos computacionais. Nessa perspectiva, a adoção do paradigma

orientado a objetos implica necessariamente que

1. os usuários utilizem as aplicações de forma mais simples.

2. os sistemas sejam encapsulados por outros sistemas.

3. os programadores de aplicações sejam mais especializados.

4. os objetos sejam implementados de maneira eficiente e simples.

5. a computação seja acionada por troca de mensagens entre objetos.

programação orientada a objetos com java

Technology