Banco de Dados em Aplicativos Mobile Java

BANCO DE DADOS EM
APLICATIVOS MOBILE JAVA

Banco de Dados em Aplicativos Mobile Java
SUMÁRIO
BANCO DE DADOS EM APLICATIVOS MOBILE JAVA - SA1.................................................. 4
PARA COMEÇAR................................................................................................................................... 5
SITUAÇÃO-PROBLEMA...................................................................................................................... 6
DESAFIO 1............................................................................................................................................... 7
INTRODUÇÃO....................................................................................................................................... 8
BANCO DE DADOS.............................................................................................................................. 8
MODELOS DE BANCO DE DADOS................................................................................................. 8
MODELO RELACIONAL....................................................................................................................11
MER.........................................................................................................................................................13
CHAVE....................................................................................................................................................21
DER – DIAGRAMA DE ENTIDADE E RELACIONAMENTO....................................................24
MODELAGEM DE DADOS...............................................................................................................25
TIPOS DE DADOS...............................................................................................................................26
SISTEMA DE GERENCIAMENTO DE BANCO DE DADOS (SGBD)......................................31
BANCO DE DADOS EM APLICATIVOS MOBILE.......................................................................36
REGRAS DE SEGURANÇA................................................................................................................39
INSTALAÇÃO E CONFIGURAÇÃO DE BANCO DE DADOS..................................................39
NESTE DESAFIO..................................................................................................................................41
DESAFIO 2.............................................................................................................................................42
INTRODUÇÃO.....................................................................................................................................43
LINGUAGEM E DEFINIÇÃO DE MANIPULAÇÃO DE DADOS..............................................44
TRATAMENTO DE DADOS...............................................................................................................51
SEGURANÇA DA INFORMAÇÃO..................................................................................................63
NESTE DESAFIO..................................................................................................................................73
PARA CONCLUIR.................................................................................................................................74
REFERÊNCIAS......................................................................................................................................75
CRÉDITOS..............................................................................................................................................76
MATERIAL COMPLEMENTAR.........................................................................................................77
Banco de Dados em Aplicativos Mobile Java | SENAI 2

Banco de Dados em Aplicativos Mobile Java
SUMÁRIO
BANCO DE DADOS EM APLICATIVOS MOBILE JAVA - SA2............................................. 154
PARA COMEÇAR.............................................................................................................................. 155
SITUAÇÃO-PROBLEMA................................................................................................................. 156
DESAFIO 1.......................................................................................................................................... 157
LINGUAGEM DE PROGRAMAÇÃO JAVA................................................................................. 158
TÉCNICAS DE PROGRAMAÇÃO................................................................................................. 160
FUNÇÕES E MÉTODOS................................................................................................................. 164
CLASSES............................................................................................................................................. 168
BIBLIOTECAS E APIS...................................................................................................................... 169
FERRAMENTAS................................................................................................................................. 180
NA PRÁTICA...................................................................................................................................... 180
NESTE DESAFIO............................................................................................................................... 181
DESAFIO 2.......................................................................................................................................... 182
INTRODUÇÃO.................................................................................................................................. 183
CRIAÇÃO DE CLASSES.................................................................................................................. 183
HERANÇA........................................................................................................................................... 188
INTERFACE......................................................................................................................................... 193
COMPOSIÇÃO.................................................................................................................................. 196
POLIMORFISMO.............................................................................................................................. 198
EXCEÇÕES.......................................................................................................................................... 200
CONEXÃO COM BANCO DE DADOS....................................................................................... 204
NESTE DESAFIO............................................................................................................................... 206
PARA CONCLUIR.............................................................................................................................. 207
REFERÊNCIAS................................................................................................................................... 208
CRÉDITOS........................................................................................................................................... 209
MATERIAL COMPLEMENTAR...................................................................................................... 210

BANCO DE DADOS EM
APLICATIVOS MOBILE
JAVA - SA1
Banco de Dados em Aplicativos Mobile Java - SA1
PARA COMEÇAR
Este material aborda conceitos relacionados às definições e aos tipos de banco de
dados, assim como apresenta orientações de como instalá-los, configurá-los e aplicar
a linguagem de programação em Java, além de diretivas de segurança da informação.
Esperamos que você desenvolva, no decorrer de seus estudos, as seguintes capacidades:
• Reconhecer as características de interoperabilidade do banco de dados

à aplicação.
• Reconhecer as especificações técnicas, bem como as características de
robustez do banco de dados integrado à aplicação.
• Realizar procedimentos de instalação e configuração de banco de dados.
• Aplicar técnicas de modelagem e de procedimentos de normalização de
dados, tendo em vista sua formatação.
• Aplicar linguagem de definição e manipulação de dados em aplicações mobile.
• Aplicar diretivas de segurança da informação.
• Realizar o tratamento de dados em conformidade com a legislação.
Para desenvolver tais capacidades, você deverá estudar os seguintes temas:
• Definição e tipos de banco de dados.

• Instalação e configuração.
• Sistema de Gerenciamento de Banco de Dados (SGBD).
• Tipos de dados.
• Linguagem de definição e manipulação de dados.
• Operações.
• Segurança da informação em banco de dados.
O estudo de tais temas também será necessário para que você resolva a situação-
problema a seguir.

SITUAÇÃO-PROBLEMA
Você foi contratado pela Datamobile, empresa com foco em criação, manutenção,
gerenciamento e segurança de banco de dados para aplicativos mobile.
A empresa Coma bem, especializada no comércio eletrônico de produtos alimentícios,

deseja lançar um novo app de compras, por isso contratou a Datamobile. Você
ficou responsável pelo planejamento e pela implementação do banco de dados da
seguinte lista de produtos:
Carne R$ 30,00 2 kilos
Óleo R$ 10,00 1 unidade
Leite R$ 5,00 1,5 litros
Alface R$ 3,00 1 unidade
Para tanto, você deverá realizar os seguintes desafios:
Desafio 1
Modelar o projeto de banco de dados, aplicando procedimentos de normalização e

padronização;
Desafio 2
Criar o banco de dados, aplicando regras de segurança e níveis hierárquicos.

DESAFIO 1
Nesta etapa, você deverá resolver o desafio 1:
• Modelar o projeto de banco de dados, aplicando procedimentos de

normalização e padronização.
Para isso, você estudará os seguintes conteúdos:
• Definição e tipos de banco de dados.

• Instalação e configuração de banco de dados.
• Sistema de Gerenciamento de Banco de Dados
(SGBD).
• Modelo relacional.
• Tipos de dados.

INTRODUÇÃO
Acesse o material e confira o vídeo de Introdução sobre Banco de Dados em
Aplicativos Mobile.
BANCO DE DADOS
Banco de dados é uma coleção organizada
de dados que são armazenados para serem
consultados e manipulados. Esses dados
estão relacionados ao mundo real e podem
ser coletados para uma aplicação específi-
ca ou para agregar mais informação a outro
conjunto de dados já existente em outra
aplicação, o que permite o aumento do es-
copo das consultas.
Um sistema online de vendas, por exemplo, é constituído por produtos, preços,

quantidades etc. Cada item ou objeto especificado pode ser criado em uma base de
dados, permitindo a extração e consulta de informações relacionadas a ele.
MODELOS DE BANCO DE DADOS

Um modelo de banco de dados mostra a estrutura lógica de um banco de dados,
incluindo as relações e restrições que determinam como os dados podem ser
armazenados e acessados. Há vários tipos de modelos de dados. Alguns dos mais
comuns são estruturados e não estruturados.

ESTRUTURADOS
Cada campo de dados apresenta estrutura rígida e constante de representação

e organização dos dados previamente planejada, antes da própria existência do
dado que será carregado naquela estrutura. Desse modo, não se permite que tipos
de dados diferentes das estruturas preestabelecidas sejam carregados. Um dos
principais formatos de dados estruturados são os das tabelas, que organizam os
valores em linhas e colunas, como planilhas eletrônicas.
Os bancos de dados estruturados podem ser relacional ou hierárquico:
RELACIONAL
O Modelo Relacional ou Modelo Entidade-Relacionamento (MER) é o modelo con-

ceitual mais popular usado para projetar um banco de dados. Ele armazena os dados e
seus relacionamentos em tabelas. As relações são a composição de registros e campos.
Dados mapeados para tabelas com seus respectivos relacionamentos
IDAlbum Nome Ano IdBanda IdEstilo

1 Empty Words 2021 3 4
2 Simplicity 2021 5 2
Rise from
3 2021 6 1
the Ashe
4 Stay like this 2021 4 1
5 Walk to you 2021 1 3
6 Above All 2021 2 1

Fonte: próprio autor
HIERÁRQUICO
Estrutura os dados na forma de árvore invertida. Assim, uma única tabela atua como
raiz da árvore de tabelas e une-se abaixo às tabelas intermediárias, que atuam como

ramos da árvore que se interconectam até chegar às tabelas na última camada,

conhecidas como raízes.
Neste modelo, as relações são representadas pelos termos pai/filho, um pai pode
ter associação com mais de um filho e um filho somente com um pai.
NÃO ESTRUTURADOS
Conjunto de dados sem uma organização ou hierarquia interna específica e abrange

a maior parte dos dados web, como arquivos de mídia, e-mail, dados de dispositivos
móveis e redes sociais, entre outros.
Os bancos de dados não estruturados são não relacionais.
NÃO RELACIONAIS
Os bancos de dados não relacionais, conhecidos também como NoSQL (Not Only
SQL), surgiram como alternativa para situações nas quais os bancos relacionais não
atendem como repositórios para dados mistos (imagens, mapas e tabelas), os quais
não podem ser tabulados em linhas e colunas, mas sim como documentos ou regis-
tros de chave e valor.

Estrutura de documentos do Mongo
Neste conteúdo, trabalharemos com o modelo de banco de dados relacional.
Você sabia?
A Teoria de Banco de Dados Relacional foi apresentada em junho de
1970 como um trabalho intitulado: “Um modelo relacional de dados
?
para grandes bancos de dados compartilhados”, apresentado pelo Dr.
Edgar F. Codd, um cientista pesquisador da IBM. A teoria foi baseada em
modelo matemático, compreendendo a teoria dos conjuntos e lógica
de predicados de primeira ordem. A parte no nome “Relacional” deriva
do termo relação, que faz parte da teoria de conjuntos na matemática.
MODELO RELACIONAL
O Modelo Relacional é o modelo conceitual mais popular usado para projetar um
banco de dados. Ele projeta o mundo real como:
• um conjunto de objetos básicos — as entidades;

• suas características - os atributos; e
• as associações entre esses objetos — os relacionamentos.

As entidades, os atributos e relacionamentos são as construções básicas de um

modelo entidade-relacionamento. Cada registro que compõe a tabela é identificado
por uma chave exclusiva, conforme mostra a tabela a seguir. A ordenação dos
registros pode ser definida no momento da consulta, ao se determinar quais campos
participarão do critério de ordenação.
Siga em frente e conheça mais sobre cada um desses conceitos.
Importante!
Os bancos de dados relacionais são transacionais1, o que garante que o
estado de todo o sistema seja consistente a qualquer momento. Eles
!
oferecem a exportação e importação de dados mesmo enquanto o
banco de dados está em execução, facilitando a restauração em caso
de falha. Alguns bancos de dados relacionais oferecem o recurso para
o espelhamento dos dados de forma contínua, o que minimiza a perda
de dados na restauração a praticamente zero. Muitas vezes, inclusive,
prometem a possibilidade de criação de réplicas de leitura e reduzem a
concorrência no acesso aos dados. Essas réplicas de leitura podem ser
promovidas a instâncias de leitura/gravação para recuperação de desastres.
1 Realização de transações de curta duração e pequeno volume de dados manipulado.

A transação ocorre no momento em que foi requerida.

MER
O Modelo Entidade Relacionamento (MER) é utilizado para descrever o domínio de
um sistema e foi publicado em 1976 por Peter Chen. Ele descreve:
ENTIDADES
A entidade é a reprodução abstrata de um objeto do mundo real a ser representado

no modelo de dados, por exemplo: álbuns, músicas e bandas. As entidades podem
ser classificadas nos tipos fortes, fracas e associativas.
FORTES E FRACAS
A entidade forte não depende de outra entidade para existir. No exemplo a seguir,
que apresenta o relacionamento entre Banda Musical e Música, a entidade Banda
é a entidade forte. A entidade Música depende da entidade Banda para existir,
logo, é uma entidade fraca.
A Entidade Forte — Banda e a Entidade Fraca — Música
A entidade fraca depende de outra entidade para existir. No relacionamento entre

a Banda Musical e a Música, a entidade Música depende da existência da Banda
Musical para ser cadastrada. Isso é reforçado pela necessidade de se informar a
chave estrangeira do registro da Banda Musical no cadastro da Música, conforme
demonstrado mais adiante.

ASSOCIATIVA
As entidades associativas são criadas para simplificar várias relações. O exemplo

mostra a necessidade de criar a entidade associativa Musicas_do_Album, contendo
as chaves estrangeiras das duas relações entre as entidades Músicas e Álbum.
ATRIBUTOS
O atributo é uma característica da entidade que tem valor para o negócio.
Há vários tipos de atributos. Conheça alguns deles.
SIMPLES
É o elemento de dado que con-

tém informação que descreve a
entidade e não pode ser dividi-
do em subpartes. A maioria dos
atributos é considerada simples
e não possui qualquer caracterís-
tica especial. Em uma entidade
como álbum, por exemplo, pode-
remos considerar como atributo
simples: nome e ano. Fonte: próprio autor

COMPOSTO
O atributo composto é formado por um ou mais subatributos, podendo ser dividido

em atributos menores. Um exemplo clássico é o endereço, que pode ser classificado
em logradouro, número, bairro, complemento, CEP, cidade e estado.
Formas de mapear o atributo composto: a esquerda como atributo composto e a direita como entidade “Endereço”.
MULTIVALORADO
O atributo multivalorado representa o elemento de dado que, em uma única entidade,

pode coexistir em diversos valores para esse atributo. Assim, seu nome é sempre
representado no plural. Este tipo de atributo é aceito conceitualmente, mas ele pode
ser um problema no banco de dados. Há duas possibilidades para seu tratamento:
• A primeira é mantê-lo como multivalorado e permitir que mais de um

dado seja inserido no mesmo campo, como, por exemplo: os membros de
uma banda musical.
• A segunda alternativa é aplicar o processo de normalização de dados e
transformá-lo em uma entidade à parte ou em uma tabela no banco de dados e
relacioná-la com a tabela principal.
No exemplo a seguir, foi aplicada a normalização e criada uma tabela para os

Membros com a chave estrangeira apontando para os registros da Tabela Banda.
O conceito um para muitos (1:N) será esclarecido mais adiante.

O atributo multivalorado mapeado como entidade relacionada 1:N
DETERMINANTE
O atributo determinante identifica de forma única uma entidade, ou seja, não pode
haver dados repetidos.
Devemos considerar que toda tabela no banco de dados precisa ter um atributo
determinante, que também chamamos de chave primária. Assim, se a entidade
não oferecer uma sugestão de
atributo determinante, criamos
um atributo ID que terá seu valor
iniciando em 1 e sequencialmente
será incrementado para cada
novo registro que for adicionado.
Esse é um princípio comum da
análise e modelagem de dados. Fonte: próprio autor
RELACIONAMENTOS
Os relacionamentos são identificados com base nas informações de um contexto de

informação que foi mapeado para tabelas. Depois de identificar os relacionamentos,
você estabelece uma conexão lógica entre as tabelas em cada relacionamento com
uma chave primária ou com uma tabela de ligação.
O que você realmente aplica depende do tipo de relacionamento que se

está estabelece entre as tabelas. Em seguida, determina-se o tipo e o grau de

participação das tabelas em cada relação. Em alguns casos, essas características de

participação serão óbvias, devido à natureza dos dados armazenados nas tabelas.
Em outros casos, você baseará as características de participação em regras de
negócios específicas.
TIPOS DE RELACIONAMENTO
Os tipos de relacionamentos são definidos pela sua cardinalidade. A cardinalidade

se refere a quantas tabelas participam do relacionamento. Assim, os tipos de
relacionamentos podem ser:
• um para um (1:1);

• um para muitos (1:N) ou muitos para um (N:1);
• muitos para muitos (N:N).
UM PARA UM – 1:1
RELAÇÃO UM PARA UM ENTRE O MEMBRO DE UMA BANDA E SEU
REGISTRO DE MÚSICO.
A relação um para um ocorre quando um registro de uma tabela relaciona-se a um

registro único e exclusivo de outra tabela.
A imagem apresenta um modelo lógico de dados. Nele, um músico membro de uma

banda musical possui somente um registro de músico e um registro de músico está
vinculado a somente um músico.

A TABELA COM A INFORMAÇÃO MAIS IMPORTANTE É A DE MEMBROS.

ASSIM, A CHAVE 1:1 É ADICIONADA NESTA TABELA.
Uma das tabelas envolvidas no relacionamento carrega o atributo identificador

que deve ser definido com chave estrangeira na outra tabela, fazendo referência
à chave primária da primeira tabela. O critério para escolher qual tabela receberá a
chave estrangeira depende do negócio que está sendo modelado, sendo necessário
analisar caso a caso. Porém, em geral, escolhe-se a tabela na qual faz mais sentido
colocar o atributo, isto é, a tabela com a informação mais importante para o negócio.
UM PARA MUITOS – 1:N OU N:1
A relação um para muitos ocorre quando um registro de uma tabela está relacionado
com um ou mais registros de outra tabela. A seguir, as imagens das tabelas ilustram
exemplos desse tipo de relação.
RELAÇÃO UM PARA MUITOS ENTRE A BANDA MUSICAL E SEUS MEMBROS.
Uma banda musical pode ter um ou mais membros. Isso define uma relação de um
para muitos, como mostra o exemplo desta tabela.

A TABELA COM A CARDINALIDADE MUITOS (N) É A QUE RECEBE A

CHAVE ESTRANGEIRA, E RELACIONA-SE À CHAVE PRIMÁRIA DA
TABELA BANDA.
A entidade, cuja relação é do tipo N, carrega o identificador da tabela cuja

cardinalidade é 1 e seus atributos.
RELAÇÃO UM PARA MUITOS EM QUE A TABELA MÚSICA É A ENTIDADE

FRACA E RECEBE A CHAVE ESTRANGEIRA DA TABELA BANDA PARA
COMPOR A SUA CHAVE PRIMÁRIA.
A tabela cuja cardinalidade é N recebe o atributo identificador da tabela com

cardinalidade 1, que será mapeado como uma chave estrangeira na tabela com
cardinalidade N.
Caso a tabela com cardinalidade N seja uma entidade fraca, então, o atributo
identificador da tabela com cardinalidade 1 deve ser mapeado de forma a compor a
chave primária da tabela criada para a entidade com cardinalidade N, pois mantém
a dependência funcional em relação à entidade com cardinalidade 1.

A CHAVE PRIMÁRIA É COMPOSTA DA CHAVE CANDIDATA E DA

CHAVE ESTRANGEIRA, POIS A TABELA MÚSICA É CONSIDERADA
ENTIDADE FRACA.
No mapeamento entre a banda e suas músicas, a música não existe sem uma banda,
assim, a música é considerada entidade fraca e, nesse caso, a chave estrangeira na
tabela Banda deve fazer composição com a chave candidata da tabela Música, para
formar a chave primária na tabela Música. A chave candidata é a coluna na tabela
que contém a informação que pode identificar o registro. Na situação apresentada,
a coluna idMusica é a chave candidata.
MUITOS PARA MUITOS – N:N

A relação muitos para muitos ocorre quando muitas instâncias de uma entidade
estão relacionadas com muitas instâncias de outra entidade.
NA RELAÇÃO MUITOS PARA MUITOS ENTRE ÁLBUM E MÚSICAS,

UTILIZANDO UMA TABELA ASSOCIATIVA
Uma música pode fazer parte de vários álbuns musicais de uma banda, também um
álbum musical tem uma ou mais músicas como parte de seu repertório. O mapeamento
dessa estrutura de dados representa uma relação de muitos para muitos.

RELAÇÃO MUITOS PARA MUITOS ENTRE AS TABELAS MÚSICA E

ÁLBUM COM A TABELA ASSOCIATIVA MUSICAS_DO_ALBUM
Deve ser criada uma tabela que recebe os atributos identificadores das tabelas que
participam do relacionamento. A partir daí, a chave primária é gerada e composta
pelas colunas derivadas dos atributos identificadores. Além disso, a tabela recebe
todos os atributos do relacionamento, se existirem. Este é o único caso em que um
relacionamento se torna uma tabela. Em todos os demais casos, são criadas chaves
estrangeiras nas tabelas, a fim de estabelecer os relacionamentos.
CHAVE
O conceito de chave em banco de dados é importante para implementar restrições
e garantir a integridade referencial dos dados. A chave é um atributo ou grupo
de atributos cujos valores podem ser usados para identificar exclusivamente uma
entidade individual em um conjunto de entidades.
Para entender melhor, vamos conhecer alguns tipos de chave: primária e estrangeira.

CHAVE PRIMÁRIA
Uma chave primária é uma coluna ou um conjunto de colunas em uma tabela,

cujos valores identificam exclusivamente uma linha na tabela. Um banco de dados
relacional é projetado para impor a exclusividade das chaves primárias, permitindo
apenas uma linha com um determinado valor de chave primária em uma tabela.
A chave primária está diretamente relacionada à consulta. Quando se realiza a

busca por um registro, utiliza-se frequentemente o identificador da tabela para ter
exclusivamente um registro como resultado da consulta.
CHAVE ESTRANGEIRA
Uma chave estrangeira é uma coluna ou um conjunto de colunas em uma tabela,
cujos valores correspondem aos valores da chave primária em outra tabela. Para
adicionar uma linha com um determinado valor de chave estrangeira, deve haver
uma linha na tabela relacionada com o mesmo valor de chave primária.

A tabela Álbum tem sua chave estrangeira apontando para o registro

correspondente à chave primária na tabela Estilo.
No exemplo, a tabela Álbum apresenta o relacionamento estabelecido com a tabela

Estilo através de sua chave estrangeira idEstilo. Uma solicitação de remoção de
qualquer registro da tabela Estilo resultará em falha, pois o banco de dados verifica
a existência de referências entre a sua chave primária idEstilo e a tabela Álbum. Essa
falha garante a integridade referencial, ou seja, não deixa que exista uma referência
na tabela Álbum sem que exista um registro com essa mesma chave primária na
tabela Estilo.
Dica!
As chaves primárias podem ser geradas automaticamente por me-
canismos nativos encontrados em alguns gerenciadores de banco
de dados ou pela utilização de sequenciamento das chaves imple-
mentado com a utilização de tabelas dedicadas. Nesse caso, sem-
pre que houver a criação de novos registros, a tabela dedicada é
consultada para a obtenção da nova chave primária a ser utilizada.
A utilização de sequências ou geradores de chave é opcional e de-
finida na criação da tabela.
INTEGRIDADE DE CHAVES
O modelo relacional possui algumas regras de integridade, confira o podcast a

seguir e conheça essas regras.

Acesse o material para ouvir o podcast e faça o download do PDF com a transcrição
do áudio.
Arquivo: Pod01_Integridade_de_Chaves.pdf
DER – DIAGRAMA DE ENTIDADE

E RELACIONAMENTO
Os diagramas de entidade e relacionamento são usados para modelar e projetar
bancos de dados relacionais, em um modelo de dados lógicos e físicos. Enquanto
o MER é o modelo conceitual, o DER é a sua representação gráfica, estruturado por
meio de símbolos geométricos interconectados. Na literatura, você pode encontrar
outros modelos diferentes para representar o DER e, mesmo essa notação que será
apresentada, conhecida como Notação Peter Chen, pode ter variações. Na engenharia
de software, o DER geralmente é uma etapa inicial na determinação dos requisitos
para um projeto de sistemas de informação. Também é usado posteriormente para
modelar um banco de dados.
A imagem a seguir mostra a elaboração do Diagrama de Entidade e Relacionamento.

MODELAGEM DE DADOS
A concepção do banco de dados e seu processo de implementação começam com
a coleta de requisitos e especificações do projeto. A próxima etapa é construir um
modelo abstrato ou conceitual de um banco de dados com base nesses requisitos.
Essa fase é conhecida como modelagem de dados. A modelagem de dados é uma
fase importante no projeto de um banco de dados de sucesso. Ela se concentra
principalmente em quais dados são necessários e como eles devem ser organizados,
em vez de quais operações devem ser realizadas nos dados.
Conforme analisamos, o Modelo Entidade-Relacionamento (MER) armazena os

dados e seus relacionamentos em tabelas.
Conheça as estruturas de modelagem de banco de dados.
TABELAS
As tabelas são as primeiras estruturas que você define no banco de dados. Você
determina os vários assuntos que as tabelas representarão, a partir dos objetivos
obtidos na análise de necessidades do projeto de modelagem de dados. As tabelas
são entidades que se relacionam entre si. Um banco de dados pode conter uma ou
mais tabelas. Cada tabela é composta por linhas e colunas.
LINHAS E COLUNAS
As linhas são um conjunto de valores de atributos de um mesmo elemento e também
podem ser chamadas de registros ou tuplas. Cada linha possui um Identificador
exclusivo, chamado chave, para não haver duplicidade de registros.
As colunas são um conjunto de valores de um mesmo atributo e também são

chamadas de campos ou atributos. As colunas armazenam um tipo específico do
valor, por exemplo, um nome.
CAMPOS
Os campos são componentes da tabela e são a base do banco de dados. Eles
representam características dos assuntos que são importantes para uma organização.

Os campos armazenam os dados que a organização usa como base de informações.

Esses dados devem ser mapeados para tipos específicos, de forma a permitir seu
correto armazenamento e consistência.
TIPOS DE DADOS
As informações inseridas dentro dos campos das tabelas são os dados. Há vários
tipos dados: texto (Strings), numéricos, datas, entre outros.
Acompanhe a seguir alguns exemplos de campos de dados mais utilizados e como eles
são tratados.
TEXTOS (STRINGS)
Os textos são representados como uma sequência de caracteres com os tipos CHAR
e VARCHAR. O tamanho máximo suportado por CHAR são 255 caracteres e o
VARCHAR 65.535 caracteres. A diferença entre CHAR e VARCHAR é que o primeiro
ocupará o total do tamanho informado na definição do campo mesmo que esteja
vazio, enquanto o VARCHAR ocupará somente o que for atribuído ao texto. O
tipo VARCHAR é o mais utilizado justamente por permitir economia de espaço no
armazenamento da informação.
Dica!
Vale lembrar que o tamanho máximo para um registro é de 65.535.
Assim, se houver a necessidade de utilizar um campo texto maior
que 1.000 caracteres, opte por utilizar o campo do tipo TEXT que
discutiremos em seguida.

NUMÉRICOS
Números são divididos em dois grupos os inteiros e os decimais.
Conheça diversos tipos de dados numéricos.
Para os números inteiros, temos os tipos da tabela conforme abaixo, com seus
valores máximos suportados. O tipo INT é o mais utilizado por cobrir a faixa de
valores bem abrangente.
Para números decimais, os tipos mais utilizados são:
Os tipos FLOAT e DOUBLE não são recomendados quando os campos forem usados
para estabelecer comparações, por não conterem exatamente a mesma informação
que foi inserida em relação, como a representação interna, por exemplo:
Ao inserir 30.40, será armazenado 30.4.
Para os casos em que a precisão matemática é necessária, é indicado utilizar o tipo

