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

Apresentação
JAVA
Java Apresentação
www.alvarofpinheiro.eti.br *

Eclipse
Java Apresentação
●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.
* www.alvarofpinheiro.eti.br

Eclipse
Java Apresentação
●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

JDK / JRE / JVM
Java Apresentação
●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 .

JDK / JRE / JVM
Java Apresentação
●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.

JAR
Java Apresentação
●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

História
Java Apresentação
●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.

Biografia
Java Apresentação
●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.

Independência
Java Apresentação
●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.

Applets
Java Apresentação
●Utilizado em páginas HTML; Pode incluir formulários,
áudio, imagens, vídeo, etc.; Aparece nos browsers e
pode se comunicar com o servidor.

Aplicação
Java Apresentaçã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
●Código é compilado para bytecodes;
Java Apresentação
●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.

Introdução
JAVA
Java Introdução

Convenções
Java Introdução
●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()

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
Java Introdução
*
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;
}
}

Bloco de código
Java Introdução
●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.

Instruções
Java Introdução
●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.

Tipos de Dados
●boolean: lógico - boolean b = true;
●byte: inteiros entre -128 e 127 - byte b = 111;
●char: caracter - char letra = ‘A’;
Java Introdução
●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
● }
●}

Tipo Literal
Java Introdução
●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”;
● }
●}

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
Java Introduçã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.

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;
Java Introdução
● res = (var2 > var1) & (var3 == 3); // falso

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”;
Java Introdução
●var1 = var1 + var2; // resulta em “ÁlvaroPinheiro”
●Var1 += var2 // resulta em “ÁlvaroPinheiro”

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
Java Introdução
*
if ( cond )
cmd1;
[else]
cmd2;

If else if else
Java Introdução
*
if (cond1)
if (cond2)
cmd1;
else
cmd2;
else
cmd3;

( ? : )
Java Introdução
*
(expr1 ? expr2 : expr3)
int var1;
var1 = (val1 > val2) ? ret_verdadeiro : ret_falso;

while
Java Introdução
*
while ( cond )
cmd;

do...while
Java Introdução
*
do
cmd;
while ( cond );

for
Java Introdução
*
for ( início; cond; passo )
cmd;

break
Java Introdução
*
● 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.

continue
Java Introdução
*
● 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;
}
}

Entrada e Saída de Dados
JAVA
Java Entrada/Saída

Saída
Java Entrada/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.

Saída
Java Entrada/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?");
}
}

Entrada
Java Entrada/Saída
*
Para entrar com dados usar a classe Scanner.
import java.util.*;
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!");
}
}

Stream
Java Entrada/Saída
*
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, ...

Stream Hierarquia
Java Entrada/Saída
*
java.io.InputStream
AudioInputStream
FileInputStream
ObjectInputStream
java.io.OutputStream
ByteArrayOutputStream
FileOutputStream
ObjectOutputStream

Input Stream
Java Entrada/Saída
*
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

Output Stream
Java Entrada/Saída
*
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

Exemplo de Stream
Java Entrada/Saída
*
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());
}

Thread
Java Entrada/Saída
*
É 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.

Thread
Java Entrada/Saída
*
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.

Thread
Java Entrada/Saída
*
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()

Thread
Java Entrada/Saída
*
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) {
}
…
}

Thread
Java Entrada/Saída
*
// 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");
}
}

Thread
Java Entrada/Saída
*
// 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

Thread
Java Entrada/Saída
*
Ciclo de vida:

Thread
Java Entrada/Saída
*
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() {
…
}
…
}

Thread
Java Entrada/Saída
*
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 MVC/JDBC
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.

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.

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
MVC -
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.

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
aAp Creasmeandtaadodse. 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 Outros Recursos
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.

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 Conceitos Gerias
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.
*

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.

Orientação a Objetos
JAVA
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.

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();
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
}

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.
*

www.alvarofpinheiro.eti.b*r

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...
*

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.
*

Entendido o conceito de classe, segue uma codificação básica em Java.
*
/**
* Classe de domínio ClassPessoa
*
* @author (Álvaro Pinheiro)
* @version (01/03/2011)
*/
public class ClassPessoa {
// variáveis de instância
private int codigo;
private String nome;
/**
* Construtor da classe ClassPessoa
*/
public ClassPessoa() {
// inicialização das variáveis de instância
codigo = 0;
nome = "";
}
/**
* Método para atribuir valor ao campo código
*
* @parampcodigo
* @return codigo
*/
public void setCodigo(int pCodigo) {
codigo = pCodigo;
}
/**
* Método para retornar valor do campo código
*
* @paramnulo
* @return codigo
*/
public int getCodigo() {
return codigo;
}
/**
* Método para atribuir valor ao campo nome
*
* @parampnome
* @return nome
*/
public void setNome(String pNome)
nome = pNome;
}
/**
* Método para retornar valor do campo nome
*
* @paramnulo
* @return nome
*/
public String getNome() {
return nome;
}
}

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;
*

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.
*

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;
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 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") }
}

Tratamento de Exceções
JAVA

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
}

Exemplo de Aplicação com POO / MVC / JDBC
JAVA

PACOTES (CAMADAS)

www.alvarofpinheiro.eti.*br

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;
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);
}
...

*
...
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ícios
1) 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.

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

5) 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.

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

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

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

10) 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.

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

Recomendados

Mais conteúdo relacionado

Mais procurados (20)

Destaque (20)

Semelhante a Programação Orientada a Objetos com Java (20)

Mais de Álvaro Farias Pinheiro (18)

Último (15)

Programação Orientada a Objetos com Java