Aluno: Vanderson R da Silva

01º Aula Conceitual:

SOBRECARGA DE MÉTODOS

Sobreposição: A sobreposição, como já vimos, nada mais é do que escrever um método que já possuímos,
sendo possível pelos recursos de herança.

Sobrecarga: já a sobrecarga consiste no recurso que a linguagem Java nos oferece de escrever métodos
com o mesmo nome, fazendo-se a distinção apenas pelos parâmetros de entrada que obrigatoriamente
precisam ser diferentes.

Obs.: O recurso oferecido pela sobrecarga vai nos ajudar muito, pois podemos trabalhar métodos com
mesmo nome, mas de várias formas diferentes sem perder o sentido do que o método se propõe a oferecer.

Nota: A sobrecarga de métodos (overload) é um conceito do polimorfismo que consiste

basicamente em criar variações de um mesmo método, ou seja, a criação de dois ou
mais métodos com nomes totalmente iguais em uma classe. A Sobrecarga permite que
utilizemos o mesmo nome em mais de um método contanto que suas listas de
argumentos sejam diferentes para que seja feita a separação dos mesmos.
01 Exemplo de Sobrecarga com dois parâmetros de entrada:

02 Exemplo de Sobrecarga com dois parâmetros de entrada:

CONSTRUTORES COM SOBRECARGA

Um recurso muito utilizado é usar sobrecarga com o construtor da classe. Os construtores sempre têm o
mesmo nome que a classe. Mesmo em uma classe que tenha vários construtores, todos eles terão o mesmo
nome. Para diferenciar um construtor de outro é usada a lista de parâmetros do construtor. Cada construtor
deve ter uma lista de parâmetros diferentes. Ao chamar um construtor para construir um novo objeto, a
lista de argumentos usada na chamada irá combinar com a lista de parâmetros de um construtor e então
ele será executado.
EXEMPLOS CONSTRUTORES COM SOBRECARGA

02º Aula Conceitual:

TRATAMENTO DE EXCEÇÕES

Exceções são erros detectados por hardware ou pelo sistema operacional

Quando um evento excepcional ocorre em Java, diz-se que uma exceção será lançada. O código que é
responsável por fazer algo com a exceção é chamado de manipulador de exceções; ele captura a exceção
lançada.

Uma exceção é uma ocorrência que altera o fluxo normal do programa. Ela pode ocorrer por diversos
motivos, incluindo os seguintes:

 Um usuário encontrou dados inválidos.

 Um arquivo que precisa ser aberto não pode ser encontrado.
 A conexão de rede foi perdida no meio de comunicação, ou a JVM está sem memória.
 Falhas no Hardware.
 Exaustão de recursos.

CAPTURA DE EXCEÇÕES

A manipulação da exceção funciona pela transferência da execução de um programa para um

manipulador de exceções apropriado quando uma exceção ocorrer.
TRY / CATCH

Esta é a forma mais usada. O Código dentro de um bloco try / catch é chamado de código protegidos.

O Try e Catch são comando que utilizamos no nosso código para envelopar um bloco de código onde
podemos detectar que possa ocorrer uma exceção.

Podemos declarar mais do que um bloco catch. Isso é importante porque podemos ter vários tipos
diferentes de exceção sendo lançados e necessitar de um tratamento específicos para cada um.

As exceções são capturadas pelo programa, mas podem ser geradas pelo comando throw

USANDO FINALLY

O bloco Finally é usado quando precisamos executar um código mesmo se houver uma exceção. Por
exemplo, se você está escrevendo em um arquivo e acontece um erro, o arquivo tem que ser fechado
mesmo assim. Ou se você está usando uma conexão a banco de dados e acontece algum problema, a
conexão tem que ser fechada.
DEFININDO EXCEÇÕES

Sabemos que elas são lançadas quando um problema de algum tipo ocorre e que efeito terá sobre o fluxo
de seu programa. Toda exceção é a instância de uma classe que possui a classe Exception em sua hierarquia
de herança. Quando uma exceção é lançada, o objeto de um subtipo Exception específico é instanciado e
inserido no manipulador de exceções como um argumento para a cláusula catch.

HIERARQUIA DE EXCEÇÕES

■ As exceções verificadas: herdam da classe Exception. O código do cliente tem de lidar com as exceções
verificadas lançadas pelo API, ou em uma cláusula try /catch ou encaminhando para fora com a cláusula
throws.

■ As Exceções não verificadas: são as RuntimeException que também se estende de Exception. No

