WEBVTT

00:00:05.434 --> 00:00:09.154
Trabalhar com padrões dentro 
da programação é muito importante.

00:00:09.154 --> 00:00:11.674
Nós vamos ver agora
um pouquinho de JavaBeans,

00:00:11.674 --> 00:00:15.044
que é a forma de padronizar
a implementação do conceito

00:00:15.044 --> 00:00:17.610
de encapsulamento 
de orientação a objetos.

00:00:17.610 --> 00:00:20.624
Na programação Java,
é usual criarmos classes

00:00:20.624 --> 00:00:23.174
para que essas classes 
possam gerar objetos

00:00:23.174 --> 00:00:26.240
a serem reutilizados
em vários outros sistemas.

00:00:26.240 --> 00:00:31.328
A especificação JavaBeans padroniza 
justamente a criação dessas classes,

00:00:31.328 --> 00:00:33.620
que nós batizamos 
de classes beans.

00:00:33.620 --> 00:00:37.028
Para fazer uma classe Java
ser uma classe JavaBeans,

00:00:37.028 --> 00:00:39.528
você precisa seguir 
três regras.

00:00:39.528 --> 00:00:44.132
A primeira, é que essa classe precisa
implementar um construtor padrão

00:00:44.132 --> 00:00:46.312
mesmo que você tenha
um construtor de classe.

00:00:46.312 --> 00:00:50.312
Por quê? Porque outras APIs
vão se utilizar desse construtor padrão

00:00:50.312 --> 00:00:52.436
para criação
de um JavaBean.

00:00:52.436 --> 00:00:55.322
A segunda regra é o conceito
de encapsulamento.

00:00:55.322 --> 00:00:58.986
É necessário você encapsular
os atributos, ou seja,

00:00:58.986 --> 00:01:03.435
proteger esses atributos
e permitir que outros métodos

00:01:03.435 --> 00:01:05.196
acessem sim
esses atributos.

00:01:05.196 --> 00:01:08.105
E a terceira regra que, 
na realidade, é uma boa prática,

00:01:08.105 --> 00:01:10.996
é você implementar
a interface Serializable.

00:01:10.996 --> 00:01:15.003
Essa interface vai marcar aquela classe 
como uma classe serializável.

00:01:15.003 --> 00:01:16.513
O que significa isso?

00:01:16.513 --> 00:01:19.813
Todos os dados que estiverem
contidos no objeto

00:01:19.813 --> 00:01:23.046
serão transformados em bits
para serem trafegados

00:01:23.046 --> 00:01:25.676
sem que a informação
seja tão transparente.

00:01:25.676 --> 00:01:28.203
Para entender um pouquinho mais
a criação de uma classe

00:01:28.203 --> 00:01:32.273
no padrão JavaBeans, vou criar
uma nova classe chamada "pessoa"

00:01:32.273 --> 00:01:34.520
dentro do projeto
do sistema bancário.

00:01:34.520 --> 00:01:37.603
Vou clicar no pacote aqui
com o botão direito,

00:01:37.603 --> 00:01:39.953
opção New, 
opção Class.

00:01:39.953 --> 00:01:44.900
Vou nomear a classe 
com o nome pessoa e dar um finish.

00:01:44.900 --> 00:01:47.489
Essa classe, por hora, 
é uma classe comum.

00:01:47.489 --> 00:01:50.969
Mas eu vou criar o atributo
nome da pessoa,

00:01:50.969 --> 00:01:53.199
só que eu já vou criar
no padrão JavaBeans,

00:01:53.199 --> 00:01:56.179
ou seja, eu vou encapsular
o atributo nome

00:01:56.179 --> 00:01:59.830
para que nenhuma outra classe 
externa altere esse nome.

00:01:59.830 --> 00:02:03.079
Então, eu declaro
o modificador private,

00:02:03.079 --> 00:02:05.960
declaro o atributo 
nome do tipo String,

00:02:05.960 --> 00:02:07.589
e ele está 
protegido.

00:02:07.589 --> 00:02:10.512
Nenhuma outra classe 
consegue alterar esse atributo.

00:02:10.512 --> 00:02:12.769
Mas eu preciso, 
de alguma forma,

00:02:12.769 --> 00:02:15.182
fazer com que esse 
atributo seja alterado,

00:02:15.182 --> 00:02:18.559
mas simplesmente por algum 
método da própria classe.

00:02:18.559 --> 00:02:20.719
É aí que eu utilizo
os métodos padrões

00:02:20.719 --> 00:02:22.869
chamados
getters and setters.

00:02:22.869 --> 00:02:26.439
O método get vai ser responsável
por obter aquela informação

00:02:26.439 --> 00:02:29.609
e o método set por alterar
aquela informação.