DECIMAL.

DATAS
Datas e períodos são armazenados conforme a tabela a seguir:
Os tipos de dados mais comumente utilizados são DATE para registrar uma
determinada data e DATETIME, quando há necessidade de ter o horário armazenado
juntamente com a data.
Dica!
Se em algum momento houver a necessidade de armazenar uma
informação que indique uma condição de VERDADEIRO ou FALSO, o
tipo apropriado é o BOOL. Nele o valor 0 (zero) representa FALSO e
qualquer outro valor representa VERDADEIRO.
Caso seja necessário o armazenamento de textos longos, o tipo TEXT
que suporta até 65.535 caracteres e o LONGTEXT que suporta até 4Gib
(4.294.967.295) de caracteres são os recomendados.
Para armazenar conteúdo binário, tais como, fotos, vídeos, músicas, exis-
tem os tipos BLOB e LPONGBLOB, em que o primeiro suporta até 64Kib
(65535) bytes e o segundo 4Gib (4.294.967.295) bytes de conteúdo.
NORMALIZAÇÃO E PADRONIZAÇÃO DE DADOS
A normalização é a técnica que aplicamos nas estruturas de dados para aumentar

a qualidade do modelo de banco de dados. É também uma base teórica para a
definição das propriedades das relações fundamentadas na Matemática. Através
do processo de normalização, podemos substituir um conjunto de entidades e
relacionamentos por outro, mais eficiente em relação às anomalias de operações
efetuadas aos dados, as quais podem causar problemas, tais como:

• Informações redundantes entre entidades.

• Dependências parciais em relação à chave composta.
• Perdas acidentais de informação.
As três normatizações mais conhecidas são:
PRIMEIRA FORMA NORMAL
A primeira forma normal assegura que não existam repetições de valores nos
atributos, nem grupos repetidos de atributos das entidades de um modelo de
dados. Também visa eliminar o aninhamento de tabelas para que cada uma
apresente informações de um único assunto. Não podemos ter mais de um
assunto em uma tabela.
O atributo endereço na tabela gravadora representa um atributo composto e

multivalorado. Com a aplicação da primeira forma normal, o atributo endereço
é transformado em uma tabela, permitindo a separação de cada subparte do
endereço, além da chave associativa para a tabela gravadora, fornecendo a referência
necessária que representa o vínculo entre os endereços de uma gravadora.
Normalização das tabelas Gravadora e Endereço na primeira forma normal
SEGUNDA FORMA NORMAL
Uma relação está na segunda forma normal quando os atributos simples devem
depender unicamente da chave primária da tabela. Assim, como as colunas da
tabela, que não são dependentes dessa chave, devem ser removidas da tabela
principal, cria-se uma tabela utilizando esses dados.

Tabela com colunas cujos dados não pertencem diretamente à informação principal.
Aplicação da segunda forma normal, separando os dados

de álbum da tabela associativa músicas_do_álbum.
TERCEIRA FORMA NORMAL
A relação está na terceira forma normal quando todos os atributos da tabela são
funcionalmente independentes uns dos outros, ao mesmo tempo em que devem
ser dependentes exclusivamente da chave primária da tabela.
O campo sobre o total da tabela Álbuns Vendidos depende da quantidade selecionada

multiplicada pelo preço unitário. Esse campo, além de dinâmico, é dependente do cálculo
de dois valores. Após a aplicação da terceira forma normal, a coluna calculada é retirada,
garantindo que não existam dados redundantes na tabela.

A tabela à esquerda tem a coluna total que é dependente das colunas preço unitário
e quantidade, e à direita está a tabela após a aplicação da 3ª forma normal
Importante!
Para estar em uma forma normal, a tabela precisa estar obrigatoriamente
nas formas normais anteriores.
!
Por exemplo: uma tabela somente estará na terceira forma normal se
estiver também na primeira e segunda formas normais.
SISTEMA DE GERENCIAMENTO
DE BANCO DE DADOS (SGBD)
Os sistemas de gerenciamento de banco de dados (SGBD) são softwares que
fornecem os mecanismos para gerenciar o acesso, armazenar, manipular e recu-
perar os dados de um ou mais banco de dados. Juntos, os dados, os sistemas de
gerenciamento de banco de dados e os programas associados, são chamados de
Sistemas de Banco de Dados.
Os sistemas de banco de dados devem apresentar como características principais

robustez e interoperabilidade.
Conheça cada uma dessas características.

ROBUSTEZ
Um banco de dados é considerado robusto quando é escalável, tolerante a falhas

(intencionais ou não) e confiável frente aos diferentes padrões de comportamento
dos usuários.
Fonte: Pixabay
INTEROPERABILIDADE
A interoperabilidade permite a troca de dados entre diferentes bancos de dados

para outro Sistema de Banco de Dados. Por exemplo: migrar um banco de dados
SQL Server para MySQL ou Oracle.
FUNCIONALIDADES DO SGBD
Os SGBDs possuem ainda as seguintes funcionalidades:
• Controle centralizado de dados - O armazenamento de dados de forma

centralizada facilita a padronização e o controle, tornando a resposta do servidor
mais eficiente.
• Controle de redundância - Evita a duplicidade de informações, mantendo
o banco consistente e economizando espaço de armazenamento.

• Facilidade de acesso - A centralização e organização de dados permitem

acesso fácil e rápido para consulta e manipulação de dados.
• Segurança de acesso e controle de informações - Diversas técnicas de
segurança de dados foram desenvolvidas para proteger o banco de dados,
assim como para restringir o acesso e controlar as informações.
• Análise e agrupamento de dados - Técnicas de agrupamento e análise de
dados têm evoluído muito e o Big Data também é outro ramo importante ligado
à área de dados.
ESTRUTURA DO SGBD
Um sistema de gerenciamento de banco de dados oferece a seguinte estrutura:
• Uma visão lógica (esquema, subesquema);

• Visão física (métodos de acesso, agrupamento de dados);
• Linguagem de definição de dados;
• Linguagem de manipulação de dados; e
• Utilitários importantes, como gerenciamento de transações e controle de
simultaneidade, integridade de dados, recuperação de falhas e segurança.
• Veja, a seguir, a imagem ilustrativa de um sistema de banco de dados.
• Confira a imagem ilustrativa de um sistema de banco de dados.

Imagem ilustrativa da estrutura de um Gerenciador de Banco de Dados
COMPONENTES
A estrutura dos componentes dos gerenciadores de banco de dados difere

ligeiramente uma da outra devido a estratégias definidas para cada implementação,
porém pode ser delineada uma estrutura básica para eles.
A imagem a seguir ilustra a arquitetura interna de um gerenciador de banco de dados.

• Os gerenciadores de banco de dados utilizam um modelo cliente/servidor de

forma que as instâncias do sistema de banco de dados atuem como servidores e
os aplicativos como clientes. Por exemplo, o cliente é o MySQLWorkbench.
• Os clientes efetuam solicitações na forma de consultas por meio da linguagem
SQL para o subsistema de transporte do gerenciador de banco de dados, que
encaminha para um processador de consulta onde são executadas a interpretação e
a validação da solicitação. Em seguida, é verificado o controle de acesso.
• Uma vez validada e autorizada, a consulta passa pelo otimizador onde são
definidos o plano de execução e a contabilização de estatísticas de uso.
• O plano de execução define a sequência de operações a ser executada
de forma otimizada para cumprir com a solicitação original. Com o plano de

execução efetuado, a resposta retorna ao cliente. Essa resposta pode ser um

conjunto de dados, a informação da quantidade de linhas processada com a
consulta ou a informação de erro de acesso ou permissão.
LINGUAGENS DE BANCO DE DADOS
As linguagens utilizadas em SGBDs podem ser

divididas em duas partes diferentes:
• Linguagem de manipulação de dados;

• Linguagem de definição de dados.
A linguagem de manipulação de dados (DML)

é a responsável por inserir, atualizar, excluir e
recuperar os dados e as informações no banco
de dados. Fonte: Pixabay
A linguagem de definição de dados (DDL) é utilizada para criar, modificar ou excluir

a parte estrutural do banco de dados, incluindo as consistências necessárias para
inserção de dados, permissões de acesso e implementação do esquema criado pelo
projetista. O esquema do banco de dados é apenas uma parte do projeto do banco
de dados.
BANCO DE DADOS EM APLICATIVOS MOBILE

Nas plataformas de software dos smartphones e tablets, já está presente um
gerenciador de dados, o SQLite, uma biblioteca escrita em linguagem C, que
oferece os recursos básicos para a criação de tabelas e seus relacionamentos,
armazenando tudo em arquivos, em locais privados dentro do espaço disponível
no próprio dispositivo.
Para saber mais, veja as imagens a seguir que ilustram as plataformas Room Database
e Core Data.

PLATAFORMA ROOM DATABASE
Na arquitetura Android de dispositivos móveis, é utilizada a plataforma JetPack

Room Database para acessar os dados localmente do gerenciador de banco de dados
interno SQLite. Esta plataforma utiliza uma variação do SQL orientada a objetos para
representar as consultas aos dados.
Imagem ilustrativa da plataforma Room Database
PLATAFORMA CORE DATA
Na Arquitetura iOS de dispositivos móveis, é utilizada a plataforma Core Data para

acessar os dados localmente do gerenciador de banco de dados interno SQLite. Esta
plataforma utiliza uma estrutura de dados na linguagem Swift para representar a
estrutura de dados que será lida e gravada no banco de dados.

Imagem ilustrativa da plataforma Room Database
Ambas arquiteturas, Android e iOS, não acessam diretamente gerenciadores

de banco de dados externos aos dispositivos móveis. Para esse tipo de acesso, é
necessária a utilização da implementação de API específica em servidor de back-
end, que fará o acesso ao banco de dados.
A ilustração representa a conexão de dispositivos móveis

ao serviço back-end para o acesso ao banco de dados

• Todas as transações utilizadas através dessa solução lançam mão da

comunicação HTTP do tipo RESTFull e os dados são representados no
formato JSON.
• RESTFull é o nome dado à forma de comunicação entre dispositivos,
utilizando o protocolo comum no acesso à internet, o HTTP.
• JSON é o nome do formato utilizado na representação dos dados na
comunicação entre dispositivos através do mecanismo RESTFull.
REGRAS DE SEGURANÇA
A segurança desempenha um papel importante nos sistemas de banco de dados
e se refere à proteção do acesso indevido ou da manipulação não autorizada de
dados. O sistema de banco de dados gerencia grandes conjuntos de informações
que precisam ser protegidos de pessoas não autorizadas.
Conheça os casos que a segurança do banco de dados abrange.
• Privacidade - Apenas pessoas autorizadas devem ter permissão para

acessar o banco de dados. Além disso, apenas a parte do banco de dados
necessária para as funções que executam deve estar disponível para elas. Em
outras palavras, os usuários têm permissão para acessar exclusivamente as
informações pertinentes ao seu trabalho.
• Integridade do banco de dados - O banco de dados deve ser protegido
de modificações impróprias, intencionais ou acidentais, para manter a sua
integridade. Apenas o tipo de operação que precisa ser realizado pelo usuário
deve ser permitido a eles.
• Disponibilidade do banco de dados - A segurança não deve restringir
os usuários autorizados a executarem suas ações na parte do banco de dados
disponível para eles.
INSTALAÇÃO E CONFIGURAÇÃO
DE BANCO DE DADOS
Para que possamos estruturar os dados, a fim de efetuar consultas posteriores,
necessitamos de um gerenciador de banco de dados. Assim, os próximos passos

auxiliarão na instalação do gerenciador MySQL para que você possa prosseguir com
seus estudos.
PDF
Acesse o passo a passo de instalação e configuração do gerenciador MySQL.
Arquivo: PDF01_InstConfigMySQL_Windows_v01.pdf

NESTE DESAFIO...
BANCO DE DADOS EM APLICATIVOS MOBILE COM JAVA |
DESAFIO 1
Você estudou sobre:
BANCO DE DADOS
MODELOS DE BANCO DE DADOS
MODELO RELACIONAL
MER
• Entidades
• Atributos
• Relacionamentos
» Tipos de Relacionamento
• Um para um – 1:1
• Um para muitos – 1:N ou N:1
• Muitos para muitos – N:N
CHAVE
• Integridade de chaves
DER – DIAGRAMA DE ENTIDADE E RELACIONAMENTO

MODELAGEM DE DADOS
TIPOS DE DADOS
• Textos (Strings)
• Numéricos
• Normalização e Padronização de dados
SISTEMA DE GERENCIAMENTO DE BANCO DE DADOS (SGBD)

• Estrutura do SGBD
• Componentes
• Linguagens de Banco de Dados
BANCO DE DADOS EM APLICATIVOS MOBILE

REGRAS DE SEGURANÇA
INSTALAÇÃO E CONFIGURAÇÃO DE BANCO DE DADOS
NO PRÓXIMO DESAFIO...
Você estudará como criar o banco de dados, aplicando regras de segurança e níveis
hierárquicos.

DESAFIO 2
No desafio anterior, você estudou como modelar o projeto
de banco de dados, aplicando o modelo relacional, além de
instalar e configurar o gerenciador MySQL.
• Criar um banco de dados, aplicando regras de

segurança e níveis hierárquicos.
• Linguagem de definição e manipulação de dados.

• Operações.
• Segurança da informação em Banco de Dados.

INTRODUÇÃO
Structured Query Language - SQL é uma linguagem de banco de dados projetada
para gerenciar dados mantidos em um sistema de gerenciamento de banco de
dados relacional.
Muitos dos gerenciadores de bancos de dados relacionais disponíveis atualmente,

como o banco de dados Oracle, Microsoft SQL Server, MySQL, IBM DB2, entre outros,
usam a SQL.
Fonte: Pixabay
+
Saiba mais
A SQL foi desenvolvida inicialmente pelos pesquisadores da IBM,
Raymond Boyce e Donald Chamberlin, no início dos anos 1970. A
versão inicial, chamada SEQUEL - Structured English Query Language, foi
projetada para manipular e recuperar dados armazenados no sistema
de gerenciamento de banco de dados quase relacional da IBM, System
R. No final dos anos 70, a Relational Software Inc., que agora é a Oracle
Corporation, apresentou a primeira implementação de SQL disponível
comercialmente: Oracle V2 para computadores VAX.

LINGUAGEM E DEFINIÇÃO
DE MANIPULAÇÃO DE DADOS
Em um Sistema de Gerenciamento de Banco de Dados, a linguagem do banco de
dados SQL é usada para:
• Criar o banco de dados e as estruturas da tabela;

• Realizar tarefas básicas de gerenciamento, tais como: adicionar, excluir e
modificar dados;
• Realizar consultas complexas para transformar dados brutos em
informações úteis.
Dica!
Utilizamos a SQL como uma linguagem de definição de dados - DDL
para criar as estruturas de banco de dados e tabelas. Já a utilização
da SQL como uma linguagem de manipulação de dados - DML nos
permite inserir, excluir, selecionar e atualizar dados nas tabelas do
banco de dados.
CRIAÇÃO DO ESQUEMA
Antes de iniciarmos a construção das tabelas para o nosso banco de dados,

necessitamos reservar o local onde elas ficarão. Isso é importante, pois, além de
permitir a organização das estruturas dentro do gerenciador de banco de dados,
também garante a segregação dos ambientes, oferecendo segurança para que os
dados de uma área não estejam mesclados com os de outra.
Essa área recebe o nome de Esquema e a criamos com o seguinte comando:
CREATE SCHEMA [IF NOT EXISTS] nome_do_esquema;
• Na declaração de criação da tabela, os colchetes representam cláusulas

opcionais. A cláusula [IF NOT EXISTS] permite que a declaração somente seja
executada se a tabela não existir, ou seja, permite que a declaração CREATE
SCHEMA seja executada somente se o esquema não existir.

O exemplo a seguir mostra a criação de um esquema com o nome Album:
1 CREATE SCHEMA Album
CRIAÇÃO DE TABELAS
Uma vez que tenhamos o esquema de banco de dados criado, poderemos acessá-
lo para armazenar os dados que necessitamos. Os dados seguirão as estruturas
definidas no Modelo de Entidade e Relacionamentos. Cada entidade existente
nesse modelo deve ser criada na forma de tabela, e o comando para a criação dessas
tabelas tem o seguinte formato:
1 CREATE TABLE [IF NOT EXISTS] nome_da_tabela (

2 nome_da_coluna tipo_de_dado [NOT NULL | NULL]
3 [AUTO_INCREMENT] [PRIMARY KEY],
4 ...
5 );
CRIAÇÃO DAS COLUNAS
A definição das colunas da tabela é composta pelas etapas seguintes.
• NOME DA COLUNA - O nome da coluna deve ser único dentro da tabela

, preferencialmente, sem espaços e acentuação para simplificar a construção
das consultas SQL. Quando utilizamos espaços ou acentuação nos nomes dos
objetos do banco de dados, como nome de esquemas, tabelas, colunas etc.,
temos que circundar esses nomes com aspas simples, por exemplo: ‘data de
lançamento’, ou podemos utilizar: data_lancamento.
• CONTEÚDO OBRIGATÓRIO - Com a cláusula NOT NULL definimos o conteúdo
da coluna como obrigatório, exigindo que a informação seja passada no momento
da inclusão dos dados na tabela. Caso seja utilizada a cláusula NULL na definição da
coluna, seu conteúdo passa a ser considerado opcional.
• INCREMENTADO AUTOMATICAMENTE - Quando a coluna é a chave
primária e seu valor deve ser numérico e sequencial, podemos utilizar a

cláusula AUTO_INCREMENT. Assim, sempre que um novo registro for incluído

nessa tabela, o valor dessa coluna será gerado automaticamente e, desta
forma, não será necessário informar seu valor na declaração SQL de inserção
de dados.
• CHAVE PRIMÁRIA - Acrescentamos a cláusula PRIMARY KEY para definir a
coluna como chave primária na tabela.
• TIPO DE DADO A SER ARMAZENADO - No desafio anterior, você estudou
os diversos tipos de dados. Relembre alguns tipos mais utilizados:
Fonte: elaborado pelo autor

Acompanhe a seguir um exemplo de declaração para a criação da tabela Banda no

esquema de banco de dados Álbum.
Note que, no local onde informamos o nome da tabela, foi acrescentado também o
nome do esquema na qual a tabela deverá ser criada. Isso ocorre porque o gerenciador
de banco de dados necessita que toda a informação seja completamente qualificada.
1 CREATE TABLE Album.Banda (

2 idBanda INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
3 nome VARCHAR(200) NOT NULL );
Para informar ao gerenciador de banco de dados que todas as declarações deverão

utilizar um determinado esquema, utilizamos a declaração a seguir. Esta declaração
é utilizada somente no início da conexão ao banco de dados.
1 USE nome_do_esquema;
A declaração para criação de tabela ficaria da seguinte forma:
1 USE Album;
2 CREATE TABLE Banda (
3 idBanda INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
4 nome VARCHAR(200) NOT NULL );
CRIAÇÃO DE RELACIONAMENTOS
Para criar uma tabela que contém relacionamentos vinculados na chave composta,
devemos acrescentar outra cláusula à instrução de criação de tabela, a qual possibilite
a definição de restrições para condicionar a forma como gravamos nossos dados
nas tabelas, de forma a manter a integridade referencial das chaves utilizadas nas
associações estabelecidas entre elas. Essa cláusula tem o seguinte formato:

1 COSTRAINT [nome_da_regra] FOREIGN KEY (nome_da_coluna)

2 REFERENCES nome_da_tabela (nome_da_coluna)
3 [ON DELETE [CASCADE | NO ACTION]]
4 [ON UPDATE [CASCADE | NO ACTION]]
A cláusula recebe um nome opcional e define qual coluna da tabela atual está
apontando para a tabela destino e sua respectiva coluna. Ainda são oferecidas
as opções para definir como serão tratadas as operações na tabela associada
de remoção e atualização, podendo repassar as atualizações para os registros
associados com a cláusula CASCADE ou não modificar nenhum registro associado
com a cláusula NO ACTION.
A seguir, acompanhe um exemplo de criação da tabela Música associada à tabela

Banda por meio da seguinte declaração:
1 CREATE TABLE Musica (

2 idBanda INT NOT NULL,
3 idMusica INT NOT NULL AUTO_INCREMENT,
4 nome VARCHAR(200) NOT NULL,
5 PRIMARY KEY (idBanda, idMusica),
6 COSTRAINT fk_musica_banda FOREIGN KEY (idBanda)
7 REFERENCES Banda (idBanda)
8 );
Na declaração observada, podemos notar que a definição da chave composta

ocorre com a definição das colunas separadas da cláusula PRIMARY KEY (idBanda,
idMusica). Também podemos observar que a cláusula COSTRAINT indica que a
coluna idBanda da tabela Musica faz referência à coluna idBanda da tabela Banda.
MODIFICAÇÃO DA ESTRUTURA
Agora confira uma situação em que há necessidade de modificar a estrutura de

uma tabela.
Conheça a declaração que podemos utilizar.

1 ALTER TABLE nome_da_tabela

2 ADD nome_da_coluna tipo_de_dado [NOT NULL | NULL]
3 [AUTO_INCREMENT] [FIRST | AFTER nome_da_coluna]
4 | ADD CONSTRAINT [nome_da_regra]
5 FOREIGN KEY (nome_da_coluna)
6 REFERENCES nome_da_tabela (nome_da_coluna)
7 [ON DELETE [CASCADE | NO ACTION]]
8 [ON UPDATE [CASCADE | NO ACTION]]
9 | DROP nome_da_coluna
10 | DROP PRIMARY KEY
11 | DROP FOREIGN KEY nome_da_regra
12 | RENAME nome_anterior_da_coluna TO novo_nome_da_coluna,
13 ...
14 );
A declaração ALTER TABLE permite acrescentar ou remover colunas e alterar seus

nomes, além de adicionar ou remover chaves primárias ou estrangeiras. A fim
de ilustrar a utilização desta declaração, vamos inserir a tabela Estilo e criar uma
associação um para muitos 1:N entre ela e a tabela Musica. Confira mais a seguir.
ASSOCIAÇÃO UM PARA MUITOS 1:N
O exemplo a seguir mostra a aplicação da declaração ALTER TABLE para acrescentar

a tabela Estilo e criar uma associação um para muitos 1:N entre ela e a tabela Musica.
1 CREATE TABLE Estilo (

2 idEstilo INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
3 nome VARCHAR(200) NOT NULL
4 );
5 ALTER TABLE Musica
6 ADD idEstilo INT NOT NULL,
7 ADD COSTRAINT fk_musica_estilo FOREIGN KEY (idEstilo)
8 REFERENCES Estilo (idEstilo);
Importante!
Essas declarações permitiram a criação da tabela Estilo e acrescenta-
!
ram a coluna idEstilo, além de estabelecerem a regra para manter a
integridade referencial entre as chaves associativas na tabela Musica.

ASSOCIAÇÃO MUITOS PARA MUITOS N:N

Agora que já temos as tabelas Banda, Musica e Estilo, podemos completar a
construção do nosso banco de dados criando também a tabela Album.
Em seguida, associaremos a tabela Album à tabela Musica para apresentar como