entanto, todas as exceções que herdam de RuntimeException recebem tratamento especial. Não há
nenhuma exigência para o código do cliente para lidar com eles, portanto, eles são chamados de exceções
não verificadas (unchecked).

DECLARAÇÃO DE EXCEÇÕES E A INTERFACE PÚBLICA

As exceções que um método pode lançar devem ser declaradas (a menos que sejam subclasses de
RuntimeException). A lista de exceções lançadas faz parte da interface pública de um método. A palavra-
chave throws é usada na forma descrita, a seguir, para listar exceções que um método pode lançar:

O conceito é semelhante ao de return, mas enquanto return está devolvendo um resultado de dentro do
método, throws está lançando uma exceção. Nunca é possível considerar uma exceção como o resultado
de um método, o objetivo do método é obter resultados sem lançar exceções. Veja, a seguir, um exemplo
de método utilizando o throws e o throw.
A Principal diferença entre throw e throws é o uso e a funcionalidade.

throws :é usado na assinatura do método para declarar exceção possivelmente lançadas

por qualquer método.

Throw: é usado para lançar exceção no código Java, acima está um exemplo de ambos throw e throws.

 try {… } - Neste bloco são introduzidas todas as linhas de código que podem vir a
lançar uma exceção.
 catch (tipo_excessao e) { … } - Neste bloco é descrita a ação que ocorrerá quando a
exceção for capturada.

UNIDADE II

03º Aula Conceitual:

O QUE É CLASSE ABSTRATA?

Uma classe abstrata é desenvolvida para representar classes e conceitos abstratos. A classe abstrata é
sempre uma superclasse que não permite que nenhum objeto seja criado a partir dela, ou seja, não pode
ser instanciada. Para formalizar que uma classe seja abstrata, usamos a palavra reservada abstract antes
da palavra reservada class.

Métodos abstratos são declarados com o modificador abstract. Se uma classe tiver algum método
abstrato, a classe também deverá obrigatoriamente ser declarada com o modificador abstract. Os
métodos de uma classe abstrata classificados como abstratos devem terminar sempre com; (ponto e
vírgula) e a classe que a estender deverá implementá-los.

Nota: Observe que tanto a classe como os métodos abstratos estão representados com a fonte em itálico
e esse comportamento representa um padrão nas modelagens UML.
REGRAS SOBRE CLASSES E MÉTODOS ABSTRATOS

Alguns pontos interessantes das imagens acima exemplificam algumas das regras de criação de classe e
métodos abstratos que são:

 Os métodos construtores não podem ser declarados como abstratos. Mesmo que a classe abstrata
não possa ser instanciada, seus construtores podem inicializar os campos da classe que serão
usados por subclasses, sendo imprescindível em praticamente todos os casos.
 Métodos declarados como abstratos não podem ser privados (private).
 Classes abstratas não podem conter métodos estáticos (static).
 Os campos de uma classe abstrata serão herdados pelas classes descendentes e poderão ser usados
por instâncias destas a não ser que sejam declarados como private.

Explicando o código
java.util.Scanner: que permite a leitura de dados vindos do teclado.

Switch: criar um menu de opções.

getInstance(). Esse método não cria um objeto toda vez que ele é chamado e se torna ideal para o nosso

exemplo, pois o nosso objetivo é apenas demonstrar o uso e as chamadas dos métodos abstratos.
O QUE SÃO INTERFACES?

Interface é um recurso da orientação a objeto utilizado em Java que define ações que devem ser
obrigatoriamente executadas, mas que cada classe pode executar de forma diferente. Na linguagem de
programação Java, uma interface é um tipo de referência, semelhante a uma classe, que pode conter
apenas constante, assinaturas de métodos e tipos aninhados. Não há corpo de método. Interfaces não
podem ser instanciadas, elas só podem ser implementadas por classes ou prorrogado por outras interfaces.

CARACTERÍSTICAS DAS INTERFACES

Uma interface tem as seguintes características:

■ Uma interface não pode ser instanciada, mas podem ser definidos referências do seu tipo.

Nesse exemplo não executamos o operador new, por isto temos apenas uma

referência.

■ Todos os métodos definidos são implicitamente do tipo public. ou abstract. Por essa razão, ao declarar
um método em uma interface, não é necessário fornecer a palavra-chave public. Os métodos não podem

ter corpo definido, somente definimos sua assinatura.

■ A classe que implementa uma interface deve obrigatoriamente implementar todos os métodos definidos
na interface.

