Bem vindo ao curso de Introdução à Ciência da Computação destinado aos alunos regulares da Universidade de São Paulo! Esta é a segunda parte do Curso, onde você vai continuar a aprender os principais conceitos introdutórios de Ciência da Computação e também aprenderá a desenvolver pequenos programas na linguagem Python. Esta disciplina não possui pré-requisitos; não é esperado que você tenha qualquer experiência prévia em programação; ela exige apenas o conhecimento dos conceitos básicos de matemática do ensino fundamental. No entanto, você deve fazer a primeira parte do Curso (também disponível aqui no Coursera). O objetivo principal é desenvolver o raciocínio aplicado na formulação e resolução de problemas computacionais, ensinar como abordar e resolver problemas computacionais. O ato de programar é uma ferramenta útil para trabalhar o raciocínio mencionado acima, bem como tornar mais concretos outros conceitos comuns em ciência da computação. Ao término do curso, o aluno estará capacitado para escrever pequenos programas em Python e a continuar com estudos mais avançados sobre Python por conta própria usando material disponível na Web. Bom curso!
POO – Programação Orientada a Objetos – Parte 2
Loading...
Do curso por Universidade de São Paulo
Introdução à Ciência da Computação com Python Parte 2
278 classificações
Na lição
– POO – Programação Orientada a Objetos
Sejam bem vindos à terceira semana do curso. Vamos estudar agora conceitos sobre programação orientada a objetos. Serão muitos novos conceitos e sua atenção na hora de ver os vídeos e fazer os exercícios será fundamental. Assista os vídeos 1, 2 ou quantas vezes forem necessárias para que você entenda muito bem cada conceito. Bom trabalho!
Conheça os instrutores
Fabio KonProfessor Titular
Departamento de Ciência da Computação - IME
[MÚSICA] Vamos continuar agora,
aprendendo mais sobre programação orientada a objetos.
Então, na aula anterior nós vimos que existe o conceito de classes,
e uma classe pode ter várias instâncias, vários objetos,
esses objetos vão ter atributos, que são variáveis, que armazenam
valores e também a gente vai ter métodos, vamos ver como é que a gente cria métodos.
Mas, antes disso vamos dar uma olhada nesse conceito que a gente chama de
construtor, que é método especial, é método da classe mas ele é método que
tem esse nome especial, que é o nome sublinhado, sublinhado init depois duas
vezes esse caractere ali de underscore, esse sublinhado duas vezes, tá.
Esse init ele é chamado de construtor da classe e ele vai ser
chamado automaticamente pelo interpretador quando os objetos são criados,
ou seja, quando as classes são instanciadas,
e ele nos dá a oportunidade de passar como parâmetro o valor dos atributos,
inicialmente, e ele já define o valor desses atributos.
Então, nessa classe carro, seria algo desse tipo aqui.
Então, eu vou experimentar aqui,
a gente digitar no iDLE por exemplo, isso aqui, seria algo desse tipo.
Então, o que é que aconteceu aqui?
Eu estou definindo uma classe carro e a classe carro vai ter método,
que é esse método init, init underscore, underscore init, underscore, underscore.
E daí ele recebe como parâmetro algumas coisas.
A primeira coisa é o nome de uma variável que vai representar o próprio objeto.
Então, por isso que a gente chama ele as vezes de self,
porque ele representa o próprio objeto.
Esse self aqui,
e é o próprio interpretador que vai passar como parâmetro valor,
que na verdade vai ser endereço de memória onde esse objeto vai estar guardado.
Então, a gente não precisa se preocupar com isso, a gente simplesmente lembra que,
no init sempre a primeira variável é a self.
E depois, os atributos que a gente quer.
Então, por exemplo, eu quero três atributos, o modelo,
o ano e a cor do carro.
E daí, aqui eu tenho a implementação,
essas três linhas é o código que implementa o método init.
O que que está dizendo essas três linhas?
Elas estão dizendo que, primeiro eu quero o modelo que é passado como parâmetro, eu
quero que você armazene como atributo de mim mesmo, do objeto que eu estou criando.
Então o self ponto modelo aqui recebe modelo, pega esse modelo que é passado
como parâmetro, cria atributo chamado modelo e armazena esse valor nesse modelo.
A mesma coisa com o ano e com a cor.
Então, ele está criando três atributos e está atribuindo o que passou como
parâmetro.
Daí então como é que a gente usa esse init?
Se eu quero dizer ali que o carro do meu avô,
eu faço carro e daí,
entre parênteses aqui, eu coloco o valor dos três atributos.
Olha, o próprio iDLE aqui já mostrou para mim que eu tenho que passar o modelo,
o ano e a cor.
Então, vou passar o modelo vamos supor que fosse
uma Ferrari, o ano não sei que ano que, 1980,
que a Ferrari estava bem, e a cor obviamente a vermelha, né.
Daí, se eu pegar
o carro_do_meu_avô.cor eu,
o que é que eu errei aqui, eu digitei errado, né.
Ccarro_do_meu_avô.cor é vermelha,
tá, então a gente quase sempre vai ter esse método init,
que vai ser o construtor onde a gente define os valores iniciais dos parâmetros.
Vamos continuar, para nos aprofundarmos pouco mais disto.
Eu vou carregar aqui programinha pouquinho mais longo,
que eu digitei anteriormente, que se chama aqui carro.py,
e ele faz série de brincadeirinhas com dois tipos de carro.
Então, aqui eu tenho a definição da classe carro, aqui embaixo,
né e tenho o método init, depois ele tem mais dois métodos,
tem o método imprima o método acelere e o método pare, tá.
E no final aqui ele executa essa função main, onde a função main a gente vê aqui,
está definida aqui essa função main.
O que que faz a função main?
É uma função que está fora da classe,
ela é simplesmente testezinho para exercitar essa classe.
Então, ela cria dois carros, ela faz carro recebe carro,
passando como parâmetro Brasília, 1968, amarelo, 80.
O que é que é 80?
80 vai ser aqui o último atributo que é a velocidade máxima.
Então, diz que essa Brasília consegue,
se você colocar na última marcha e acelerar ao máxima ela chega a 80 km/h.
Já esse carro dois aqui é Fuscão, preto de 1981,
ele consegue atingir a incrível marca de 95 km/h, se você está na descida, né.
E daí, eu chamo, então criou aqui duas instâncias da classe carro, guardando
nas variáveis, carro e carro dois, e agora eu chamo alguns métodos nesses carros.
Então, eu faço, carro acelera até 40 km/h, carro dois acelera até 50.
Carro acelere até 80, carro pare.
Carro dois acelere até 100 km/h, né.
E vamos ver o que é que fazem esses métodos, né.
Então, primeiro tenho o construtor, né.
Como está o construtor aqui, sempre começa com o self e depois aqui ele colocou nomes
muito curtinhos nesses parâmetro.
Na verdade eu até não gosto muito, acho que eu vou, o nome das variáveis tem que
ser mais explicativas, depois a gente podia mudar isso aqui.
Eu preferi usar o próprio modelo, ano, cor e velocidade máxima, né.
Anote que o velocidade aqui, não é passado como parâmetro, né,
então o M ele guarda no modelo, o A ele guarda no ano,
o C ele guarda na cor e o VM ele guarda nesse máx V,
que seria a velocidade máxima que o carro consegue andar.
E a velocidade inicial ele define outro atributo mas o valor dele é
inicializado com zero, não é inicializado com nada que foi passado como parâmetro.
Todo carro quando é criado, ele começa com velocidade zero, ele começa parado.
Depois, se alguém quiser mudar a velocidade, tem que chamar o método que
acelere, que é quem vai mudar a velocidade, tá.
Então, aqui aqui está definido o construtor.
Esse nome máx V, também aqui, eu talvez preferia máx vel,
de velocidade, né, ia deixar mais claro o nome das coisas.
Tá, e quais são os métodos que essa classe tem, ela tem três métodos.
Então, note que todos os métodos, imprima, acelere e pare primeira
variável é sempre esse self, que a gente não precisa passar como parâmetro,
quem vai passar como parâmetro é o próprio interpretador.
E dentro do método, quando a gente quiser se referir ao próprio objeto,
aos próprios atributos do meu objeto, daí eu vou fazer self ponto e depois,
o nome do atributo, tá, eu estou me referindo à mim
mesmo o objeto se refere a si mesmo ele vai usar esse self.
Então, o que é que faz esse imprima aqui, vamos ver, ele faz o seguinte.
Se self ponto vel, que é a velocidade, se a velocidade é igual a zero,
daí quer dizer que o carro está parado, e daí com o carro parado a gente
consegue ver o ano do carro ali, né, daí a gente imprime o que?
A gente imprime o modelo, a cor e o ano, né.
Agora, se a velocidade, não, então caso contrário,
ou seja, se a velocidade não é zero, se o carro está andando,
daí você não consegue ver direito o ano, né, nessa brincadeirinha aqui, né.
Daí o que é que ele faz?
Se a velocidade é menor que a velocidade máxima,
daí a gente fala, esse carro aqui, ele está indo a tantos km/h.
Então, a gente fala o modelo do carro, a cor dele, está indo nessa velocidade aqui.
Por outro lado, se a velocidade não é menor que a velocidade máxima, ou seja,
se ela é maior ou igual a velocidade máxima, daí a gente está falando,
o carro aqui, esse carro, desse modelo, dessa cor está indo muito rápido.
Muito rápido!
Tá bom.
Então esse aqui é o método imprima, o que que ele faz.
Daí vamos ver, o método acelere.
O método acelere tem sempre aquele self, o primeiro parâmetro,
e depois ele recebe como parâmetro V, uma velocidade que vai ser definida, né.
Então, eu preferia colocar algo como velocidade, né.
E daí, o que é que a gente faz?
Essa velocidade, a gente guarda no atributo vel, primeira coisa,
e depois a gente faz o seguinte.
Se a velocidade que o usuário passou como parâmetro aí é maior
que a velocidade máxima do carro, ele quer que o Fusca vá a 100 km/h, não dá,
o Fusca não consegue ir a 100 km/h, então, o que que a gente faz?
A gente faz a velocidade passa ser a velocidade máxima, tá,
então se alguém coloca uma velocidade maior que a máxima,
a gente coloca exatamente a velocidade máxima do carro.
E depois manda imprimir aqui informações desse meu objeto,
então note aqui, é método está chamando outro método.
O método acelere, no final, ele chama o método imprima.
Então, primeiro ele vai executar o método acelere, como a última linha
do acelere chama imprima, daí depois ele executa o imprima e daí termina.
Note que, quando a gente acelera e cai nesse caso
que a gente colocou a velocidade máxima, quando chega no imprima,
ele vai cair nesse último else, porque a velocidade está igual a velocidade máxima,
então ele não é nem zero nem menor que a velocidade máxima, ela é igual.
Então ela cai aqui dizendo que está muito rápido,
quando ela está nessa velocidade máxima.
E daí, finalmente, tem o método pare que fora o self, não recebe nenhum
outro parâmetro, o que ele faz, ele coloca zero na velocidade e manda imprimir.
Então, vamos executar isso aqui e ver o que acontece.
Então, dá run aqui, salvar, que eu fiz uma alteração, né.
Olha o que ele faz ali, ele chamou o main, né ele falou,
primeiro vamos, passo a passo aqui ver o que está acontecendo.
Criou esses dois carros e daí aqui ele acelera até 40.
Quando ele faz o acelere até 40, ele define a variável aqui no acelere
40 e depois chama o imprima, daí o imprima vai lá imprime aqui.
Brasília amarela indo a 40 km/h.
Depois, segundo comando aqui, ele vai dizer, carro dois, acelere até 50.
E daí, como resultado ele vai imprimir Fuscão preto indo a 50 km/h.
Depois ele fala.
Carro acelere até 80.
Note que 80 era a velocidade máxima aqui da Brasília.
Então ele está acelerando até a velocidade máxima.
Daí o que é que ele imprime?
Brasília amarela indo muito rápido!
Depois ele fala, carro pare.
Brasília foi da velocidade máxima até parado, né.
Deve ter feito isso três minutos.
E daí, o pare o que é que faz?
Ele coloca velocidade zero e manda imprimir.
Daí eu imprimi do carro parado, ele consegue ver aqui o ano,
então ele imprime Brasília amarela 1978.
E a mesma coisa no final, ali o Fuscão preto indo muito rápido, tá.
Dessa forma a gente viu uma classe carro, com duas instâncias diferentes,
com atributos diferentes, né, tinha o Fuscão preto e a Brasília amarela,
e a gente chamou métodos, nesses diferentes objetos,
cada método gerou uma execução diferente,
e note que cada objeto tem o seu conjunto de valores para as variáveis, né.
Todo mundo tem os mesmos atributos, as mesmas variáveis, mas os valores,
cada instância tem os seus valores diferentes.
Que carro é diferente de outro carro.
O que a classe define é quais são os atributos que carro tem,
daí todos os carros vão ter aqueles atributos,
mas o valor dos atributos varia de carro para o outro.
A gente viu também que método pode chamar outro método ali e eventualmente
passando parâmetros né, a gente vê que método pode receber parâmetros ou não.
Por exemplo, o imprima aqui não tem nenhum parâmetro passado pelo usuário,
tem apenas o self que é aquela variável que o próprio interpretador passa,
e que se refere ao próprio objeto e a gente usa o self,
tanto para acessar os arquivos atributos desse objeto, quanto,
por exemplo, para chamar aqui outro método deste mesmo objeto, tá bom.
Então, já aprendemos a criar objetos com seus construtores,
manipular os atributos e como que a gente define métodos dentro de uma classe.
Métodos, na verdade são funções definidas dentro do escopo de uma determinada
classe, então essa classe carro aqui nesse caso,
tem quatro métodos sendo construtor e três outros métodos, tá bom.
Espero que vocês tenham gostado.
É ideal que você pratique pouco, inventa alguma coisinha,
algum tipo de objeto aí que você gosta, seu objeto preferido, animais,
jogos, qualquer coisa,
e crie uma classe representando quais são as características principais desse seu
objeto preferido e depois tente instanciar alguns desses objetos.
Então, por hoje é só.
[MÚSICA]
[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.
© 2018 Coursera Inc. Todos os direitos reservados.
