Neste curso, assumimos que você já sabe desenvolver programas pequenos em Java, mas você talvez não se sinta ainda confortável em projetar programas mais complexos com método e organização. O objetivo deste curso é fazer você compreender os princípios de orientação a objetos por meio da linguagem Java e saber como eficientemente aplicar esses princípios na prática quando projetando e desenvolvendo software de maneira ágil. Os conceitos discutidos e experimentados por você neste curso serão a base para você poder compreender os novos conceitos apresentados nos cursos seguintes desta especialização. Os conceitos Java apresentados neste curso incluem o seguinte: revisão de conceitos básicos de orientação a objetos, tais como classes, objetos, métodos e atributos, variáveis de instância e de classe; responsabilidades, colaborações e cartões CRC; testes de unidade, uso de plataforma IDE como o Eclipse; herança, classes concretas e abstratas, interfaces, modificadores de acesso, encapsulamento, métodos de acesso; aprofundamento nos conceitos de polimorfismo, sobrecarga e sobreposição; associação de classes, agregação e composição; exceções, delegação e acoplamento abstrato. Em seguida, vocês serão apresentados aos principais princípios usados para organizar o desenvolvimento de programas orientados a objetos com qualidade, dentre os quais, os princípios "Tell, Don't Ask!" e "Law of Demeter". Sempre que conveniente, cada conceito será representado por meio de diagramas UML. Você será exposto a propriedades e anotações em Java. Ao final deste curso, você terá amadurecido de tal modo suas habilidades de programação que você será capaz de implementar versões iniciais do componente de gamificação constante do Trabalho de Conclusão da Especialização, com base nas boas práticas exercitadas neste curso.
Modelagem CRC: Identificando Responsabilidades e Colaborações
Loading...
Do curso por Instituto Tecnológico de Aeronáutica
Orientação a Objetos com Java
900 classificações
Na lição
Classes com Java e Modelagem CRC
Olá! Bem-vindo à semana 2 do curso Orientação a Objetos com Java! Nesta semana você aprofundará seu contato com classes e métodos, bem como com modelagem CRC. Ao final desta semana, você será capaz de: 1) modelar o comportamento de classes com métodos em Java; 2) projetar novas classes para uma aplicação por meio da modelagem CRC
Conheça os instrutores
Clovis FernandesProfessor Titular in Portuguese
Ciência da Computação
Eduardo GuerraProfessor Colaborador
[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]
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2019 Coursera Inc. Todos os direitos reservados.