construir uma tabela associativa para a relação do tipo muitos para muitos N:N,
utilizando declarações SQL.
DECLARAÇÃO SQL PARA CRIAR A TABELA ALBUM
1 CREATE TABLE Album (

2 idAlbum INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
4 ano INT NOT NULL,
6 idEstilo INT NOT NULL,
7 COSTRAINT fk_album_banda FOREIGN KEY (idBanda)
8 REFERENCES Banda (idBanda),
9 COSTRAINT fk_banda_estilo FOREIGN KEY (idEstilo)
10 REFERENCES Estilo (idEstilo)
A declaração SQL observada segue a mesma estrutura da declaração utilizada para

criar a tabela Musica. Note que estão presentes as definições das chaves estrangeiras
para as tabelas Banda e Musica, mantendo-se as cláusulas que geram as regras
para a manutenção da integridade referencial dessas associações.
DECLARAÇÃO SQL PARA CRIAÇÃO DA TABELA ASSOCIATIVA
1 CREATE TABLE Musicas_do_Album (

3 idMusica INT NOT NULL,
4 idAlbum INT NOT NULL,
5 PRIMARY KEY (idBanda, idMusica, idAlbum),
6 COSTRAINT fk_da_musica FOREIGN KEY (idBanda, idMusica)
7 REFERENCES Musica (idBanda, idMusica),
8 COSTRAINT fk_do_album FOREIGN KEY (idAlbum)
9 REFERENCES Album (idAlbum)
10 );
A associação de muitos para muitos entre a tabela Musica e a tabela Album necessita
da criação de tabela associativa, que manterá as chaves estrangeiras, representando
as músicas que pertencem aos álbuns.

Importante!
A tabela associativa, na maioria vezes, somente contém chaves
!
associativas, mas, dependendo da característica da associação, é
possível que a tabela associativa também contenha atributos que não
sejam chaves.
A declaração SQL da tabela associativa Musicas_do_Album tem a chave

primária composta pelas três chaves estrangeiras para garantir que não
existam duplicidades de registros. As regras de integridade referencial
definem os vínculos necessários para fazer a correta referência às tabelas
pela chave primária correspondente a cada tabela.
TRATAMENTO DE DADOS
Agora que temos as tabelas criadas, utilizamos declarações SQL para inserir, consultar,
atualizar e destruir dados. No entanto, é necessário garantir que não existam chaves
primárias duplicadas e, se for o caso, devemos tratar essa duplicidade.
INSERÇÃO DE DADOS
A declaração SQL para inserir dados tem três formatos. Clique nas abas e conheça
cada um deles.
PRIMEIRO FORMATO
No primeiro formato da declaração INSERT, além do nome da tabela, também

informamos quais as colunas que receberão os valores da lista definida pela
cláusula VALUES.
1 INSERT [INTO] nome_da_tabela

2 (nome_da_coluna [, nome_da_coluna] ...)
3 VALUES (valor [, valor] ...);

SEGUNDO FORMATO
No segundo formato, o nome das colunas é informado em conjunto com os valores
na cláusula SET.

2 SET nome_da_coluna = valor [, nome_da_coluna = valor]
3 ...;
TERCEIRO FORMATO
Na terceira forma, além do nome da tabela e dos nomes das colunas, é informado o
nome da tabela na cláusula TABLE da qual os valores serão importados.

3 TABLE nome_da_tabela;
Dica!
Para o controle de duplicidade de chaves primárias que possam
ocorrer durante a operação de inserção de dados, podemos utilizar
a seguinte cláusula:
1 [ON DUPLICATE KEY UPDATE

2 nome_da_coluna = valor [, nome_da_coluna =
valor] ...];
Essa cláusula permite que sejam informadas quais colunas deverão ser
atualizadas em caso de colisão de chaves primárias, dessa forma, a se-
quência da operação de inserção de dados seguiria sem qualquer falha.
PASSO A PASSO PARA INSERÇÃO DOS DADOS EM TABELAS
Acesse o material conheça o passo a passo para inserção de dados nas tabelas, a
partir do que já estudamos até aqui.

CONSULTA DE DADOS
A declaração SQL nos permite extrair informações a partir da base de dados e, em

muitos casos, ao analisar os dados históricos, podemos identificar as tendências que
dão auxílio à tomada de decisão.
PDF
Conheça a sintaxe utilizada para consultar dados cadastrados, bem como as operações que permitem
filtrar e agrupar dados.
Arquivo: PDF01_consultadedados.pdf
ATUALIZAÇÃO DOS DADOS
Muitas vezes as informações que cadastramos no banco de dados necessitam ser

ajustadas para adequação a um novo contexto ou correção de dados que foram
inseridos anteriormente. O comando SQL que utilizamos para a atualização de
dados é a declaração UPDATE e sua sintaxe é apresentada a seguir:

3 TABLE nome_da_tabela;
• O formato da declaração SQL UPDATE segue o mesmo do segundo formato

na declaração SQL INSERT, em que o nome das colunas é informado em
conjunto com os valores na cláusula SET.
• A cláusula WHERE define as condições em que a atualização irá ocorrer.
Caso essa cláusula não seja informada, a atualização atuará em todos os
registros da tabela informada, algo que é extremamente danoso, caso seja
executado inadvertidamente.
Agora podemos atualizar um registro em que a informação inserida está incorreta,

além de incluir os dados faltantes para uma banda. Para isso, utilizaremos a declaração
SQL UPDATE e uma declaração SQL INSERT, mas, primeiro, observaremos o que é
necessário ser ajustado.
Observe o código e, logo abaixo, o resultado da pesquisa para apresentar os dados

cadastrados:

1 SELECT b.nome 'Banda', a.nome 'Álbum', m.nome 'Música',

2 e.nome 'Estilo da Música', eb.nome 'Estilo do Álbum'
3 FROM Musica AS m
4 RIGHT JOIN Musicas_do_Album AS ma
5 ON ma.idBanda = m.idBanda
6 AND ma.idMusica = m.idMusica
7 RIGHT JOIN Album AS a ON ma.idAlbum = a.idAlbum
8 LEFT JOIN Estilo AS e ON m.idEstilo = e.idEstilo
9 JOIN Banda AS b ON m.idBanda = b.idBanda
10 JOIN Estilo AS eb ON a.idEstilo = eb.idEstilo;
Primeiramente, vamos examinar a consulta SQL da tabela anterior e analisar cada

junção, a fim de entender a origem dos dados apresentados no resultado.
Acompanhe a explicação a seguir.
Na primeira junção, selecionamos todos os registros da tabela associativa Musicas_

do_Album em relação às informações constantes na tabela música:


A segunda junção relaciona os resultados da junção da primeira figura com todos os

registros da tabela álbum: RIGHT JOIN Album AS a ON ma.idAlbum = a.idAlbum.
Essas duas junções permitem apresentar os dados das colunas “Álbum” e “Música”
constantes no resultado da consulta SQL e demonstram a ausência de músicas
cadastradas para um determinado álbum que é destacado com o resultado NULL.
A terceira junção busca relacionar as músicas com o respectivo estilo musical:
LEFT JOIN Estilo AS e ON m.idEstilo = e.idEstilo
O resultado dessa junção traz os dados para a coluna “Estilo da Música” no resultado
da consulta SQL.

A quarta junção relaciona as músicas e suas respectivas bandas musicais:
JOIN Banda AS b ON m.idBanda = b.idBanda
As informações obtidas desse relacionamento obtêm os dados da coluna “Banda” na

tabela apresentada como resultado da consulta SQL.
A quinta junção busca o estilo musical para um determinado álbum:
JOIN Estilo AS eb ON a.idEstilo = eb.idEstilo
O resultado dessa junção traz os dados para a coluna “Estilo do Álbum”.

Note que o registro para a banda “Maduk” apresenta o álbum “Stay Like This”,
mas não contém músicas cadastradas, como indicado pelo NULL nas respectivas
colunas “Música” e “Estilo da Música”. Também o estilo musical para esse álbum
está cadastrado como “Rock”, porém o correto é “Drum’n’bass”.
Os ajustes necessários são dois:
• a atualização da informação de estilo musical para o álbum “Stay Like

This”; e
• a inserção das músicas desse álbum.
Vamos iniciar com a atualização, porém necessitamos antes identificar como

informar a chave associativa para o estilo musical correto na declaração SQL de
atualização. Assim, vamos construir uma consulta SQL para pesquisar as informações
que necessitamos na tabela Estilo.

Confira a seguir:
1 SELECT idEstilo, nome FROM Estilo WHERE nome LIKE “%bass”;

2 +----------+-----------------+
3 | idEstilo | nome |
4 +----------+-----------------+
5 | 3 | Drum’n’bass |
6 +----------+-----------------+
7 1 row in set (0,00 sec)
Agora que já obtemos a informação da chave associativa na tabela Estilo para

informar na atualização SQL da tabela Album, vamos construir a declaração SQL
para a atualização, conforme segue:
1 UPDATE Album
2 SET idEstilo = ( SELECT idEstilo FROM Estilo
3 WHERE nome LIKE “%bass” )
4 WHERE nome = “Stay Like This”;
5 Query OK, 0 rows affected (0,01 sec)
6 Rows matched: 1 Changed: 0 Warnings: 0
Neste exemplo, a construção da declaração SQL utiliza um recurso conhecido como

sub-select. Trata-se de uma consulta SQL aninhada em outra declaração SQL. É um
recurso muito útil e flexível para fornecer dados necessários a operações de consulta,
inserção, atualização e deleção.
O próximo passo será incluir as músicas do referido álbum que estão faltando no
banco de dados.
Os relacionamentos existentes entre as tabelas Album e Musica são estabelecidos na ta-

bela associativa Musicas_do_Album. Assim, para cada registro inserido na tabela Música,
será necessário criar um registro referente à associação na tabela Musicas_do_Album.
Essa execução pode ser construída com os recursos que a linguagem SQL nos
oferece, de forma que possamos inserir manualmente as chaves associativas com a
utilização de variáveis que são criadas, conforme ilustrado a seguir.
1 SET @estilo = ( SELECT idEstilo FROM Estilo

2 WHERE nome LIKE “%bass” );
3 SET @album = ( SELECT idAlbum FROM Album
4 WHERE nome = “Stay Like This” );

5 SET @banda = ( SELECT idBanda FROM Banda

6 WHERE nome = “Maduk” );
• As variáveis @estilo, @banda e @album guardam o resultado das consultas

SQL que buscam pela chave primária correspondente a cada uma das tabelas.
• Essas chaves são necessárias na inserção dos novos registros de músicas e
sua associação com o álbum.
1 INSERT INTO Musica SET idBanda = @banda,

2 nome = “Nothing More”, idEstilo = @estilo;
3 INSERT INTO Musicas_do_Album SET idBanda = @banda,
4 idMusica = LAST_INSERT_ID(), idAlbum = @album;
• Para cada registro, executaremos duas instruções SQL, conforme você pode
verificar nesta imagem.
Duas ocorrências importantes estão presentes nessas duas declarações SQL:
• A primeira é a ausência do atributo idMusica na declaração SQL que

insere a música na tabela de mesmo nome.
1 CREATE TABLE Musica (

3 idMusica INT NOT NULL AUTO_INCREMENT,
5 idEstilo INT NOT NULL,
6 PRIMARY KEY (idBanda, idMusica),
7 COSTRAINT fk_musica_banda FOREIGN KEY (idBanda)
8 REFERENCES Banda (idBanda)
9 COSTRAINT fk_musica_estilo FOREIGN KEY (idEstilo)
10 REFERENCES Estilo (idEstilo);
11 );
Se observarmos na declaração SQL utilizada para a construção desta tabela, o

atributo identificador idMusica tem a cláusula AUTO_INCREMENT, que permite
gerar automaticamente o valor identificador para o atributo, quando sua declaração
estiver ausente no momento da inserção do registro.
• A segunda ocorrência que está presente na segunda declaração SQL

utilizada para a inserção das chaves associativas na tabela Musicas_do_
Album é a utilização da função LAST_INSERT_ID().
• Esta função retorna o valor da última chave primária que foi gerada
automaticamente numa declaração de inserção de dados.

• Nesse caso, a chave primária idMusica, gerada automaticamente na

inserção dos dados da música, foi executada imediatamente antes da utilização
da função.
• A partir dessas informações, poderemos seguir adicionando as outras
músicas que faltam.
Observe na tabela a seguir um exemplo dessa adição.

2 nome = “Got me Thinking”, idEstilo = @estilo;
6 nome = “The End”, idEstilo = @estilo;
10 nome = “One Way”, idEstilo = @estilo;
14 nome = “Never Give Up”, idEstilo = @estilo;
Após a inserção de todas as informações que exemplificamos, confira, nas imagens

seguintes, como ficou aquela consulta SQL que lista todos os dados cadastrados e
que anteriormente tinha apresentado a falta de certas informações.
1 SELECT b.nome 'Banda', a.nome 'Álbum', m.nome 'Música',

2 e.nome 'Estilo da Música', eb.nome 'Estilo do Álbum'
3 FROM Música AS m
7 RIGHT JOIN Album AS a ON ma.idAlbum = a.idAlbum
8 LEFT JOIN Estilo AS e ON m.idEstilo = e.idEstilo
9 JOIN Banda AS b ON m.idBanda = b.idBanda
10 JOIN Estilo AS eb ON a.idEstilo = eb.idEstilo;

Importante!
Note que a atualização do estilo no registro do álbum da banda
!
Maduk passou para “Drum’n’bass” e suas músicas foram cadastradas
com sucesso.
DESTRUIÇÃO DE DADOS E TABELAS
Quando necessitamos remover informações do banco de dados, devemos ter atenção

às relações que essas informações têm com outras, a fim de respeitar a integridade
referencial. Caso contrário, nossa ação não terá sucesso e uma mensagem de erro
será emitida em resposta.
O formato da declaração SQL para a remoção de registros de tabelas é apresentado

a seguir:
1 DELETE FROM nome_da_tabela [WHERE condição];

Vamos remover uma música e, neste caso, também temos que remover o registro
associativo da tabela Musicas_do_Album. A declaração fica como podemos conferir
a seguir:
1 DELETE FROM Musicas_do_Album

2 WHERE idMusica = (
3 SELECT idMusica FROM Musica
4 WHERE nome = “Empty Words” );
5 DELETE FROM Musica WHERE nome = “Empty Words”;
Importante!
As declarações SQL têm que ser executadas nesta sequência para ter
sucesso. A primeira declaração remove o registro associativo entre
!
a tabela Musicas_do_Album e a tabela Musica. Por fim, a segunda
declaração SQL remove o registro da música.
Caso desejássemos remover uma tabela, deveríamos analisar todas
as regras associativas existentes entre a tabela e outras na forma de
CONSTRAINT e, na existência dessas regras, a primeira ação a ser
executada é a exclusão da regra existente na tabela associada, seguida
da coluna correspondente na mesma tabela. Somente após o sucesso
dessa ação, será possível remover a tabela objeto da ação.
Para exemplificar, vamos remover a tabela Estilo. Ela tem relações de integridade
referencial entre as tabelas Musica e Album. Na sequência, temos as instruções para
a remoção dessas regras e da coluna correspondente:
1 ALTER TABLE Album DROP CONSTRAINT fk_album_estilo;

2 ALTER TABLE Album DROP COLUMN idEstilo;
3
4 ALTER TABLE Musica DROP CONSTRAINT fk_musica_estilo;
5 ALTER TABLE Musica DROP COLUMN idEstilo;
Agora que a tabela Estilo não tem qualquer regra de integridade referencial com
as tabelas Musica e Album, e essas tabelas também não têm o atributo associativo
idEstilo em suas estruturas, podemos executar a instrução SQL que permite remover
a tabela e todos os seus registros.
1 DROP TABLE Estilo;

Saiba mais
O comando DROP TABLE permite a remoção de todos os dados e da
tabela de uma única vez. Esse comando falhará se houver qualquer
+
regra de integridade referencial existente entre duas tabelas no banco
de dados, retornando uma mensagem de erro.
SEGURANÇA DA INFORMAÇÃO
Segurança da informação, também conhecida como infosec, segundo a definição
do Computer Security Resource Center1 é:
“The protection of information and information systems from unauthorized

access, use, disclosure, disruption, modification, or destruction in order to
ensure confidentiality, integrity, and availability.”
Na tradução literal:
“A proteção da informação e dos sistemas de informação contra acesso não

autorizado, uso, divulgação, interrupção, modificação ou destruição, a fim
de garantir a confidencialidade, integridade e disponibilidade.”
Seu objetivo é reduzir os riscos e prevenir ameaças, garantindo o sigilo das

informações e assegurando a confidencialidade dos dados e a saúde/continuidade
da instituição.
1 CENTRO DE RECURSOS DE SEGURANÇA INFORMÁTICA.

Você sabia?
Diferença entre dados e informações. ?
Dados são os recursos isolados que não possuem valor relevante para
uma tomada decisão ou embasamento de conclusões. Por exemplo, em
um determinado mês, 100 pessoas visitaram um site; este é um dado. Já
a Informação é a organização dos dados para ter compreensão sobre um
determinado contexto. Os dados, quando organizados e processados,
tornam-se informações úteis. Por exemplo, em um determinado mês,
100 pessoas visitaram um site e, no mês seguinte, após a divulgação do
site em redes sociais, esse número aumentou para 160 pessoas. Podemos
concluir que houve um aumento de 60% no número de acessos.
Portanto, um dado é um recurso que compõe uma informação.
PILARES
A segurança da informação está fundamentada em alguns pilares, que podem variar

entre 3 a 5 (dependendo da literatura), para garantir seu objetivo. Neste desafio,
você vai conhecer os pilares: disponibilidade, confidencialidade e integridade.
Veja o infográfico a seguir para conhecê-los:

CONFIDENCIALIDADE
Os dados devem ser disponibilizados somente para pessoas autorizadas, portanto,

não podem ser divulgados a pessoas externas e que não devam ter acesso a eles. Se
a informação for enviada pela rede, deve-se utilizar criptografia, em que somente o
receptor e o emissor da mensagem possam decifrar as informações.
Exemplo de comprometimento de confidencialidade: você não pode divulgar uma

informação que contenha dados internos de vendas ou números referentes ao
crescimento da empresa.
INTEGRIDADE
A integridade está relacionada à não modificação ou exclusão durante ou após

o envio da informação. Para que esse pilar exista, é necessário que a informação
original mantenha todas as suas características, sem sofrer nenhuma modificação,
desde a origem até as pessoas autenticadas que são destinatárias desses dados.
Exemplo de comprometimento da integridade: ao enviar um e-mail para o

departamento de compras com um desconto de 5%, alguém intercepta o e-mail e
remove ou altera o desconto.
DISPONIBILIDADE
Está relacionada à disponibilidade da informação sem falhas, quando solicitada e

para usuários autorizados. Para um sistema ter disponibilidade, deve-se ter uma
infraestrutura com controles de segurança e ser resiliente contra ameaças, além de
ter recursos contra quedas de energia e falhas de hardware (equipamentos físicos).
Exemplo de comprometimento da disponibilidade: você precisa acessar um

determinado sistema para concluir e fechar a folha de pagamento do mês e o sistema
não está disponível.
Saiba mais
A norma ISO 27001:2013 estabelece os requisitos para implementar,
+
manter e melhorar, continuamente, um sistema de gestão de segurança
da informação. Acesse em: https://www.27001.pt/index.html

LEI GERAL DE PROTEÇÃO DE DADOS
O governo federal define o escopo da Lei Geral de Proteção de Dados, também

conhecida como LGPD, do seguinte modo:
“A Lei Geral de Proteção de Dados Pessoais (LGPD), Lei nº 13.709, de 14 de

agosto de 2018, dispõe sobre o tratamento de dados pessoais, inclusive nos
meios digitais, por pessoa natural ou por pessoa jurídica de direito público ou
privado, com o objetivo de proteger os direitos fundamentais de liberdade e de
privacidade e o livre desenvolvimento da personalidade da pessoa natural.”
Em outras palavras:
A LGPD trata de todos os tipos de dados pessoais, com o objetivo de proteger os

direitos fundamentais das pessoas naturais. Ela incide sobre as regras para coleta,
tratamento e compartilhamento de informações pessoais. Não importa se seu RG
está no cadastro federal de pessoas naturais ou no banco de dados do mercado do
seu bairro: todas as organizações têm responsabilidades e deveres ao manipular e
guardar informações pessoais.
Dica!
O SENAI-SP oferece gratuitamente o curso “Privacidade e proteção de
dados (LGPD)”. Para se inscrever, acesse o link: https://online.sp.senai.
br/6884/privacidade-e-protecao-de-dados-lgpd
A prática de proteção de dados envolve tanto o lado do desenvolvimento

(elaboração de códigos e configurações segurança) quanto o lado comercial/
negócios, para que a organização não sofra sansões legais, como multas e
suspensão do site ou serviço prestado.
Neste sentido, os desenvolvedores possuem papel importante a desempenhar,

a fim de contribuir para o cumprimento das diretrizes da LGPD, no que se refere
à prevenção de perdas ou exposição de dados e informações e à captura de
dados desnecessário.

PRÁTICAS DE SEGURANÇA EM BANCO DE DADOS
As práticas de segurança envolvem ações (técnicas ou físicas) individuais ou coletivas

para garantir a segurança e menor vulnerabilidade a situações adversas, como
políticas de segurança, controles de acesso lógicos e físicos, auditórias e criptografia.
Conheça cada uma dessas ações.
POLÍTICAS DE SEGURANÇA
Os dados das empresas são considerados ativos importantes e imensuráveis. A política

de segurança da informação (PSI) determina regras e diretrizes para o acesso a dados
e informações, além de responsabilidades dos membros da organização, visando
atender aos pilares da segurança da informação (confidencialidade, integridade e
disponibilidade). Exemplos:
• Não enviar e-mail em nome de outro emissor;

• Não compartilhar senhas;
• Não compartilhar informações internas com empresas parceiras, entre outros.
CONTROLE DE ACESSO FÍSICO
A segurança da informação não visa somente restringir o acesso e a visualização de

uma informação no sistema, mas também envolve a proteção física. Nesse sentido,
o controle de acesso está relacionado aos mecanismos que limitarão o acesso de
pessoas não autorizadas a áreas físicas da organização, a fim de evitar danificações
de equipamentos, modificações não desejadas etc.
Exemplo: para entrar na sala do servidor da empresa, é necessário um crachá que

contém a permissão para o usuário entrar no local; sem ele, a porta não é aberta.
CONTROLE DE ACESSO LÓGICO
O controle de acesso lógico está relacionado à proteção dos dados, programas e

sistema, como logins, biometrias, capturas faciais, entre outros, para que somente
usuários autenticados tenham acesso a determinados recursos, por exemplo, o
código fonte de um projeto (possibilitando a cópia ou alteração do fluxo lógico do
sistema), o banco de dados (que contém os dados internos de domínio da empresa),
sistemas operacionais e senhas (delimitando regras de implementação e validação).

AUDITORIAS
Trata-se de uma avaliação feita para analisar e identificar pontos em que pode haver
violação de segurança, de acordo com um conjunto de critérios preestabelecidos.
Exemplo: as senhas podem ser descobertas facilmente? Há logs (registros) de quem
acessa as informações?
CRIPTOGRAFIA
Do grego kriptos (oculto) e grafo (escrita), a criptografia codifica uma informação, dei-
xando-a ilegível ou dificultando a leitura por pessoas não autorizadas. Uma chave crip-
tográfica é aquela que codifica um texto, que só o emissor e o receptor podem decifrar,
conforme mostra o esquema abaixo. Dessa maneira, consegue-se manter os três atribu-
tos básicos da segurança da informação (confiabilidade, integridade e disponibilidade).
As assinaturas digitais em documentos são exemplos de utilização da criptografia

para a proteção das informações.
PDF
Entenda como uma chave assimétrica é gerada.
Arquivo: 01_chave_assimetrica.pdf

+
Saiba mais
Codificar funciona como traduzir uma mensagem de um idioma para
outro. Quem conhece o segundo idioma poderá entender a mensagem
final. Criptografar, por sua vez, é o processo de transformação da
mensagem em um código que somente poderá ser lido depois de
descriptografado com a chave correta. Esse processo é feito por meio
de algoritmos.
Para saber mais sobre criptografia em banco de dados, acesse: https://

docs.microsoft.com/pt-br/sql/relational-databases/security/encryption/
choose-an-encryption-algorithm?view=sql-server-ver15
As moedas digitais, ou criptomoedas, utilizam a criptografia como

elemento de segurança. A tecnologia que está por trás das transações
que envolvem criptomoedas, como o Bitcoin, é a Blockchain.
Aproveite e faça, gratuitamente, o curso ofertado pelo SENAI-SP

"Desvendando a Blockchain". Para mais informações, acesse: https://
online.sp.senai.br/curso/87241/483/desvendando-a-blockchain
NA PRÁTICA
Em segurança da informação para banco de dados, focaremos em quatro técnicas

principais que, em conjunto, garantem a segurança básica de um banco de dados.
HIERARQUIA DE PERFIS
Define a estrutura de perfis que terão acesso ao banco de dados. Perfis mais baixos,
por exemplo, devem ter acesso apenas à consulta, e os perfis mais altos devem ter
acesso total, inclusive ao monitoramento de logs e alterações de perfis e permissões.
NÍVEIS DE PERMISSÃO
Define as ações que cada perfil poderá ter. Um cliente da livraria não deve ter
permissão para alterar o estoque da livraria, apenas vendedores e gerentes. Um
usuário com um perfil de acesso incorreto pode ter acesso a dados protegidos

e informações confidenciais. Em alguns cenários bancários, por exemplo, um

desenvolvedor não pode ter acesso ao banco de dados dos clientes em produção,
pois, teoricamente, eles conhecem como consultar o saldo das contas, por exemplo.
LOGS DE ACESSO
Grava todas as ações do usuário. No caso de um erro, como uma tabela ser deletada
sem querer, podemos encontrar o usuário que cometeu a ação, não para puni-
lo, mas para identificar que o usuário está com o perfil errado ou para ajustar as
permissões daquele perfil.
Como exemplo, podemos criar um usuário com senha e restringir sua permissão
de acesso para apenas consulta (ou leitura). Então, ao tentar realizar comandos
de inserção, atualização, o comando não será considerado e nenhuma ação será
efetuada. Isso garante a restrição a uma determinada lista de pessoas sob um
determinado contexto de banco de dados.
PDF
Para ver um exemplo de como fazer uma permissão, acesse:
Arquivo: 11_permissao.pdf
AUDITORIA
A auditoria envolve o registro de logs e o recurso do SQL Server Audit permite

auditar um grupo de eventos ou eventos específicos. Esse recurso é muito utilizado
para auditar ações como DDL e DML da base de dados e pode ser criado a nível de
servidor ou de banco de dados, por exemplo.
A auditoria é baseada no registro e controle dos eventos ocorridos no banco de

dados em um log. Podemos fazer um log para cada evento monitorado ou podemos
centralizar todos os eventos monitorados em um único log, de acordo com as regras
de negócio definidas no escopo.
PDF
Para ver um exemplo de como criar uma auditoria, acesse:
Arquivo: 12_auditoria.pdf

RESTRIÇÃO DE ACESSO DE USUÁRIOS À BASE DE DADOS DE

ACORDO COM PERFIL DE AUTENTICAÇÃO
A concessão de acesso às estruturas do banco de dados pode ser controlada com

base em: Perfis, Contas e Privilégios.
1 CREATE ROLE [IF NOT EXISTS]

2 nome_do_perfil [, nome_do_perfil] ...;
Confira as instruções para criação de perfis clicando sobre cada caixa a seguir:
1. Comando para criar o perfil usuário
Vamos iniciar criando o perfil usuário com o comando a seguir:
1 CREATE ROLE usuario;
2. Sintaxe para criar conta de acesso de usuário
Uma vez que tenhamos o perfil, podemos criar a conta de usuário para vincular a
esse perfil. A sintaxe para a criação de conta de acesso está apresentada abaixo:
1 CREATE USER [IF NOT EXISTS]

2 nome_da_conta IDENTIFIED BY ’senha’
3 [, nome_da_conta IDENTIFIED BY ’senha’] ...
4 DEFAULT ROLE nome_do_perfil [, nome_do_perfil] ...;
3. Comando para adicionar a conta do usuário ao perfil
Com este comando, podemos criar a conta do usuário e adicionar ao perfil que foi
criado no comando anterior:
1 CREATE USER analista IDENTIFIED BY ’senhaBemForte’

2 DEFAULT ROLE usuario;

4. Sintaxe dos comandos que atribui autorização aos perfis
Confira a sintaxe do comando que atribui a autorização para perfis:
1 CREATE USER analista IDENTIFIED BY ’senhaBemForte’

2 DEFAULT ROLE usuario;
Neste comando, o tipo_de_privilégio representa quais declarações SQL serão

concedidas à autorização de uso. O tipo_de_recurso representa a instância de banco
de dados e quais tabelas poderão ter acesso. O nome_do_perfil é o nome dos perfis
criados que receberão o privilégio com este comando.
5. Comando para permissão de acesso para executar operação de

manipulação de dados
Para darmos permissão de acesso somente para executar as operações de manipulação

de dados nas tabelas da instância Álbum, executamos o seguinte comando:
1 GRANT SELECT, INSERT, UPDATE, DELETE ON Album.* TO usuario;
O usuário que acessar com a conta “analista” somente terá acesso à instância álbum
e poderá executar apenas os comandos SQL de manipulação de dados. Qualquer
comando para alterar uma estrutura de dados nesta instância retornará uma
mensagem de erro.

NESTE DESAFIO...
BANCO DE DADOS EM APLICATIVOS MOBILE COM JAVA |
DESAFIO 2
Neste módulo, você aprendeu como criar um banco de

dados, desde a criação da instância, passando para as tabelas,
inserindo os dados, alterando as estruturas, consultando as
informações e analisando os resultados obtidos para ajustar
estruturas e adicionar mais informações.
Também compreendeu como remover dados e estruturas e

ter atenção à integridade referencial, seja ao inserir dados,
seja ao remover estruturas e informações. Acrescentamos
critérios de segurança e agora você já pode construir o seu
banco de dados para armazenar o mais importante: seus
dados pessoais ou profissionais.

PARA CONCLUIR...
PARABÉNS, VOCÊ CONCLUIU A PRIMEIRA ETAPA DA UNIDADE
CURRICULAR DE BANCO DE DADOS EM APLICATIVOS MOBILE
COM JAVA!
Neste conteúdo, no Desafio 1, você estudou os tipos de banco de dados, o Sistema

de Gerenciamento de Banco de Dados e os tipos de dados: strings, numéricos, data;
aplicou o modelo relacional para modelagem de dados, além de instalar e configurar
seu banco de dados.
Já no Desafio 2, você estudou a codificação, na linguagem JAVA, para criar o banco de

dados e manipular as informações, aplicando regras de segurança e níveis hierárquicos.
Continue estudando e se aprimorando.
Até breve e sucesso!

REFERÊNCIAS
AGUIAR, Camila Zacché; FALBO, Ricardo de Almeida; SOUZA, Vítor E. Silva. Ontological
Representation of Relational Databases. CEUR, v. 2228, [s. d.]. Disponível em: http://
ceur-ws.org/Vol-2228/paper9.pdf. Acesso em: 15 set. 2021.
BROOKS, Chad. What is SQL? Business News Daily, 2014. Disponível em: https://
www.businessnewsdaily.com/5804-what-is-sql.html. Acesso em: 07 set. 2021.
CODD, Edgar F. A Relational Model of Data for Large Shared Data Banks.
Communications of the ACM, v. 13, n. 6, jun. 1970, p. 378-387. Disponível em:
https://www.seas.upenn.edu/~zives/03f/cis550/codd.pdf . Acesso em: 15 set. 2021.
CORE DATA. Developer Apple, [s. d.]. Disponível em: https://developer.apple.com/

documentation/coredata. Acesso em: 15 set. 2021.
ETL – O que é e qual sua importância. SAS Institute, Inc., [s. d.]. Disponível em: https://www.
sas.com/pt_br/insights/data-management/o-que-e-etl.html. Acesso em: 15 set. 2021.
HARRINGTON, Jan. L. Relational Database Design and Implementation. 4. ed.

Burlington, Massachusetts: Morgan Kaufmann, 2016.
IBM Cloud Education. Relational Databases. IBM, 2019. Disponível em: https://www.
ibm.com/cloud/learn/relational-databases . Acesso em: 15 set. 2021.
MY SQL 8.0 Reference Manual: Including MySQL NDB Cluster 8.0. MySQL, [s. d.].
Disponivel em: https://dev.mysql.com/doc/refman/8.0/en/. Acesso em: 07 set. 2021.
PETROV, Alex. Database Internals. Sebastipol, CA: O'Reilly, 2019.
ROOM – Referência da API. Developers, 2021. Disponível em: https://developer.

android.com/jetpack/androidx/releases/room. Acesso em: 15 set. 2021.
TRINH, Quang; BARKER, Ken; ALHAJJ, Reda. Semantic Interoperability Between

Relational Database Systems. In: Database Engineering and Applications Symposium,
11, 2007. Anais […]. Banff, Canadá: IDEAS, 2007. [s. p.]. Disponível em: https://www.
researchgate.net/publication/4276351_Semantic_Interoperability_Between_
Relational_Database_Systems. Acesso em: 15 set. 2021.
VAUGHAN, Jack. Data. Tech Target, 2019. Disponível em: https://searchdatamanage

ment.techtarget.com/definition/data. Acesso em: 15 set. 2021.

Créditos
CONFEDERAÇÃO NACIONAL DA INDÚSTRIA SENAI - DEPARTAMENTO REGIONAL DE SÃO
-CNI PAULO
Robson Braga de Andrade Ricardo Figueiredo Terra

Presidente Diretoria Regional
DIRETORIA DE EDUCAÇÃO E TECNOLOGIA - Cassia Regina Souza da Cruz

DIRET Gerência de Educação
Rafael Esmeraldo Lucchesi Ramacciotti Izabel Rego de Andrade

Diretor de Educação e Tecnologia Supervisora da Supervisão de Educação Online
SERVIÇO NACIONAL DE APRENDIZAGEM Claudia Baroni Savini Ferreira

INDUSTRIAL – SENAI Coordenação do Desenvolvimento do Curso
Conselho Nacional
Luiz Carlos Machi Lozano
Robson Braga de Andrade Vitoria Stefany Bessera Pinho
Presidente Wilson Jose de Santana
Elaboração de Conteúdo
SENAI - Departamento Nacional
Rafael Esmeraldo Lucchesi Ramacciotti Adilson Moreira Damasceno
Diretor-Geral Orientação de Práticas de Educação a Distância
Gustavo Leal Sales Filho Paula Cristina Bataglia Buratini

Diretor de Operações Coordenação da Produção do Curso
Neide Araujo
SENAI – DEPARTAMENTO NACIONAL Design Educacional
UNIDADE DE EDUCAÇÃO PROFISSIONAL E
TECNOLÓGICA – UNIEP Caio Marques Rodrigues
Diagramação
Felipe Esteves Morgado
Gerente Executivo Cleriston Ribeiro de Azevedo
Fabiano José de Moura
Luiz Eduardo Leão Juliana Rumi Fujishima
Gerente de Tecnologias Educacionais Ilustrações
Anna Christina Theodora Aun de Azevedo Camila Ciarini Dias

Nascimento Produção e Edição de Vídeos
Adriana Barufaldi
Bianca Starling Rosauro de Almeida Rafael Santiago Apolinário
Laise Caldeira Pedroso Programação
Coordenação Geral de Desenvolvimento dos
Recursos Didáticos Nacionais Aldo Toma Junior
Gustavo Cardoso de Carvalho
Luana Dorizo de Melo
Web Design

MATERIAL
COMPLEMENTAR
Banco de Dados em Aplicativos Mobile
Integridade de chaves
Olá! Seja bem-vindo e bem-vinda ao podcast sobre integridade de
chaves.
Para começar, vamos relembrar alguns conceitos já estudados, para

auxiliar sua compreensão.
Você se recorda do estudo sobre Modelo Relacional ou Modelo

Entidade-Relacionamento?
Lembre-se que este, é o modelo conceitual mais popular usado para
projetar um banco de dados.
O modelo Entidade-Relacionamento vê o mundo real como um
conjunto de objetos básicos - as entidades, suas características - os
atributos e associações entre esses objetos - os relacionamentos.
Os relacionamentos são identificados com base nas informações de um

contexto de informação que foi mapeado para tabelas.
Depois de identificar os relacionamentos, você estabelece uma
conexão lógica entre as tabelas em cada relacionamento com uma
chave primária ou com uma tabela de ligação.
Dentre esses Relacionamentos, esta outro conceito que são as Chaves.
Tudo bem até aqui? Então, vamos em frente!
SENAI 1
Chaves
O conceito de chave em banco de dados é importante para
implementar restrições e garantir a integridade referencial dos dados.
A chave é um atributo ou grupo de atributos cujos valores podem ser
usados para identificar exclusivamente uma entidade individual em um
conjunto de entidades.
As chaves podem ser primarias ou estrangeiras:
• Uma chave primária é uma coluna ou um conjunto de colunas em
uma tabela cujos valores identificam exclusivamente uma linha na
tabela. Um banco de dados relacional é projetado para impor a
exclusividade das chaves primárias, permitindo apenas uma linha com
um determinado valor de chave primária em uma tabela.
• Uma chave estrangeira é uma coluna ou um conjunto de colunas
em uma tabela cujos valores correspondem aos valores da chave
primária em outra tabela. Para adicionar uma linha com um
determinado valor de chave estrangeira, deve haver uma linha na
tabela relacionada com o mesmo valor de chave primária.
Agora que já relembramos esses conceitos, podemos falar sobre o

compreensão da Integridade de Chaves.
É muito importante que você saiba que o modelo relacional possui
duas regras de integridade descritas a seguir.
• Integridade de Identidade - A chave primária não pode conter
valores nulos. Como toda informação em um banco de dados
relacionam precisa ter uma identidade exclusiva, a chave primária deve
ser obrigatoriamente preenchida. Além disso, a chave primária não
deve ter valores repetidos em uma tabela, de forma a garantir que
exista apenas uma linha para cada valor definido para a chave primária.
SENAI 2
• Integridade Referencial - Se uma determinada tabela A possui uma

chave estrangeira que estabelece relacionamento com uma tabela B,
então o valor da chave estrangeira da tabela A deve ser igual a um
valor de chave primária na tabela B. Esta regra garante que as
referencias de uma tabela para outra tabela sejam válidas, de forma
que os relacionamentos sejam consistentes e não ocorra inconsistência
nos dados, como haver uma música informado ser de uma banda que
não existe. Assim, para todo valor de uma coluna que é chave
estrangeira em uma tabela, deve haver um valor correspondente na
coluna que é chave primária da tabela com a qual a chave estrangeira
faz referência. Como nem sempre o relacionamento entre tabelas é
obrigatório uma chave estrangeira pode possuir valor nulo.
• Integridade de Domínio - Restringe o conjunto de valores que

podem ser gravados em uma coluna de uma tabela. Desta forma,
somente os valores que pertencem ao domínio podem ser gravados na
coluna da tabela. Outros valores não são permitidos e a atualização é
desfeita pelo gerenciador de banco de dados. O domínio define um
conjunto de valores. Quando este domínio é associado a uma coluna
de uma tabela, somente os valores definidos para o domínio podem
ser gravados na coluna. Este tipo de restrição garante a qualidade de
dados na base de dados.
SENAI 3
É importante ressaltar que em um modelo relacional estas regras de

integridade são garantidas pelo gerenciador de banco de dados de
forma automática, sem a necessidade de se tratar estas regras no
código da aplicação.
Álgebra relacional
Outro conceito importante em um banco de dados que segue o
modelo relacional, que falamos no inicio, é o de álgebra relacional.
Consiste em um conjunto de operações utilizadas para manipular
relações.
Uma consulta em um banco de dados que segue o modelo relacional é
realizada através da aplicação de uma serie de operações da álgebra
relacional que são executadas e retornam os dados na forma de uma
tabela.
Por exemplo, uma consulta pode selecionar alguns dados de uma
relação, as músicas do estilo “Dance” e, adicionalmente, combinar está
conjunto com dados de outra relação, as músicas do estilo “Dance” e
suas respectivas bandas.
As operações da álgebra relacional são as seguintes:
• Seleção - seleciona um subconjunto de linhas de uma relação

• Projeção – apaga colunas desnecessárias de uma relação
• Produto cartesiano – permite combinar duas relações
• União - linhas na relação 1 e na relação 2
• Diferença – linhas na relação 1, mas não na relação 2
Por enquanto é isso, espero que tenha gostado.

Bons estudos e até a próxima!
SENAI 4
É importante ressaltar que em um modelo relacional estas regras de

integridade são garantidas pelo gerenciador de banco de dados de
forma automática, sem a necessidade de se tratar estas regras no
código da aplicação.
Álgebra relacional
Outro conceito importante em um banco de dados que segue o

modelo relacional, que falamos no inicio, é o de álgebra relacional.
Consiste em um conjunto de operações utilizadas para manipular
relações.
Uma consulta em um banco de dados que segue o modelo relacional é
realizada através da aplicação de uma serie de operações da álgebra
relacional que são executadas e retornam os dados na forma de uma
tabela.
Por exemplo, uma consulta pode selecionar alguns dados de uma
relação, as músicas do estilo “Dance” e, adicionalmente, combinar está
conjunto com dados de outra relação, as músicas do estilo “Dance” e
suas respectivas bandas.
As operações da álgebra relacional são as seguintes:
• Seleção - seleciona um subconjunto de linhas de uma relação

• Projeção – apaga colunas desnecessárias de uma relação
• Produto cartesiano – permite combinar duas relações
• União - linhas na relação 1 e na relação 2
• Diferença – linhas na relação 1, mas não na relação 2
Por enquanto é isso, espero que tenha gostado. Bons estudos e até a
próxima!
SENAI 5
Banco de Dados com Java
MySQL e MySQL Workbench
Instalação e configuração
Neste tutorial, você acompanhará a instalação e a configuração do

banco de dados MySQL e do sistema gerenciador de banco de dados
MySQL Workbench.
1. Acesse: https://dev.mysql.com/downloads/mysql/ e clique em

Go To Download Page para ser redirecionado para a próxima página.
SENAI 1
2. Clique na segunda opção de Download para realizar o download

completo do MySQL Community Server.
3. Clique na opção No thanks, just start my download.
SENAI 2
4. Clique duas vezes no arquivo baixado para iniciar a execução.
5. Cada opção possui recursos pré-selecionados e a versão Custom

instala todos os recursos disponíveis.
Neste tutorial, vamos optar pela versão Developer Default, que

contém o MySQL Server e o MySQL Workbench (interface gráfica).
Clique em Next para ir para a próxima etapa.
SENAI 3
6. Na próxima etapa, é necessário verificar se todos os itens

requeridos estão instalados em seu computador. Se estiver tudo OK,
clique em Next (A). Caso contrário, selecione o item pendente (B) para
realizar a instalação.
SENAI 4
7. Abra o site indicado (neste exemplo é o Python) e realize o

download do arquivo.
Após o download do arquivo, clique duas vezes para instalar a

ferramenta necessária para prosseguir com a instalação.
SENAI 5
Clique em Install Now e aguarde o término da instalação.
Clique em Close e volte ao instalador do MySQL Server.
SENAI 6
8. No instalador do MySQL Server, clique em Check (A) após a

instalação do requisito pendente para verificar se tudo está instalado
e configurado conforme esperado. Clique em Next (B) para dar
continuidade.
SENAI 7
9. Clique em Execute para finalizar o processo de instalação dos

recursos necessários.
SENAI 8
10. Aguarde até que todas as etapas sejam concluídas.
SENAI 9
11. Após o término da instalação, clique em Next para avançar à próxima

etapa.
SENAI 10
12. Clique em Next para iniciar a etapa de configuração do produto.
SENAI 11
13. Neste tutorial, vamos manter as configurações padrões de conexão

e rede.
Clique em Next para avançar para a próxima etapa.
SENAI 12
14. Nesta etapa, vamos escolher o método de autenticação. A partir da

versão 8, é recomendado escolher o tipo de criptografia melhorado (A)
disponível para instalação.
Clique em Next (B) para avançar à próxima etapa.
SENAI 13
15. O usuário padrão, chamado de root, deverá configurar uma senha

(A). Nesse exemplo, vamos adicionar a senha: root. Você poderá
escolher uma senha de seu interesse.
Clique em Next (B) para avançar para a próxima etapa.
SENAI 14
16. Nesta etapa, iremos adicionar o MySQL Server para iniciar quando
o sistema operacional for iniciado (A) e será configurado como um
serviço do Windows (B).
Clique em Next (C) para avançar à próxima etapa.
SENAI 15
17. Clique em Execute para avançar para aplicar as configurações

selecionadas nas etapas anteriores.
SENAI 16
18. Aguarde o término da instalação.
SENAI 17
19. Clique em Finish para avançar à próxima etapa.
SENAI 18
20. Clique em Next para avançar à próxima etapa.
SENAI 19
SENAI 20
SENAI 21
23. Para conferir se a conexão e o usuário foram configurados

corretamente, coloque o password (senha) criado anteriormente (em
nosso caso, root) e clique em Check para verificar se a conexão foi
bem sucedida (A).
SENAI 22
24. Clique em Execute para avançar à próxima etapa.
SENAI 23
SENAI 24
SENAI 25
SENAI 26
28. Você pode visualizar o console e a interface gráfica após a

instalação do produto.
SENAI 27
29. Agora é só fazer o login com a senha criada.
SENAI 28
Banco de Dados Mobile
Consulta de Dados
Utilizando a declaração SQL
A declaração SQL que nos permite extrair informações a partir da base de dados.
Em muitos casos, ao analisar os dados históricos, podemos identificar as
tendências que dão auxílio à tomada de decisão.
Confira a seguir a sintaxe da declaração SQL que utilizamos para consultar os
dados cadastrados:
SELECT nome_da_coluna [, nome_da_coluna] ...

FROM nome_da_tabela [, nome_da_tabela] ...;
SENAI 1
Consulta de Dados
Para listar o que foi cadastrado na tabela Banda, utilizamos a declaração SQL
indicada a seguir.
Podemos analisar o resultado da execução da declaração SQL logo abaixo de sua
declaração, nela são apresentadas todas as colunas da tabela Banda e todos os
seus conteúdos.
Note que, logo após a instrução SELECT, há um * (asterisco), esse asterisco, na
declaração SQL, indica que todas as colunas deverão ser apresentadas como
resultado da consulta.
SELECT * FROM Banda;

+---------+------------------+
| idBanda | nome |
+---------+------------------+
| 1 | Tecnimatic |
| 2 | Trapt |
| 3 | Alix Perez |
| 4 | Maduk |
| 5 | AudioSketch |
| 6 | The Ghost Inside |
+---------+------------------+
6 rows in set (0,00 sec)
SENAI 2
Se ao invés de listar todas as colunas, desejássemos listar apenas a coluna nome,
a sintaxe ficaria conforme a próxima imagem. Agora o resultado contém somente
a coluna que solicitamos na declaração SQL. A última linha representa o total de
linhas consultadas durante a execução da declaração SQL e o tempo gasto, em
segundos.
SELECT nome FROM Banda;

+------------------+
| nome |
+------------------+
| Tecnimatic |
| Trapt |
| Alix Perez |
| Maduk |
| AudioSketch |
| The Ghost Inside |
+------------------+
Sempre que efetuamos uma consulta nesse formato, todos os dados

armazenados na tabela são retornados. Mas, e se quisermos consultar se a
banda com o nome Trapt foi cadastrada? Qual seria o formato da declaração SQL
que deveríamos utilizar?
Será necessário acrescentar alguma outra informação à declaração SQL para
informar o que estamos procurando. Esta cláusula adicional é apresentada a
seguir:
[WHERE condição]
SENAI 3
A cláusula WHERE permite que sejam informadas expressões para identificar o

que estamos procurando dentro dos dados em colunas da tabela consultada.
Assim, para pesquisarmos se o nome da banda Trapt foi cadastrado na tabela
Banda, utilizamos a seguinte declaração SQL:
SELECT * FROM Banda WHERE nome = “Trapt”;

+---------+-------+
| idBanda | nome |
+---------+-------+
| 2 | Trapt |
+---------+-------+
1 row in set (0,00 sec)
Operações
As operações permitem filtrar e agrupar os dados aplicando expressões na

seleção de registros, tais como:
• OR - Utilizada em comparações condicionais do tipo “OU” entre dois
elementos;
• AND - Utilizada em comparações condicionais do tipo “E” entre dois
elementos;
• LIKE - Utilizada em comparações para verificar se um atributo “CONTÉM”
um determinado valor;
• IN - Utilizada em comparações condicionais para testar se o conteúdo de um
atributo está contido em um determinado grupo;
SENAI 4
• LIMIT - Utilizada para limitar a quantidade de registros retornados;

• ORDER BY - Utilizada para ordenar o conjunto de resultados com base nos
valores de atributos;
• GROUP BY – Utilizada para agrupar dados aplicando um determinado
atributo da consulta;
• JOIN – Utilizada no agrupamento de dados entre duas tabelas com base na
associação de atributos;
• UNION – Utilizada na junção de dois conjuntos de resultados oriundos de
consultas SQL.
Filtragem de dados
A filtragem de dados tem o objetivo de selecionar as informações que desejamos
como resultado por meio das cláusulas que indicamos em nossas consultas SQL.
Inicialmente, utilizamos a cláusula WHERE nesta consulta:
SELECT * FROM Banda WHERE nome = “Trapt”;

+---------+-------+
| idBanda | nome |
+---------+-------+
| 2 | Trapt |
+---------+-------+
SENAI 5
Se acrescentarmos o operador OR, podemos construir uma condição que nos

permitirá selecionar mais dados, como no exemplo a seguir.
Neste exemplo, é possível observar que as informações retornadas também
incluíram outro registro por termos acrescentado uma condição OR, indicando
que tanto registros com o nome Trapt quanto com o nome Maduk deveriam ser
retornados.
+---------+-------+
| idBanda | nome |
+---------+-------+
| 2 | Trapt |
| 4 | Maduk |
+---------+-------+
SENAI 6
Algumas vezes necessitamos pesquisar registros que tenham uma parte do texto
armazenada em um determinado atributo. Confira um exemplo a seguir.
SELECT * FROM Banda WHERE nome LIKE “T%”;

+---------+------------------+
| idBanda | nome |
+---------+------------------+
| 1 | Tecnimatic |
| 2 | Trapt |
+---------+------------------+
Aqui a consulta foi para procurar em todos os registros de atributos que tenham
armazenado um texto que inicia com a letra T. O símbolo % demarca o ponto no
texto em que o conteúdo é indeterminado, assim, se utilizarmos a expressão
%de% estamos procurando por textos que contenham “de” em qualquer um de
seus trechos. Acompanhe no exemplo:
SELECT * FROM Banda WHERE nome LIK

E “T%”;
+---------+------------------+
| idBanda | nome |
+---------+------------------+
| 1 | Tecnimatic |
| 2 | Trapt |
+---------+------------------+
SENAI 7
Caso necessitemos aplicar dois critérios de pesquisa que são obrigatórios estar
presentes no resultado de uma consulta, utilizamos a seguinte consulta SQL:
SELECT * FROM Banda WHERE nome LIKE “T%” AND idBand

a >= 2;
+---------+------------------+
| idBanda | nome |
+---------+------------------+
| 2 | Trapt |
+---------+------------------+
Na consulta anterior, o operador AND permitiu combinar duas expressões:

pesquisar o atributo nome com textos iniciando com a letra T e pesquisar o
atributo identificador do registro contendo o valor maior ou igual a 2.
Todos os registros que atenderam aos dois critérios foram listados.
SENAI 8
Uma outra forma de selecionar registros é utilizarmos o operador IN, que

permite oferecer uma lista de valores para o teste, a fim de selecionar registros
como resultados de uma consulta SQL.
A lista de valores aceita todos os tipos de dados válidos na linguagem SQL, como
você poderá observar nos exemplos a seguir.
SELECT * FROM Banda WHERE nome

IN (“Trapt”, “AudioSketch”, “Alix Perez”);
+---------+-------------+
| idBanda | nome |
+---------+-------------+
| 2 | Trapt |
| 3 | Alix Perez |
| 5 | AudioSketch |
+---------+-------------+
Neste primeiro exemplo, foi passada a lista de nomes das bandas Trapt,
AudioSketch e Alix Perez para a consulta SQL através do operador IN, que
comparou cada valor contido no atributo nome com os valores da lista.
O registro foi selecionado toda vez em que o valor contido no atributo combinou
com qualquer elemento da lista.
SENAI 9
Já neste segundo exemplo, foi passada a lista de números 2, 4, 6 e 8 para a

consulta SQL no operador IN, que comparou cada valor contido no atributo
identificador de registro com os valores da lista.
Todo registro cujo atributo identificador é idêntico a qualquer elemento da lista
foi selecionado para ser exibido na lista de resultado.
SELECT * FROM Banda LIMIT 3;

+---------+------------+
| idBanda | nome |
+---------+------------+
| 1 | Tecnimatic |
| 2 | Trapt |
| 3 | Alix Perez |
+---------+------------+
SENAI 10
A cláusula LIMIT permite limitar a quantidade de registros retornados como no

exemplo a seguir:
SELECT * FROM Banda LIMIT 3;

+---------+------------+
| idBanda | nome |
+---------+------------+
| 1 | Tecnimatic |
| 2 | Trapt |
| 3 | Alix Perez |
+---------+------------+
O limite é imposto ao resultado, restringindo a quantidade de registros

retornados até a quantidade que foi informada na cláusula LIMIT.
SENAI 11
Todos os resultados apresentados até agora nos exemplos expõem os dados na

ordem na qual os registros foram inseridos na tabela.
A ordenação do resultado pode ser modificada ao acrescentarmos a cláusula
ORDER BY, essa cláusula aceita o nome de um atributo que será utilizado para a
ordenação. Confira no exemplo a seguir:
SELECT * FROM Banda ORDER BY nome;

+---------+------------------+
| idBanda | nome |
+---------+------------------+
| 3 | Alix Perez |
| 5 | AudioSketch |
| 4 | Maduk |
| 1 | Tecnimatic |
| 2 | Trapt |
+---------+------------------+
SENAI 12
O resultado foi ordenado com base nos valores contidos na coluna “nome”, em
ordem crescente.
Caso necessitemos que o resultado seja ordenado na ordem decrescente,
deveremos acrescentar o operador DESC.
Esse operador informa ao gerenciador de banco de dados que utilize a
ordenação decrescente no conjunto de resultado.
Assim, ao modificarmos a consulta SQL anterior, obtemos o resultado observado
a seguir.
Observe que o resultado foi apresentado em ordem decrescente.
SELECT * FROM Banda ORDER BY nome DESC;

+---------+------------------+
| idBanda | nome |
+---------+------------------+
| 2 | Trapt |
| 1 | Tecnimatic |
| 4 | Maduk |
| 5 | AudioSketch |
| 3 | Alix Perez |
+---------+------------------+
SENAI 13
Agrupamento de dados
Algumas vezes necessitamos contar a quantidade de informações cadastradas
para um determinado tipo de dado no nosso banco de dados. Isso é possível
utilizando a função COUNT e informando sobre qual atributo da tabela
desejamos a contabilização.
Sempre que desejamos contar quantos registros existem em uma tabela,
utilizamos a consulta SQL indicada a seguir:
SELECT COUNT(*) FROM Banda;

+----------+
| count(*) |
+----------+
| 6 |
+----------+
Importante
Observe que a quantidade de registros é informada no

formato de uma tabela, porém o nome da coluna é igual ao
nome da expressão utilizada na função indicada para a
consulta SQL.
SENAI 14
Para produzirmos um resultado em que o nome da coluna tenha um significado

mais claro e diferente, utilizamos o operador AS, ele substituirá o título da coluna
no resultado final.
Observe a mudança:
SELECT COUNT(*) AS Quantidade FROM Banda;

+------------+
| Quantidade |
+------------+
| 6 |
+------------+
Se o título que desejarmos informar contiver espaços ou caracteres especiais,

tais como acentuação ou cedilha, deveremos envolver o texto do título com
aspas simples, como ilustrado a seguir:
SELECT COUNT(*) AS ‘Quantidade de

Registros’ FROM Banda;
+-------------------------+
| Quantidade de Registros |
+-------------------------+
| 6 |
+-------------------------+
SENAI 15
Ao utilizarmos a função COUNT em conjunto com a cláusula GROUP BY aplicando

uma expressão, podemos produzir resultados mais completos.
Confira, no exemplo seguinte, como é utilizada essa funcionalidade:
SELECT COUNT(*) AS ‘Qtd Músicas’ FROM Musica GROUP BY idBanda;

+--------------+
| Qtd Músicas |
+--------------+
| 1 |
| 1 |
| 2 |
| 1 |
| 4 |
+--------------+
SENAI 16
Nesta consulta SQL, que contabilizaram-se quantas músicas foram cadastradas

para cada banda musical. Foi utilizada a chave estrangeira que a tabela Música
contém para identificar à qual banda uma música pertence.
Para acrescentarmos mais informação a este resultado, é interessante que o
nome da banda também apareça, correspondente a cada registro retornado.
Isso é possível se fizermos uso da cláusula JOIN, que permite associar os registros
correspondentes entre tabelas que representam associações dos tipos um para
um, um para muitos e muitos para muitos.
Como exemplo inicial, vamos acrescentar o nome das bandas ao resultado da
consulta SQL que vimos anteriormente. Confira:
SELECT Banda.nome AS ‘Nome da Banda’,

COUNT(*) AS ‘Qtd Músicas’
FROM Musica
JOIN Banda ON Musica.idBanda = Banda.idBanda
GROUP BY Musica.idBanda;
+------------------+--------------+
| Nome da Banda | Qtd Músicas |
+------------------+--------------+
| Tecnimatic | 1 |
| Trapt | 1 |
| Alix Perez | 2 |
| AudioSketch | 1 |
| The Ghost Inside | 4 |
+------------------+--------------+
SENAI 17
É possível notar que, ao construir uma consulta SQL com junção de uma ou mais
tabelas, passa a ser necessário qualificar cada atributo referenciado, seja na
definição das colunas para o resultado, seja nas expressões passadas como
argumentos nas funções ou cláusulas SQL utilizadas.
O qualificador é o nome da tabela seguido de um ponto “.”, que serve para
identificar cada parte, podendo ser o nome da tabela ou o nome do atributo.
Outro fato que podemos notar é que o resultado SQL fica mais informativo
quando o nome da banda aparece à frente da quantidade de músicas.
Se desejarmos ordenar o nome das bandas, a consulta SQL ficará assim:
SELECT Banda.nome AS ‘Nome da Banda’,

COUNT(*) AS ‘Qtd Músicas’
FROM Musica
JOIN Banda ON Musica.idBanda = Banda.idBanda
GROUP BY Musica.idBanda
ORDER BY Banda.nome;
+------------------+--------------+
| Nome da Banda | Qtd Músicas |
+------------------+--------------+
| Alix Perez | 2 |
| AudioSketch | 1 |
| Tecnimatic | 1 |
| The Ghost Inside | 4 |
| Trapt | 1 |
+------------------+--------------+
SENAI 18
A cláusula ORDER BY sempre ficará ao final da declaração SQL, após o

processamento de todas as etapas necessárias para a produção do resultado
final.
A cláusula JOIN, que aparece nas duas consultas SQL anteriores, permite definir
quais associações desejamos seguir para construir a lista de colunas.
A junção funciona conforme as regras de conjuntos.
Observe as ilustrações a seguir:
SENAI 19
O LEFT JOIN permite definir junções que extraem as informações de duas

tabelas, dando prioridade para a tabela à esquerda da junção. Assim, caso não
existam valores correspondentes aos registros na tabela à direita da associação,
as colunas apresentarão valores nulos.
Um exemplo desse tipo de junção pode ser visualizado a seguir:
SELECT a.nome AS ‘Álbum’, m.nome AS ‘Música’

FROM Album AS a
LEFT JOIN Musicas_do_Album AS ma
ON a.idAlbum = ma.idAlbum
LEFT JOIN Musica AS m
ON ma.idBanda = m.idBanda
AND ma.idMusica = m.idMusica;
+--------------------+-------------------+
| Álbum | Música |
+--------------------+-------------------+
| Empty Words | Burning Babylon |
| Empty Words | Empty Words |
| Simplicity | Devotion |
| Rise from the Ashe | Avalanche |
| Rise from the Ashe | Between the Lines |
| Rise from the Ashe | Dear Youth |
| Rise from the Ashe | Greater Distance |
| Stay Like This | NULL |
| Walk to you | Everlasting |
| Above it All | Above it All |
+--------------------+-------------------+
SENAI 20
Dica!
Como a associação entre álbuns e músicas é uma relação
muitos para muitos, temos uma tabela associativa para a
manutenção desses relacionamentos. Dessa forma, para
acessarmos as músicas a partir de um álbum, necessitamos
utilizar duas junções, uma entre a tabela Álbum e a tabela
Musicas_do_album e outra da tabela Musicas_do_Album e
a tabela Música.
Saiba mais
Para reduzir o tamanho da expressão SQL, também foi

utilizado o operador AS para criar um nome alternativo, a
fim de referenciar todos os atributos nas expressões
utilizadas na consulta SQL.
SENAI 21
Por fim, a utilização do LEFT JOIN causou o aparecimento de NULL para o álbum
”Stay Like This” por não ter músicas cadastradas na tabela Música e,
consequentemente, não existir o registro de relacionamento na tabela
associativa Musicas_do_Album.
Ao utilizar o INNER JOIN ou somente JOIN nesta consulta SQL, somente
aparecerão no resultado final os registros constantes nos relacionamentos em
ambas as tabelas.
Confira a seguir como fica a consulta SQL e seu resultado.
Note que neste exemplo não foi apresentado qualquer valor NULL no resultado.

FROM Album AS a
INNER JOIN Musicas_do_Album AS ma
ON a.idAlbum = ma.idAlbum
INNER JOIN Musica AS m
AND ma.idMusica = m.idMusica;
+--------------------+-------------------+
+--------------------+-------------------+
+--------------------+-------------------+
SENAI 22
Para apresentar o efeito do RIGHT JOIN, vamos construir uma consulta SQL que
inicie a relação pela tabela Música, ao invés de, tal como nos exemplos
anteriores, iniciar a consulta pela tabela Álbum.
Isso permite colocarmos a tabela Álbum ao lado direito da relação, e como
existem álbuns sem músicas cadastradas, poderemos comprovar o correto
funcionamento da consulta SQL. Confira a seguir:

FROM Musica AS m
RIGHT JOIN Musicas_do_Album AS ma
AND ma.idMusica = m.idMusica
RIGHT JOIN Album AS a
ON ma.idAlbum = a.idAlbum;
+--------------------+-------------------+
+--------------------+-------------------+
| Stay Like This | NULL |
+--------------------+-------------------+
SENAI 23
No exemplo anterior, observe como foram construídas as relações nos RIGHT

JOIN, iniciando entre a tabela Música e a tabela associativa Musicas_do_Album
e, em seguida, entre a tabela associativa Musicas_do_Album e a tabela Álbum.
O fato de estarmos utilizado RIGHT JOIN causa o aparecimento do valor NULL, da
mesma forma como na utilização do LEFT JOIN, por faltar registros relacionados
com um álbum já cadastrado.
A cláusula UNION requer que o resultado das consultas SQL que participam da
união tenha o mesmo número de colunas, caso isso não ocorra, será emitida
uma mensagem de erro.
Para exemplificar o resultado que a cláusula UNION oferece, vamos apresentar o
resultado de duas consultas SQL isoladas para posteriormente unir esses
resultados com a utilização desta cláusula.
1. Esta consulta SQL, pesquisa por bandas musicais cujo estilo seja “Rock”.
SELECT a.nome AS ‘Álbum’, b.nome AS Banda FRO

M Album AS a
JOIN Banda AS b ON a.idBanda = b.idBanda
JOIN Estilo AS e ON a.idEstilo = e.idEstilo
WHERE e.nome = “Rock”;
+--------------------+------------------+
| Álbum | Banda |
+--------------------+------------------+
| Rise from the Ashe | The Ghost Inside |
| Stay Like This | Maduk |
| Above it All | Trapt |
+--------------------+------------------+
SENAI 24
2. Esta consulta SQL pesquisa por bandas musicais que tenha seu nome iniciado
pela letra “T” e cujo estilo musical seja diferente de “Rock”.
SELECT a.nome AS ‘Álbum’, b.nome AS Banda FROM

Album AS a
WHERE b.nome LIKE “T%” AND e.nome != “Rock”;
+-------------+------------+
| Álbum | Banda |
+-------------+------------+
| Walk to you | Tecnimatic |
+-------------+------------+
SENAI 25
Podemos notar que essas duas consultas SQL retornam o mesmo número de
colunas e têm a característica de serem unidas pela cláusula UNION.
Na sequência, temos o exemplo de como fica a consulta SQL após a união:
SELECT a.nome AS ‘Álbum’, b.nome AS Banda FROM A

lbum AS a
WHERE e.nome = “Rock”
UNION
SELECT a.nome AS ‘Álbum’, b.nome AS Banda FROM A
lbum AS a
WHERE b.nome LIKE “T%” AND e.nome != “Rock”;
+--------------------+------------------+
| Álbum | Banda |
+--------------------+------------------+
| Rise from the Ashe | The Ghost Inside |
| Stay Like This | Maduk |
| Above it All | Trapt |
| Walk to you | Tecnimatic |
+--------------------+------------------+
SENAI 26
Codificação Back-End
Chave assimétrica
A criptografia assimétrica é baseada em duas chaves: a chave privada e

a chave pública. Imagine que você deseja transmitir um arquivo em
uma rede e quer garantir que apenas o destinatário possa ler seu
conteúdo. Para isso, você pode fazer uso da chave pública desse
destinatário para cifrar o documento, criptografando-o. Somente com
a chave privada (que fica em posse do destinatário) será possível
decifrar o texto. Observe a imagem a seguir que ilustra essa situação:
Fonte: SENAI-SP
Codificação Back-End | SENAI 1

Codificação Back-End
A geração dessas chaves se dá a partir de números aleatórios,

normalmente, números primos. Podemos resumir esse processo
conforme o exemplo a seguir, simulando o algoritmo RSA, um dos mais
utilizados:
Escolha dois números primos distintos, p e q;
Calcule n: n = p ∙ q.
Calcule z: z = (p − 1) ∙ (q − 1).
Obtenha um número 𝑒𝑒 (sendo 𝑒𝑒 um número primo qualquer, logo,
escolha um número).
Calcule: e ∙ d (mod z) = 1.
O par (e, n) é a chave pública, ao passo que o par (d, n) é a chave
privada.
Acompanhe um exemplo prático:

Suponha dois números primos: p = 29 e q = 37.
Resolvendo:
Adotando e = 71, temos:
Então, agora, podemos montar o par de chaves:

Chave pública: (e, n) = (71, 1073)
Chave privada: (d, n) = (1079, 1073)
Codificação Back-End | SENAI 2

Banco de dados
Criando uma permissão
Para criar uma permissão, vamos criar um login e uma senha para um
aluno, que precisa de acesso ao banco de dados da livraria para
encontrar um livro de estudo. Devemos garantir, porém, que ele só
possa consultar o banco de dados, sem modificá-lo.
CREATE LOGIN aluno

WITH PASSWORD = '1234'
CREATE USER aluno FOR LOGIN aluno
GRANT SELECT TO aluno
Na primeira linha, o create login aluno é o identificador utilizado para

se conectar com o SQL Server, ou seja, cria um login com o qual o
usuário será reconhecido no sistema.
O CREATE USER aluno cria um usuário no banco de dados, ele é
identificado pelo login que é utilizado para realizar a conexão, ou seja,
liga o usuário ao login.
O GRANT SELECT TO aluno permite restringir o acesso somente de
leitura ao usuário identificado. No caso, o aluno, ao tentar realizar
outra ação além de seleção, não será permitido.
SENAI 1
Banco de dados
Veja na imagem a seguir o mesmo código no SSMS. Note que na janela

inferior há uma mensagem de comandos concluídos com êxito.
Agora vamos acompanhar o user aluno em uma consulta ao banco de

dados.
a) Login no banco de dados com senha.
SENAI 2
Banco de dados
b) O user aluno faz uma consulta no banco de dados, selecionando