00:02:29.609 --> 00:02:32.119
Então, eu venho aqui
e defino esses métodos.

00:02:32.119 --> 00:02:34.049
Vou definir manualmente
e depois eu vou mostrar

00:02:34.049 --> 00:02:36.582
como fazemos
automaticamente.

00:02:36.582 --> 00:02:39.019
Ambos os métodos têm
modificadores públicos

00:02:39.019 --> 00:02:43.019
justamente para serem acessados
fora do escopo dessa classe.

00:02:43.019 --> 00:02:46.139
O método get vai retornar 
o tipo de dado

00:02:46.139 --> 00:02:49.399
justamente do atributo em questão, 
que é o atributo nome.

00:02:49.399 --> 00:02:54.584
Então, vai ter um retorno String
e o nome vai ser "getNome".

00:02:54.584 --> 00:02:56.544
Ele não vai ter 
nenhum parâmetro,

00:02:56.544 --> 00:03:02.287
e a grande lógica dele é retornar 
o nome daquele atributo da pessoa.

00:03:02.287 --> 00:03:05.387
Vou criar aqui também
o que chamamos de método set.

00:03:05.387 --> 00:03:08.137
Esse método não vai 
ter nenhum retorno.

00:03:08.137 --> 00:03:11.827
Vai ter o prefixo set mais o nome 
do atributo que eu quero trabalhar,

00:03:11.827 --> 00:03:13.957
e ele tem que receber 
como parâmetro

00:03:13.957 --> 00:03:17.357
o novo nome 
que será associado.

00:03:17.357 --> 00:03:19.367
E a lógica 
desse método é:

00:03:19.367 --> 00:03:22.437
eu alterar o atributo 
nome da classe

00:03:22.437 --> 00:03:25.082
pelo novo nome 
que veio de parâmetro.

00:03:25.082 --> 00:03:29.303
Nesse exemplo, nós criamos 
então o atributo nome, privado,

00:03:29.303 --> 00:03:33.413
e demos dois métodos
de acesso a esse atributo nome.

00:03:33.413 --> 00:03:35.973
Você pode pensar:
"Poxa, mas esses métodos

00:03:35.973 --> 00:03:37.853
estão simplesmente
fazendo o acesso

00:03:37.853 --> 00:03:40.583
de obter e de alterar 
a informação".

00:03:40.583 --> 00:03:44.662
Ok, mas eu posso colocar
mais lógicas dentro dos métodos,

00:03:44.662 --> 00:03:48.242
ou seja, o atributo não vai ser
acessado diretamente,

00:03:48.242 --> 00:03:51.432
mas esses métodos podem, 
além de alterar o atributo,

00:03:51.432 --> 00:03:54.242
fazer outras lógicas 
a respeito desse atributo.

00:03:54.242 --> 00:03:55.792
E para que essa classe 
realmente tenha

00:03:55.792 --> 00:03:58.112
a característica 
de uma classe JavaBeans,

00:03:58.112 --> 00:04:01.802
eu preciso implementar
a interface Serializable,

00:04:01.802 --> 00:04:06.092
que vai marcar aquela classe
como uma classe serializável.

00:04:06.092 --> 00:04:08.612
Então, eu adiciono lá
o implements,

00:04:08.612 --> 00:04:10.912
adiciono a interface
Serializable,

00:04:10.912 --> 00:04:13.546
que está dentro 
do pacote java.io.

00:04:13.546 --> 00:04:17.082
E, com isso, essa classe já é 
marcada como serializável,

00:04:17.082 --> 00:04:21.576
ou seja, quando eu gerar
um objeto a partir dessa classe pessoa,

00:04:21.576 --> 00:04:24.686
as informações desse objeto
serão serializáveis,

00:04:24.686 --> 00:04:29.236
transformadas, de fato, em pacotes de bits 
para serem trafegados pela rede.

00:04:29.236 --> 00:04:32.173
Note que, ao implementar
a interface Serializable,

00:04:32.173 --> 00:04:34.433
aparece em amarelinho
o nome da classe.

00:04:34.433 --> 00:04:35.513
Isso significa o quê?

00:04:35.513 --> 00:04:40.059
Que a classe está requisitando
algum identificador de serialização.

00:04:40.059 --> 00:04:41.199
Por que isso acontece?

00:04:41.199 --> 00:04:43.729
Porque eu posso ter num mesmo
ambiente de memória

00:04:43.729 --> 00:04:47.729
mais de um objeto da classe pessoa
com versões diferentes.

00:04:47.729 --> 00:04:51.419
Então, com isso, eu consigo identificar 
qual versão é aquele objeto

00:04:51.419 --> 00:04:53.559
para que os objetos
não se confundam.

