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.
Apresentação do Exercício Final
Loading...
來自 Instituto Tecnológico de Aeronáutica 的課程
Orientação a Objetos com Java
862 個評分
從本節課中
Polimorfismo, Law of Demeter e Exceções em Java
Olá! Bem-vindo à semana 6 do curso Orientação a Objetos com Java! Nesta semana você aprofundará seu contato com o conceito de Polimorfismo, princípio "Law of Demeter" e Exceções em Java. Ao final desta semana, você será capaz de 1) projetar e estruturar programas Java mais flexíveis e com acoplamento baixo, 2) além de garantir o tratamento adequado de exceções em Java
與講師見面
Clovis FernandesProfessor Titular in Portuguese
Ciência da Computação
Eduardo GuerraProfessor Colaborador
[MÚSICA] [MÚSICA]
Chegamos enfim ao final do primeiro módulo do nosso curso.
O Curso de Orientação a Objetos com Java.
Foi longo caminho, espero que tenha sido longo aprendizado,
e agora chegou a hora de a gente fazer aquele exercício que vai digamos
assim, juntar tudo aquilo que a gente aprendeu,
e colocar numa aplicação.
O que a gente vai fazer?
A gente vai fazer pequeno jogo, ta?
É o jogo das palavaras embaralhadas, ta?
É jogo simples que você recebe uma palavra embaralhada, que as letras foram
embaralhadas e você tem que adivinhar qual que é a palavra original, ta?
Você vai falar assim: " mas isso é muito simples, como que eu vou exercitar?"
A questão é que a gente vai fazer esse jogo de forma que pedaços desse jogo
possam ser facilmente trocados e que existem várias classes
que possam ser utilizadas para determinadas tarefas, ta?
No caso o que é que a gente vai fazer?
Algumas classes, as classes que por exemplo, que embaralham
palavras e as classes que determinam lá o andamento do jogo,
a dinâmica do jogo, a gente vai poder trocar elas, para dar por exemplo, uma
dinâmica de jogo diferente ou embaralhar as palavras de uma forma diferente, ta?
Permitindo também que eu possa desenvolver novas classes desse tipo, certo?
E com isso eu consiga, digamos assim expandir o meu jogo, criar novas versões
com mais funcionalidades de uma forma bem fácil, ta?
Eu vou ler aqui junto com vocês e vou esclarecendo algumas questões para
facilitar aí a tarefa de vocês, ta?
Então o objetivo do exercício é criar jogo onde partes de sua execução possam ser
trocadas.
O jogo é simples: apresentado ao jogador uma palavra com letras embaralhadas e
o jogador deve tentar adivinhar a palavra correta, certo?
O jogo será jogado no próprio console e a lista de palavras utilizadas pode ser fixa
(pelo menos 20 palavras), tá?
E eu gostaria muito que vocês tentassem fazer
com que essas palavras fossem lidas de arquivo.
Eu sei que a gente não viu essas partes das bibliotecas de Java,
mas eu acho que faz parte de toda a tarefa de programação,
a gente correr atrás de alguma coisa que a gente ainda nunca usou,
de utilizar alguma biblioteca para ler arquivo, acessar outro sistema, não é?
Isso faz parte.
Então, nesse exercício, esse fator novo vai ser vocês
estarem lendo de arquivo, essas palavras, certo?
Vem uma dica aí.
Você pode fazer o jogo no próprio console, existe aí a classe Scanner,
que lê a entrada do usuário e ela tem que ser, ela é criada,
você pega o System.in, que é a entrada do usuário e aí você pode usar nextLine,
nextInt, para pegar aí o que é que o usuário está digitando, ta?
Isso aí é uma dica para vocês fazerem o jogo no console, ta?
Então, o jogo ele tem os componentes, eu já estou
facilitando e colocando aí quais os componentes o jogo tem que ter, ta?
Para já dar uma orientada aí vocês, ta?
Ela vai ter a classe principal, que é a aquela classe com método main,
uma coisa importante é que, essa classe principal, é a única que pode
ler as entradas do usuário do console, nenhuma outra pode fazer isso, ta?
Então eu estou determinando muito bem essa responsabilidade aqui, ta?
O BancoDePalavras, que é uma classe que possui o método que vai estar retornando
uma palavra que é retornada aleatoriamente ali de uma lista de palavras,
vinda a partir de arquivo, certo?
Eu tenho uma interface, Embaralhador, que representa ali as classes responsáveis
por embaralhar uma palavra, ou seja, ela recebe uma palavra e retorna a palavra
embaralhada e eu quero que essa interface tenha pelo menos duas implementações, ta?
Eu tenho uma fábrica de embaralhadores,
que tem método que vai retornar aleatoriamente, embaralhador, ta?
Então o que é que vai acontecer?
Eu vou ter vários embaralhadores, certo?
E aí eu vou chegar para a fábrica de embaralhadores e vou falar assim: olha,
me dá dos seus embaralhadores, aí vai te retornar,
você não sabe qual que é e você vai chamar o método para embaralhar a palavra, ta?
Aí que vem uma grande sacada, vamos lá,
vai ter uma interface chamada MecanicaDoJogo, ta?
Essa interface que vai dar o andamento para o jogo.
Então por exemplo, ela que vai dizer se o jogo já acabou,
vai dizer se o usuário acertou ou não a palavra,
se ele pode tentar novamente, quantos pontos ele ganha.
E eu também quero por exemplo duas implementações dessa interface.
Só para dar exemplo aqui, eu posso ter jogo que o usuário,
ele vai tentar acertar,
5 palavras embaralhadas, e vão ser sempre 5, se ele acertar,
ele marca os pontos, se ele errar, ele diz que errou e passa para a próxima.
Ou eu posso ter por exemplo, jogo que sei lá, que o usuário tenha vidas,
ou seja, ele pode ir tentando novamente, mas ele pode errar no máximo 3
vezes e aí ele vai fazendo isso quantas palavras forem possíveis.
Eu posso ter modo, morte súbita, que quando ele errar a primeira palavra acaba,
mas o número de palavras é quantas ele conseguir.
Então eu posso ter várias formas de jogo diferentes, com essa mesma, dentro
dessa mesma ideia de você dar uma palavra embaralhada e a pessoa adivinhar, ta?
A própria pontuação pode ser de acordo com a dificuldade da palavra,
com o número de letras da palavra, ta?
Então, tudo isso vai depender dessa classe MecanicaDoJogo, ta?
Então, aí tem a fabrica da mecânica do jogo que vai retornar
a mecânica do jogo que você vai querer utilizar naquela partida.
Pode ser aleatório, ou você pode setar individualmente,
mas a ideia é que seja fácil de mudar a mecânica do jogo, sem você ter que
mexer no método principal, simplesmente trocando a instância de mecânica,
a classe da MecanicaDoJogo que está sendo retornada, ta?
Então, a classe principal tem que recuperar a instância de MecanicaDoJogo de
FabricaMecanica, a partir dessa classe fábrica de
mecânica do jogo e a classe principal não pode ter nenhuma referência a uma
implementação específica da MecanicaDoJogo, ta?
Somente a interface dela.
Da mesma forma, aqui a MecanicaDoJogo, eu falei que é uma interface,
mas se você quiser fazer que seja uma classe abstrata, deixo isso aí
aberto para vocês, de repente vocês querem jogar uma lógica maior aí, não sei, ta?
Da mesma forma as implementações de MecanicaDoJogo devem recuperar os
embaralhadores da fabrica de embaralhadores também não pode ter nenhuma
referência direta a uma implementação específica do embaralhador,
somente a interface, ta?
E as implementações de embaralhador tem que ter algoritmos de embaralhamentos de
palavras, como sei lá, inverter a string, permutar randomicamente algumas letras,
trocar letras pares por letras ímpares e aí fica a cargo da criatividade de
cada inventar aí embaralhador, ta?
As implementações da MecanicaDoJogo devem retratar o andamento do jogo.
Dei aí alguns exemplos,
mas exemplos de questões que podem mudar nessa mecânica do jogo.
Quando é que jogo termina por exemplo, após número fixo de palavras; após número
de erros e etc, após fazer uma determinada quantidade de pontos, ta?
Quantas tentativas podem ser feitas por palavra, ou seja, qual é que é a próxima
palavra a ser tentada; como é que são computados os pontos; qual é que é o
embaralhador ou seja, se você vai a cada palavra pegar embaralhador diferente,
ou se você vai usar o mesmo embaralhador para todas as palavras daquele jogo, ta?
O que é importante é que, independente desse funcionamento,
a classe principal tem que interagir com ela da mesma forma,
ou seja, como é que a classe principal vai saber se terminou o jogo?
Vai estar perguntando para a MecanicaDoJogo:!
Já terminou?
Se ainda não terminou me dá a próxima palavra.
Alguma coisa desse tipo.
E por exemplo, no final do jogo:!
Como é que eu vou saber a pontuação?
Também você vai perguntar lá para a MecanicaDoJogo,
qual que é a pontuação que o usuário conseguiu fazer, certo?
Uma dica aqui,
é que você é que vai definir essas interfaces, você que tem que pensar e
falar assim: quais são os métodos que o meu MecanicaDoJogo precisa ter?
Eu dei algumas dicas aqui, mas você é que vai determinar isso, até os próprios
embaralhadores, de repente se você quer falar assim: embaralhador ele vai ter ali
nível de dificuldade dele que vai ser usado, sei lá, para calcular os pontos.
Então isso vai ser a cargo de vocês, eu não vou vou dizer, eu falei que tem que
ter uma interface para os embaralhadores e uma para a mecânica do jogo,
agora os métodos dessa interface é você que vai definir, ta certo?
O que é que você tem que entregar para mim?
O código que você criar de todas essas classes do jogo; diagrama de classe com
classes que você criou; os testes de pelo menos das classes de embaralhamento, ta?
Se você quiser criar testes para as outras classes, fique à vontade,
recomendo, mas talvez precise de algumas técnicas que a gente não viu ainda,
mas pelo menos as classes de embaralhamento,
tenho certeza que vocês conseguem criar os testes e por fim eu quero que você faça,
uma ou mais partidas do jogo mostrando ele funcionando e grave
video para mim e disponibilize esse video de uma forma aberta, passando o link,
sei lá, você pode compartilhar o arquivo, você pode colocar
ele alguma plataforma aberta, como Youtube e outras que têm por aí, ta certo?
Então é isso, espero que vocês tenham entendido.
Boa sorte executar a tarefa e aplicar aí todos os conhecimentos que você adquiriu
nesse primeiro módulo do curso.
Até mais!
[MÚSICA]
