[MÚSICA] [MÚSICA] Olá. Bem vindos ao curso de orientação a objetos com Java. Eu sou o Clovis Fernandes e iremos dar continuidade ao Hands-On sobre a modelagem CRC. Iremos apresentar dos passos a 3 a 5 numa pequena aplicação. No passo 3 iremos identificar as responsabilidades óbvias cada classe que foi definida. Nós tínhamos definidas então 3 classes: biblioteca, livro e usuário. Iremos então agora examinar quais são as responsabilidades que naturalmente fazem sentido fazerem parte dessas classes. Imagine você a classe biblioteca, quais são as responsabilidades que poderiam ser consideradas óbvias? Eu estou considerando aqui 3, representando pela cor verde 3 responsabilidades do tipo Sabe. A biblioteca sabe o nome, a biblioteca sabe o catálogo de livros, a biblioteca sabe a sua lista de usuários. E estou identificando duas responsabilidades do tipo Faz. Registra usuário, se usuário quer emprestar livro ele precisa de estar registrado e então a classe biblioteca precisa registrar o usuário. O usuário está querendo retirar algum livro. Se ele se encontra registrado, ele vai querer retirar livro que tenha sido adicionado ao catálogo. Então eu adiciono esse novo livro ao catálogo. Agora na classe livro o que é que vocês podem-me dizer a respeito das responsabilidades que são óbvias? Pense você. Nesse exemplo, eu estou só usando as responsabilidades do tipo Sabe e porque isso é que estão verde ai. Sabe título, sabe autor, sabe número único de livro, sabe a disponibilidade de empréstimo, se o livro está disponível para empréstimo ou não, sabe o usuário, se o livro foi emprestado você fica sabendo que usuário é que está com aquele livro emprestado. Então essas são as que eu identifiquei. Vamos agora dar uma olhada então na classe usuário. O que você pode me dizer a respeito da classe usuário? Quais são as responsabilidades óbvias para a classe usuário? Vejamos se vocês vão chegar perto do que eu vou colocar. O usuário sabe o nome, o usuário sabe a lista de livros emprestados, que foram emprestados para ele. Inicialmente ela é vazia, está certo? Bom, eu faço isso sozinho? Não. Normalmente todo esse processo da modelagem CRC é feita com outros desenvolvedores e com usuários e clientes do sistema. Pessoas que entendem do sistema. Pode ser que tanto os conhecedores quanto os desenvolvedores esqueçam algumas responsabilidades. Não tem problema nesse processo. Elas vão aparecer mais cedo ou mais tarde. Algum momento isso acaba aparecendo e não precisamos de nos preocupar se estamos lembrando de todas as responsabilidades óbvias. O passo 4 nós vamos identificar responsabilidades lá na especificação. Por isso é que eu estou reapresentando a especificação do SAB e eu vou examinar os verbos, as responsabilidades. Enquanto que as classes de objetos eu faço uso de nomes e substantivos, para responsabilidades eu olho os verbos e os predicados. Eles é que vão indicar quais são as responsabilidades. Então por exemplo: amarelo, eu estou identificando os verbos e predicados que correspondem às responsabilidades do tipo sabe. Então no caso ali eu tenho: tem nome, mantém catálogo de livros, tem título, autor, número único de catálogo, cada com nome único de usuário e verde eu estou representando as responsabilidades do tipo faz. Emprestar livro, devolver o livro, registrar novo usuário da biblioteca, exibir ordem crescente do número único de catálogo os livros disponíveis para empréstimo, ou então exibir os livros já emprestados. O que eu faço então, eu estou esquecendo pouco nesse momento de trabalhar com as responsabilidades do tipo Sabe que elas são mais diretas, elas correspondem a atributos, não é, está certo? Então o que eu vou colocar para a gente começar a trabalhar aqui são com as responsabilidades do tipo faz. Então eu tenho emprestar livro, devolver livro, registrar novo usuário, exibir livros disponíveis para empréstimo, exibir livros indisponíveis para empréstimo. Inclusive, quando eu listo e retiro da especificação eu posso fazer pequenas adaptações nos nomes para eles ficarem ou mais curtos ou mais apropriados, para corresponderem às responsabilidades. Já no passo 5 eu vou fazer a atribuição das responsabilidades que eu acabei de identificar. Normalmente, quando eu trabalho nas responsabilidades pelos verbos, olhando os verbos na especificação do sistema que eu estou tentando automatizar, Eu não sei para que classe elas vão pertencer então eu vou ter que analisar, fazer uma análise disso. E o processo é: eu vou olhando para cada classe. Então no nosso caso nós temos 3 classes: eu vou olhar para as classes biblioteca, livro e usuário. Cada responsabilidade daquela minha lista. Bom, eu não preciso olhar as do tipo sabe porque elas estão muito associadas a cada classe. Quando eu sei o nome da biblioteca, significa que eu estou essa responsabilidade ela é da biblioteca então é muito simples desvendar, fazer a atribuição das responsabilidades do tipo sabe. As do tipo faz não é tão simples assim, demanda certo trabalho. Então eu vou olhar cada classe, pego a primeiro responsabilidade e vou olhando cada classe. Essa responsabilidade faz sentido nessa classe? O que é que pode acontecer? Na classe já existia uma responsabilidade óbvia que faz a mesma coisa, elas são muito análogas, ela pode estar até escritas diferente mas podem fazer a mesma coisa. Está certo? Então se já existe, eu não vou fazer a atribuição. Mas eu parto para olhar as outras porque uma mesma responsabilidade ela pode aparecer várias classes. Isso ai tem a ver com o polimorfismo, eu posso ter responsabilidades de mesmo nome mas cuja lógica vai ser diferente cada classe que ela fizer sentido ser atribuída. Está certo? Ai eu vou olhando, mesmo tendo feito a atribuição: nesta classe faz sentido ser atribuído determinada responsabilidade? Mesmo fazendo isso, eu tenho que olhar se faz sentido nas outras classes também por causa dessa característica de polimorfismo. Nós temos então neste caso 5 responsabilidades do tipo faz: emprestar livro, devolver livro, registrar novo usuário, exibir livros disponíveis para empréstimo e exibir livros indisponíveis para empréstimo. Por acaso, o emprestar livros vai valer por exemplo para a classe livro? Eu não pergunto para o livro se eu devo emprestá-lo ou não ou se eu vou devolver livro para o próprio livro. Isso não faz sentido. Então emprestar livro, devolver livro, registrar novo usuário é para livro também? Não. Exibir livros disponíveis de empréstimo? Espera, eu sou livro. Eu não tenho noção dos outros livros que existem disponíveis para empréstimo, assim como estão indisponíveis. Então essas 5 responsabilidades não servem para livro. Eu vou perguntar para o usuário, emprestar o livro? Também não. Não cabe a ele decidir isso. Está? Porque, cabe a alguém que vai perguntar se o livro está disponível ou não. Se o livro estiver disponível ele pode emprestar. Então isso não pode ser o usuário porque o usuário não vai ter essa ação, nem para devolver e obviamente a própria classe usuário não pode registrar novo usuário porque para registrar novo usuário eu estou criando uma classe, objeto da classe usuário. Então eu não vou perguntar para o usuário. Ele nem existe. Está certo? Então tem que ser para outro que eu tenho que perguntar. E não pode ser para livro e não pode ser para o usuário. Eu estou também tirando a palavra novo porque se eu vou registrar usuário, já está implícito que ele é novo porque se ele não for novo, ele já existe no sistema e então eu não preciso de registrar. Então estou tirando essa palavra. Aindo para o usuário: não cabe a ele exibir os livros disponíveis para empréstimo porque o usuário só sabe os livros que ele tomou de empréstimo. Ele não fica registrado nele todos os livros que estão disponíveis nem os livros que estão indisponíveis então não cabe para livro. Então, certamente, só sobrou para a biblioteca. Ou seja, fiz aqui uma análise por exceção que eu estou trabalhando esse tipo de coisa. Notem que eu coloquei registrar usuário agora azul porquê? Eu tinha registrado as responsabilidades do tipo faz cada classe, que eram óbvias, azul. Quando eu fiz a análise das responsabilidades que eu descobri olhando a especificação do sistema SAB, eu identifiquei 5 responsabilidades e elas estavam todas marrom. O que é que acontece? Já existia registrar usuário na classe biblioteca que tinha sido levantado de forma óbvia, eu identifiquei como sendo uma responsabilidade óbvia. Aqui eu levantei também registrar usuário como houve uma coincidência, ele já existia e então eu não precisei de fazer a atribuição. Essa registrar usuário que está azul, já existia biblioteca. Então eu só atribui o emprestar livro, devolver livro exibir livros disponíveis para empréstimo e exibir livros indisponíveis para empréstimo. Como é que ficou então a classe biblioteca, com as atribuições que eu acabei de fazer? Verde as do tipo Sabe, sabe nome, sabe catálogo de livros e sabe lista de usuários. Azul tenho o registra usuário, existia uma registra usuário também que tinha sido identificada na especificação, como já existia não precisei de fazer a atribuição. Uma antiga adiciona livro ao catálogo e 4 novas que eram o empresta livro, devolve livro, exibe livros disponíveis para empréstimo, exibe livros indisponíveis para empréstimo que foram atribuídas agora. Então essas últimas 6 são todas responsabilidades do tipo faz. As cores só estão identificando quando é que apareceram e foram atribuídas para a classe biblioteca. Encerramos então a parte 2 da modelagem CRC, desse Hands-On da modelagem CRC que apresentamos os passos 3 a 5 da modelagem CRC que estamos empregando neste curso. Obrigado. [MÚSICA]
