Bom, isso posto, tá aqui a classe Disciplina.
Então, a classe Disciplina agora,
ela não tem mais um objeto LAlunos do tipo ListaAluno,
ela tem um objeto LAlunos do tipo Lista parametrizada com Aluno.
E olha que legal ali, ó.
Eu não preciso criar a classe ListaAluno agora,
uso direto a classe genérica.
Claro que tá faltando um #include aqui em cima, tá,
conforme vocês, com certeza, sabem.
Vou fazer lá o meu #include "Lista.h", né, obviamente, tá.
Isso aqui não se trata de código.
Aqui do lado de cá, eu vou ter o quê?
Uma disciplina do... tô até chamando a construtora do ObjLAlunos aqui.
Fazendo inicializações na construtora,
destrutora tem algo ali,
set e getId.
Esses id's provavelmente foram importantes pra trabalhar lá com arquivos,
coisa que a gente trabalhou em slides anteriores.
Set e getNome,
set e getDepartamento.
Aqui, sim, o incluaAluno.
Eu recebo... Isso não é uma Disciplina?
A Disciplina ela tem alunos
ou, pelo menos, ela se associa a Alunos,
ela precisa receber o endereço desses alunos.
Aí, eu faço o quê?
Cada um desses Alunos, eu pego aqui,
e incluo no meu ObjLAlunos.
Quem que é o ObjLAlunos mesmo? Retornamos um slide.
É uma lista parametrizada com Aluno.
Então, se ele é uma lista parametrizada com Aluno,
ele tá habilitado a receber ponteiro de Aluno,
porque o parâmetro é Aluno.
Em o parâmetro sendo Aluno,
se eu volto um pouquinho e olho aqui na implementação da lista.
pInfo, ponteiro do TIPO.
Se o TIPO é Aluno, então é ponteiro de Aluno.
Aqui eu estou incluindo o Aluno obviamente.
Incluindo o endereço do Aluno, bem entendido, né.
Então, tô passando aqui o ponteiro de Aluno,
e além de passar o ponteiro de Aluno, eu estou passando nome do Aluno.
Essa função incluaInfo, como vocês bem sabem,
ela vai criar um elemento lá dentro parametrizado com Aluno,
pra cuidar do Aluno apontado nessa lista.
Além de cuidar do Aluno que tá apontado, ele vai replicar
dentro desse elemento que ele tá criando pra cuidar desse cara,
o nome desse cara aqui.
E aqui eu tenho o listeAlunos, que faz o quê?
Chama o listeInfos.
Aqui ele não tem,
nessa versão que eu criei, não tem um listeAlunos2
ou seja, as pesquisas são sempre do início pro fim,
não são do fim pro começo,
por isso que isso aqui tá comentado.
Certo.
E lá o que ele faz?
Ele vai utilizar aquela versão de navegar nos elementos
e utilizar justamente os nomes que estão aplicados nos Elementos,
que a gente já sabe que não é bom, porque cria esse acoplamento.
Como é que eu resolvo isso, professor?
Ora, uma solução é fazer isso aqui, ó.
Então, tem essa versão aqui, ó, que vocês tão vendo aqui em cima.
Eu vou trocar por uma coisa, supostamente, mais desacoplante.
Eu, aqui, eu tô fazendo o quê?
Comentei aquele código lá.
Tem réplicas de nomes de Alunos, isso não é bom,
porque... Eu já expliquei o porquê.
Aqui eu crio um paux, dentro de Disciplina, hein.
Um pAux, ponteiro de Elemento parametrizado com Aluno.
Faço esse pAux receber o primeiro
através do getPrimeiro do ObjLAluno
então eu tô entrando na lista aqui
na prática, tá, através do getPrimeiro, o getPrimeiro me permite isso.
Aí, eu vou fazer o quê?
Já que eu estou navegando na lista a partir de Disciplina,
eu posso, a partir de cada Elemento,
recuperar cada Aluno,
imprimir as informações do Aluno aqui,
passar pro próximo, recuperar o Elemento tratado pelo próximo Elemento,
recuperar o Aluno tratado pelo próximo Elemento,
imprimir as informações desse Aluno.
Dar próximo, recuperar o Aluno tratado pelo Elemento em questão,
imprimir as informações, dar próximo e assim eu vou
até percorrer toda lista.
Isso é bom ou isso é ruim?
Bom, eu não tô mais replicando o nome dentro da Lista.
Tão vendo aqui, ó.
Professor, mas como é que funciona aqui?
Provavelmente eu fiz algum estratagema lá na classe pra isso funcionar.
Cadê o incluaInfo?
Ali, ó.
Tem valor default,
se eu não colocar nada ele ignora o valor,
ou seja, vai existir um nome dentro do Elemento, mas ele vai tá vazio.
A questão é:
essa solução posta aí, nesse slide 19,
ela é boa ou é ruim?
Bom, pelo menos já não tem dentro dos Elementos
o nome dos Alunos replicados.
E aí eu vou lá e acesso os alunos direto lá, né.
Através de um estratagema aqui
e imprimo as informações fidedignas dele.
Inclusive, aqui eu não tô imprimindo só o nome,
tô imprimindo RA ademais, registro acadêmico.
poderia imprimir a idade todas as informações que eu quisesse.
Agora imaginem o seguinte que vocês tem uma classe Departamento
e vocês têm uma classe...
e vocês querem que na classe Departamento
tenha a lista de todos os Alunos que existem no Departamento.
O que vocês vão fazer?
Ah, vocês vão lá dentro do Departamento e vão criar um LAlunos
do tipo Lista parametrizado com Aluno.
Bom, pra incluir Alunos dentro do Departamento vai ser algo assim.
E pra listar?
Bom, pra listar, daí, você vai ser obrigado a fazer um algoritmo muito similar a esse aqui
aliás, exatamente esse mesmo algoritmo,
só que na classe... replicado na classe Departamento
no método listeAlunosDepartamento.
Se eu vou replicar código em classes,
isso significa que a solução também não tá boa.
E aí entra o meu exercício.
Tá aqui o exercício.
Item a: melhorar o template de Lista desenvolvido
e a solução como um todo
para que suas instâncias,
as instâncias da solução, bem entendido, né,
que vão envolver a Lista template
tratem de listas no sentido
de tratar tanto a parte genérica quanto específica com um certo equilíbrio.
Será que eu consigo achar à luz da coesão e desacoplamento
uma boa maneira de tratar o que é genérico de lista
como inclusão e exclusão, com o que é específico, como listagem?
Bom, essa é a reflexão posta.
Depois que você fizer isso, achar uma solução melhor.
Aí, você vai substituir todas as 'listas específicas'
elaboradas nas versões anteriores do 'sistema exemplo', o Sistema Acadêmico,
por 'instâncias' conforme a solução supostamente desenvolvida no tópico anterior,
nomeadamente o tópico (a).
Aqui também tem uma retomada de exercício que é o seguinte.
Retomando um exercício anterior à luz dos avanços alcançados até então nos tópicos (a) e (b),
aqui desse exercício posto,
elaborar uma solução para armazenar as notas (1ª parcial, 2ª parcial e final)
e número de faltas de cada Aluno em cada Disciplina.
Esse é o exercício posto.
Talvez pra fazer esse tópico A aqui,
algo que ajude seja olhar o diagrama de classes.
Aqui eu tenho, do ponto de vista de análise que tá em azul aqui,
o Aluno conhece um Departamento,
aqui é engraçado que justamente o exemplo que eu trouxe ali
era fazer com que o Aluno tivesse agora..
para que o Departamento agora tivesse
uma Lista de Alunos,
foi isso que eu falei inclusive no meu discurso.
O que aconteceria se quisesse que o Departamento tivesse uma Lista de Alunos?
Bom, tá aqui o modelo que fala um pouco disso.
Bom, tá aqui o Departamento e eu vou ter ali, ó,
um ObjLAlunos, Lista parametrizado com Aluno,
conforme eu já tinha dito.
Construtora e destrutora, incluaAluno,
tranquilo, né, vai receber o Aluno e vai chamar o...
o setInfo desse cara aqui, ou o incluaInfo, sei lá eu, como eu chamei lá.
incluaInfo, suponho.
incluaInfo, de fato.
E boa.
E a listagem?
Bom, a listagem aqui no Departamento
você, grosseiramente, iria fazer um Ctrl+C nesse código
do listeAlunos de Disciplina, vir aqui no listeAlunos do Departamento e colar ali.
Ia até funcionar,
só que você está com aquela situação de código replicado.
Bom, em todo caso, foi até aqui que a gente chegou com a solução e a partir daqui vocês têm que evoluir.
Pra resolver essa relação de associação teórica,
ou seja, de análise,
eu vou fazer algo prático.
Vou fazer com que o Aluno tenha um ponteiro do Departamento
então essa associação em projeto aqui, né,
ela é realizada, aliás, ela realiza parte dessa situação.
Parte, outra, dessa situação dessa associação teórica,
é realizada por essa agregação.
Que agregação é essa?
Ora o Departamento agrega uma Lista,
inclusive, direcional, aqui tem que ser direcional a agregação.
Naturalmente, muito naturalmente.
Por que que o Departamento agrega uma Lista
e essa Lista em questão vai ser agregada por um Departamento só?
Porque tá ali, ó, você tem um ObjLAlunos, que é Lista parametrizada com Aluno.
Se ela é parametrizada com Aluno,
significa que essa agregação
depende... isso aqui é uma dependência, tá, em UML.
Conceito que vocês não conheciam ainda, mas tão conhecendo agora em diagrama de classes.
Então, classe Lista depende da classe Aluno.
Particularmente, quando a classe é instanciada, na verdade,
que é o caso aqui do ObjLAlunos,
que ela vai depender.
Nesse momento preciso, por isso que a agregação
e não a classe, mas a agregação em questão,
tá criando esse objeto aqui, ó,
que depende, esse pontilhado aqui, depende do Aluno.
Se eu quiser esquecer a parte de análise, a parte teórica,
e só olhar a parte prática, aqui em vermelho é a parte de projeto,
eu posso olhar o próximo slide, tá, ele traz isso.
Mas novamente, tá, aqui a solução vai funcionar
mas é uma solução que tem acoplamentos
que tem imperfeições.
Que imperfeições são essas?
Aquelas que eu falei, por exemplo, aqui dentro tem o código replicado
entre Departamento e Disciplina.
listeAlunos tanto na classe Departamento quanto na classe Disciplina,
vão ter o mesmo código e isso não é legal.
Quando você tem código replicado em vários lugares,
smell bad, cheira mal, tem coisa errada.
Então, reflitam, pensem em como vocês resolveriam essa situação,
Mas procurem resolver, procurem elaborar, fazer a reflexão
o engenho de vocês pra resolver essa situação posta,
e uma vez resolvido,
daí, vocês vão lá e testem o que vocês fizeram
contemplem o que vocês fizeram, vejam se a solução é boa.
Depois em um segundo momento, aí vocês podem fazer o seguinte.
Vocês podem, como de hábito,
ir na minha página. Tá aqui.
Técnicas de Programação.
A gente já está em conceitos avançados aqui.
Aqui tá o Grupo de Slides número 10
que é aonde a gente tá.
Eu acho que atualizei essa página, aqui não tá atualizado, tá vendo, ó.
Isso significa que eu devo dar um refresh aqui.
Agora atualizou, agora tá mais bonitinho.
Tá aqui o Grupo de Slides 10,
que foi o que a gente viu nessa exposição de hoje.
E aqui, eu tenho a parte B.
Adivinhem.
Aqui nessa parte B, justamente, a gente vai resolver
esse exercício que a gente propôs pra vocês ali, tá.
Ele vai dar uma solução
que permite resolver com elegância
aquilo que eu tô pedindo pra vocês
investigarem e tentarem gerar uma solução
a priori de vocês, justamente, pra poder confrontar com essa.
Pessoal, eu espero que vocês tenham aproveitado a aula,
eu estou de férias, mas em férias em pandemia,
a gente faz várias coisas, particularmente, trabalhar.
Inclusive gravando aula.
Espero que essa aula tenha ficado entendível,
Sem o quadro, sem toda a gestualística
todos os gestos que uma sala de aula permite,
talvez não seja a mesma dinâmica, né, de explicação,
mas eu procurei fazer o meu melhor aqui.
Isso posto, nos vemos em nossa próxima exposição brevemente.
Bons estudos aí.