[MÚSICA] [MÚSICA] Olá, bem vindo ao curso de Orientação a Objetos com Java. Eu sou Clóvis Fernandes, e nesta aula iremos apresentar a parte 2 da modelagem CRC. Nesta parte iremos identificar completamente as classes, no passo anterior, até o passo 2, nós identificamos apenas os nomes das classes e a sua descrição. Agora iremos complementar isso identificando as responsabilidades e as colaborações de cada uma das 3 classes que nós levantamos na aula anterior. Relembrando pouco, nós estamos falando então, da modelagem CRC. O sistema que nós estamos exemplificando didaticamente nesta aula é sobre o sistema de automação de biblioteca, que nós já tínhamos identificado 3 classes. A classe biblioteca, a classe livro e a classe usuário. Para cada uma delas nós tínhamos também feito uma descrição da finalidade de cada uma dessas classes. Nesta aula iremos começar a apresentar o passo 3. Descrevemos as responsabilidades óbvias. O que são as responsabilidades óbvias? São aquelas que ao olhar o nome da classe e ao olhar a descrição que nós demos para a finalidade da classe, algumas resposabilidades aparecem naturalmente. Por isso é que a gente diz que elas são óbvias. Neste passo 3, então a nossa atividade vai ser para cada classe identificada fazer o levantamento das responsabilidades óbvias. Por exemplo, na classe biblioteca nós temos 5 responsabilidades óbvias. A classe biblioteca sabe o nome da biblioteca, sabe o catálogo de livros, sabe a lista de usuários registrados na biblioteca. Com relação às responsabilidades do tipo Faz, a biblioteca registra novo usuário, ela adiciona novo livro ao catálogo. Essas são as responsabilidades óbvias. Mas uma coisa que tem que ficar bem claro para todo mundo. Mesmo que eu não consiga identificar uma responsabilidade óbvia, que potencialmente seria óbvia, mais para a frente, ao trabalhar colaborações, ao trabalhar novas classes, eventualmente essas classes que tenhamos esquecido, elas vão aparecer. Então não precisamos ficar muito preocupados se estamos sendo completos, se estamos conseguindo identificar todas as responsabilidades que são óbvias. Com relação à classe livro, a classe livro sabe o título do livro, ela sabe o autor do livro, ela sabe também o número único do livro que é identificado pela biblioteca, para diferenciar livro do outro. A classe livro também sabe se o livro está disponível para empréstimo ou não. Isso é uma informação que ela sabe. Outra informação que ela sabe é, caso o livro tenha sido emprestado, para qual usuário ele foi emprestado. A classe livro sabe. Se o livro não foi emprestado ainda, não tem usuário. Mas se o livro foi emprestado, ela sabe para qual usuário o livro foi emprestado. Já a classe usuário, ela sabe o nome do usuário. Ela sabe também a lista dos livros que esse usuário emprestou num dado momento. Inicialmente ele é vazio, se ele emprestar livro, vai ter livro indicando que livro é esse. Então ele tem uma lista dos livros que ele emprestou. Quando não tiver nenhum livro, ela é uma lista vazia. Uma maneira usual de descobrir as responsabilidades é inicialmente examinando as responsabilidades óbvias. Mas nem sempre nós descobrimos ou conseguimos identificar com clareza quais são essas responsabilidades óbvias. Então no próximo passo, iremos analisar os verbos de ação que se encontram na especificação de requisitos do sistema de automação de biblioteca. Eu consigo identificar tem nome, pode emprestar livro, devolver o livro, registrar novo usuário de biblioteca e outros verbos que se encontram na especificação. O que é que eu faço? Eu faço uma lista desses verbos, desconsiderando as responsabilidades do tipo Sabe, eu listo todos os verbos de ação que eu encontro na especificação. Aqui eu vou apresentar apenas os verbos que correspondem à responsabilidades do tipo Faz. Então eu tenho aqui o Emprestar livro, Devolver livro, Registrar novo usuário, Exibir livros disponíveis para empréstimo e Exibir livros indisponíveis para empréstimo. Diferentemente do esquema anterior, que eu dada uma classe eu definia as responsabilidades óbvias, agora eu estou fazendo uma lista de todos os verbos e consigo identificar responsabilidades mas que essas responsabilidades não estão claramente definidas para quais classes elas pertencem. Por isso, eu preciso fazer, nesta parte desse passo, a atribuição da responsabilidade a alguma das classes que já estão definidas. No nosso caso, as 3 classes anteriores, biblioteca, livro e usuário. Para cada potencial responsabilidade, eu examino as classes existentes, se ela corresponde a alguma responsabilidade óbvia. Se corresponder a alguma responsabilidade óbvia de alguma classe, eu examino se ela pertence, ou pode pertencer à outra classe. Se não existir nenhuma responsabilidade óbvia, eu vou analisar se ela deve fazer parte dessa classe ou não. Se fizer, eu atribuo a essa classe, se não eu passo para a próxima classe, para examinar se a responsabilidade deve ser atribuída a essa nova classe ou não. E assim eu vou fazendo para todas as classes, até esgotar a lista de responsabilidades. Passo para a próxima responsabilidade potencial, examino qual classe ela poderá ser atribuída e assim por diante. Por exemplo, a lista das responsabilidades que eu apresentei anteriormente, como exemplo, o emprestar livro, devolver livro, registrar novo usuário, exibir lista de livros disponíveis e exibir lista de livros indisponíveis. Por acaso, nesse exemplo, essas 5 responsabilidades devem ser atribuídas à classes biblioteca. Então é isso que eu vou fazer. Se essas responsabilidades devem ser atribuídas à classe biblioteca, é o que eu vou fazer. Porque é que elas vão ser atribuídas a essa classe? Porque toda a transação que eu fizer com a classe biblioteca vai coincidir com essas responsabilidades. O que é que eu faço então? Acrescento. Vocês podem ver que agora a classe biblioteca tem 5 novas responsabilidades, além daquelas óbvias que eu tinha examinado anteriormente. Eu poderia ter esquecido alguma óbvia e ela apareceria porque ao examinar a especificação e ver verbo de ação, eu poderia encontrar essa classe óbvia que eu tivesse esquecido provavelmente. Nesse passo 5 nós conseguimos então, fazer a atribuição de todas as responsabilidades que nós levantamos olhando a especificação, no nosso caso agora, do exemplo, elas foram todas atribuídas à classe biblioteca. O passo 6 vai ampliar pouco o escopo da identificação de responsabilidades. O que nós vamos fazer no passo 6? É descrever a lógica de cada responsabilidade de cada classe que nós levantamos. Sabemos de antemão que as responsabilidades do tipo Sabe elas são muito simples de serem descritas, vamos nos fixar apenas nas responsabilidades do tipo Faz, como por exemplo, emprestar livro, devolver livro e assim por diante. Vemos agora a lógica emprestar livro da biblioteca. Ou seja, quais são as ações que eu preciso fazer nessa responsabilidade? Primeiramente, eu tenho livro para empréstimo para dado usuário, ou seja, para emprestar esse livro, eu já tenho isso mãos. Eu sei qual é o livro e eu sei qual é o usuário. O 2º passo é marcar esse livro como emprestado, para que ninguém mais possa ver esse livro na lista dos livros ainda disponíveis e poder querer emprestar. O 3º passo a gente anexa o usuário como emprestador do livro. O usuário que está emprestando esse livro, ele vai para o constar do livro mostrando quem é o usuário que está com aquele livro emprestado. E anexa, nessa lógica, a 4º parte, anexa o livro à lista de livros do usuário. Essas 3 últimas ações, o marca livro como emprestado, anexa Usuário como emprestador do livro. Anexa livro à lista de livros do usuário são novas responsabilidades, são responsabilidades que eu estou identificando na lógica emprestar livro de biblioteca. Dentro do passo 6 eu quero agora identificar colaborações. Eu verifico que essas 3 responsabilidades são novas. O que significa isso? Elas não se encontram descritas nem na hora que eu listei as responsabilidades óbvias para cada classe, nem quando eu olhei a especificação dos meus requisitos para o sistema de automação da biblioteca. Elas só apareceram quando eu comecei a fazer a descrição da lógica. Por isso é que é importante, muito importante, fazer a descrição da lógica. Nessa hora, eu identifico responsabilidades e são novas e encontro responsabilidades que já apareceram como óbvias ou foram retiradas da parte da especificação de requisitos. Para identificar as colaborações eu tenho que identificar quais são as classes colaboradoras para quem eu devo atribuir essas responsabilidades. Então, as 2 primeiras responsabilidades, marca livro como emprestado, anexa usuário como emprestador do livro, essas 2 responsabilidades, elas devem ser atribuidas à classe livro. É uma responsabilidade da classe livro marcar quando alguém emprestar aquele dado livro, que o livro está emprestado. No caso é simplesmente valor de verdadeiro ou falso. Inicialmente falso, o livro ainda não foi emprestado para ninguém. Foi emprestado para alguém, ele fica verdadeiro. E a segunda responsabilidade é para pegar o objeto do usuário que está emprestando o livro e incluir isso, anexar isso, ao dado livro que está sendo emprestado a esse usuário. Já a responsabilidade anexa livro à lista de livros emprestados do usuário, ela claramente tem que fazer parte, tem que ser atribuída à classe usuário porque é a classe usuário que vai, quando ele faz o empréstimo de dado livro, anexar o objeto desse livro à sua lista de livros emprestados. Então, claramente, é a classe usuário. Tendo identificado as minhas colaborações que significa identificar as classes colaboradoras e as responsabilidades dessas classes colaboradoras, o que acontece? Eu acabo aclopando, fazendo com que a classe biblioteca dependa das classes livro e usuário. O que é que eu tenho agora? Eu tenho que a classe biblioteca depende da classe livro. Pelo menos levando consideração a responsabilidade emprestar livro, eu preciso para completar a minha responsabilidade que é emprestar livro, eu preciso da colaboração da classe livro para marcar livro e marcar quem é o usuário que está emprestando esse livro. Eu preciso também da colaboração, ou seja, eu dependo da classe usuário. O que, para eu cumprir a minha responsabilidade como todo, que é o emprestar o livro como todo, que a classe usuário também marque na sua lista de livros emprestados esse livro que ele acabou de emprestar. Com isso concluímos a modelagem CRC. Ao terminarmos essa parte 2, que é composta dos passos 3 a 6, nós conseguimos identificar completamente as classes da aplicação de automação da biblioteca. Isso que nós fizemos para esse exemplo didático pode ser feito para qualquer aplicação. O que nós fizemos foi exemplo de dados com requisitos simplificados mas ele pode ser aplicado para qualquer sistema. Muito obrigado! [MÚSICA] [MÚSICA]