■ Uma interface é formalmente uma classe abstrata, somente com atributos constantes (Final) e estáticos
(static) e métodos sem corpo. Estes deverão ser implementados pelas classes que irão implementar a
interface. É importante observar que os atributos na interface precisam ser inicializados.
Nota: A linha tracejada e com uma ponta de flecha vazada demonstra que a classe Blu-ray implementa a
interface. Outra forma de mostrar que uma classe implementa uma interface é desenhar uma linha com
um círculo em uma das extremidades com o nome dessa interface. As interfaces e seus métodos sempre
são abstratos em Java.

Observe que estamos utilizando um atributo do tipo Final e static.

Final: indica que a classe, método ou variável assim declarada tem uma única atribuição que se mantém
constante, ou seja, não pode ser alterada no decorrer do processamento.

static: é utilizada para se criar uma variável que poderá ser acessada por todas as instâncias de objetos
desta classe como uma variável comum.
COMPARANDO INTERFACES E CLASSES ABSTRATAS

Outras linguagens de programação, especialmente o C++, permitem que uma classe tenha mais de uma
superclasse. Esse recurso é chamado de Herança Múltipla. Os projetistas do Java optaram por não dar
suporte à herança múltipla, porque ela torna a linguagem muito complexa (como no C++). Ao invés disso,
as interfaces suportam a maioria dos benefícios da herança múltipla e, ao mesmo tempo, evitam as
complexidades e ineficiências. Abaixo um quadro comparativo para tornar mais fácil a compreensão entre
diferenças e similaridades entre Classes Abstratas e Interfaces.
04º Aula Conceitual:

Unidade III

ENTENDENDO UM ARRAY

A estrutura de um Array, e um grupo de posições na memória, um imediatamente após o outro, que

possuem o mesmo nome e o mesmo tipo de dado.

Para verificar o tamanho do array, usa-se a variável length: dados. Length → 8

Declaração de arrays.

O código, a seguir, mostra declarações válidas e inválidas de Arrays de tipo primitivo.

O código, a seguir, mostra declarações válidas e inválidas de referência a objetos.

Arrays multidimensionais.

CONSTRUINDO ARRAYS UNIDIMENSIONAIS

Nota: todo e qualquer Array alocado na memória possui um valor default para cada elemento do Array
de acordo com o tipo do elemento.
CONSTRUINDO ARRAYS MULTIDIMENSIONAIS

Um Array multidimensional consiste em um Array onde cada elemento possui outro Array armazenado.

Para identificar um elemento específico da tabela, devemos utilizar os dois subscritos, no qual o primeiro
representa uma linha do elemento e o segundo representa a coluna.

Podemos recuperar o tamanho de uma Array utilizando a variável length. Então, agora vamos ver um
exemplo que utiliza esta variável em um laço de repetição para inicializarmos nosso Array carros, por
exemplo, for.

PASSANDO ARRAYS PARA MÉTODOS

Quando passamos um argumento por valor, é realizada uma cópia do valor deste argumento e passado
essa cópia para o método chamador. Quando fazemos uma chamada por referência, na verdade estamos
passando para o método chamado, o endereço daquele objeto na memória, ou seja, estamos passando
uma referência desse objeto. Neste caso, o método chamador permite que o método chamado possa
acessar e modificar os dados do chamador se for necessário.

Obs.: Java não permite que você escolha entre passar cada argumento por valor ou referência.

Passando arrays para métodos

 Passagem por referência

 Tipos primitivos → passados por valor
 Objetos → passados por referência

Coleções: estruturas que permitem armazenar outros objetos sem se preocupar como essas estruturas
foram criadas.

VISÃO GERAL DAS COLEÇÕES

No começo do nosso estudo, vimos que Arrays são estruturas que consistem em itens de dados de um
mesmo tipo, seja este primitivo ou de referência a outros objetos, e que quando precisamos manipular
informações de um Array, temos que criar programas que atendam a essa necessidade.

As interfaces definem várias operações a serem realizadas genericamente sobre vários tipos de Coleções
minimizando a quantidade de código que um programador precisa escrever para criar e manipular
Coleções.

O conjunto de interfaces e classes de coleções contidos na API Java constitui o chamado Framework
Collections que tem por Raiz duas interfaces básicas:

Collection: utilizada para manipular coleções onde os elementos são objetos individuais.

Map: onde se mapeia uma chave única para um valor específico, por meio de uma estrutura de pares de
objetos, no qual um é utilizado como chave para acesso.
Veja algumas das principais interfaces fornecidas pelo pacote java.util.*.

■ Collection – interface raiz da hierarquia de Coleções a partir da qual se derivam as interfaces Set e List.

■ Set – Conjuntos – dá relevância à exclusividade, ou seja, contém elementos únicos.