todas as colunas da tabela Autores.
SELECT * FROM Autores
Note, na janela inferior, que o sistema retornou Id = 1, Nome = Autor

João da Silva, Id = 2, Nome = Novo Autor.
c) Agora o user aluno tenta inserir dados na tabela Autores, usando:
INSERT INTO Autores

VALUES (‘Novo Autor A’)
SENAI 3
Banco de dados
Na janela inferior, aparece uma mensagem de erro “A permissão

INSERT foi negada no objeto ‘Autores’, banco de dados EditiveBD...”,
mostrando que o user aluno pode visualizar os dados das tabelas, mas
não pode realizar outras operações.
SENAI 4
Banco de dados
Auditoria
1. Para criar uma auditoria, abra o SSMS e, no menu lateral esquerdo,

clique e abra a opção Segurança e clique em Auditorias → Nova
Auditoria.
SENAI 1
Banco de dados
2. Na janela seguinte, crie a auditoria com as seguintes configurações.

O nome da auditoria do exemplo remete à data e hora. Defina o atraso
de fila em 1000 milissegundos. Para caso de falha do log de auditoria,
marque 'Continuar'. Configure o destino da auditoria como 'File' e o
caminho como 'C:\AuditoriaExemplo'. Em Limite Máximo do Arquivo
de Auditoria, marque a opção 'Máximo de arquivos de substituição' e
'ilimitado'. Em Tamanho máximo de arquivo, marque 100 MB. Clique
em OK.
Nesse cenário, vamos armazenar em um arquivo físico em uma pasta

