Return to Video

LTP CAP03 VA11 JAVABEAN ENCAPSULAMENTO

  • 0:05 - 0:09
    Trabalhar com padrões dentro
    da programação é muito importante.
  • 0:09 - 0:12
    Nós vamos ver agora
    um pouquinho de JavaBeans,
  • 0:12 - 0:15
    que é a forma de padronizar
    a implementação do conceito
  • 0:15 - 0:18
    de encapsulamento
    de orientação a objetos.
  • 0:18 - 0:21
    Na programação Java,
    é usual criarmos classes
  • 0:21 - 0:23
    para que essas classes
    possam gerar objetos
  • 0:23 - 0:26
    a serem reutilizados
    em vários outros sistemas.
  • 0:26 - 0:31
    A especificação JavaBeans padroniza
    justamente a criação dessas classes,
  • 0:31 - 0:34
    que nós batizamos
    de classes beans.
  • 0:34 - 0:37
    Para fazer uma classe Java
    ser uma classe JavaBeans,
  • 0:37 - 0:40
    você precisa seguir
    três regras.
  • 0:40 - 0:44
    A primeira, é que essa classe precisa
    implementar um construtor padrão
  • 0:44 - 0:46
    mesmo que você tenha
    um construtor de classe.
  • 0:46 - 0:50
    Por quê? Porque outras APIs
    vão se utilizar desse construtor padrão
  • 0:50 - 0:52
    para criação
    de um JavaBean.
  • 0:52 - 0:55
    A segunda regra é o conceito
    de encapsulamento.
  • 0:55 - 0:59
    É necessário você encapsular
    os atributos, ou seja,
  • 0:59 - 1:03
    proteger esses atributos
    e permitir que outros métodos
  • 1:03 - 1:05
    acessem sim
    esses atributos.
  • 1:05 - 1:08
    E a terceira regra que,
    na realidade, é uma boa prática,
  • 1:08 - 1:11
    é você implementar
    a interface Serializable.
  • 1:11 - 1:15
    Essa interface vai marcar aquela classe
    como uma classe serializável.
  • 1:15 - 1:17
    O que significa isso?
  • 1:17 - 1:20
    Todos os dados que estiverem
    contidos no objeto
  • 1:20 - 1:23
    serão transformados em bits
    para serem trafegados
  • 1:23 - 1:26
    sem que a informação
    seja tão transparente.
  • 1:26 - 1:28
    Para entender um pouquinho mais
    a criação de uma classe
  • 1:28 - 1:32
    no padrão JavaBeans, vou criar
    uma nova classe chamada "pessoa"
  • 1:32 - 1:35
    dentro do projeto
    do sistema bancário.
  • 1:35 - 1:38
    Vou clicar no pacote aqui
    com o botão direito,
  • 1:38 - 1:40
    opção New,
    opção Class.
  • 1:40 - 1:45
    Vou nomear a classe
    com o nome pessoa e dar um finish.
  • 1:45 - 1:47
    Essa classe, por hora,
    é uma classe comum.
  • 1:47 - 1:51
    Mas eu vou criar o atributo
    nome da pessoa,
  • 1:51 - 1:53
    só que eu já vou criar
    no padrão JavaBeans,
  • 1:53 - 1:56
    ou seja, eu vou encapsular
    o atributo nome
  • 1:56 - 2:00
    para que nenhuma outra classe
    externa altere esse nome.
  • 2:00 - 2:03
    Então, eu declaro
    o modificador private,
  • 2:03 - 2:06
    declaro o atributo
    nome do tipo String,
  • 2:06 - 2:08
    e ele está
    protegido.
  • 2:08 - 2:11
    Nenhuma outra classe
    consegue alterar esse atributo.
  • 2:11 - 2:13
    Mas eu preciso,
    de alguma forma,
  • 2:13 - 2:15
    fazer com que esse
    atributo seja alterado,
  • 2:15 - 2:19
    mas simplesmente por algum
    método da própria classe.
  • 2:19 - 2:21
    É aí que eu utilizo
    os métodos padrões
  • 2:21 - 2:23
    chamados
    getters and setters.
  • 2:23 - 2:26
    O método get vai ser responsável
    por obter aquela informação
  • 2:26 - 2:30
    e o método set por alterar
    aquela informação.
  • 2:30 - 2:32
    Então, eu venho aqui
    e defino esses métodos.
  • 2:32 - 2:34
    Vou definir manualmente
    e depois eu vou mostrar
  • 2:34 - 2:37
    como fazemos
    automaticamente.
  • 2:37 - 2:39
    Ambos os métodos têm
    modificadores públicos
  • 2:39 - 2:43
    justamente para serem acessados
    fora do escopo dessa classe.
  • 2:43 - 2:46
    O método get vai retornar
    o tipo de dado
  • 2:46 - 2:49
    justamente do atributo em questão,
    que é o atributo nome.
  • 2:49 - 2:55
    Então, vai ter um retorno String
    e o nome vai ser "getNome".
  • 2:55 - 2:57
    Ele não vai ter
    nenhum parâmetro,
  • 2:57 - 3:02
    e a grande lógica dele é retornar
    o nome daquele atributo da pessoa.
  • 3:02 - 3:05
    Vou criar aqui também
    o que chamamos de método set.
  • 3:05 - 3:08
    Esse método não vai
    ter nenhum retorno.
  • 3:08 - 3:12
    Vai ter o prefixo set mais o nome
    do atributo que eu quero trabalhar,
  • 3:12 - 3:14
    e ele tem que receber
    como parâmetro
  • 3:14 - 3:17
    o novo nome
    que será associado.
  • 3:17 - 3:19
    E a lógica
    desse método é:
  • 3:19 - 3:22
    eu alterar o atributo
    nome da classe
  • 3:22 - 3:25
    pelo novo nome
    que veio de parâmetro.
  • 3:25 - 3:29
    Nesse exemplo, nós criamos
    então o atributo nome, privado,
  • 3:29 - 3:33
    e demos dois métodos
    de acesso a esse atributo nome.
  • 3:33 - 3:36
    Você pode pensar:
    "Poxa, mas esses métodos
  • 3:36 - 3:38
    estão simplesmente
    fazendo o acesso
  • 3:38 - 3:41
    de obter e de alterar
    a informação".
  • 3:41 - 3:45
    Ok, mas eu posso colocar
    mais lógicas dentro dos métodos,
  • 3:45 - 3:48
    ou seja, o atributo não vai ser
    acessado diretamente,
  • 3:48 - 3:51
    mas esses métodos podem,
    além de alterar o atributo,
  • 3:51 - 3:54
    fazer outras lógicas
    a respeito desse atributo.
  • 3:54 - 3:56
    E para que essa classe
    realmente tenha
  • 3:56 - 3:58
    a característica
    de uma classe JavaBeans,
  • 3:58 - 4:02
    eu preciso implementar
    a interface Serializable,
  • 4:02 - 4:06
    que vai marcar aquela classe
    como uma classe serializável.
  • 4:06 - 4:09
    Então, eu adiciono lá
    o implements,
  • 4:09 - 4:11
    adiciono a interface
    Serializable,
  • 4:11 - 4:14
    que está dentro
    do pacote java.io.
  • 4:14 - 4:17
    E, com isso, essa classe já é
    marcada como serializável,
  • 4:17 - 4:22
    ou seja, quando eu gerar
    um objeto a partir dessa classe pessoa,
  • 4:22 - 4:25
    as informações desse objeto
    serão serializáveis,
  • 4:25 - 4:29
    transformadas, de fato, em pacotes de bits
    para serem trafegados pela rede.
  • 4:29 - 4:32
    Note que, ao implementar
    a interface Serializable,
  • 4:32 - 4:34
    aparece em amarelinho
    o nome da classe.
  • 4:34 - 4:36
    Isso significa o quê?
  • 4:36 - 4:40
    Que a classe está requisitando
    algum identificador de serialização.
  • 4:40 - 4:41
    Por que isso acontece?
  • 4:41 - 4:44
    Porque eu posso ter num mesmo
    ambiente de memória
  • 4:44 - 4:48
    mais de um objeto da classe pessoa
    com versões diferentes.
  • 4:48 - 4:51
    Então, com isso, eu consigo identificar
    qual versão é aquele objeto
  • 4:51 - 4:54
    para que os objetos
    não se confundam.
  • 4:54 - 4:57
    Então, eu posso simplesmente pegar
    a opção que o próprio Eclipse me dá,
  • 4:57 - 5:01
    que é adicionar
    um default serialVersionUID.
  • 5:01 - 5:03
    E aí você pode
    colocar a identificação
  • 5:03 - 5:05
    que melhor for compatível
    com o seu projeto.
  • 5:05 - 5:07
    Agora, eu vou
    fazer o seguinte:
  • 5:07 - 5:10
    vou alterar o código
    do meu sistema bancário
  • 5:10 - 5:12
    da classe conta
    e da classe teste
  • 5:12 - 5:15
    para ser colocado
    no padrão de JavaBeans.
  • 5:15 - 5:17
    Vou acessar
    a minha classe conta,
  • 5:17 - 5:20
    e na classe conta eu vou fazer
    as devidas alterações.
  • 5:20 - 5:26
    A primeira coisa que eu devo fazer
    é deixar encapsulado todos os atributos.
  • 5:26 - 5:28
    Então, eu vou colocar
    o assessor private
  • 5:28 - 5:32
    em todos os atributos
    do escopo da minha classe.
  • 5:32 - 5:37
    Então, private dentro de agência,
    para o número da conta e para o saldo.
  • 5:37 - 5:41
    Dessa forma, nenhuma dessas informações
    pode ser alterada diretamente.
  • 5:41 - 5:43
    Notem que, logo que eu
    protejo esses atributos,
  • 5:43 - 5:45
    a classe teste
    passa a dar erro.
  • 5:45 - 5:48
    Por quê? Porque tanto o saldo,
    quanto a agência, quanto o número,
  • 5:48 - 5:50
    não são mais acessíveis
    diretamente.
  • 5:50 - 5:52
    E isso está ok.
  • 5:52 - 5:54
    Outra coisa que eu
    preciso fazer aqui
  • 5:54 - 5:56
    é trabalhar com os métodos
    getters and setters.
  • 5:56 - 5:57
    Mas é claro que eu
    preciso identificar
  • 5:57 - 6:00
    se todos eles são válidos
    de serem colocados ou não.
  • 6:00 - 6:04
    Por exemplo: eu posso permitir
    a alteração de um saldo diretamente?
  • 6:04 - 6:06
    Ou esse saldo só pode
    ser atualizado
  • 6:06 - 6:08
    através de um depósito
    ou de uma retirada?
  • 6:08 - 6:11
    Nesse caso, eu não preciso
    ter um método setSaldo,
  • 6:11 - 6:13
    mas eu posso ter
    um método getSaldo.
  • 6:13 - 6:17
    E aqui eu também posso ter
    os métodos setAgencia, getAgencia,
  • 6:17 - 6:19
    setNumero, getNumero.
  • 6:19 - 6:22
    Nós podemos fazer essas
    alterações na programação
  • 6:22 - 6:25
    ou eu posso fazer a geração
    automática dos getters and setters.
  • 6:25 - 6:29
    Para fazer a alteração automática
    dos getters and setters,
  • 6:29 - 6:31
    eu posso fazer
    de duas maneiras.
  • 6:31 - 6:34
    Eu posso clicar com o botão
    direito no código,
  • 6:34 - 6:38
    ir à opção Source,
    Generate Getters and Setters,
  • 6:38 - 6:42
    ou, ainda, através
    do atalho Ctrl + Shift + S.
  • 6:42 - 6:45
    Uma vez selecionada a opção
    Generate Getters and Setters,
  • 6:45 - 6:49
    eu seleciono quais os atributos
    que eu quero gerar os getters and setters.
  • 6:49 - 6:54
    Nesse caso, eu quero simplesmente
    gerar da agência e do número.
  • 6:54 - 6:59
    Clico em ok, e ele
    gera automaticamente
  • 6:59 - 7:01
    os métodos getAgencia,
    setAgencia,
  • 7:01 - 7:04
    getNumero,
    setNumero.
  • 7:04 - 7:07
    "Mas, professor, e o método
    getSaldo e setSaldo?".
  • 7:07 - 7:10
    Nesse caso, para fazer
    as devidas adaptações,
  • 7:10 - 7:12
    eu vou simplesmente
    substituir
  • 7:12 - 7:17
    o nome do método
    verificarSaldo para getSaldo,
  • 7:17 - 7:19
    e a alteração do saldo
    já está sendo realizada
  • 7:19 - 7:22
    através dos métodos
    retirar e depositar.
  • 7:22 - 7:25
    Portanto, eu não preciso
    criar o método setSaldo.
  • 7:25 - 7:28
    Para que essa minha classe
    vire, de fato, um JavaBean,
  • 7:28 - 7:31
    eu ainda preciso implementar
    a interface Serializable.
  • 7:31 - 7:36
    Então, basta fazer
    o implements
  • 7:36 - 7:39
    na interface
    Serializable.
  • 7:39 - 7:42
    Eu posso completar
    com um Ctrl + espaço,
  • 7:42 - 7:45
    e também posso implementar
    o meu controle de versão.
  • 7:45 - 7:47
    Pois bem, agora vamos
    adaptar a classe teste
  • 7:47 - 7:50
    para que ela possa
    usar a classe conta
  • 7:50 - 7:52
    da maneira correta
    no padrão de JavaBeans.
  • 7:52 - 7:55
    Então, ao invés de eu acessar
    diretamente o atributo,
  • 7:55 - 7:58
    eu posso simplesmente
    setar essas informações.
  • 7:58 - 8:01
    Ao invés de colocar
    o saldo como 50,
  • 8:01 - 8:05
    então eu vou setar
    o método depositar...
  • 8:07 - 8:09
    ... com o valor 50.
  • 8:09 - 8:12
    Então, não vai ser mais possível
    eu alterar diretamente um atributo.
  • 8:12 - 8:16
    Também vou dar
    um set na agência
  • 8:16 - 8:21
    passando o valor daquela
    agência dentro do método
  • 8:21 - 8:26
    e também o número da conta
    através do método setNumero.
  • 8:26 - 8:29
    Com isso, quaisquer lógicas
    que eu tenha que fazer
  • 8:29 - 8:33
    dentro da alteração de uma agência
    ou dentro da alteração de um número,
  • 8:33 - 8:37
    ou até no saldo, eu consigo fazer dentro
    desses métodos previamente criados,
  • 8:37 - 8:40
    gerando assim, uma segurança
    e uma melhor manutenção.
  • 8:40 - 8:43
    E uma última alteração
    a ser realizada aqui
  • 8:43 - 8:47
    é alterar o método
    verificarSaldo para getSaldo
  • 8:47 - 8:50
    em ambos os objetos
    que estamos trabalhando.
  • 8:50 - 8:54
    "Ah, professor, eu preciso alterar
    alguma coisa do construtor de classe?".
  • 8:54 - 8:57
    Nesse caso, não, porque o construtor
    de classe já está utilizando
  • 8:57 - 9:00
    e alterando os atributos
    da própria classe.
  • 9:00 - 9:03
    Vou realizar o teste aqui,
    e é possível verificar
  • 9:03 - 9:04
    que não houve alteração
    no resultado.
  • 9:04 - 9:07
    Simplesmente
    implementamos um padrão
  • 9:07 - 9:10
    que é muito utilizado
    no mercado de programação Java.
  • 9:10 - 9:14
    Duas dicas muito importantes
    a respeito do padrão JavaBeans.
  • 9:14 - 9:18
    Primeira: nem todas as classes
    devem ser colocadas nesse padrão.
  • 9:18 - 9:21
    Somente aquelas classes
    que carregam informações,
  • 9:21 - 9:24
    ou seja, que serão gerados
    objetos em memória
  • 9:24 - 9:26
    para armazenar
    e carregar informações.
  • 9:26 - 9:29
    E a segunda dica é que,
    toda essa estrutura de padrões,
  • 9:29 - 9:32
    não deve ser pensada
    diretamente na programação.
  • 9:32 - 9:35
    Isso pode ser realizado
    durante a análise do sistema
  • 9:35 - 9:38
    desde o ato da criação
    de diagramas de classes,
  • 9:38 - 9:42
    onde eu já consigo identificar
    toda a parte de construtores,
  • 9:42 - 9:45
    de encapsulamento, e também
    da geração dos métodos.
Title:
LTP CAP03 VA11 JAVABEAN ENCAPSULAMENTO
Video Language:
Portuguese, Brazilian
Duration:
10:31

Portuguese, Brazilian subtitles

Incomplete

Revisions Compare revisions