■ List- Listas– interface onde o índice tem relevância. Esta interface possui diversas operações relacionadas
ao índice que outras interfaces não list não têm.

■ Map – Mapas – diz respeito a identificadores únicos, onde se mapeia uma única chave para um
determinado valor.

Queue – Filas – o mesmo que Fila. Geralmente utilizada para se manter uma lista de execuções a serem
processadas. A ela se atribui o conceito de FIFO (First in First out. Que em português significa primeiro a
entrar, primeiro a sair).

Interfaces fornecidas pelo pacote java.util.*

 Collection – interface raiz de onde derivam set e list

 Set – Conjunto, elementos não se repetem
 List – Elementos podem se repetir e a ordem importa
 Map – Mapeia chaves a valores
 Queue – Fila, "FIFO"

Nota: Para os Maps são associados chaves e valores onde estas não podem ser duplicadas, ou seja, cada
chave pode mapear somente um valor.

A INTERFACE LIST

 ArrayList, LinkedList e Vector.

 Um "array redimensionável".
 List<String> listaFrutas = new
 ArrayList<String>();

Também chamada de sequência, a interface List é uma Collection que permite elementos duplicados de
maneira ordenada, onde o programador tem controle preciso sobre onde o elemento está inserido na lista.
Assim como os Arrays, essa interface também á baseada em índice, onde o primeiro elemento da lista é
zero. Uma das vantagens que uma coleção list possui sobre as coleções não list é a grande variedade de
métodos relacionados com índices, como o get(int index), indexOf(Object o), add(int index, Object obj),
entre outros.

1) Se você precisa acessar elementos frequentemente pelo índice, use ArrayList.

2) Se precisa armazenar elementos e manter uma ordem, escolha algum dos tipos de List.

3) Se precisa de uma coleção de elementos únicos, que não podem ser duplicados,

escolha um tipo de Set (HashSet, LinkedSet ou TreeSet). (LinkedHashSet também mantém a ordem)

4)Se precisa de dados na forma chave → valor, use Map.

Diferenças entre ArrayList, Vector e LinkedList

ArrayList: um Array que é dimensionado dinamicamente.

Vector: Muito similar ao ArrayList Sincronizado (thread-safe). Aumento em 100%.

LinkedList: Lista duplamente ligada Ganho em performance ao adicionar e remover.

A INTERFACE SET

HashSet: LinkedHashSet e TreeSet.

TreeSet tree = new TreeSet();

A interface Set é uma Collection que não permite elementos duplicados, ou seja, só contém elementos
únicos. O que determinará que dois objetos sejam idênticos é o método equals (), situação onde só um
objeto poderá ficar no Set, ou seja, se você tentar adicionar um elemento que já existe nele, o método add
() retornará false e o elemento não será adicionado. As três classes que implementam Set são HashSet,
LinkedHashSet e TreeSet.Quando construímos um HashSet, ele remove qualquer duplicidade existente na
Collection. A interface SortedSet mantém seus elementos em ordem natural ou uma ordem especificada
por um Comparator. A classe TreeSet implementa SortedSet e cria uma estrutura de árvore garantindo que
os elementos estejam ordenados de forma ascendente, de acordo com a ordem natural.

Diferenças entre TreeSet, HashSet e LinkedHashSet

HashSet: mais rápido, não garante ordenação

TreeSet: árvore rubro-negra, implementa

SortedSet ao invés de Set. Elementos são ordenados.

LinkedHashSet: meio termo. Um pouco do poder de performance com um pouco do poder de ordenação.

A INTERFACE MAP

SortedMap, HashTable, HashMap, TreeMap e LinkedHashMap.

HashMap map = new HashMap();

O primeiro ponto que você precisa saber sobre a interface Map é que embora as classes SortedMap,
Hashtable, HashMap, TreeMap e LinkedHashMap sejam consideradas coleções, nenhuma destas estendem
de Collection como as classes que implementam as interfaces Set e List.

Chamamos este tipo de mapeamento de mapeamento um para um. Um objeto Map difere de um Set no
fato de que Map possui chave e valor, enquanto Set possui somente chave.

A interface que estende Map responsável por manter suas chaves ordenadas é a SortedMap.

Diferenças: HashMap, TreeMap, Hashtable e LinkedHashMap

HashMap: não é ordenado.

TreeMap: é ordenado pelas chaves.

HashMap: é quase igual ao Hashtable, exceto que é não sincronizado e permite nulls.

LinkedHashMap: é muito semelhante ao HashMap, acrescenta reconhecimento à ordem na qual os itens