criada no C:\ com no máximo 100mb de tamanho.
SENAI 2
Banco de dados
3. Após a criação da auditoria, você deverá habilitá-la. Então, retorne

ao menu lateral esquerdo, siga o caminho
Segurança/Auditorias/Auditoria recém-criada e clique na opção
“Habilitar Auditoria”.
3. A janela seguinte mostra uma mensagem de êxito. Clique em

‘Fechar’.
SENAI 3
Banco de dados
4. Vamos criar uma auditoria a nível de banco de dados para registrar

toda vez que o logon aluno realizar uma consulta de select no banco
de dados de nosso exemplo: EditiveDB.
No menu lateral esquerdo, clique e abra a opção Bancos de Dados,
depois abra a opção EditiveBD, depois Segurança, então Especificações
de Auditoria de Banco de Dados e selecione a opção Especificação de
Auditoria de Novo Banco de Dados.
SENAI 4
Banco de dados
5. Siga as configurações. No exemplo, em nome, deixe

DatabaseAuditSpecification, com data e hora. Em Auditar, coloque a
auditoria recém-criada. Na janela Ações, na primeira coluna (Tipo de
ação de auditoria), marque SELECT. Em Classe de Objeto, marque
OBJECT. Em Esquema de Objeto, defina como dbo. Em nome de
objeto, configure como Livros e, em nome da entidade, escreva aluno.
Clique em OK.
SENAI 5
Banco de dados
6. Para habilitar a auditoria após a criação, retorne ao menu lateral

esquerdo, siga o caminho Bancos de Dados → EditiveBD → Segurança
→ Especificações de Auditoria de Banco de Dados → Auditoria recém-
criada e selecione a opção Habilitar Especificação de Auditoria de
Banco de Dados.
SENAI 6
Banco de dados
7. A janela seguinte mostra uma mensagem de êxito. Clique em

‘Fechar’.
SENAI 7
Banco de dados
8. Para visualizar os logs da Auditoria, expanda novamente no menu

lateral esquerdo a sessão de Segurança → Auditoria e clique com o
botão direito para abrir os logs da auditoria.
SENAI 8
Banco de dados
9. Você pode visualizar todas as vezes que o aluno realizou as

operações de SELECT na tabela livros.
SENAI 9
Banco de dados
10. Você pode executar novamente a instrução SELECT com o logon

aluno para visualizar o log sendo atualizado.
SENAI 10
Banco de dados
11. Você pode visualizar que após o select ser realizado na tabela de
autores, não auditado, o log não será atualizado.
Saiba mais
Para saber mais sobre auditorias, acesse
https://docs.microsoft.com/pt-br/sql/relational-
databases/security/auditing/sql-server-audit-database-
engine?view=sql-server-ver15.
SENAI 11
BANCO DE DADOS EM
APLICATIVOS MOBILE
JAVA - SA2
PARA COMEÇAR
Este material aborda conceitos relacionados ao Banco de Dados em aplicativos
Mobile Java.
Esperamos que você desenvolva, no decorrer de seus estudos, as seguintes

capacidades:
• Implementar os requisitos do projeto utilizando a linguagem de programação.

• Identificar as características da linguagem Java.
• Reconhecer os tipos, características e funcionalidades dos recursos da
linguagem Java empregados na programação.
• Realizar a programação de classes e objetos.
• Reconhecer tipos primitivos da linguagem Java.
• Aplicar técnicas de modelagem de dados.
• Realizar a programação da estrutura funcional da aplicação.
• Documentar o código, em tempo de programação, para permitir a evolução
da aplicação.
• Implementar uma rotina de comandos de programação de conectividade
com Banco de Dados.
• Implementar os requisitos do projeto, utilizando linguagem de definição e
manipulação de bancos de dados.
• Aplicar procedimentos de normalização de dados, tendo em vista sua formatação.
• Aplicar procedimentos de coleta, armazenamento e consulta de dados,
tendo em vista sua padronização.
• Aplicar linguagem de definição e manipulação de dados em aplicações mobile.
Para desenvolver tais capacidades, você deverá estudar os seguintes temas:
• Linguagem de programação Java;

• Criação de classes;
• Conexão com o banco de dados.
O estudo de tais temas será necessário para que você resolva a situação-problema
a seguir.

SITUAÇÃO-PROBLEMA
Você modelou e criou o projeto de banco de dados para o aplicativo de compras
de produtos alimentícios da empresa Coma bem, aplicando procedimentos de
normalização e padronização, além de regras de segurança. Agora, chegou a hora
de iniciar a construção da aplicação das rotinas para o acesso ao banco de dados.
Como responsável por este desenvolvimento, você deverá solucionar dois desafios.
DESAFIO 1
Modelar as classes de objetos para a aplicação de compras de produtos alimentícios,
utilizando a linguagem Java.
DESAFIO 2
Implementar as rotinas de conectividade ao banco de dados, além de documentar
o código.

DESAFIO 1
• Modelar as classes de objetos para a aplicação de compras de produtos

alimentícios, utilizando a linguagem Java.
• Linguagem de Programação Java

• Histórico
• Tipos primitivos
• Operadores
• Controle de fluxo
• Funções e métodos
• Parâmetros
• Bibliotecas e APIs
• Classes Java

LINGUAGEM DE PROGRAMAÇÃO JAVA

A linguagem de programação Java é considerada
simples, limpa e muito segura, por ser nativamente
orientada a objetos. Além disso, é:
• compilada1;
• interpretada2;
• portável3;
• com tipagem forte4;
• oferece suporte à programação concorrente5 e
de sistemas distribuídos6.
Além de ser uma linguagem de programação, o Java também é uma plataforma de

desenvolvimento. Isso quer dizer que ele possui elementos e funcionalidades que
proporcionam a execução de softwares e aplicativos.
Para executar um programa em seu computador, é necessário ter um sistema

operacional (Windows, OSX, Linux ou Solaris) compatível. Os sistemas operacionais
possuem arquiteturas diferentes e são incompatíveis uns com os outros. No
caso da plataforma Java, porém, esse problema é resolvido utilizando-se uma
JVM (Java Virtual Machine), como veremos mais adiante.
HISTÓRICO
Desenvolvida por James Gosling, a linguagem de programação Java teve como base
a linguagem C++, que, por sua vez, evoluiu da C.
1 Gera um código em linguagem de máquina.
2 Executa o código em tempo de execução.
3 Executado em diferentes arquiteturas, independentemente de plataforma.
4 A conversão de tipos não é automática.
5 Paradigma de programação que foca na interação de várias tarefas simultâneas.
6 Conjunto de dispositivos autônomos, unidos por uma rede de comunicação, que trabalham juntos para
realizar uma tarefa. Um sistema distribuído é percebido pelo usuário como um único dispositivo.

Conheça um resumo da evolução do Java ao longo dos anos.
• 1992: O Java foi batizado de Oak, porém já existia uma outra linguagem
de programação com o mesmo nome. A equipe da Sun, empresa detentora
do Java na época, renomeou o Oak para Java em homenagem ao café que
costumavam tomar.
• 1995: O Netscape, navegador mais utilizado na época, implementou a
tecnologia Java e lançou uma nova versão com suporte à execução de pequenos
aplicativos escritos em Java, denominados applets. Nesse mesmo ano, outros
navegadores também disponibilizaram versões com suporte ao Java.
• 1996: Surpreendentemente, a Sun disponibilizou, sem custos, um kit de
ferramentas para desenvolvimento de software, chamado JDK (Java Developer’s
Kit). Disponível para os sistemas operacionais Solaris, Windows 95 e Windows NT
e, em seguida, para Linux, OS2 e OSX (Macintosh), o kit alavancou o crescimento
e a utilização do Java entre as empresas desenvolvedoras de software.
• 1997: Surgiu o SDK 1.1, que possuía foco em aplicações distribuídas e
desenvolvimento de interface gráfica.
• 1999: O JDK 1.2 foi lançado com outras inovações importantes. Depois
disso, a empresa continuou liberando gratuitamente novas versões de sua
tecnologia e retomou os investimentos no projeto original de programação para
pequenos dispositivos eletrônicos.
PLATAFORMA JAVA
Como já estudado, o Java é uma linguagem de programação e também uma plataforma
de desenvolvimento, com conjuntos diferentes de ferramentas e utilitários.
Conheça esses conjuntos.
• JVM – Java Virtual Machine: possibilita rodar aplicações Java em qualquer

sistema operacional. Está incluso tanto no JRE quanto no JDK e não pode ser
instalado sozinho.
• JRE – Java Runtime Environment: ambiente de execução, com apenas o
que é necessário para rodar programas já existentes, como bibliotecas e o JVM.
• JDK – Java Development Kit: ambiente de desenvolvimento Java, com
tudo que é necessário para desenvolver novos programas, como o JVM,
depurador, compilador e documentação.
O conjunto mais adequado de ferramentas depende da situação. Se você necessita
apenas rodar um programa em uma máquina sem Java (de um cliente, por exemplo),

será necessário apenas instalar o JRE. Se você vai desenvolver um programa, então
será necessário instalar o JDK.
DICA
Os sistemas operacionais Windows, Linux e Solaris já contêm um
ambiente de execução para aplicativos Java. Portanto, antes de realizar
a instalação do JRE, verifique se isso é realmente necessário.
TÉCNICAS DE PROGRAMAÇÃO
Nesse tópico, abordaremos alguns conceitos
importantes comuns a todas as linguagens de
programação, também aplicadas à linguagem
Java, como variáveis, dados e seus tipos,
além de algumas técnicas de programação,
como operadores e controle de fluxo.
VARIÁVEIS
Podemos definir variável como local reservado na memória para armazenamento

de dados. Uma variável deve possuir um nome, que funciona como um
identificador e também um tipo de dado.
O principal objetivo de uma variável é armazenar um tipo de dado para que possa
ser acessado posteriormente.
Ao declarar uma variável, o programa reserva um espaço na memória para que

algum dado seja armazenado. O tamanho do espaço reservado depende do tipo
da variável que foi declarada; portanto, deve-se atentar ao tipo do dado, para que
o armazenamento seja o mais otimizado possível.

Você pode declarar uma variável em Java com a sintaxe:
tipoDeDado nomeVariavel;
Veja no exemplo a seguir.
1. int xpto; // declaração de uma variável chamada ‘xpto’

2. /*como o valor não foi declarado, por padrão é zero.
3. Veremos os tipos de dados a seguir, siga adiante.
4. */
TIPOS DE DADOS
Há diversas maneiras de classificar as variáveis. Nesse tópico, vamos conhecer um
pouco melhor os tipos primitivos.
Os tipos primitivos são dados pré-definidos, comuns em várias linguagens de

programação. Assim como ocorre com as linguagens de programação tradicionais,
são palavras reservadas pela sintaxe do Java. As palavras reservadas7 para os tipos
primitivos são: byte, short, int, long, float, double, char, String8 e boolean.
Caso o valor do tipo primitivo não seja declarado, há um valor padrão inicial para
cada um deles, como mostra a tabela a seguir.
Tipo primitivo Valor padrão

byte 0
short 0
int 0
long OL
7 Palavras que são usadas exclusivamente para tipificar dados, não podendo ser usadas para nomenclatura
de variáveis ou funções.
8 O “S” de String é maiúsculo, pois uma String representa uma classe de caracteres.

Tipo primitivo Valor padrão

float 0.0f
double 0.0d
char ‘\u0000’
String (ou qualquer objeto) null
boolean false
Fonte: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
A seguir, vamos conhecer um pouco mais sobre dois subtipos numéricos dos tipos
primitivos: os inteiros (byte, short, int e long) e os de ponto flutuante (float e double).
INTEIROS
Assim como na matemática, os valores inteiros podem ser positivos ou negativos,

porém não possuem casas decimais. Na linguagem de programação Java, utilizam-
se os valores do tipo inteiro da seguinte forma:
Tipo Tamanho Mínimo Máximo

byte 1 byte -128 127
short 2 bytes -32768 322767
int 4 bytes -2147483648 2147483647
long 8 bytes -9223372036854775808 9223372036845775807
Veja um exemplo de código a seguir. Na primeira parte, o código; na segunda parte,

a compilação do código de exemplo na janela console do IntelliJ9 (ferramenta que
conheceremos melhor mais adiante).
1. package sp.senai;
2.
9 Ferramenta de desenvolvimento.

3. public class Main {

4.
5. public static void main(String[] args) {
6. int decimal = 10;
7.
8. //declara a variável do tipo int com valor igual a 10
9. System.out.println(decimal);
10.
11. //mostra o valor da variável int
12. long inteiroLongo = 10L;
13.
14. //declara a variável do tipo long com valor igual a 10
15. //o L simboliza que o valor é de uma variável do tipo
long
16. System.out.println(inteiroLongo);
17.
18. //mostra o valor da variável long
19. }
20. }
PONTO FLUTUANTE
Os números de ponto flutuante são valores positivos ou negativos, porém possuem

casas decimais. Na linguagem de programação Java, utiliza-se o ponto flutuante das
seguintes maneiras:
Tipo Tamanho Mínimo Máximo Precisão
float 4 byte -3,4028E+38 3,4028E+38 6-7 dígitos
double 8 bytes -7,7976E+308 7,7976E+308 15 dígitos
Veja um exemplo de código a seguir:

CONTROLE DE FLUXO
Para controlar e alterar o fluxo da sua aplicação baseada em uma condição ou um
conjunto delas, você pode usar técnicas como a estrutura de decisão e de repetição,
com o auxílio de operadores.
PDF
Para conhecer as estruturas de decisão, repetição e os operadores, acesse o material.
Arquivo: PDF01_OperadoresDecisaoRepeticao.pdf
FUNÇÕES E MÉTODOS
Com o aumento da complexidade dos softwares em desenvolvimento, surge a
necessidade de simplificar sua construção por meio de pequenos módulos. Métodos
(funções ou procedimentos1⁰) ajudam a modularizar sua aplicação, encapsulando
as tarefas sob uma estrutura única.
10 Funções possuem retorno; procedimentos, não. Em POO, ambos são chamados de métodos (com ou
sem retorno) e representam o comportamento de uma classe.

Ao modularizar a sua aplicação em funções

menores e mais simples, reaproveitamos
partes do código e instruções já
desenvolvidas. Blocos de instrução muito
grandes tornam o entendimento e a
manutenção mais difíceis.
Fonte: Pixabay
Não há necessidade de entender o funcionamento total de um procedimento,

método ou função ao utilizá-los. Na verdade, é necessário entender apenas se há
parâmetros necessários para seu funcionamento, quais são eles ou se há retorno e
de qual tipo, escondendo, assim, os detalhes da implementação – o que é uma boa
prática no desenvolvimento de sistemas.
As funções possuem um nome e podem – ou não – possuir parâmetros de entrada.

Podem também conter um retorno ou apenas executar alguma instrução.
A forma para escrever uma função é:

visibilidade tipo_de_retorno_da_função nome_da_função (parâmetros) {
instruções a serem executadas ou conhecidas como assinatura do método
Veja um exemplo a seguir:

package sp.senai;
public class Main {
public static void SomarNumeros() {

int primeiroNumero = 10;
int segundoNumero = 20;
System.out.println(primeiroNumero + segundoNumero);
}
public static void main(String[] args) {

somarNumeros();
}

Veja outro exemplo:

2.
4.
5. public static int calcSomaComRet() {
6. int primeiroNumero = 10;
7. int segundoNumero = 20;
8. return primeiroNumero + segundoNumero;
9. }
10.
12. System.out.println(calcSomaComRet());
13. }
14. }
No primeiro exemplo, o void significa que o método não tem retorno, ou seja, só
realiza o que foi pedido (no exemplo, soma os números passados como parâmetros).