00:04:53.559 --> 00:04:57.429
Então, eu posso simplesmente pegar 
a opção que o próprio Eclipse me dá,

00:04:57.429 --> 00:05:00.659
que é adicionar 
um default serialVersionUID.

00:05:00.659 --> 00:05:03.049
E aí você pode 
colocar a identificação

00:05:03.049 --> 00:05:05.185
que melhor for compatível 
com o seu projeto.

00:05:05.185 --> 00:05:07.169
Agora, eu vou 
fazer o seguinte:

00:05:07.169 --> 00:05:09.849
vou alterar o código
do meu sistema bancário

00:05:09.849 --> 00:05:11.999
da classe conta
e da classe teste

00:05:11.999 --> 00:05:14.865
para ser colocado 
no padrão de JavaBeans.

00:05:14.865 --> 00:05:17.129
Vou acessar 
a minha classe conta,

00:05:17.129 --> 00:05:20.479
e na classe conta eu vou fazer
as devidas alterações.

00:05:20.479 --> 00:05:25.676
A primeira coisa que eu devo fazer
é deixar encapsulado todos os atributos.

00:05:25.676 --> 00:05:28.426
Então, eu vou colocar 
o assessor private

00:05:28.426 --> 00:05:31.526
em todos os atributos
do escopo da minha classe.

00:05:31.526 --> 00:05:36.591
Então, private dentro de agência,
para o número da conta e para o saldo.

00:05:36.591 --> 00:05:41.051
Dessa forma, nenhuma dessas informações
pode ser alterada diretamente.

00:05:41.051 --> 00:05:43.378
Notem que, logo que eu 
protejo esses atributos,

00:05:43.378 --> 00:05:45.098
a classe teste 
passa a dar erro.

00:05:45.098 --> 00:05:48.048
Por quê? Porque tanto o saldo,
quanto a agência, quanto o número,

00:05:48.048 --> 00:05:50.308
não são mais acessíveis
diretamente.

00:05:50.308 --> 00:05:51.561
E isso está ok.

00:05:51.561 --> 00:05:53.588
Outra coisa que eu 
preciso fazer aqui

00:05:53.588 --> 00:05:55.968
é trabalhar com os métodos
getters and setters.

00:05:55.968 --> 00:05:57.438
Mas é claro que eu 
preciso identificar

00:05:57.438 --> 00:06:00.428
se todos eles são válidos
de serem colocados ou não.

00:06:00.428 --> 00:06:03.995
Por exemplo: eu posso permitir
a alteração de um saldo diretamente?

00:06:03.995 --> 00:06:05.658
Ou esse saldo só pode
ser atualizado

00:06:05.658 --> 00:06:07.875
através de um depósito
ou de uma retirada?

00:06:07.875 --> 00:06:10.628
Nesse caso, eu não preciso 
ter um método setSaldo,

00:06:10.628 --> 00:06:13.298
mas eu posso ter 
um método getSaldo.

00:06:13.298 --> 00:06:17.018
E aqui eu também posso ter
os métodos setAgencia, getAgencia,

00:06:17.018 --> 00:06:19.055
setNumero, getNumero.

00:06:19.055 --> 00:06:21.778
Nós podemos fazer essas
alterações na programação

00:06:21.778 --> 00:06:25.135
ou eu posso fazer a geração
automática dos getters and setters.

00:06:25.135 --> 00:06:28.612
Para fazer a alteração automática 
dos getters and setters,

00:06:28.612 --> 00:06:30.652
eu posso fazer
de duas maneiras.

00:06:30.652 --> 00:06:33.602
Eu posso clicar com o botão
direito no código,

00:06:33.602 --> 00:06:38.065
ir à opção Source, 
Generate Getters and Setters,

00:06:38.065 --> 00:06:41.863
ou, ainda, através 
do atalho Ctrl + Shift + S.

00:06:41.863 --> 00:06:45.025
Uma vez selecionada a opção
Generate Getters and Setters,

00:06:45.025 --> 00:06:49.306
eu seleciono quais os atributos 
que eu quero gerar os getters and setters.

00:06:49.306 --> 00:06:54.277
Nesse caso, eu quero simplesmente 
gerar da agência e do número.

00:06:54.277 --> 00:06:58.565
Clico em ok, e ele 
gera automaticamente

00:06:58.565 --> 00:07:01.275
os métodos getAgencia, 
setAgencia,

00:07:01.275 --> 00:07:03.723
getNumero, 
setNumero.

00:07:03.723 --> 00:07:07.165
"Mas, professor, e o método
getSaldo e setSaldo?".

00:07:07.165 --> 00:07:09.915
Nesse caso, para fazer 
as devidas adaptações,

00:07:09.915 --> 00:07:12.125
eu vou simplesmente
substituir