são adicionados (ou acessados), portanto, a ordem de iteração é igual à ordem de inserção (ou ordem de
acesso, dependendo dos parâmetros de construção). HashMap. Ela mantém a ordem de inserção.

A INTERFACE QUEUE

Você, provavelmente, já deve ter ouvido falar do conceito FIFO (First in First out), ou em português:
primeiro a entrar, primeiro a sair. Pois bem, uma Queue, que significa fila em português, segue este
conceito (embora outras ordens sejam possíveis) e tem como objetivo manter uma lista de tarefas a serem
processadas de alguma maneira. Além de suportar todos os métodos padrões de uma Collection, ela
também possui métodos adicionais para adicionar, extrair e revisar os elementos da fila.A classe
responsável por implementar uma Queue é a PriorityQueue.

PriorityQueue.

Queue<Integer> queue = new

LinkedList<Integer>();
Unidade IV

O QUE É A BIBLIOTECA SWING?

O Swing é um toolkit que inclui um conjunto de componentes para fornecer uma construção de interface
gráfica para usuário (GUI) de programas Java. O Swing é a principal biblioteca para criação de aplicações
desktop com Java.

Além de componentes familiares, tais como botões, caixas de seleção e rótulos, há ainda uma seção
especialmente sobre gerenciamento de layout, os chamados “Layout Managers”, item muito importante
quanto se trata de programação de Interfaces Gráficas.

CONSTRUINDO A INTERFACE

JLabel: permite inserir textos e imagens, também representa um rótulo de texto. Entre os principais
métodos temos o setText (String) que altera o texto e getText () que retorna o texto atual.

JTextField: caixa de texto para que o usuário insira os dados no programa. – Lembrando que todos os dados
inseridos em um JTextField são tratados como String. Entre os principais métodos temos setText
(String) que altera o texto e getText () que retorna o texto atual.

JRadioButton: botão que permite apenas seleção de uma opção quando relacionado a um ButtonGroup.
representa um componente que permite seleciona uma entre diversas opções. O JRadioButton é
semelhante ao JCheckBox, inclusive com os mesmos construtores e métodos.

JComboBox: representa uma caixa de combinação, da qual o usuário pode selecionar uma opção. Entre
os principais métodos temos o addItem(Object) que adiciona um item à lista de
opções, setEditable(boolean) que permite ao usuário digitar uma opção, getSelectedIndex() que retorna
a posição do item atualmente selecionado, getSelectedItem() que retorna o texto do item atualmente
selecionado, setSelectedIndex(int) que seleciona o item da posição especificada
e setSelectedIndex(Object) que seleciona o objeto especificado na lista.

JButton: botão onde serão implementados os eventos, representa um botão destinado a executar uma
ação. Entre os principais métodos temos o setText(String) que altera o texto do botão e setIcon(Icon) que
altera o ícone do botão.

JTextArea: campo semelhante ao JTextField, normalmente usados para entrada de textos maiores. Como
críticas, sugestões etc. representa uma caixa onde o usuário pode informar várias linhas de texto. Entre os
principais métodos temos o setText(String) que altera o texto, getText() que retorna o texto
atual, getSelectedText() que retorna o texto selecionado pelo usuário e insert(String, int) que insere um
texto na posição especificada.

JCheckBox: caixas de múltiplas seleções, permite o usuário marcar várias opções ao mesmo tempo,
representa uma caixa de seleção e permite selecionar ou não uma opção. Entre os principais métodos
temos o setSelected(boolean) que altera o estado da caixa de seleção e o método isSelected() que
retorna true se a caixa estiver marcada e false se não estiver marcada.STRUINDO A INTERFACE

Frame: Representa a janela do programa com barra de título, ícone, botões de comando, etc. Entre os
principais métodos temos o pack() que compacta a janela para o tamanho dos componentes, setSize(int,
int) que define a largura e altura da janela, setLocation(int, int) que define a posição da janela na tela
(x,y), setBounds(int, int, int, int) que define posição e tamanho, setVisible(boolean) que exibe a janela
e setDefaultCloseOperation(int) que define o que ocorre quando o usuário tenta fechar a janela (as
opções são: DO_NOTHING_ON_CLOSE, HIDE_ON_CLOSE, DISPOSE_ON_CLOSE, EXIT_ON_CLOSE).

JPanel: Representa um tipo básico de container para inserção de componentes. Entre os principais
métodos temos add(Component, int) que adiciona o componente definindo sua posição
e setLayout(LayoutManagaer) que altera o tipo de layout.

JPasswordField representa um campo de texto protegido, subclasse de JTextField. O principal método é