O resultado só é mostrado no console do programa devido ao comando System.

out.println(primeiroNumero + segundoNumero);.
No segundo exemplo, o método retorna um static int, conforme o comando return

primeiroNumero + segundoNumero;. Note que há um retorno, mas é necessário
pedir para mostrá-lo, como no comando System.out.println(calcSomaComRet());.
PARÂMETROS
Como já dito, as funções podem receber parâmetros de entrada, ou seja, a entrada de
dados para a execução da instrução. A função poderá ou não retornar um resultado
a partir do valor passado. Confira no exemplo a seguir.
2.
4.
5. public static int calcularSomaComRetornoEParametro(int
primeiroNumero, int segundoNumero) {
6. return primeiroNumero + segundoNumero;
7. }
8.
10. System.out.println(calcularSomaComRetornoEParametro(10,
20));
11. }
12. }

CLASSES
A POO (Programação Orientada a Objetos) surgiu como uma representação do
mundo real para o desenvolvimento de software e se orienta em classes e objetos. A
linguagem Java segue o paradigma de Orientação a Objetos e, portanto, é baseada
em classes e objetos.
Uma classe pode ser definida como um modelo ou a forma para a criação de um
objeto. Uma única classe pode dar origem a vários objetos. Para construir os objetos,
definimos quais serão as características (atributos) e seus métodos. Um método é
uma função e faz parte de uma classe, representando seu comportamento.
Modelagem de classes e objetos é o diagrama (representação gráfica) do seu sistema.

A modelagem deve ser visualmente inteligível e será a base para a implementação
(codificação) do sistema.
O diagrama a seguir traz um exemplo de modelagem.
Note que, na representação da classe Carro, existem dois objetos: CarroDaCris

e CarroDaClaudia, criados a partir do modelo definido (entre propriedades e
métodos). Ao criar um objeto a partir de uma classe, pode-se dizer que a classe foi
instanciada e que esse objeto é uma instância da classe referida.
Carro CarroDaCris = new Carro();

IMPORTANTE!
A maneira para obter maior produtividade em Programação Orientada
a Objetos é tornar cada objeto responsável por realizar um grupo
!
de tarefas, que podem estar relacionadas. Na situação de um objeto
que tenha dependência de uma tarefa/atividade pela qual não seja
o responsável, deve-se acessar o objeto responsável por essa tarefa/
atividade por meio de troca de mensagens para solucionar esse
problema complexo.
BIBLIOTECAS E APIS
Todo código escrito na linguagem Java está dentro de uma classe. Como o Java é
orientado a objetos, então o projeto é estruturado em partes reutilizáveis de código.
O reaproveitamento de código é o conceito base das bibliotecas e APIs.

“Programas Java consistem em partes chamadas classes. As classes incluem partes

chamadas métodos que realizam tarefas e retornam informações quando as tarefas
são concluídas. [...]. Entretanto, a maioria dos programadores Java tira proveito das
ricas coleções de classes existentes nas bibliotecas de classe Java, que também são
conhecidas como Java APIs (Application Programming Interfaces).”(DEITEL, 2010, p. 7)
A biblioteca Java padrão fornece diversas classes para diversos propósitos,

como projeto de interface de usuário e programação em rede. Apesar disso, você
terá que criar suas próprias classes para descrever os objetos de seus aplicativos, e
adaptar as classes que são fornecidas pela biblioteca padrão para atender a seus
próprios objetivos.
Portanto, você pode desenvolver e programar suas classes, ou reaproveitar o
conjunto de classes e funcionalidades que as bibliotecas do Java provêm.
Verifique nas próximas imagens um exemplo de biblioteca: a classe Math, que
contém métodos para calcular operações numéricas básicas.
A primeira parte mostra o código do método max da classe Math, que recebe duas
variáveis do tipo double como parâmetros de entrada e retorna o maior valor. No
exemplo, foram passados os valores 10 e 20, que são inteiros. Nesses casos, o próprio
Java completa as classes decimais com zeros. A situação contrária (o Java arrendondar
valores para retirar as casa decimais)
não acontece. Portanto, se o método
precisa de um parâmetro do tipo inteiro,
não pode receber um double.
Note que, na segunda imagem, o print
mostra a janela auxiliar com nome e
parâmetros do método chamado. Na
janela inferior, temos o resultado da
função no destaque, ou seja, o número
mais alto entre os parâmetros enviados.
2.
4.
6. System.out.println(“O maior numero é: “ + Math.max(10,
20));
7. }
8. }

Veja o código em destaque.
FUNÇÕES MATEMÁTICAS
Em Java, utilizamos a biblioteca math para trabalhar com cálculos matemáticos. Essa
biblioteca é muito útil em situações nas quais precisamos realizar alguns cálculos de
funções específicas. Veja alguns exemplos no código a seguir.

2. import static java.lang.Math.*;
3.
4. public class FuncoesMatematicas {
5.
7. System.out.println(“A raiz quadrada de 16 é: “ + sqrt(16));
8. // a função sqrt calcula a raiz quadrada
9. System.out.println(“O número 3 elevado à
potencia 2 é: “ + pow(3,2));\
10. /* a função pow calcula potências. Note que é necessário
passar dois parâmetros: o primeiro é a base e o segundo, o expoente. */
11. System.out.println(“O valor de PI é: “ + PI);
12. // a função PI é usada para achar o valor de PI
13. }
14. }
Veja a compilação do código a seguir:
RESULTADO
Ao executar esse bloco de código, o resultado será:
• A raiz quadrada de 16 é: 4.0

• O número 3 elevado à potência 2 é: 9.0
• O valor de PI é: 3.141592653589793

SAIBA MAIS...
Para saber mais sobre a classe Math, clique no link a seguir:
+
https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html
MANIPULAÇÃO DE STRINGS
Podemos definir uma String como uma sequência de caracteres que compõe um
texto. No Java, uma String nada mais é do que uma classe que possui diversos
métodos para manipulação desses caracteres. Vamos demonstrar alguns métodos
muito utilizados dentro da classe String.
Veja alguns exemplos de manipulação de Strings.

REPLACE
Utilizamos o método replace() para substituir um valor encontrado no texto por
outro valor. Portanto, como parâmetro, esse método precisa receber o que será
substituído no texto e também o texto que será introduzido em seu lugar. Veja o
código e depois o resultado.
2.
3. public class ManipulacaoStrings {
5. String texto = “Você teve uma ótima ideia”;
6. texto = texto.replace(“ótima»,»excelente”);
7. System.out.println(texto);
8. }
9. }

TRIM
Utilizamos o método trim() para remover os espaços no início ou final de uma String:
2.
3. public class ManipulacaoStrings2 {
5. String texto = “ Esse texto irá aparecer sem espaços no
início ou no fi m “;
6. System.out.println(texto.trim());
7. }
8. }
LENGTH
Utilizamos o método Length() para contar a quantidade de caracteres existentes
em uma String. Esse método é muito utilizado principalmente em comandos de
decisão para realizar validações.
2.
5. String texto = “Senai”;
6. System.out.println(texto.length());
7. }
8. }

toUpperCase() e toLowerCase()
Utilizamos o método toUpperCase() para deixar todos os caracteres de uma String
em maiúsculas. Podemos usar também o método toLowerCase() para deixar todos
os caracteres de uma String em minúsculas.
2.
3. import java.util.Locale;
4.
7. String texto = “Joao Carlos”;
8. System.out.println(texto.toUpperCase());
9. System.out.println(texto.toLowerCase());
10. }
11. }
SAIBA MAIS...
Apresentamos os principais métodos utilizados por meio de uma String.
+
Essa classe, no entanto, possui uma enormidade de funcionalidades que

vale apena ser conferida em outro momento. Para saber mais, clique no

link a seguir:
https://docs-oracle-com.translate.goog/javase/7/docs/api/java/lang/
String.html?_x_tr_sl=en&_x_tr_tl=pt&_x_tr_hl=pt-BR&_x_tr_pto=nui,sc
OPERAÇÕES COM DATA

Assim como acontece com as Strings, para trabalharmos com datas, temos uma classe
específica. A diferença é que a classe Date() precisa ser importada e instanciada,
como mostrado no código a seguir.
2. import java.util.Date;
3.
4. public class Datas {
6. Date data = new Date();
7. /* Criado o objeto chamado data, instância da classe
Date(). O objeto data armazenou por padrão o
8. valor da data atual */
9. System.out.println(data);
10. // impressão desse objeto
11. }
12. }
Veja a compilação do código:
RESULTADO
Ao executar esse bloco de código, o resultado será a data no momento. No exemplo,

a data mostra Fri Oct 08 09:19:05 BRT 2021, ou seja, dia da semana, mês, dia, hora,
linguagem e ano, em inglês.

A classe date possui diversos métodos para trabalhar com datas. Veja o exemplo a seguir.
2. import java.util.Date;
3.
4. public class Datas2 {
6. Date data = new Date();
7. System.out.println(data.getDay()); // pega o dia
8. System.out.println(data.getMonth()); // pega o mês
9. System.out.println(data.getYear()); // pega o ano
10. System.out.println(data.getHours()); // pega a hora
11. System.out.println(data.getMinutes()); // pega os minutos
12. System.out.println(data.getSeconds()); // pega os segundos
13. }
14. }
Veja a compilação do código:
RESULTADO
Ao executar esse bloco de código, o resultado será:
• 5 (dia)
• 9 (mês)
• 121 (ano)
• 9 (horas)
• 26 (minutos)
• 57 (segundos)
Obs.: O método do ano é usado para retornar o valor, subtraindo 1900 do objeto da
data atual.

FORMATAÇÃO DE DADOS
Os valores provenientes de um campo na tela (ou seja, digitados pelo usuário),
independentemente de serem um número ou um texto, normalmente são
armazenados em uma variável do tipo String – portanto, um texto. No caso de
valores numéricos, é necessário fazer a conversão para realizar operações ou mesmo
armazená-los em um banco de dados no formato correto.
No exemplo a seguir, realizamos a conversão de um número em uma variável do

tipo String e, posteriormente, convertemos para número real e inteiro.
2.
3. public class FormatacaoConversao {
5. String numero = “10”;
6. double numeroDouble = Double.parseDouble(numero);
7. int numeroInteiro = Integer.parseInt(numero);
8. System.out.println(numeroDouble);
9. System.out.println(numeroInteiro);
10. }
11. }
Outro exemplo de conversão é o usado no padrão numérico. No Brasil, adotamos

um padrão de numeração diferente do padrão americano (utilizado como base
para o desenvolvimento de softwares). Nossas casas decimais são separadas por
vírgula em vez de ponto. Aqui, o ponto marca a casa do milhar, diferentemente do
padrão americano.

Então, para realizar a criação de uma máscara de valores, usamos a

classe DecimalFormat(). No exemplo a seguir, criamos uma máscara para o
padrão utilizado no Brasil e convertemos um valor do padrão americano para o
padrão brasileiro.
2. import java.text.DecimalFormat;
3.
4. public class FormatacaoConversao2 {
6. double numero = 10000.0;
7. DecimalFormat df = new DecimalFormat(“#,###.00”);
8. System.out.println(df.format(numero));
9. }
10. }
COLEÇÕES
Podemos definir coleção como uma estrutura de dados que permite que seja
armazenado um grupo de objetos. Basicamente, uma coleção também pode
ser considerada um objeto.
Os métodos que podem ser realizados por meio das coleções servem para inserir
novos elementos, remover elementos existentes, acessar elementos e também
realizar a pesquisa de elementos.
Vamos agora fazer um passo a passo de um projeto para criação de uma coleção de
objetos. Siga adiante para acompanhar os tutoriais.

FERRAMENTAS
Para aplicar todos esses conceitos na prática, vamos utilizar as ferramentas:
• IntelliJ: IDE11 em Java para desenvolvimento de softwares. Vamos usá-lo para
implementação das classes.
• Git/GitHub: Programa de versionamento12 e plataforma de repositório13.
Acesse o material e assista o vídeo para saber mais sobre a instalação do IntelliJ.
PDF
Para conhecer um pouco mais sobre GiT e GitHub, acesse o material.
Arquivo: PDF02_git.pdf
NA PRÁTICA
Acesse o material e assista o vídeo e acompanhe o tutorial de como iniciar um projeto
no IntelliJ.
PDF
Confira a versão pdf do conteúdo do vídeo.
Arquivo: VID01_CriandoProjIntelliJ.pdf
11 Ambiente de desenvolvimento integrado.
12 Sistema para controlar e documentar as versões de seu projeto.
13 Local online para armazenar e mostrar seu projeto.

NESTE DESAFIO...
BANCO DE DADOS EM APLICATIVOS MOBILE JAVA | DESAFIO 1

Você estudou:
• Linguagem de Programação Java

» Histórico
» Tipos primitivos
» Operadores
» Controle de fluxo
» Funções e métodos
» Parâmetros
» Bibliotecas e APIs
» Classes Java
NO PRÓXIMO DESAFIO...
Você estudará como aplicar os conceitos na construção de classes.

DESAFIO 2
• Implementar as rotinas de conectividade ao

banco de dados, além de documentar o código.
• Criação de classes;
• Heranças;
• Visibilidade;
• Composição;
• Interface;
• Polimorfismo;
• Exceções.
• Conexão com o banco de dados.

INTRODUÇÃO
Iniciaremos esse conteúdo com alguns conceitos importantes para a criação de
classes, como visibilidade e os métodos get, set e constructor.
Em seguida, abordaremos a implantação de classes e a criação de instâncias de

classe por meio de um exemplo prático.
Depois, resgataremos alguns conceitos importantes de POO, como herança,

interface, composição e polimorfismo, para a implementação do projeto e conexão
com o banco de dados.
Fonte: Depositphotos
CRIAÇÃO DE CLASSES
Para criar uma classe na linguagem de programação Java, utiliza-se a palavra class,
seguida do nome desejado para a classe criada.
1. <modifi cador de acesso> class NomeClasse {
2. /* aqui dentro da classe criada, vão os atributos, métodos e
3. construtores */
4. }

IMPORTANTE!
Uma regra simples na identificação de classes é procurar por
substantivos na análise de um problema. Já os métodos, por outro lado,
!
correspondem a verbos e ações.
Em um sistema de compra online, por exemplo, alguns dos substantivos a seguir

podem servir como nomenclatura:
• Item
• Produto
• Endereço
• Pagamento
Esses nomes podem ajudar na criação de classes. Para os métodos das classes, você
deve identificar os verbos, pois eles representam ação: aplicar desconto, adicionar
em estoque etc.
PENSE NISSO
Perceba que os nomes (substantivos) representam itens do mundo real.
Acesse o material e veja o vídeo para aprender a criar e instanciar uma classe no IntelliJ
com Java.
PDF
Leia a versão pdf do conteúdo do vídeo.
Arquivo: VID01_CriandoClasses.pdf
Agora, vamos abordar como controlar o acesso às classes e seus atributos e métodos,
usando o conceito de visibilidade. Siga em frente e descubra como.
VISIBILIDADE
Na linguagem e programação Java, a visibilidade, ou grau de acesso de um atributo
ou método, está diretamente ligada ao conceito de pacotes. Um pacote ou package
significa pasta ou diretório local em que a classe foi construída.

Note que, no exemplo a seguir, a pasta (ou package) sp.senai contém todos os
arquivos de classes.
Para uma melhor organização, estruturamos o projeto em pacotes. Para utilizar uma
classe de um pacote, você pode importá-la.
No exemplo, dentro do package sp.senai, temos outro package chamado modelos –

e, dentro dele, a classe Conta. Para usar a classe Conta no arquivo Main (fora da
pasta modelos), usamos o import:
1. import sp.senai.modelos.Conta;

MODIFICADORES DE ACESSO
Você pode controlar o acesso às variáveis e aos métodos de uma classe utilizando
modificadores de acesso (ou de visibilidade): public, private e protected.
Esses modificadores aparecem no início da linha de comando e auxiliam na

visualização dos serviços que a classe disponibiliza.
1. Public: Público ou public refere-se ao acesso livre por qualquer classe; ou
seja, o acesso é irrestrito.
2. Protected: Protegido ou protected pode ser acessado apenas pela própria
classe ou pelas suas subclasses, ou seja, o acesso é limitado à classe ou a tipos que
derivem da mesma classe.
3. Private: Privado ou private apenas os métodos da própria classe podem
manipular o atributo, ou seja, o acesso é limitado à própria classe.
O exemplo a seguir mostra a utilização dos métodos depositar e sacar, usando
modificadores de acesso. Um atributo private é visível apenas dentro da própria
classe; um atributo public é visível dentro de todo o projeto; um atributo protected é
visível apenas dentro do pacote no qual a classe foi criada.
Classe Conta usando os modificadores de acesso em sua implantação.

1. package sp.senai.modelos;
2. public class Conta {
3. private double saldo;
4. public double getSaldo() {
5. return saldo;
6. }
7. public void depositar(double valor) {
8. this.saldo = saldo + valor;
9. }
10. public void sacar(double valor) {
11. this.saldo = saldo - valor;
12. }
13. }
Na classe Main, também usamos modificadores de acesso.

2. import sp.senai.modelos.Conta;
5. Conta contaDoWilson = new Conta();
6. contaDoWilson.depositar(100);

7. System.out.println(contaDoWilson.getSaldo());
8. contaDoWilson.sacar(50);
9. System.out.println(contaDoWilson.getSaldo());
10. }
11. }
A compilação mostra, como resultado, 100.0 de saldo após o depósito e, em seguida,

50.0 de saldo após saque de 50.
MÉTODOS GET E SET
Uma classe normalmente consiste em um ou mais métodos que manipulam os
atributos dos objetos e estão declarados dentro das classes. Os atributos funcionam
da mesma maneira que variáveis e são declarados na classe. Normalmente, são
conhecidos como propriedades de uma classe. Para alterar, acessar ou modificar
os atributos do objeto, criamos métodos para realizar essas ações, também
conhecidos como métodos get e set.
Veja a seguir um exemplo de código, usando os métodos get e set com comentários.

2.
3. public class Curso {
4. // atributo nome do curso
5. private String nomeCurso;
6.
7. // metodo para alterar o nome do curso
8. public void setNomeCurso(String curso) {
9. nomeCurso = curso; // armazena o nome do curso
10. } // fi m do metodo

11.
12. // metodo para recuperar o nome do curso
13. public String getNomeCurso() {
14. return nomeCurso; // retorno do valor
15. } // fim do metodo
16.
17. }
CONSTRUTORES
Toda classe possui um método que tem o mesmo nome da classe, chamado
construtor. O método construtor é invocado quando se realiza a instanciação
de uma classe, criando assim um objeto. Ao criar um objeto de uma classe na qual
não foi implementado um método construtor, o próprio Java cria um construtor
vazio em tempo de execução.
Confira o exemplo a seguir.

2.
5. Curso curso = new Curso();
6. \\ cria uma nova instância chamada curso da classe
7. Curso
8. }
9. }
Acesse o material e veja o vídeo para aprender a usar os métodos get, set e construtor
no IntelliJ.
PDF
Acesse o material para baixar a versão pdf do conteúdo do vídeo.
Arquivo: VID02_GetSetConstrutor.pdf
Siga adiante para estudar conceitos importantes para a implementação de classes,

como herança, interface, composição e polimorfismo.
HERANÇA
Na programação orientada a objetos, as classes normalmente são formadas a partir
de outras classes.

Como o próprio nome sugere, herança é um procedimento de reutilização de

código. Uma classe derivada utiliza os atributos e métodos da sua classe base,
adicionando novas propriedades e métodos. Isso elimina retrabalho ao reescrever
o código.
Vamos supor que você precise definir, em sua empresa, um cadastro dos veículos que
ela tem em seu inventário (classe Veículo), como motos ou carros. Essas subclasses
(Moto, Carro) poderão herdar características e comportamentos de veículo e
adicionar funcionalidades específicas de cada uma.
Confira a seguir a classe Veículo seguida da classe Carro e seus seu respectivos códigos.
CLASSE VEÍCULO
2. public class Veiculo {
3. private int Ano;
4. private String modelo;
5. public int getAno() {
6. return Ano;
7. }

8. public void setAno(int ano) {

9. Ano = ano;
10. }
11. public String getModelo() {
12. return modelo;
13. }
14. public void setModelo(String modelo) {
15. this.modelo = modelo;
16. }
17. }
CLASSE CARRO
2. public class Carro extends Veiculo {
3. private int quantidadePortas;
4. public int getQuantidadePortas() {
5. return quantidadePortas;
6. }
7. public void setQuantidadePortas(int quantidadePortas) {
8. this.quantidadePortas = quantidadePortas;
9. }
10. }
A palavra-chave extends na primeira linha da classe Carro indica que a classe referida
está herdando as propriedades da classe base existente.

A classe base também pode ser chamada de superclasse. A classe que herda é
denominada classe derivada ou subclasse. Os termos superclasse e subclasse são
os mais usados habitualmente por programadores Java.
Imagem representando a herança. Veículo possui as propriedades e métodos que

serão compartilhados entre as classes filhas. As classes filhas herdam todas as
propriedades e comportamentos da classe pai, podendo também implementar
funcionalidades específicas.
Fonte: próprio Autor
Note, no exemplo a seguir, que a instância chamada carroDoWilson da classe Carro

herda os atributos da classe Veículos.
Veja o código da instância.

INSTÂNCIA DA CLASSE CARRO

2. import java.util.regex.Pattern;
5. Carro carroDoWilson = new Carro();
6. carroDoWilson.setQuantidadePortas(4);
7. carroDoWilson.setAno(2021);
8. carroDoWilson.setModelo("Honda Civic");
9. }
10. }
CLASSES E MÉTODOS ABSTRATOS

Ao subir na hierarquia de heranças, as classes tornam-se mais genéricas, tornando-
se, de certa forma, mais abstratas. Em certo momento, a superclasse torna-se tão
genérica que é vista como uma classe modelo para as demais, sendo impossível
imaginar sua possível instanciação.
O propósito das classes abstratas é fornecer uma superclasse apropriada com um

modelo comum para outras classes nas quais não será possível criar instâncias
da superclasse abstrata. Para definir uma classe como abstrata, utiliza-se a
palavra abstract.
Normalmente, uma classe abstrata possui ao menos um método abstrato. Os

métodos abstratos possuem apenas sua assinatura, porém não são implementados

em classes abstratas. Portanto, apenas se implementa um método abstrato em

classes concretas que o herdam.
Confira um exemplo de classe abstrata a seguir.

2. public abstract class Player {
3. public abstract void correr();
4. }
Não é possível criar instâncias da classe player. Na imagem, o IntelliJ mostra o aviso
“Player é abstrata, não pode ser instanciada”.
INTERFACE
Interface é um tipo de classe utilizada na programação orientada a objetos para diminuir
a dependência entre módulos do sistema (chamamos de acoplamento). Podemos
dizer que, em programação, a interface é um tipo abstrato de dados que irá
conter somente a definição, mas não a implementação.
A implementação será feita na subclasse e é definida utilizando a palavra

reservada interface. Ao criar uma interface, cria-se um contrato que ambas as

partes devem aceitar. Portanto, ao implementar uma interface, obriga-se as

classes ou grupo de classes que herdam sua implementação a possuir métodos ou
propriedades em comum.
No exemplo, a imagem mostra a interface IPagamento salva no arquivo IPagamento.

java, com o código:
2. public interface IPagamento {
3. void calcularDesconto();
4. }
Na imagem a seguir, note que há uma mensagem de erro na classe da interface:

quando implementamos uma interface, a classe apresenta erro até que os métodos
declarados na interface sejam implementados.

A seguir, classe PagamentoCredito implementa a interface IPagamento.

2. public class PagamentoCredito implements IPagamento {
3. @Override
4. public void calcularDesconto() {
5. System.out.println(“codigo desconto credito”);
6. }
7. }
Assim como a classe PagamentoDebito implementa a interface IPagamento.

2. public class PagamentoDebito implements IPagamento {
3. @Override
4. public void calcularDesconto() {
5. System.out.println(“codigo desconto debito”);
6. }
7. }
Na classe Main, criamos instâncias das classes PagamentoCredito e PagamentoDebito,

implementando o método criado na interface.
2.
4. public static void main(String[] args){
5. PagamentoCredito pc = new PagamentoCredito();
6. pc.calcularDesconto();
7. PagamentoDebito pc = new PagamentoDebito();
8. pd.calcularDesconto();
9. }
10. }
RESULTADO
A compilação mostra como resultado:
• Código desconto crédito

• Código desconto débito

COMPOSIÇÃO
Composição é um mecanismo para reutilização de código, assim como a herança.

A diferença primordial entre elas é a especialização.
A composição é fácil de entender, pois é concreta: objetos da classe A contêm

objetos da classe B. Um objeto Pedido, por exemplo, contém objetos Item. A relação
de herança entre Pedido e Item denota especialização.
Temos as classes Veículo, Carro, Moto, Pneu, Volante, Janela e Guidão. As classes
Carro e Moto são subclasses de Veículo, portanto, herdam todos os atributos e
métodos da classe pai. Apesar disso, a classe Carro é composta das classes Pneu,
Volante e Janela, enquanto a classe Moto é composta pelas classes Pneu e Guidão.
Com a composição, podemos inserir comportamentos simples para compor

comportamentos mais complexos. Podemos, então, criar uma classe Avião, como
subclasse de Veículo, e criar as classes Turbina e TremDePouso para a composição.

Podemos criar a subclasse Navio, composta pelas classes Ancora e Leme, ou a

subclasse Bicicleta, com Guidão, Selim e Pedal.
Conheça um exemplo de implantação de composição.
CLASSE CASA
2.
3. public class Casa {
4. private Porta portaDeEntrada;
5. // getters and setters
6. public Porta getPortaDeEntrada() {
7. return portaDeEntrada;
8. }
9. public void setPortaDeEntrada(Porta portaDeEntrada) {
10. this.portaDeEntrada = portaDeEntrada;
11. }
12. }

CLASSE PORTA
2. public class Porta {
3. private double largura;
4. private double altura;
5. // getters and setters
6. public double getLargura() {
7. return largura;
8. }
9. public void setLargura(double largura) {
10. this.largura = largura;
11. }
12. public double getAltura() {
13. return altura;
14. }
15. public void setAltura(double altura) {
16. this.altura = altura;
17. }
18. }
CLASSE MAIN, COM A INSTÂNCIA CASA COMPOSTA PELA INSTÂNCIA PORTA.

2.
4.
6. Porta portaDeEntrada = new Porta();
7. portaDeEntrada.setAltura(3);
8. portaDeEntrada.setLargura(3);
9. Casa casa = new Casa();
10. casa.setPortaDeEntrada(portaDeEntrada);
11. }
12. }
POLIMORFISMO
A palavra polimorfismo tem origem grega e significa “muitas formas” (poli
= muitas, morfos = formas). No jogo de videogame Super Mario, você pode ter
diferentes personagens que realizam uma ação em comum, como a ação de correr.
O polimorfismo permite que cada personagem (Mario, Luigi e Yoshi) crie sua própria
forma de correr.

As subclasses de uma superclasse podem possuir a mesma assinatura em seus

