Return to Video

LTP CAP03 VA10 JAVADOC

  • 0:05 - 0:07
    Assim como existe toda
    a documentação do Java
  • 0:07 - 0:10
    dentro do Java API Specification
    na Oracle,
  • 0:10 - 0:14
    você também pode criar
    a especificação do seu projeto
  • 0:14 - 0:16
    através do uso
    de Javadoc.
  • 0:16 - 0:20
    Para poder utilizar o Javadoc
    para documentar as suas classes,
  • 0:20 - 0:25
    métodos e atributos,
    você precisa utilizar o "/**".
  • 0:25 - 0:30
    A partir do /**, você pode fazer
    como se fosse uma outra programação.
  • 0:30 - 0:34
    Você vai poder utilizar tags
    e referenciar as informações dessas tags.
  • 0:34 - 0:38
    Essas tags serão lidas
    por um executável Javadoc,
  • 0:38 - 0:42
    que irá gerar todo um HTML
    com todas essas informações.
  • 0:42 - 0:44
    Para utilizar
    as tags do Javadoc
  • 0:44 - 0:47
    você sempre vai utilizar
    arroba e o nome da tag.
  • 0:47 - 0:51
    As principais tags são:
    @author, que é para você indicar
  • 0:51 - 0:54
    qual é o nome do desenvolvedor
    daquele programa.
  • 0:54 - 0:58
    O @deprecated, que é para você
    indicar que aquele método,
  • 0:58 - 0:59
    ou aquele atributo,
    ou aquela classe,
  • 0:59 - 1:02
    já não está mais em uso,
    e aí você pode indicar
  • 1:02 - 1:06
    qual a outra classe que está
    substituindo aquela classe,
  • 1:06 - 1:07
    ou, enfim,
    aquele método.
  • 1:07 - 1:11
    O @param, que é para definir
    um parâmetro do método,
  • 1:11 - 1:14
    ou seja, quais são os parâmetros
    e a descrição desses parâmetros
  • 1:14 - 1:16
    que estão de entrada
    para um método.
  • 1:16 - 1:21
    O @return, que é para documentar
    um valor de retorno de um método.
  • 1:21 - 1:25
    Só note o seguinte: essa tag não
    deve ser utilizada para construtores
  • 1:25 - 1:27
    ou para métodos
    que não têm retorno.
  • 1:27 - 1:32
    O @see, que é simplesmente para você
    indicar uma outra documentação
  • 1:32 - 1:34
    relacionada àquele
    método classe
  • 1:34 - 1:37
    ou atributo no qual
    você está documentando.
  • 1:37 - 1:40
    O @since, que é para você
    identificar desde quando
  • 1:40 - 1:44
    aquela alteração ou aquela
    construção foi realizada.
  • 1:44 - 1:47
    O @exception, que,
    assim como o @throws,
  • 1:47 - 1:52
    são utilizados para poder identificar
    qual o tipo de erro ou de exceção
  • 1:52 - 1:54
    que um método
    pode lançar.
  • 1:54 - 1:58
    E o @version, que é para você
    identificar qual é o número daquela versão,
  • 1:58 - 2:00
    seja para um método
    ou para uma classe.
  • 2:00 - 2:04
    Vou realizar agora um teste
    fazendo a documentação
  • 2:04 - 2:07
    dentro da classe conta e depois
    gerando toda essa documentação.
  • 2:07 - 2:10
    Logo de início, antes
    da declaração da classe,
  • 2:10 - 2:13
    eu já identifiquei
    informações sobre a classe.
  • 2:13 - 2:15
    Então, eu utilizei
    o /**,
  • 2:15 - 2:18
    descrevi do que se trata
    aquela classe,
  • 2:18 - 2:21
    coloquei qual é o autor
    daquela classe
  • 2:21 - 2:23
    e qual é a versão
    daquela classe.
  • 2:23 - 2:28
    Logo em seguida, eu criei a documentação
    para cada um dos métodos da classe.
  • 2:28 - 2:30
    Logo acima
    do método depositar,
  • 2:30 - 2:33
    eu coloquei a descrição
    a respeito do método
  • 2:33 - 2:37
    e qual é a descrição
    do parâmetro valor.
  • 2:37 - 2:40
    Logo em seguida, eu realizei
    a documentação do método retirar.
  • 2:40 - 2:43
    Descrevi
    o que o método fará,
  • 2:43 - 2:46
    também descrevi
    o parâmetro de entrada
  • 2:46 - 2:49
    e coloquei mais uma tag,
    que é a tag see,
  • 2:49 - 2:51
    que vai apontar
    para um outro método,
  • 2:51 - 2:53
    que é o método
    depositar,
  • 2:53 - 2:57
    para que, toda vez que qualquer
    programador veja essa documentação,
  • 2:57 - 3:00
    ele visualize que, tanto o método
    retirar quanto o método depositar,
  • 3:00 - 3:01
    têm alguma relação.
  • 3:01 - 3:05
    E, por fim, eu também documentei
    o método verificarSaldo,
  • 3:05 - 3:08
    colocando simplesmente
    a declaração do que o método faz
  • 3:08 - 3:11
    e também qual é o tipo
    de retorno desse método,
  • 3:11 - 3:15
    informando que ele vai retornar
    o valor do saldo da conta.
  • 3:15 - 3:18
    Note o seguinte: só de realizar
    esses comentários no padrão Javadoc,
  • 3:18 - 3:21
    ao passar o mouse
    em cima do método,
  • 3:21 - 3:24
    ele já mostra essa
    descrição que nós fizemos
  • 3:24 - 3:26
    no padrão
    de documentação.
  • 3:26 - 3:29
    Mas se eu quiser gerar
    todo um HTML a respeito,
  • 3:29 - 3:31
    então eu tenho
    um comando para fazer isso,
  • 3:31 - 3:32
    que é o comando
    Javadoc.
  • 3:32 - 3:35
    Eu posso fazer esse
    comando manualmente
  • 3:35 - 3:36
    através do comando
    Javadoc,
  • 3:36 - 3:40
    que é um executável que fica
    na mesma pasta do JDK
  • 3:40 - 3:43
    onde estão os comandos
    de compilação e interpretação,
  • 3:43 - 3:46
    mas eu também posso vir
    através do Eclipse.
  • 3:46 - 3:49
    Para poder gerar todo
    o HTML dessa documentação,
  • 3:49 - 3:52
    basta eu acessar
    a opção Project,
  • 3:52 - 3:54
    Generate Javadoc.
  • 3:54 - 3:56
    Nessa opção aqui eu
    preciso identificar
  • 3:56 - 3:59
    qual é o comando
    de geração desse Javadoc,
  • 3:59 - 4:02
    porque existem várias outras
    ferramentas de geração.
  • 4:02 - 4:06
    Então, eu vou colocar qual é
    o endereço onde está esse comando.
  • 4:06 - 4:08
    Normalmente
    está na pasta bin.
  • 4:08 - 4:10
    Basta selecionar
    o comando Javadoc
  • 4:10 - 4:14
    que está dentro
    da pasta bin do seu JDK.
  • 4:14 - 4:17
    Uma vez selecionado
    o comando Javadoc,
  • 4:17 - 4:20
    eu seleciono quais são
    as classes dos projetos
  • 4:20 - 4:22
    que eu quero gerar
    a documentação.
  • 4:22 - 4:25
    Nesse caso, só fizemos a documentação
    a partir da classe conta.
  • 4:25 - 4:27
    Então, eu seleciono
    a classe conta
  • 4:27 - 4:29
    e também coloco
    qual a pasta destino
  • 4:29 - 4:31
    para gerar essa
    documentação.
  • 4:31 - 4:33
    Clico em finish,
    ele verifica se eu quero
  • 4:33 - 4:37
    alterar o local de destino
    dessa documentação
  • 4:37 - 4:41
    ou também substituir
    algumas informações que ali estão,
  • 4:41 - 4:43
    eu posso
    simplesmente confirmar,
  • 4:43 - 4:47
    e é feita automaticamente
    a geração de todo o HTML
  • 4:47 - 4:49
    com essa
    documentação.
  • 4:49 - 4:52
    Ao término da execução,
    você vai poder observar
  • 4:52 - 4:56
    na sua estrutura do projeto que ele
    gerou uma nova pasta chamada doc
  • 4:56 - 4:58
    com diversos
    arquivos HTML.
  • 4:58 - 5:01
    Basta você acessar
    o arquivo index.html
  • 5:01 - 5:02
    no navegador
    do próprio Eclipse
  • 5:02 - 5:04
    ou em qualquer
    outro navegador.
  • 5:04 - 5:08
    Caso seja pelo Eclipse,
    basta ir à opção Open With,
  • 5:08 - 5:12
    Web Browser, e ele vai abrir
    toda a documentação do seu projeto
  • 5:12 - 5:15
    no padrão
    de Java API Specification.
  • 5:15 - 5:18
    Claro que, nesse caso,
    temos somente a classe conta,
  • 5:18 - 5:21
    e a classe conta com as descrições
    que nós colocamos
  • 5:21 - 5:24
    lá na documentação
    dentro do programa.
  • 5:24 - 5:28
    O Javadoc, ou qualquer outro
    software de geração de documentação,
  • 5:28 - 5:30
    é muito importante
    para a programação.
  • 5:30 - 5:32
    Eu sei que dá
    uma certa preguiça,
  • 5:32 - 5:35
    mas é importante porque, de fato,
    essa documentação pode ser muito útil
  • 5:35 - 5:38
    para outros desenvolvedores
    desse seu projeto.
Title:
LTP CAP03 VA10 JAVADOC
Video Language:
Portuguese, Brazilian
Duration:
06:07

Portuguese, Brazilian subtitles

Incomplete

Revisions Compare revisions