o setEchoChar(char) que define o caractere que aparece ao digitar um texto.
JList representa uma lista de opções que permite a seleção de mais de um item simultaneamente. Entre
os principais métodos temos o setListData(Object[]) que preenche ou altera os itens de uma
lista, getSelectedValues() que retorna um array de objetos contendo itens selecionados na lista.

ESCREVENDO O CÓDIGO

Para iniciar a implementação do código, deve-se alterar o nome das variáveis de todos os componentes
que serão utilizados para que nosso código fique mais limpo e organizado.

Unidade V

JDBC – JAVA DATABASE CONNECTIVITY

JDBC (Java Database Connectivity). JDBC trata-se de uma API para acesso a banco de dados relacionais por
meio de comandos SQL em que a programação do sistema é a mesma para qualquer SGBD (Sistema
Gerenciador de Banco de Dados.

 Estabelecer uma conexão com um banco de dados ou com qualquer fonte de dados tabular.
 Executar instruções SQL.
 Processar os resultados obtidos.

DRIVERS JDBC

Para que seja possível estabelecer uma conexão com um banco de dados permitindo que uma aplicação
Java interaja com esse banco, o JDBC utiliza drivers específicos de acordo com cada SGDB.

Atualmente, existem quatro tipos de drivers que são classificados da maneira a seguir.

 Ponte JDBC-ODBC – é o mais simples, porém restrito a plataforma Windows. Geralmente

utilizado quando não existe para o SGDB um driver nativo (tipo 4), sendo necessário um ODBC
para se conectar ao banco de dados.
 Driver API-Nativo – converte as chamadas JDBC para as chamadas da API cliente do SGDB.
 Driver de Protocolo de Rede – trata-se do tipo mais flexível, pois possibilita criar aplicações Java
independe de banco de dados, ou seja, a mesma aplicação pode se conectar a vários SGDBs
diferentes.
 Driver Nativo – é o mais recomendado, pois as chamadas JDBC são traduzidas no protocolo do
SGDB.

CONECTANDO A UM SGDB COM CONNECTION

A primeira interface que vamos estudar é a java.sql.Connection. Um objeto Connection representa uma
sessão de conexão com um determinado banco de dados na qual as instruções SQL são executadas e os
resultados obtidos dentro do contexto desta sessão. Para uma aplicação, ela permite que seja criada uma
ou mais conexões com um mesmo banco de dados ou várias conexões com diferentes bancos de dados

■ Qual o fabricante e a versão do banco de dados.

■ O nome e versão do driver JDBC utilizado.

■ O nome do usuário utilizado na conexão.

■ A URL de conexão.

■ As estruturas das tabelas do banco de dados.

■ Qual a gramática SQL suportada.

■ Procedimentos.
A maneira mais comum de estabelecer uma conexão com um banco de dados é por meio de uma
chamada para o método DriverManager.getConnection(). Esse método recebe como argumento três
Strings contendo a URL JDBC de conexão com o banco de dados, o usuário e a senha, respectivamente.
Veja, a seguir, um pequeno trecho de código que representa uma conexão.

Quando utilizamos o DriverManager em uma aplicação para criarmos um objeto Connection, devemos
fornecer para o método getConnection uma URL JDBC que tem a finalidade de fornecer uma maneira de
identificar com qual banco de dados determinados driver irá estabelecer uma conexão. Veja, a seguir, a
sintaxe de uma URL JDBC, perceba que ela é separada em três partes utilizando dois pontos.

Jdbc: indica que a URL em questão é uma URL JDBC.

<subprotocol>: representa o nome do driver de conexão utilizado para um determinado SGDB.

<subname>: representa a fonte de dados a qual será realizada a conexão.

EXECUTANDO INSTRUÇÕES SQL COM STATEMENT

Um objeto Statement tem por objetivo executar uma instrução SQL simples sem parâmetros, retornando
os resultados que ela produz por meio de um ResultSet. um ResultSet contém o resultado da execução de
uma instrução SQL). Por padrão, cada execução de Statement retorna apenas um ResultSet contendo
todos os resultados daquela instrução SQL realizada. Quando criamos uma conexão com um determinado
banco de dados utilizando um objeto Connection, podemos utilizar esta conexão para enviar instruções
SQL neste banco por meio desse objeto. Para isso, precisamos criar um objeto Statement a partir do
método createStatement () de Connection.
Para executar instruções SQL com o objeto Statement obtido, você pode utilizar alguns dos métodos
execute fornecidos por ele, passando como argumento uma String que contenha o SQL que será
executado.

EXECUTANDO INSTRUÇÕES SQL COM PREPAREDSTATEMENT