métodos, porém podem possuir comportamentos diferentes. A ideia por trás
do polimorfismo é que, embora a ação possa ser a mesma, os objetos podem
responder diferentemente.
Veja a implantação de um exemplo de polimorfismo.
PLAYER
Na classe Player, definimos o método correr() como Correr padrão.
2. public class Player {
3. public void correr() {
4. System.out.println(“Correr padrão”);
5. }
6. }
MARIO
Na classe Mario, definimos o método correr como Correr do Mario.
2. public class Mario extends Player {
3. @Override
5. System.out.println("Correr do Mario");
6. }
7. }
LUIGI
Na classe Luigi, definimos o método correr() como Correr do Luigi.
2. public class Luigi extends Player {
3. @Override
5. System.out.println("Correr do Luigi");
6. }
7. }

MAIN
Na classe Main, criamos instâncias de Mario e Luigi e implantamos o método correr()
de cada um.
4. Mario mario = new Mario();
5. mario.correr();
6. Luigi luigi = new Luigi();
7. luigi.correr();
8. }
9. }
RESULTADO
• Correr do Luigi
• Correr do Mario
EXCEÇÕES
É comum, durante a execução de um sistema, acontecerem situações inesperadas.
Em programação, o inesperado é chamado de exceção. As exceções podem surgir
por diversos motivos, porém normalmente são falhas no projeto ou em sua

implementação. Também podem ocorrer por bugs causados por ações dos
usuários do sistema.
Em um sistema para calcular a soma entre

dois números inteiros, o usuário entra com
valores contendo letras, resultando em
erro na execução, pois o programa não irá
conseguir converter “1AB” em um inteiro.
Fonte: Pixabay
Para isso, será necessário entender o uso de cinco palavras reservadas.
• try: Utiliza-se o try para delimitar um pedaço de código que pode gerar

alguma exceção.
• catch: O comando catch deve ser utilizado para prover uma alternativa ao
fluxo em uma situação de exceção.
• finally: O comando finally é executado em todas as situações, ocorrendo ou
não a exceção.
• throw e throws: Em Java, utilizamos os termos throw e throws para realizar
o disparo das exceções.
Você sabe diferenciar o throw de throws?
• throw: O throw aparece como uma instrução no código para gerar,

propositalmente, uma exceção.
• throws: O throws é manipulado pelo sistema para lançar uma exceção
ocorrida. Você apenas irá utilizar o termo throws quando declarar um método
que pode gerar uma exceção com a qual ele próprio não consegue lidar.
A sintaxe geral para tratamentos de exceções é:

1. try {
2. <bloco protegido>
3. } catch(<tipo da exceção 1>) {
4. <tratamento para exceção do tipo 1>
5. [throw(<nome1>);]

6. } catch(<tipo da exceção 2>) {

7. <tratamento para exceção do tipo 2>
8. [throw(<nome2>);]
9. }
10. ...
11. } catch(<tipo da exceção N>) {
12. <tratamento para exceção do tipo N>
13. [throw(<nomeN>);]
14. } finally {
15. <bloco de finalização>
16. }
A seguir, um exemplo de try e catch.

5. String emailValido = null;
6. try {
7.
8. System.out.println(Pattern.matches(“^(.+)@(.+)$”,
9. emailValido.toLowerCase()));
10. } catch (Exception e) {
11. System.out.println(“Ocorreu o erro: “ + e);
12. }
13. }
14. }
RESULTADO
• Ocorreu o erro: java.lang.NullPointerException: Cannot invoke “String.

toLowerCase() because “email” is null.

No exemplo a seguir, usaremos uma validação para tratar exceções. Para validação,
usaremos o método matches, que vai dizer se a String inteira corresponde
à regex1 pattern2. No caso, o matches verifica se há o símbolo @ e no mínimo um
ponto no endereço. O retorno desse método matches é booleano e, nesse exemplo,
retornou true.
5. String emailValido = “EMAIL@gmail.com”;
6. try {
7.
8. System.out.println(Pattern.matches(/*regen*/”^(.+)@(.+)$”,
9. emailValido.toLowerCase()));
10. } catch (Exception e) {
11. System.out.println(“Ocorreu o erro: “ + e);
12. }
13. }
14. }
1 Abreviação do inglês Regular Expression (expressão regular).
2 Solução comprovada para um problema recorrente.

SAIBA MAIS...
As regex são sentenças com códigos que podem identificar, de forma
+
flexível e concisa, uma string de caracteres de interesse, ou seja,
com um padrão desejado de caracteres. Dentro da classe regex, há a
classe Pattern, de soluções comprovadas para problemas recorrentes.
E, dentro da Pattern, há o método matches, que compara os dados
digitados pelo usuário à regex determinada.
CONEXÃO COM BANCO DE DADOS

“Um banco de dados é uma coleção organizada de dados. [...] Um SGDB (sistema de
gerenciamento de banco de dados) fornece mecanismos para armazenar, organizar,
recuperar e modificar dados.” DEITEL, 2010
Os programas Java comunicam-se com os bancos de dados utilizando a JDBC

(Java Database Connectivity). Um driver JDBC permite aos aplicativos Java a
comunicação com os bancos e a manipulação de seus registros por meio da
JDBC API.
Há diversos drivers disponíveis e a implementação será feita com o MySQL. Por

definição, sabemos que um banco de dados do tipo relacional realiza o armazenamento
dos dados em um conjunto de tabelas relacionadas entre si. As linhas representam os
registros e as colunas, os dados.
Antes de iniciar o desenvolvimento do projeto Java, instale o MySQL Workbench e

execute o script bd.sql disponibilizado.
PDF
Acompanhe o tutorial de instalação e configuração do MYSQL Workbench.
Acesse o material para obter o script bd.sql.
Arquivo: PDF01_InstConfigMySQL.pdf
O arquivo bd.sql consiste em um banco de dados chamado Sistemaensino com uma

tabela de alunos para armazenar os registros de dados pessoais como: nome, data
de nascimento, e-mail e turma.

Acesse o material e veja o vídeo para aprender a fazer a conexão com o banco de dados.
PDF
Veja a versão pdf do conteúdo do vídeo.
Arquivo: VID03_conexaoBD_v08.pdf

NESTE DESAFIO...
BANCO DE DADOS JAVA | DESAFIO 2

Você estudou:
• Criação de classes
» Heranças
» Visibilidade
» Composição
» Interface
» Polimorfismo
» Exceções
• Conexão com banco de dados
» Estabelecendo a Conexão
» Executando comando de Ação
» Efetuando consultas
» Atualizações em Lote

PARA CONCLUIR...
PARABÉNS, VOCÊ CONCLUIU A ETAPA DE BANCO DE DADOS

EM APLICATIVOS MOBILE COM JAVA!
Você estudou a linguagem de programação Java e sua história, a estrutura base
de um programa, os tipos primitivos de dados e técnicas para controle de fluxo
(estrutura de decisão, repetição e operadores). Conhecer o funcionamento das
funções e métodos serviu como base para abordar o funcionamento de bibliotecas
de APIs, além da implementação de classes.
Você também conheceu a linguagem de programação Java, criando instâncias

de classes, entendendo os métodos setters e getters, modificadores de acesso e
métodos construtores.
Finalmente, você estudou o funcionamento das exceções e implementou os pilares

da orientação a objetos com java: herança, polimorfismo, classes e métodos abstratos,
interface, composição, visibilidade e como ocorre a conexão de um programa com o
banco de dados utilizando JDBC.
Continue estudando e se aprimorando.
Até breve e sucesso!

REFERÊNCIAS
BAKKER, Paul; MARK, Sander. Java 9 Modularity. Massachusetts: O’Reilly Media
Inc., 2017.
CLEMENTS, Nick; DAUX, Patrice; WILLIAMS, Gary. Java Programming. Califórnia:

Oracle Corporation, 2000.
CORNELL, Gary; HORSTMANN, Cay. Core Java2 – v. I – Fundamentos. Série Java.

California: The Sun Microsystems Press, 2003.
DEITEL, H.M. Java – Como Programar. 8. ed. [S.l.]: Pearson & Artmed, 2010.
DEITEL, Paul. Understanding Java 9 Modules. Java Magazine, set./out. 2017.
KÖLLING, Michael. The Evolving Nature of Interfaces. Java magazine, set./out. 2016.
ORACLE HELP CENTER. Package java.util.function. Disponível em: http://docs.

oracle.com/javase/8/docs/api/java/util/function/package-summary.html. Acesso
em: 29 out. 2021.
ORACLE. Primitive Data Types. Disponível em: https://docs.oracle.com/javase/

tutorial/java/nutsandbolts/datatypes.html. Acesso em: 29 out. 2021.
ORACLE. The Java Tutorials. Disponível em: http://docs.oracle.com/javase/tutorial/

index.html. Acesso em: 29 out. 2021.
ORACLE. What's New in JDK 8. Disponível em: http://www.oracle.com/technetwork/

java/javase/8-whats-new-2157071.html. Acesso em: 29 out. 2021.
SANTOS, Rui. Programando em Java 2 – Teoria & Aplicações. Rio de Janeiro: Axcel
Books, 2004.
TECHEMPOWER. Everything about Java 8. Disponível em: https://www.techempower.

com/blog/2013/03/27/everything-about-java-8/. Acesso em: 29 out. 2021.

CRÉDITOS
CONFEDERAÇÃO NACIONAL DA INDÚSTRIA SENAI - DEPARTAMENTO REGIONAL
– CNI DE SÃO PAULO
Robson Braga de Andrade
Presidente Ricardo Figueiredo Terra
Diretor Regional
DIRETORIA DE EDUCAÇÃO E TECNOLOGIA –
DIRET Cassia Regina Souza da Cruz
Rafael Esmeraldo Lucchesi Ramacciotti Gerente de Educação
Diretor de Educação e Tecnologia
Izabel Rego de Andrade
SERVIÇO NACIONAL DE APRENDIZAGEM Supervisora da Supervisão de Educação Online
INDUSTRIAL – SENAI – CONSELHO NACIONAL
Robson Braga de Andrade Claudia Baroni Savini Ferreira
Presidente Coordenação do Desenvolvimento do Curso
SENAI – DEPARTAMENTO NACIONAL Luiz Carlos Machi Lozano

Rafael Esmeraldo Lucchesi Ramacciotti Elaboração de Conteúdo
Diretor-Geral
Adilson Moreira Damasceno
Gustavo Leal Sales Filho Orientador de Práticas de Educação a Distância
Diretor de Operações
Paula Cristina Bataglia Buratini
SENAI – DEPARTAMENTO NACIONAL Coordenação da Produção do Curso
UNIDADE DE EDUCAÇÃO PROFISSIONAL
E TECNOLÓGICA – UNIEP Cristina Yurie Takahashi
Felipe Esteves Morgado Design Educacional
Gerente Executivo
Caio Marques Rodrigues
Diagramação
Luiz Eduardo Leão
Gerente de Tecnologias Educacionais Cleriston Ribeiro de Azevedo
Luiz Tadeu Silva Sansone
Anna Christina Theodora Aun de Azevedo Nascimento
Juliana Rumi Fujishima
Adriana Barufaldi Ilustrações
Bianca Starling Rosauro de Almeida
Laise Caldeira Pedroso Camila Ciarini Dias
Coordenação Geral de Desenvolvimento dos Produção e Edição de Vídeos
Recursos Didáticos Nacionais
Gustavo Cardoso de Carvalho
Luana Dorizo de Melo
Web Design
Rafael Santiago Apolinário

Programação

MATERIAL
COMPLEMENTAR
Banco de Dados em aplicativos Mobile Java
Controle de fluxo
Operadores: aritméticos, lógicos e relacionais
Operadores são símbolos que auxiliam na sintaxe de comandos,

expressões e funções. A operação é determinada pelo tipo de
operador utilizado. Os operandos, por sua vez, assumem o papel de
argumentos na operação, podendo ser valores literais, variáveis,
constantes ou expressões.
Operadores aritméticos
Os operadores aritméticos são os símbolos que representam os
cálculos básicos matemáticos. Assim como na álgebra, também são
utilizados em programação. Na linguagem de programação Java, os
operadores aritméticos são declarados conforme mostra a tabela a
seguir.
SENAI 1
Sinal Operação
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Módulo (resto de divisão)
++ Incremento
-- Decremento
+= Atribuição aditiva
-= Atribuição subtrativa
*= Atribuição de multiplicação
/= Atribuição de divisão
%= Atribuição de módulo
No código a seguir, há alguns exemplos de operadores.
SENAI 2
package sp.senai;
public class Main {

int primeiroNumero = 10;
int segundoNumero = 5;
System.out.println("Soma: " + (primeiroNumero +
segundoNumero));
System.out.println("Subtração: " + (primeiroNumero -
segundoNumero));
System.out.println("Multiplicação: " + (primeiroNumero *
segundoNumero));
System.out.println("Divisão: " + (primeiroNumero /
segundoNumero));
}
}
A seguir, a compilação desse trecho mostra como resultado: “Soma:

15, Subtração: 5, Multiplicação: 50, Divisão: 2”.
SENAI 3
Operadores Lógicos
Os operadores lógicos possuem retorno booleano, portanto o
resultado deve ser sempre verdadeiro ou falso. Normalmente, são
utilizados para comparação de ao menos duas proposições e são
aliados à lógica matemática para a resolução de expressões
computacionais.
A seguir, uma demonstração dos operadores lógicos na linguagem de

programação Java:
Operador Função
| OR lógico
|| OR dinâmico
& AND lógico
&& AND dinâmico
^ XOR lógico
! NOT unário lógico
|= Atribuição de OR
&= Atribuição de AND
^= Atribuição de XOR
?: if-then-else ternário
SENAI 4
package sp.senai;
public class Main {

int numero = 20;
if (numero > 15 && numero < 30) {
System.out.println(numero);
}
}
}
A seguir, a compilação desse trecho mostra 20.
SENAI 5
Operadores Relacionais
Quando há necessidade de realizar comparação entre valores e
expressões, utiliza-se os operadores relacionais. Os operadores
relacionais possuem um comportamento similar aos operadores
lógicos, pois o resultado de uma comparação entre ao menos duas
proposições deverá retornar um valor booleano – portanto,
verdadeiro ou falso.
A utilização de operadores relacionais se dá, em grande parte, dentro
de condicionais ou laços de repetição.
A tabela a seguir demonstra como os operadores relacionais são

declarados na linguagem de programação Java:
Operador Função
== Igual a
!= Diferente de
> Maior que
< Menor que
>= Maior ou igual a
<= Menor ou igual a
SENAI 6
package sp.senai;
public class Main {

int relacional = 20;
if (relacional == 20) {
System.out.println("Iguais!");
}
}
}
A seguir, a compilação desse trecho mostra 20.
Siga adiante para conhecer como aplicar os operadores em estruturas

de decisão e de repetição.
SENAI 7
Estruturas de decisão
Para trabalhar com desvios condicionais, utiliza-se o comando if, que

pode ser traduzido como “SE”. Note que aqui só há instrução caso a
condição seja atendida, então não há ação específica e o restante do
código é executado.
If (<condição>) <instrução ou bloco>
Veja um exemplo no código a seguir.

package sp.senai;
public class Main {

int numero = 10;
if (numero <= 10) {
System.out.println("Menor ou igual a 10");
}
}
}
A seguir, a compilação desse trecho mostra “Menor ou igual a 10”.
SENAI 8
Já no comando if-else, o comando if vem acompanhado de uma

instrução caso a condição não seja atendida, como uma bifurcação no
caminho. O comando “senão”, em linguagens de programação, é
conhecido como else. Ele atende a uma negação do comando “se” –
basicamente, é executado quando o comando if não for atendido.
A forma de declarar um comando de decisão com if-else é:
if (<condição>) <instrução ou bloco>

else <instrução ou bloco>
Veja um exemplo no código a seguir.
package sp.senai;
public class Main {

int numero = 20;
if (numero <= 10) {
System.out.println("Menor ou igual a 10");
} else {
System.out.println("Maior que 10");
}
}
}
A seguir, a compilação desse trecho mostra como resultado “maior

que 10”.
SENAI 9
A estrutura switch-case é um aperfeiçoamento da estrutura if em

situações de encadeamento. Nessa estrutura, pode haver algumas
situações para serem testadas e uma instrução para ser executada
associada a cada uma das condições. Este comando é muito utilizado
quando uma quantidade maior de condições é necessária para ser
utilizada em sua aplicação, quando há uma variedade maior na sua
quantidade de alternativas necessárias. Na linguagem de programação
Java, o switch-case é utilizado da seguinte maneira:
switch(<expressão ou variável>) {
case <valor1>:
<instrução 1>;
break;
case <valor 2>:
<instrução 2>;
break;
case <valor N>:
<instrução N>;
break;
default:
<instrução Default>;
}
SENAI 10
Veja um exemplo a seguir.
package sp.senai;
public class Main {

int numeroDoMes = 3;
String mes = "mês não válido";
switch (numeroDoMes)
{
case 1:
mes = "janeiro";
break;
case 2:
mes = "fevereiro";
break;
case 3:
mes = "março";
break;
case 4:
mes = "abril";
break;
case 5:
mes = "maio";
break;
case 6:
mes = "junho";
break;
case 7:
mes = "julho";
break;
SENAI 11
case 8:
mes = "agosto";
break;
case 9:
mes = "setembro";
break;
case 10:
mes = "outubro";
break;
case 11:
mes = "novembro";
break;
case 12:
mes = "dezembro";
break;
default:
break;
}
System.out.println(mes);
}
}
A compilação desse trecho mostra como resultado “março”.
SENAI 12
Agora, siga adiante para conhecer as estruturas de repetição.
SENAI 13
Estruturas de repetição
As estruturas de repetição também costumam ser conhecidas como

laço ou loop. São estruturas que possibilitam que um conjunto de
instruções seja repetido uma quantidade definida de vezes, sendo
possível utilizar um contador ou mesmo uma variável de controle.
Essas estruturas têm usos diversos, como tecidos com desenhos em

padrão, renderização de estruturas metálicas, jogos em geral,
embalagem de produtos em lotes, entre outros.
Da mesma maneira que acontece com a declaração de variáveis, as

estruturas de repetição podem apresentar diferenciações entre
algumas linguagens de programação.
Uma estrutura de repetição deve conter quatro elementos básicos:
• Inicialização – compõe a condição inicial com o início do laço.

• Condição – para que o bloco continue sendo executado, é uma
expressão que serve para avaliar a condição depois de cada vez
que o bloco é executado.
• Instrução – composta de instruções que deverão ser executadas
dentro do bloco após cada execução e enquanto a condição for
verdadeira ou estiver sendo atendida.
• Interação – instrução que deverá ser executada após o corpo e
antes da próxima condição. Imagine que para calcular a tabuada,
você comece do 1 e vá até o 10. A interação é utilizada para
aumentar em um (ou outro valor), cada passo de execução.
SENAI 14
A estrutura de repetição while é utilizada para executar uma instrução

ou um bloco enquanto a condição for satisfeita.
A sua forma de escrita é:
<inicialização>
while(<condição>) {
<instrução>
<iteração>
}
A inicialização da condição deve ser atribuída antes do início do laço

para indicar o estado inicial dos elementos. A palavra-chave reservada
while é seguida dos () e dentro deles constará a condição atendida. A
instrução será executada caso a condição seja atendida, ele entre no
laço e o incremento seja executado no final.
package sp.senai;
public class Main {

int inicializacao = 0; // inicializacao
while (inicializacao <= 3) // condicao
{
System.out.println(inicializacao);
inicializacao++; // incremento
}
}
}
SENAI 15
A compilação desse trecho mostra como resultado “0 1 2 3”.
O comando do-while funciona da mesma maneira que o comando

while, porém a verificação da condição é realizada apenas ao final do
bloco de instruções. Portanto, isso garante que o laço de repetição
será executado ao menos uma vez.
A sua forma de escrita é do comando do-while; veja a seguir:
<inicialização>
do {
<instrução>
<iteração>
} while(<condição>);
SENAI 16
package sp.senai;
public class Main {

int inicializacao = 0; // inicializacao
do
{
System.out.println(inicializacao); // instrucao
inicializacao++; // incremento
} while (inicializacao <= -1); // condicao
}
}
A compilação desse trecho mostra como resultado “0 1 2 3 4 5”.
SENAI 17
O laço de repetição for possui alguns elementos. Dentre eles,

podemos mencionar: inicialização, condição e interação.
A sua forma de escrita é:
for(<inicialização>;<condição>;<iteração>) {
<instrução>
}
Os comandos de repetição for e while são maneiras diferentes de

escrever uma estrutura básica de repetição. No caso do for, ele utiliza
uma variável de controle que é responsável por controlar a quantidade
de vezes que a instrução será repetida, podendo ser incrementado ou
decrementado a cada interação. A condição é geralmente utilizada
para avaliar se o valor iniciado alcançou um determinado valor.
package sp.senai;
public class Main {

for (int indice = 0; indice <= 10; indice++)
{
System.out.println(indice);
}
}
}
SENAI 18
A compilação desse trecho mostra como resultado “0 1 2 3 4 5 6 7 8 9

10”.
SENAI 19
GIT
Um repositório Git é um espaço de armazenamento virtual
para projetos, utilizado para gravar e deixar sempre
acessíveis as versões do código. O repositório local é a
pasta/diretório de sua máquina, no qual está seu projeto.
No Git, o código fonte do projeto é o tronco principal,

chamado master. A partir do master, são criadas
ramificações, chamadas branches. Cada tarefa do projeto é
feita em uma branch e, depois de concluída, unificada no
master. Assim, podemos ter várias tarefas de vários
programadores sendo feitas ao mesmo tempo
independentemente e, mesmo assim, manter a integridade
da master.
SENAI 1
Criando um repositório remoto no GitHub

Para deixar o projeto acessível, é necessário criar um repositório
remoto, ou seja, publicá-lo online usando a plataforma gratuita
chamada GitHub.
Acesse o site do
GitHub
(https://github.com).
Na tela da home,
clique em “Sign up”
para criar uma conta. Git – Fonte: https://github.com/.
Feito o cadastro no site,

clique em “Sign in”
para acessar seu perfil.
Depois, clique em “New

repository”, para criar o
repositório.
Git – Fonte: https://github.com/.
SENAI 2
Agora, siga o passo a passo:
1) Preencha com o
tipo de usuário.
2) Atribua um nome
ao repositório.
3) Opcionalmente,
faça uma breve
descrição do
repositório.
4) Escolha o tipo de
visualização do
repositório:
▪ Public: qualquer
pessoa pode ver
o projeto.
▪ Private: apenas
Git – Fonte: https://github.com/new. o proprietário
pode ver o
projeto.
5) Escolha quais arquivos podem ser criados junto com o
repositório:
• README: arquivo de informações sobre o projeto, que
funciona como cartão de visitas e histórico. É opcional, mas
altamente recomendado.
• .gitignore: arquivo especial do Git. Os arquivos listados dentro
dele são ignorados pelo Git.
• License: licença do seu projeto.
6) Para finalizar, clique em “Create repository” para criar o
repositório.
SENAI 3
Criando um repositório local no Git

Depois de criado o repositório remoto, é necessário cloná-lo no
repositório local. Desse modo, é possível publicar arquivos locais
ou importar arquivos remotos.
O primeiro passo é
acessar o site https://git-
scm.com/downloads,
baixar e instalar o Git.
GitHub – Fonte: https://github.com/.
Agora, abra um prompt de comando em seu computador para

fazer as configurações iniciais do Git e digite os seguintes
comandos:
• git config --global user.name “Seu nome”
Importante: O seu nome deve corresponder ao seu usuário do
GitHub. Por exemplo, caso seu usuário criado seja joaodasilva-
123456789, faça git config --global user.name “joaodasilva-
123456789”, aperte “enter” e depois digite:
• git config --global user.email exemplo@seuemail.com.br
Importante: O e-mail que você irá configurar deve ser o mesmo
utilizado para criar a conta no GitHub.
SENAI 4
Começando a usar o Git

Agora é o momento de clonar o repositório remoto em sua
máquina.
Acesse o site do GitHub, entre no repositório remoto do projeto

e clique em “Code”, depois em “HTTPS” e copie o link.
GitHub – Repository – Fonte: https://github.com/.
Em sua máquina, dentro da pasta do projeto, clique com o botão

direito do mouse, selecione a opção “git bash here” para abrir o
terminal do Git e digite os comandos:
• git init: para iniciar o Git.
• git remote add origin: para colar a URL copiada do GitHub.
Exemplo: git remote add origin https://github.com/seu-
usuario/seu-repositorio-criado. Dessa forma, a sua máquina local
será sincronizada com o repositório do Git.
SENAI 5
Além desses dois comandos iniciais, há outros comandos que são

importantes:
• git status: utilizado para verificar os arquivos alterados;

• git clone: utilizado para copiar um repositório local;
• git add nome-do-arquivo: adiciona o arquivo alterado para o
staging;
• git add . : adiciona todos os arquivos alterados;
• git commit -m “comentário”: confirma e salva as alterações no
histórico;
• git push origin master: publica os arquivos locais no repositório
remoto;
• git pull: importa as atualizações do repositório remoto para a sua
máquina;
• git log: utilizado para ver o histórico do projeto, ou seja, ver os
commits já feitos em uma branch;
• git branch: cria uma nova branch;
• git checkout: utilizado para navegar entre as branchs;
• git merge: utilizado para fazer a junção de branch;
• git pull origin master: utilizado para atualizar o repositório local.
Dica!
Antes de iniciar os trabalhos, é uma boa prática fazer o
comando git pull origin nome-branch. Assim, evita-se o
trabalho em um código desatualizado, minimizando
conflitos.
SENAI 6
Saiba mais
Para mais informações, clique e acesse o site do Git
https://git-scm.com/docs e leia a documentação disponível.
SENAI 7
Criando Projeto
Tutorial para criar o projeto
Neste material, abordaremos o conteúdo do vídeo sobre como criar

um projeto Java no IntelliJ.
1. Abra seu IntelliJ e selecione a opção “New Project”.
SENAI 1
2. Selecione a opção “Java” e clique em “Next”.
SENAI 2
3. Selecione a opção “Create Project from template” para que seja

criada uma classe java, denominada Main, contendo já um método
principal para execução do projeto. Clique em “Next”.
SENAI 3
4. Agora, escolha um nome para o projeto, o local onde ele será

armazenado e também um pacote principal – no caso, sp.senai. Na
sequência, clique em “Finish” e o projeto será criado.
SENAI 4
5. Seu projeto estará pronto para ser codificado. Note que, ao lado
esquerdo da tela, foi criada uma estrutura de pastas. Dentro da pasta
src do projeto, podemos encontrar o pacote sp.senai e, dentro desse
pacote, a classe Main. Mais ao centro da tela, temos a aba da classe
Main aberta. Note que já foi criado um método Main para executar a
classe.
SENAI 5
6. Agora, vamos criar um pacote chamado Model; ele armazenará

possíveis classes oriundas da modelagem do sistema. Em nosso
exemplo, conforme o diagrama de classes a seguir, esta será uma
classe chamada Pessoa, com os atributos nome, idade e o método
construtor Pessoa – além de métodos de acesso aos atributos, e um
método chamado toString, para realizar a impressão do estado do
objeto.
Para criar o pacote Model, do lado esquerdo, clique com o botão

direito do mouse na pasta SRC e selecione a opção “NEW/PACKAGE”.
SENAI 6
7. Na sequência, digite o nome do pacote e aperte “enter”.
Poderemos notar que o pacote Model foi adicionado ao projeto com

