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.
Hands-on: Exemplo de Violação Encapsulamento
Loading...
Do curso por Instituto Tecnológico de Aeronáutica
Orientação a Objetos com Java
914 classificações
Na lição
Encapsulamento, Acoplamento entre Classes e Interfaces do Java
Olá! Bem-vindo à semana 5 do curso Orientação a Objetos com Java! Nesta semana você aprofundará seu contato com os conceitos de Encapsulamento, Acoplamento entre Classes e Interfaces em Java. Ao final desta semana, você será capaz de 1) projetar e estruturar programas Java evitando quebras de encapsulamento e propiciando acoplamento baixo entre classes, 2) além de garantir acoplamento abstrato entre classes pelo uso adequado de interfaces em Java
Conheça os instrutores
Clovis FernandesProfessor Titular in Portuguese
Ciência da Computação
Eduardo GuerraProfessor Colaborador
[MÚSICA] [MÚSICA] Olá a todos,
esse é o curso de Orientação a Objetos com Java.
Nesse hands on vamos falar pouco sobre encapsulamento está?
A ideia é eu mostrar para vocês uma classe uma classe pilha,
não é, estrutura de dados que todos aí já conhecem, certo,
e mostrar que se a gente quebrar o encapsulamento dela,
expôr demais as informações pode causar funcionamento não desejado,
completamente errado aí na classe, está?
Então para mostrar isso para vocês eu vou começar aqui criando projeto,
está eu vou chamar de pilha encapsulada, não é, já que estamos
falando de encapsulamento e vou criar aqui
rapidamente uma classe pilha, certo?
Vou utilizar array não é para armazenar
internamente as informações da pilha, está certo?
Então eu vou chamar aqui a classe de pilha.
Bom, na minha pilha, não é, eu já vou criar
aqui todos, toda a estrutura de dados como privada, não é,
vou criar aqui array de objetos,
para guardar os elementos da minha pilha, vou chamar aqui de elementos,
certo, e eu
vou criar aqui uma variável inteira
para poder guardar o ponto da minha pilha,
onde que está o topo da minha pilha, não é,
vou chamar aqui de topo, certo?
Então o topo ele começa com o 0, não é, eu começo sem nada.
Aqui no construtor da pilha eu preciso criar ali o meu array.
Eu vou criar aqui a pessoa passando o tamanho máximo da pilha, está?
Então eu já vou ali e já vou criar o meu array de elementos é igual
a new Object coloco 1, 10 não
máximo aqui, não é, eu vou passando ali como parâmetro.
está?
Então a pilha ela tem 3 operações básicas está?
A operação de empilhar, que você coloca novo elemento na pilha,
você empilha a pilha como se fosse uma pilha mesmo de livros.
O que você coloca você coloca cima e quando você retira você retira de cima.
Então o empilhar você vai colocando
cima e o desempilhar você vai retirando de cima, está?
E aí topo ela serve justamente para marcar esse, onde que ele está.
Então eu vou criar aqui o não é,
ele vai receber objeto,
elemento aí o que é que ele vai fazer?
Ele vai colocar aquele elemento na posição onde está o topo ali certo?
Então obviamente ele vai começar com 0 mas aí eu tenho que incrementar o meu topo,
não é, então eu vou fazer aqui topo mais mais,
então depois que ele coloca ele aumenta o topo.
Eu preciso fazer agora o meu desempilhar, não é?
É, vou
aqui colocar o
meu [SEM ÁUDIO]
o desempilhar na verdade retorna objeto, não é, o que está mais cima, não é?
certo?
Então eu vou fazer o seguinte eu vou pegar paraRetorno,
eu vou pegar o elemento que está na posição
eu posso até já diminuir o topo aqui não é, fazer aqui topo mas eu tenho que,
isso, topo menos menos certo,
o objeto para retorno é o que está, não eu já vou retornar ele de uma vez,
eu nem vou fazer isso aqui não vou fazer return
elementos eu já subtrai ali o topo não é,
então se ele tem 1, vamos pegar aqui o primeiro exemplo,
ele vai estar na posição 0 não é, então eu vou retornar aqui.
Eu tenho também o topo,
não é, e esse não remove, ele só me diz quem que está
cima então nesse caso como eu não estou reduzindo o topo seria o elementos
opa topo mais
opa menos e por fim vou criar
método aqui que vai retornar o tamanho, qual que é o tamanho atual da minha pilha,
esse aqui simplesmente vai retornar o topo, certo?
Bom, mas aí eu
posso querer criar
métodos get set ali daqueles, dessas informações.
Tem gente que acha que encapsulamento é simplesmente colocar os atributos
privados, não é,
mas não adianta nada se você expôr aquelas informações de outra forma, não é?
Então eu vou vir aqui, só para a gente fazer aqui esse
exercício, não é, eu vou gerar aqui os métodos get set,
que o próprio Eclipse faz isso aqui para mim marca tudo aqui, não é,
já vi muita gente fazer isto sem pensar muito.
Então vai fazer esse getTopo ali ser equivalente ao tamanho,
então vou até tirar isso daqui está certo?
Então vou salvar, não é,
e aí agora vou criar aqui codigozinho só a gente
usando a pilha para a gente entender como que ela funciona.
Então vou criar uma nova classe aqui, vou chamar ela de principal,
[SEM ÁUDIO]
opa vou apagar isso aqui, vou deixar só o método main mesmo.
Então vou criar uma pilha e pilha,
vou criar uma pilha com 10
no máximo, certo, e aí vou empilhar aqui.
empilhar, vou colocar aqui vários nomes,
não é, vou colocar aqui Eduardo, vou colocar
aqui Maria,
vou colocar aqui por exemplo, sei lá, José, certo?
Aí, por exemplo, se eu pedir para ele me imprimir o topo
ele tem que imprimir o José.
Se eu pedir para ele me imprimir o
tamanho, tem que ser 3, certo?
Vamos ver se ele está rodando direitinho isso aqui?
Então eu rodo, deveria estar fazendo teste de unidade, não é,
mas aqui como eu quero mostrar o errado, eu estou fazendo aqui no main mesmo,
está, então o topo deu José e o tamanho está 3, está tranquilo, está?
Vamos remover uns agora, não é, eu já vou remover dentro do sysout eu
vou fazer aqui eu vou fazer
p.desempilhar, certo,
e aí vou imprimir novamente o topo e o tamanho, está?
Então eu vou até colocar comentariozinho aqui Desempilhando, certo?
Então eu vou vir aqui e vou rodar, certo?
Então ele está aqui o José e o 3,
é o que a gente tinha feito eu vou até fazer assim
para ele dar uma separadinha ali para a gente, no console.
Deixa eu rodar de novo aqui, salva, roda outra vez, não é,
para a gente poder visualizar.
Então José e 3 é o que ele fez ali no começo não é,
aí aquela ali desempilhou, desempilhou o José.
Agora o topo ficou Maria e o tamanho ficou 2, perfeito, certo?
Imagina que, por exemplo aqui na hora que eu desempilho,
eu quero fazer isso aqui, está, é uma string não é?
Eu posso querer chamar algum método por exemplo, só que veja que a pilha,
não é, imagina que eu sou desenvolvedor que estou usando a pilha aqui,
o que é que eu posso fazer aqui?
"Olha eu posso mudar o topo" não é?
Então eu venho aqui e seto o meu topo para 6 certo?
O que é que será que vai acontecer?
Eu vou rodar aqui e ele,
ele está retornando todo o mundo null ali, certo?
Se de repente eu venho aqui nesse desempilhar, não é,
chamo aqui
toString.toUpperCase por exemplo, não é,
eu quero o nome todo maiúscula não é?
Certo, vou fazer a mesma coisa aqui com o topo, então eu salvo aqui vou rodar,
olha lá ele vai colocar o José e o Maria como maiúsculo, certo?
Agora se eu mudar pouco aqui quando eu
rodar aquilo ali ele vai dar por exemplo nullPointerException,
se eu clicar aqui ele já me mostra de onde que está dando o problema.
Porquê?
Porque eu estou recebendo cara nulo.
Então mudar esse topo aqui eu estou mudando a estrutura
interna da minha pilha está certo?
Então eu não posso permitir isso certo?
Então a gente vê que não é porque eu tenho aqui uma propriedade
que eu vou deixar que as pessoas mudem à vontade não é?
Obviamente pegar o topo, podia nem ser o caso não é,
pegar o topo aqui é relevante porque isso aqui é o tamanho que está a minha
pilha e a quantidade de elementos atual da minha pilha, está certo?
Quer ver deixa eu mostrar mais problema aqui Imagina
que eu venho aqui e desempilho.
Se eu desempilhar 2 e somar no topo, eu vou retornar, não é,
como eu não removo aqui por exemplo eu desempilho, eu simplesmente reduzo o topo
porque ele não vai ter mais acesso aqueles elementos ali de cima não é, de repente eu
posso ter acesso aqueles elementos de cima então não é para fazer isso, está?
Eu vou deixar esse get set aqui para a próximo,
para o próximo hands on a gente discutir está certo?
Então com isso a gente vê que o encapsulamento realmente é importante e
a gente dá a brecha para que quem está usando a classe possa modificar qualquer
coisa pode quebrar completamente o funcionamento esperado da classe,
podendo gerar bugs como eu mostrei no PointerException aí no programa,
está certo?
Então esse hands on foi isso, até ao próximo.
[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.