O objetivo de um objeto PreparedStatement é executar uma instrução SQL pré-compiladas, ou seja, um

PreparedStatement envia a instrução SQL para o SGDB de modo a deixá-la preparada para receber
parâmetros esperados por esta instrução. A instrução SQL contida nesse objeto pode ter um ou mais
parâmetros IN (entrada) em que o valor deste parâmetro não é definido quando o SQL é criado. Ao invés
disso, é definido um ponto de interrogação “?” representando um espaço reservado para cada
parâmetro.

Antes de uma instrução SQL ser executada com PreparedStatement você deve definir um valor para cada
ponto de interrogação. Isso pode ser feito por meio de chamadas do método setter (setInt, setString, ...)
apropriado para cada tipo de parâmetro esperado pelo ponto de integerrogação.
RECUPERANDO E UTILIZANDO DADOS DE UM RESULTSET

Um ResultSet consiste em uma tabela que representa um conjunto de dados obtidos de um banco de
dados por meio de uma instrução SQL executada por Statement ou PreparedStatement. Um objeto de
ResultSet mantém um cursor para a linha corrente dos dados selecionados. Inicialmente, este cursor fica
posicionado antes da primeira linha e para mover este cursor para a próxima linha você pode utilizar o
método next retornando false quando não existir mais linhas para serem percorridas no objeto.

Para recuperar os valores da coluna da linha atual, você pode utilizar os métodos getter fornecidos pelo
objeto de ResultSet como getBoolean, getLong etc.

O JPA – JAVA PERSISTENCE API

O JPA ou Java Persistence API é um framework de persistência no qual permite que um desenvolvedor
Java realize mapeamentos objetos/relacionais para o gerenciamento de dados entre uma aplicação Java e
um banco de dados relacional. JPA permite que o desenvolvedor trabalhe diretamente com objetos e não
com a execução de instruções SQL. Estamos falando de uma abstração de alto nível sobre JDBC que
basicamente consiste em três áreas.

■ A API de persistência.

■ A linguagem de consulta.

■ Mapeamento objeto/relacional.

ENTIDADES

O primeiro conceito que vamos estudar é o de entidades. Uma Entity (ou em português, entidade) em JPA
se refere a uma classe de entidade no qual representa uma tabela em um banco de dados e cada instância
dessa classe é um objeto que se refere a um registro armazenado nesta tabela.Entity Class. é uma classe
também conhecida por Classe de Entidade em que o estado de persistência desta classe se dá pelos
atributos com anotações que representam um mapeamento objeto/relacional para uma tabela de um
banco de dados.

Para que uma classe possa ser considerada uma Entity Class, ela deve seguir os seguintes requisitos:

■ A classe deve ser anotada como @Entity (javax. persistence. Entity).

■ A classe deve possuir uma chave primária podendo ser um campo único ou uma combinação de
campos.

■ A classe deve ter o mesmo nome da tabela quando não anotada como @Table (javax. persistence.
Table). Essa anotação define o nome da tabela que a Entity Class. representa.

■ A classe deve possuir um construtor público ou protegido sem argumentos havendo a possibilidade de
declarar outros construtores.

■ Tanto a classe como os métodos ou atributos de persistência não podem ser declarados com o
modificador final.

■ Uma classe de entidade pode estender outras classes de entidades e classes que não são entidades
podem estender classes de entidades.

■ Uma classe de entidade deve implementar a interface java.io. Serializable.

■ As variáveis de instâncias devem ser declaradas com os modificadores de acesso private ou protected
permitindo ser acessados diretamente pelos métodos da classe.

Perceba que na linha 10 foi declarada a anotação @Entity de javax.persistence.Entity. Quando declaramos
esta anotação, a classe tornou-se uma Entity Class ou Classe de Entidade e, a partir desta linha passou a
representar uma tabela em um banco de dados Com base nestas características podemos dizer que esta
classe se trata de um POJO.Um POJO (Plain Old Java Object) – que em português significa Velho e Simples
Objeto Java – é uma classe que realiza referência a objetos que não dependem de herança ou quaisquer
outras classes externas são objetos que seguem uma estrutura simplificada onde os construtores são
default sem argumentos e os métodos seguem o padrão getter e setter para acessar os atributos privados
da classe.

PRINCIPAIS ANOTAÇÕES JPA

A seguir, você vai conhecer as principais anotações JPA e suas funcionalidades. Essas anotações estão no
pacote javax.persistence.

@Entity – define que a classe em questão é uma entidade a ser persistida em uma tabela no banco de
dados. Caso esta tabela não exista o JPA cria ela para você.