sucesso:
SENAI 7
8. Agora, iremos criar a classe Pessoa dentro do projeto. Para isso,

clique sobre o pacote Model com o botão direito do mouse e vá na
opção “NEW”, em seguida, “JAVA CLASS”. Defina o nome da classe
como Pessoa e aperte “enter”.
Após a criação da classe Pessoa, seu projeto estará da seguinte forma:
SENAI 8
9. Vamos implementar o diagrama de classes da classe pessoa.

Primeiramente, vamos criar os atributos nome e idade.
SENAI 9
10. Agora, vamos utilizar os atalhos do IntelliJ IDEA para criar os

métodos de acesso aos atributos e, também, o método construtor.
Para isso, após clicar no editor de código na classe Pessoa, clique nas
teclas ALT + INSERT do seu teclado. Selecione a opção “Getter and
Setter” no menu que será aberto.
SENAI 10
11. Na tela seguinte, selecione os dois atributos e clique em “Ok”.
SENAI 11
12. Após esse procedimento, você irá notar que os métodos sets e
gets foram criados.
SENAI 12
13. Segundo o encapsulamento, os métodos de uma classe devem

ficar escondidos – e apenas seus métodos de acesso devem ficar
visíveis. Para isso, iremos deixar os atributos privados.
SENAI 13
14. Agora, iremos criar o método construtor. Lembrando que o

método construtor é um método sem retorno, que possui o mesmo
nome da classe. Uma classe pode possuir mais de um método
construtor; quando um construtor não for criado, o próprio Java cria
um vazio em tempo de execução. Em nosso diagrama de classes foi
declarado um método construtor; portanto, iremos criá-lo. Vamos
novamente selecionar o atalho ALT + INSERT e, agora, clicar na opção
“Constructor”. Selecione os dois atributos e clique em “Ok”.
SENAI 14
15. Note que foi criado um método contendo o próprio nome da

classe e os dois atributos selecionados como parâmetros de entrada.
No corpo desse método, podemos notar que a palavra this é utilizada
para acessar diretamente os atributos – porém, foram criados
métodos sets para essa tarefa.
SENAI 15
16. Vamos alterar o método construtor para que os atributos da

classe sejam acessados apenas pelos métodos sets. Para isso, realize a
seguinte alteração.
SENAI 16
17. Para finalizar a classe Pessoa, precisamos implementar o método

toString. Esse método é nativo do Java; portanto, toda classe já o
herda automaticamente. Vamos reescrevê-lo para que ele possa
imprimir os valores dos atributos da classe Pessoa.
A palavra reservada Override serve para realizar a sobrescrita do

método.
SENAI 17
18. Agora, trabalharemos na classe Main, que será a responsável por

executar o projeto. Nesta classe, iremos criar instâncias da classe
Pessoa, gerando alguns objetos. Iremos armazená-los em uma lista –
criando, assim, uma Coleção de objetos.
Primeiramente, vamos importar a classe Pessoa na classe mãe:
SENAI 18
19. Na sequência, iremos criar três objetos da classe pessoa: os

objetos p1, p2 e p3. Lembrando que a classe pessoa possui um
método construtor que pede como parâmetro nome e idade;
portanto, para gerar as instâncias da classe pessoa, precisamos passar
esses valores como parâmetros.
SENAI 19
20. Agora, para criar a nossa lista de objetos, iremos importar a classe
ArrayList. No código na sequência, logo após a criação dos três
objetos, criaremos um objeto chamado lista – que é uma instância da
classe ArrayList. Usaremos a propriedade add para inserir os objetos
criados à lista.
SENAI 20
21. Agora, iremos criar um laço de repetição para imprimir todos os

objetos armazenados na lista. Basicamente, esse laço é repetido
enquanto houver itens na lista, realizando a impressão de um a um.
Note que estamos imprimindo os objetos existentes na lista. Portanto,

o método toString da classe pessoa está sendo invocado
automaticamente, pois é um método que realiza a impressão do
estado do objeto – porém, nós o configuramos para realizar a
impressão do nome e da idade.
SENAI 21
Criando classes e
instâncias
Criando Classes
1. Para criar uma classe utilizando o IntelliJ, clique com o botão direito
na pasta/package sp.senai, depois selecione New e, em seguida, Java
Class.
SENAI 1
2. Na janela pop-up, entre com o nome da classe desejada. Digite o

nome Aluno e tecle enter.
Imagem da classe Aluno após sua criação:
Código da classe Aluno:

package sp.senai;
public class Aluno {

}
SENAI 2
3. Agora vamos incluir as propriedades (Id, Nome, Email,

DataNascimento) e métodos (ValidarEmail) da classe Aluno.
Código inserido:
package sp.senai;
import java.util.Date;
import java.util.regex.Pattern;
public class Aluno {

// atributos
private int id;
private String nome;
private String email;
private Date dataNascimento;
// métodos
public boolean validarEmail(String emailDeEntrada) {
return Pattern.matches("^(.+)@(.+)$", emailDeEntrada);
}
}
SENAI 3
Criando instâncias de classe
Agora que já sabemos como criar uma classe, vamos criar uma
instância dela, ou seja, criar um objeto.
1. Para realizar a criação de um objeto (instância) de uma classe,

utiliza-se a palavra new e em seguida o nome da classe.
Código para criar uma instância aluno da classe Aluno.
package sp.senai;
public class Main {

Aluno aluno = new Aluno();
}
SENAI 4
Métodos get e set
Nesse conteúdo, vamos mostrar um exemplo de como usar os

métodos get e set, usando atalhos do IntelliJ. Podemos realizar a
criação desses métodos utilizando recursos da IDE, facilitando e
otimizando o desenvolvimento.
1. Crie a classe Curso, clicando com o botão direito na pasta/package

sp.senai, depois selecione New e, em seguida, Java Class. Nomeie a
classe como Curso e tecle enter.
SENAI 1
2. Na janela pop-up, nomeie a classe como Curso e tecle enter.
SENAI 2
3. Abra a classe/arquivo Main e crie uma instância da classe Curso,

digitando:
Curso curso = new Curso();
Na linha abaixo, digite:
curso.
E clique ALT + Insert para abrir um menu. Escolha a opção

setNomeCurso().
SENAI 3
4. O próprio IntelliJ irá inserir parte do código. Digite Banco de Dados

e Java como parâmetros do método set.
A seguir, o código comentado:
package sp.senai;
public class Main {

// alterando o nome do curso
curso.setNomeCurso("Banco de Dados e Java");
// acessando o nome alterado do objeto curso
System.out.println(curso.getNomeCurso());
}
}
A compilação mostrará o nome do curso como Banco de Dados e Java.
SENAI 4
5. Agora no arquivo/classe Curso, digite o bloco de código usando o

atalho ALT + Insert. Atenção aos comentários marcando o código.
package sp.senai;
public class Curso {
// atributo nome do curso
private String nomeCurso;
// metodo para alterar o nome do curso
public void setNomeCurso(String curso) {
nomeCurso = curso; // armazena o nome do curso
} // fim do metodo
// metodo para recuperar o nome do curso
public String getNomeCurso() {
return nomeCurso; // retorno do valor
} // fim do metodo
private int quantidadeAlunos;
}
SENAI 5
6. Vamos adicionar um novo campo à classe Curso, chamado de

quantidadeAlunos.
Aperte ALT + Insert para abrir a janela pop up de opções. Selecione os

métodos que deseja adicionar e aperte enter.
SENAI 6
7. Clique em Ok para adicionar e os métodos serão gerados

automaticamente.
package sp.senai;

} // fim do metodo
} // fim do metodo
public int getQuantidadeAlunos() {
return quantidadeAlunos;
}
public void setQuantidadeAlunos(int quantidadeAlunos) {
this.quantidadeAlunos = quantidadeAlunos;
}
}
SENAI 7
Construtores
As instâncias são criadas através do método construtor. Também é

possível criar o método construtor através do atalho ALT + Enter. Siga
adiante para aprender como.
1. Como o método construtor é criado dentro da classe, devemos ter a

classe pronta. Clique com o botão direito na pasta sp.senai, no lado
esquerdo, e escolha a opção New. Em seguida, clique em Java Class.
SENAI 8
2. Nomeie a nova classe como Curso e tecle enter.
Está criada a classe Curso
SENAI 9
3. Na classe Curso, depois de inserir os getters e setters, clique dentro

das chaves e tecle ALT + insert para apresentar as opções da classe.
Clique em Constructor.
Para indicar a inicialização da classe Curso com o nome, você pode

criar um construtor recebendo o nome como argumento. Pode-se
identificar qual será o parâmetro na construção de um curso.
SENAI 10
4. Um problema irá ocorrer ao adicionar esse construtor, pois na classe

principal (Main), a instância da classe Curso não passa uma String do
nome do curso como argumento.
SENAI 11
O código da classe Curso.
package sp.senai;

} // fim do metodo
} // fim do metodo
}
}
// construtor com argumentos
public Curso(String nomeCurso) {
this.nomeCurso = nomeCurso;
}
}
SENAI 12
5. Na classe Main, crie uma instância da classe Curso digitando:
Dentro dos parênteses, digite “Curso com construtor” como argumento

do construtor. O código ficará:
Curso curso = new Curso(“Curso com construtor”);
SENAI 13
6. Quando uma mesma classe possui mais de um método construtor,

realiza-se assim um processo chamado sobrecarga de métodos, em
que métodos com mesmo nome e assinaturas diferentes são
declarados na mesma classe. Veja um exemplo.
SENAI 14
O código mostrado na imagem:
package sp.senai;

} // fim do metodo
} // fim do metodo
}
}
// construtor sem argumentos
public Curso() {
}
// construtor com argumentos
public Curso(String nomeCurso) {
this.nomeCurso = nomeCurso;
}
}
Dica!
Na linguagem de programação Java, utiliza-se a palavra
reservada this para realizar referência às propriedades da
própria classe (objeto).
SENAI 15
MySQL e MySQL Workbench
Instalação e configuração
Neste tutorial, você acompanhará a instalação e a configuração do

banco de dados MySQL e do sistema gerenciador de banco de dados
MySQL Workbench.
1. Acesse: https://dev.mysql.com/downloads/mysql/ e clique em

Go To Download Page para ser redirecionado para a próxima página.
SENAI 1
2. Clique na segunda opção de Download para realizar o download

completo do MySQL Community Server.
3. Clique na opção No thanks, just start my download.
SENAI 2
4. Clique duas vezes no arquivo baixado para iniciar a execução.
5. Cada opção possui recursos pré-selecionados e a versão Custom

instala todos os recursos disponíveis.
Neste tutorial, vamos optar pela versão Developer Default, que

contém o MySQL Server e o MySQL Workbench (interface gráfica).
Clique em Next para ir para a próxima etapa.
SENAI 3
6. Na próxima etapa, é necessário verificar se todos os itens

requeridos estão instalados em seu computador. Se estiver tudo OK,
clique em Next (A). Caso contrário, selecione o item pendente (B) para
realizar a instalação.
SENAI 4
7. No instalador do MySQL Server, clique em Check (A) após a

instalação do requisito pendente para verificar se tudo está instalado
e configurado conforme esperado. Clique em Next (B) para dar
continuidade.
SENAI 5
8. Clique em Execute para finalizar o processo de instalação dos

recursos necessários.
SENAI 6
9. Aguarde até que todas as etapas sejam concluídas.
SENAI 7
10. Após o término da instalação, clique em Next para avançar à próxima

etapa.
SENAI 8
11. Clique em Next para iniciar a etapa de configuração do produto.
SENAI 9
12. Neste tutorial, vamos manter as configurações padrões de conexão

e rede.
Clique em Next para avançar para a próxima etapa.
SENAI 10
13. Nesta etapa, vamos escolher o método de autenticação. A partir da

versão 8, é recomendado escolher o tipo de criptografia melhorado (A)
disponível para instalação.
SENAI 11
14. O usuário padrão, chamado de root, deverá configurar uma senha

(A). Nesse exemplo, vamos adicionar a senha: root. Você poderá
escolher uma senha de seu interesse.
Clique em Next (B) para avançar para a próxima etapa.
SENAI 12
15. Nesta etapa, iremos adicionar o MySQL Server para iniciar quando
o sistema operacional for iniciado (A) e será configurado como um
serviço do Windows (B).
Clique em Next (C) para avançar à próxima etapa.
SENAI 13
16. Clique em Execute para avançar para aplicar as configurações

selecionadas nas etapas anteriores.
SENAI 14
17. Aguarde o término da instalação.
SENAI 15
SENAI 16
SENAI 17
SENAI 18
SENAI 19
22. Para conferir se a conexão e o usuário foram configurados

corretamente, coloque o password (senha) criado anteriormente (em
nosso caso, root) e clique em Check para verificar se a conexão foi
bem sucedida (A).
SENAI 20
23. Clique em Execute para avançar à próxima etapa.
SENAI 21
SENAI 22
SENAI 23
SENAI 24
27. Você pode visualizar o console e a interface gráfica após a

instalação do produto.
SENAI 25
28. Agora é só fazer o login com a senha criada.
SENAI 26
Co n e x ã o c o m o Ba n c o
d e Da d o s
Nesse conteúdo, vamos abordar várias etapas para conectar o banco

de dados MySQL, mediante um exemplo prático. Vamos mostrar
como:
• Estabelecer a conexão;
• Executar comando de ação;
• Efetuar consultas;
• Fazer uma atualização em lote.
Iniciando projeto
1. Abra o IntelliJ e clique em “New Project”.
SENAI 1
2. Selecione a opção “Java” e clique em “Next”.
SENAI 2
3. Marque a opção “Create Project from template (Comand Line

App)” e pressione “Next”.
SENAI 3
4. Nomeie o projeto como prj_banco_de_dados e note que a

localização do projeto é automática (no caso, a pasta
prj_banco_de_dados na área de trabalho). Denomine o pacote base
como sp.senai e clique em “Finish”.
SENAI 4
5. Aguarde alguns segundos e o projeto será carregado.
Confira o código criado de modo imediato na classe Main.
package sp.senai;
public class Main {

// write your code here
}
}
SENAI 5
Gerando as tabelas
1. Dê um duplo clique no arquivo bd.sql para abri-lo com o MySQL

Workbench, rode o script e gere as tabelas.
Dica!
O arquivo bd.sql disponibilizado é apenas um script, como
um texto, que abrimos no Workbench e executamos os
scripts para gerar a tabela. Depois de criada a tabela, o
arquivo fica sem uso e pode até ser excluído, pois o banco
de dados se encontra no interior do MySQL. Portanto, não
há necessidade de fazer uma pasta para salvá-lo.
SENAI 6
2. Selecione trecho por trecho do script antes de rodá-lo. Escolha a

linha “create database SistemaEnsino;” (a) e clique em “Run” (b) para
produzir o banco de dados chamado Sistema de Ensino (c).
b
a
SENAI 7
3. Selecione a linha “use SistemaEnsino;” (a) e clique em “Run” (b)

para inserir o sistema em uso (c).
b
a
SENAI 8
4. Opte pelo trecho da tabela (a) e clique em “Run” (b) para criar a
tabela (c).
SENAI 9
5. Selecione o trecho de inserção de dados (a) e pressione “Run” (b)

para incluir dados na tabela (c).
SENAI 10
6. Escolha a linha “select * fromAlunos;” (a) e clique em “Run” (b) para

selecionar tudo da tabela Alunos (c).
Os dados que a tabela mostra são:
AlunoId Nome DataNascimento Email Turma

1 Luiz 1984-02-18 luiz@gmail.com 2A
2 Fabio 1980-12-27 fabio@gmail.com 2A
3 Caique 1994-05-19 caique@gmail.com 1B
4 Maria 1992-10-15 maria@gmail.com 1B
O banco MySQL já está pronto e em funcionamento.
SENAI 11
Verifique, a seguir, o script do bd.sql:

create database SistemaEnsino;
use SistemaEnsino;
create table Alunos
(
AlunoId INT AUTO_INCREMENT PRIMARY KEY,
Nome VARCHAR(120) NOT NULL,
DataNascimento DATE,
Email VARCHAR(120) UNIQUE,
Turma VARCHAR(2)
);
insert into Alunos (Nome, DataNascimento, Email, Turma) values ('Luiz','1984-02-

18','luiz@gmail.com','2A');
insert into Alunos (Nome, DataNascimento, Email, Turma) values ('Fabio','1980-12-
27','fabio@gmail.com','2A');
insert into Alunos (Nome, DataNascimento, Email, Turma) values ('Caique','1994-05-
19','caique@gmail.com', '1B');
insert into Alunos (Nome, DataNascimento, Email, Turma) values ('Maria','1992-10-
15','maria@gmail.com', '1B');
select * from Alunos;
SENAI 12
Conexão com banco de horas
1. Antes de iniciar, adicione o driver JDBC ao módulo do projeto. Para

tanto, clique com o botão direito do mouse na pasta do projeto (no
exemplo é a pasta fundamentos) e opte pelo “Open Module Settings”.
Dica!
Não é necessário seguir essa estrutura de pastas.
SENAI 13
Conexão com banco de horas
Para facilitar a próxima etapa, a conexão com o banco de dados,

iremos copiar um arquivo que foi instalado junto com o MySQL para a
pasta do projeto.
1. Em seu computador, procure o arquivo mysql-conector-java-

8.0.27.jar no caminho C:\\Arquivos de Programas
(x86)\MySQL\Connector J 8.0.
SENAI 14
2. Copie o arquivo e cole-o dentro da pasta do projeto

prj_banco_de_dados.
SENAI 15
3. Abra o IntelliJ, clique com o botão direito na pasta do projeto

prj_banco_de_dados e escolha a opção “Open Module Settings”.
SENAI 16
4. Clique na guia “Dependencies” (A) e, depois, no sinal de “+” (B).
SENAI 17
5. Selecione “JARs and Directories”.
SENAI 18
6. Localize, na pasta do projeto prj_banco_de_dados, o arquivo que foi

copiado, o driver de conexão do MySQL. Logo após, clique em “OK”.
SENAI 19
7. Clique em “OK”.
SENAI 20
8. Agora, o projeto está com o driver do MySQL instalado e o banco

MySQL pronto e em funcionamento.
SENAI 21
9. Dentro da classe Main, elaboraremos a URL de conexão com o

banco de dados. Marque a URL do banco de dados com um
comentário de uma linha, e digite:
//URL do banco de dados
Na linha abaixo do comentário, tecle a URL:
static final String DATABASE_URL =

"jdbc:mysql://localhost:3306/SistemaEnsino";
Localhost é a máquina local; 3306, a porta padrão e SistemaEnsino, o

nome do banco de dados criado no MySQL.
SENAI 22
10. Para realizar a importação de diversas funcionalidades do SQL,

digite na linha abaixo do package sp.senai;
import.java.sql.*;
SENAI 23
11. No interior da função main, crie um objeto denominado

connection do tipo Connection para gerenciar a conexão, um objeto
stm do tipo Statement para instrução de consulta e um objeto rs do
tipo ResultSet para administrar o resultado. Vamos marcar a função de
cada objeto em um comentário de uma linha.

Connection connection = null; // gerencia a conexao
Statement stm = null; // instrucao de consulta
ResultSet rs = null; // gerencia o resultado
}
SENAI 24
12. Em seguida, produza uma estrutura try/catch para tratar um

possível erro. No interior do try, iremos precisar de conexão, consulta
e resultado do banco de dados. Para isso, digite o código:
try {
// estabelece a conexao com o banco
connection = DriverManager.getConnection(DATABASE_URL,
"root", "root");
// cria statement para a consulta ao banco
stm = connection.createStatement();
// consulta o banco
rs = stm.executeQuery("select * from alunos");
}
SENAI 25
13. Para apresentar o resultado, criaremos um laço com um método

get para cada coluna da tabela. Atenção ao usar o mesmo tipo de dado
da coluna no método get correspondente. No final, fecharemos a
conexão.
// apresenta o resultado
while (rs.next())
System.out.println(rs.getInt(1) +
" " + rs.getString(2) +
" " + rs.getDate(3) +
" " + rs.getString(5));
connection.close();
SENAI 26
14. Para testar, clique em “Run”, localizado no menu superior, e, logo

em seguida, em “Run ‘Main’”.
A compilação deve mostrar no terminal o resultado:
1 Luiz 1984-02-18 luiz@gmail.com 2A

2 Fabio 1980-12-27 fabio@gmail.com 2A
SENAI 27
Confira a seguir o código completo.

package sp.senai;
import java.sql.*;
public class Main {
// URL do banco de dados


Connection connection = null; // gerencia a conexao
Statement stm = null; // instrucao de consulta
ResultSet rs = null; // gerencia o resultado
try {
// estabelece a conexao com o banco
"root", "root");
// cria statement para a consulta ao banco
// consulta o banco
// apresenta o resultado
while (rs.next())
System.out.println(rs.getInt(1) +
connection.close();
} catch (SQLException se) {
se.printStackTrace();
}
}
}
SENAI 28
15. Agora, faremos uma atualização de dados na tabela do banco de

dados. Para tanto, mudaremos a linha do stament.
Perceba que o trecho do início do código até a criação do statement

permanece igual.
package sp.senai;
import java.sql.*;
public class Main {
//URL do banco de dados


Connection connection = null; //gerenciar a conexao
Statement stm = null; //instrução de consulta
ResultSet rs = null; //gerenciar o resultado
try{
//estabelecer uma conexao com o banco
"root", "root");
//criar statement para consulta ao banco
SENAI 29
Neste trecho (depois de criar o stament), o código se modifica para

executar uma atualização no banco de dados. A linha de código:
stm.execute("update alunos set turma = '2C' where turma='2A';");
O statement vai executar uma atualização em lote: os alunos cuja

turma for 2A serão alterados para 2C. Observe que a parte de
apresentar o resultado não muda.
//executa o comando no banco

stm.execute("update alunos set turma = '2C' where turma =
'2A';");
//apresentar o resultado
while(rs.next())
System.out.println(rs.getInt(1)+
" " + rs.getString(4)+
connection.close();
}catch (SQLException se){
se.printStackTrace();
}
}
}
SENAI 30
16. Após essas alterações, salve o arquivo e clique em “Run”, no menu

superior, e, depois, em “Run ‘Main’”.
SENAI 31
17. Após a atualização ter sido feita, o terminal do IntelliJ apresentará

o seguinte resultado:
1 Luiz 1984-02-18 luiz@gmail.com 2C

2 Fabio 1988-12-27 fabi@gmail.com 2C
SENAI 32
Note que todos os alunos que eram da turma 2A foram atualizados

para a turma 2C, logo, uma atualização que afetou mais de um
estudante ao mesmo tempo.
18. Se você abrir o banco de dados no MySQL, clicar na linha select *

from Alunos; e der um play, verá que os alunos Luiz e Fabio, que
estavam na turma 2A, agora se encontram na turma 2C.
SENAI 33
Importante
Precisamos prestar atenção ao realizar updates, pois o uso
incorreto da cláusula where, responsável por filtrar os
registros que serão alterados, pode ocasionar em perdas de
informações irrecuperáveis dentro de um sistema de banco
de dados.
Ao atualizar o nome de um cliente, por exemplo, especifique o registro,

caso contrário o nome de todos os clientes serão modificados.
Imagine uma loja de discos que quer colocar em promoção todos os

álbuns de um artista. Se a cláusula where não for definida corretamente,
toda a loja pode entrar em promoção, o que provavelmente ocasionará
enormes prejuízos.
SENAI 34

Banco de Dados em Aplicativos Mobile Java

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Banco de Dados em Aplicativos Mobile Java

Enviado por

Direitos autorais:

Formatos disponíveis

BANCO DE DADOS EM

APLICATIVOS MOBILE JAVA

Banco de Dados em Aplicativos Mobile Java | SENAI 2

Banco de Dados em Aplicativos Mobile Java | SENAI 3

Esperamos que você desenvolva, no decorrer de seus estudos, as seguintes capacidades:

• Reconhecer as características de interoperabilidade do banco de dados

Para desenvolver tais capacidades, você deverá estudar os seguintes temas:

• Definição e tipos de banco de dados.

Banco de Dados em Aplicativos Mobile Java | SENAI 5

A empresa Coma bem, especializada no comércio eletrônico de produtos alimentícios,

Carne R$ 30,00 2 kilos

Óleo R$ 10,00 1 unidade

Leite R$ 5,00 1,5 litros

Alface R$ 3,00 1 unidade

Para tanto, você deverá realizar os seguintes desafios:

Modelar o projeto de banco de dados, aplicando procedimentos de normalização e

Criar o banco de dados, aplicando regras de segurança e níveis hierárquicos.

Banco de Dados em Aplicativos Mobile Java | SENAI 6

• Modelar o projeto de banco de dados, aplicando procedimentos de

Para isso, você estudará os seguintes conteúdos:

• Definição e tipos de banco de dados.

Banco de Dados em Aplicativos Mobile Java | SENAI 7

Um sistema online de vendas, por exemplo, é constituído por produtos, preços,

MODELOS DE BANCO DE DADOS

Banco de Dados em Aplicativos Mobile Java | SENAI 8

Cada campo de dados apresenta estrutura rígida e constante de representação

Os bancos de dados estruturados podem ser relacional ou hierárquico:

O Modelo Relacional ou Modelo Entidade-Relacionamento (MER) é o modelo con-

Dados mapeados para tabelas com seus respectivos relacionamentos

IDAlbum Nome Ano IdBanda IdEstilo

5 Walk to you 2021 1 3

6 Above All 2021 2 1

Banco de Dados em Aplicativos Mobile Java | SENAI 9

ramos da árvore que se interconectam até chegar às tabelas na última camada,

Fonte: próprio autor

Conjunto de dados sem uma organização ou hierarquia interna específica e abrange

Os bancos de dados não estruturados são não relacionais.

Banco de Dados em Aplicativos Mobile Java | SENAI 10

Estrutura de documentos do Mongo

Neste conteúdo, trabalharemos com o modelo de banco de dados relacional.

• um conjunto de objetos básicos — as entidades;

Banco de Dados em Aplicativos Mobile Java | SENAI 11

As entidades, os atributos e relacionamentos são as construções básicas de um

Siga em frente e conheça mais sobre cada um desses conceitos.

1 Realização de transações de curta duração e pequeno volume de dados manipulado.

Banco de Dados em Aplicativos Mobile Java | SENAI 12

A entidade é a reprodução abstrata de um objeto do mundo real a ser representado

Fonte: próprio autor

A entidade fraca depende de outra entidade para existir. No relacionamento entre

Banco de Dados em Aplicativos Mobile Java | SENAI 13

As entidades associativas são criadas para simplificar várias relações. O exemplo

Fonte: próprio autor

O atributo é uma característica da entidade que tem valor para o negócio.

Há vários tipos de atributos. Conheça alguns deles.

É o elemento de dado que con-

Banco de Dados em Aplicativos Mobile Java | SENAI 14

O atributo composto é formado por um ou mais subatributos, podendo ser dividido

Fonte: próprio autor

O atributo multivalorado representa o elemento de dado que, em uma única entidade,

• A primeira é mantê-lo como multivalorado e permitir que mais de um

No exemplo a seguir, foi aplicada a normalização e criada uma tabela para os

Banco de Dados em Aplicativos Mobile Java | SENAI 15