00:07:12.125 --> 00:07:16.689
o nome do método 
verificarSaldo para getSaldo,

00:07:16.689 --> 00:07:19.069
e a alteração do saldo
já está sendo realizada

00:07:19.069 --> 00:07:22.062
através dos métodos
retirar e depositar.

00:07:22.062 --> 00:07:25.323
Portanto, eu não preciso 
criar o método setSaldo.

00:07:25.323 --> 00:07:28.283
Para que essa minha classe
vire, de fato, um JavaBean,

00:07:28.283 --> 00:07:31.372
eu ainda preciso implementar
a interface Serializable.

00:07:31.372 --> 00:07:36.435
Então, basta fazer
o implements

00:07:36.435 --> 00:07:38.525
na interface 
Serializable.

00:07:38.525 --> 00:07:41.915
Eu posso completar
com um Ctrl + espaço,

00:07:41.915 --> 00:07:44.673
e também posso implementar
o meu controle de versão.

00:07:44.673 --> 00:07:47.365
Pois bem, agora vamos 
adaptar a classe teste

00:07:47.365 --> 00:07:49.525
para que ela possa 
usar a classe conta

00:07:49.525 --> 00:07:51.853
da maneira correta
no padrão de JavaBeans.

00:07:51.853 --> 00:07:54.895
Então, ao invés de eu acessar
diretamente o atributo,

00:07:54.895 --> 00:07:58.205
eu posso simplesmente 
setar essas informações.

00:07:58.205 --> 00:08:00.855
Ao invés de colocar 
o saldo como 50,

00:08:00.855 --> 00:08:05.006
então eu vou setar 
o método depositar...

00:08:07.357 --> 00:08:09.007
... com o valor 50.

00:08:09.007 --> 00:08:12.397
Então, não vai ser mais possível
eu alterar diretamente um atributo.

00:08:12.397 --> 00:08:16.287
Também vou dar
um set na agência

00:08:16.287 --> 00:08:20.766
passando o valor daquela
agência dentro do método

00:08:20.766 --> 00:08:25.696
e também o número da conta
através do método setNumero.

00:08:25.696 --> 00:08:29.266
Com isso, quaisquer lógicas
que eu tenha que fazer

00:08:29.266 --> 00:08:32.856
dentro da alteração de uma agência
ou dentro da alteração de um número,

00:08:32.856 --> 00:08:37.307
ou até no saldo, eu consigo fazer dentro 
desses métodos previamente criados,

00:08:37.307 --> 00:08:40.438
gerando assim, uma segurança
e uma melhor manutenção.

00:08:40.438 --> 00:08:42.647
E uma última alteração
a ser realizada aqui

00:08:42.647 --> 00:08:46.817
é alterar o método 
verificarSaldo para getSaldo

00:08:46.817 --> 00:08:50.249
em ambos os objetos 
que estamos trabalhando.

00:08:50.249 --> 00:08:53.537
"Ah, professor, eu preciso alterar
alguma coisa do construtor de classe?".

00:08:53.537 --> 00:08:57.147
Nesse caso, não, porque o construtor
de classe já está utilizando

00:08:57.147 --> 00:08:59.539
e alterando os atributos
da própria classe.

00:08:59.539 --> 00:09:02.547
Vou realizar o teste aqui,
e é possível verificar

00:09:02.547 --> 00:09:04.457
que não houve alteração
no resultado.

00:09:04.457 --> 00:09:07.207
Simplesmente 
implementamos um padrão

00:09:07.207 --> 00:09:10.179
que é muito utilizado 
no mercado de programação Java.

00:09:10.179 --> 00:09:14.267
Duas dicas muito importantes
a respeito do padrão JavaBeans.

00:09:14.267 --> 00:09:18.427
Primeira: nem todas as classes
devem ser colocadas nesse padrão.

00:09:18.427 --> 00:09:21.227
Somente aquelas classes
que carregam informações,

00:09:21.227 --> 00:09:24.077
ou seja, que serão gerados
objetos em memória

00:09:24.077 --> 00:09:26.363
para armazenar 
e carregar informações.

00:09:26.363 --> 00:09:29.327
E a segunda dica é que,
toda essa estrutura de padrões,

00:09:29.327 --> 00:09:32.323
não deve ser pensada
diretamente na programação.

00:09:32.323 --> 00:09:35.297
Isso pode ser realizado
durante a análise do sistema

00:09:35.297 --> 00:09:38.137
desde o ato da criação
de diagramas de classes,

00:09:38.137 --> 00:09:41.567
onde eu já consigo identificar
toda a parte de construtores,

00:09:41.567 --> 00:09:44.953
de encapsulamento, e também
da geração dos métodos.