@Id – define qual atributo da classe representa uma chave primária no banco de dados.

@GeneratedValue – define estratégias para a geração automática de uma chave primária simples.

@Table – quando anotada na classe, define o nome da tabela do banco de dados que a entidade
representa. Se você não anotar a classe com @Table(name=”nome_tabela”) o JPA irá definir o nome da
tabela com o nome da classe.

@Transient – define quais atributos da classe não serão mapeados para o banco de dados.

@Temporal – define qual atributo será mapeado para uma coluna do tipo temporal que pode ser date
(data), Time (tempo) ou Timestamp (carimbo de tempo).

@Enumerated – mapeia um atributo para um campo enumerado de uma tabela onde a informação é
persistida como uma String.

@Column – define quais atributos da classe representam colunas de uma tabela.

@Embeddable – uma entidade com esta anotação pode ser embutida em outra entidade.

@Embedded – embuti uma entidade dentro de outra.

@JoinColumn – indica que o atributo é um relacionamento para uma outra entidade (outra tabela).

@ManyToMany – define uma associação com multiplicidade de muitos para muitos.

@ManyToOne – define uma associação com valor único para outra entidade com multiplicidade de
muitos para um.

@MappedSuperclass – os mapeamentos realizados em uma entidade com esta anotação podem ser
aplicados às entidades que herdam dela.
RELACIONAMENTOS JPA

Para ser mais preciso as anotações que definem relações ou associações entre as entidades são quatro de
acordo com a sua cardinalidade. Estas associações mantêm uma forma de relação entre os objetos
associados permitindo que eles se comuniquem mantendo uma relação estática

@OneToOne (Um para Um) – define uma associação de um único valor para outra entidade que possui
multiplicidade de um para um.

@OneToMany (Um para Muitos) – define uma associação polivalente (muitos valores) com
multiplicidade de um para muitos.

@ManyToOne (Muitos para Um) – define uma associação com valor único para outra entidade com
multiplicidade de muitos para um.
@ManyToMany (Muitos para Muitos) – define uma associação com multiplicidade de muitos para
muitos.

Unidades de persistência (persistence unit)

Uma unidade de persistência é um agrupamento lógico na qual são definidas as classes de persistência
como classes de entidade, classes incorporáveis e superclasses mapeadas, assim como as configurações
pertinentes de cada classe. Em geral, as unidades de persistência são definidas em um arquivo .XML de
persistência chamado de persistence.xml, no qual podem ser definidas uma ou mais unidades de
persistência. Este arquivo deve ser salvo em uma pasta chamada META-INF. Este diretório é chamado de
raiz da unidade de persistência.

Veja abaixo um exemplo de configuração do persistence.xml.

GESTOR DE ENTIDADE (ENTITY MANAGER)

Pertencente ao pacote javax. Persistence, a instância de um EntityManager é responsável por praticamente

todas as operações de persistência de objetos. Esta instância está associada a um contexto de persistência
que se refere a um conjunto de instâncias de entidades administradas pelo EntityManager. A interface
EntityManager define operações que permitem interagir com o contexto de persistência como, incluir,
alterar, excluir e consultar instâncias de entidades dentro deste contexto.
No exemplo anterior criamos um objeto do tipo Pessoa. Se você recordar nos exemplos anteriores, você
vai lembrar que criamos uma classe Pessoa e a anotamos com a anotação @Entity. Pois bem, utilizamos
uma instância dessa entidade e a partir de uma instância de um EntityManager nós persistimos o objeto no
banco de dados. Mas como criamos uma instância de EntityManager? Para isso, antes precisamos criar um
EntityManagerFactory relacionado a uma Persistence Unit. Perceba na linha 14 do nosso exemplo que
criamos uma variável factory do tipo EntityManagerFactory e a ela atribuímos uma referência de
EntityManagerFactory obtida por meio da expressão Pesistence.createEntityManagerFactory("UEM-
EADPU"). Note que passamos como referência o nome da unidade de persistência criada na sessão
Unidades de Persistência (Persistence Unit) mediante uma String com o texto UEM-EADPU. Bem, caro(a)
aluno(a), agora nós já temos um fábrica de EntityManager associado à unidade de persistência UEM-
EADPU, portanto já podemos obter um EntityManager como mostra a linha 16 do nosso exemplo. Perceba
que utilizamos factory para criar um EntityManager por meio da expressão factory. createEntityManager ()
e atribuímos o objeto criado à variável manager do tipo EntityManager. A persistência do objeto pessoa do
tipo Pessoa ocorre na linha 25 mediantes a expressão manager. persiste(pessoa).