Agora, a melhor maneira de aprender é realmente ver o código em ação, então chega de teoria, vamos realmente codificar
nossa própria classe.
Vou apenas deletar tudo e começar do zero.
E vamos dizer que estamos trabalhando para uma empresa de jogos e esta empresa de jogos tem todo esse jogo
mágico que eles querem criar, quase como Harry Potter.
Agora, como podemos pensar sobre isso e a programação orientada a objetos?
Bem, a primeira coisa que precisamos é que os jogadores escrevam.
Cada jogador tem um personagem que precisa para jogar.
Então, vamos criar uma classe aqui e chamá-la de jogador.
Novamente, observe a convenção de nomenclatura porque é uma classe.
E.
Outra regra é que normalmente você queria ser singular, não plural, então você não pode dizer personagens
dos jogadores, porque quero dizer, é um projeto deste projeto.
Vamos criar muitos personagens, mas esses serão objetos.
Então personagem do jogador, único no singular.
Agora, aqui, vou fazer algumas coisas e vou avisá-lo, vai parecer confuso no início.
Mas tenha paciência comigo.
Eu vou explicar isso.
Vamos definir um sublinhado, sublinhado nele, sublinhado, sublinhado.
Agora aqui vamos dizer eu.
E então dê um nome, o nome do personagem daqui, vamos fazer Callon mais uma vez.
E simplesmente diga o nome do Self Doc.
É igual a nome.
Oh, cara, o que aconteceu aqui?
Novamente, vou adiar a explicação do que isso faz e apenas escrever mais algumas linhas de código para que faça um
pouco mais de sentido.
Vou escrever outro método aqui e definir, digamos, um método de execução que cada
jogador pode executar aqui.
Vou ter mais uma vez essa palavra estranha e, simplesmente, aqui dentro, diga imprimir.
Ron.
Tudo bem, acabei de criar essa classe, ainda é meio confusa, não sabemos realmente o que é
isso, o que é o eu e todo esse novo visual.
Mas vamos ignorar isso por um segundo e simplesmente dizer.
Jogador.
Um vai igualar o personagem do jogador e instanciar esse jogador.
Para que possamos imprimir o player e ver o que há com ele.
Se eu clicar, corra.
Tudo bem, recebo um erro, é um erro de digitação, diz INET sem um nome de argumento posicional obrigatório.
Tudo bem, vamos fazer uma pausa aqui e ver o que está acontecendo aqui.
Você vê este inet.
Método é um método especial.
Você vê os dois sublinhados aqui.
Isso é chamado de método Dundar ou método mágico, e vamos ter um vídeo especificamente sobre isso.
Mas quando estamos criando uma classe, geralmente você vê isso no topo.
E isso é o que geralmente é chamado de método construtor ou método init.
E isso é automaticamente frio sempre que instanciamos.
Lembre-se, instanciar significa que estamos chamando a classe para criar um objeto.
Portanto, quando eu fizer isso, ele executará automaticamente tudo o que estiver neste bloco de código.
Então, quando eu executo isso, você vê que estou colocando o ar online 9:00 bem aqui na linha nove e
quando tentei instanciar o personagem do jogador.
Ele roda nele e então tenta fazer o nome autodidata igual a nome, mas o problema é que não
estou atribuindo a um nome de argumento, e isso é porque quando o invocamos, aceitamos tudo o que vem depois de
mim como o parâmetro.
Quer dizer que precisamos dar a ele um nome desse personagem, então vamos dizer que o nome é Cindy, se eu clicar em executar aqui.
Tudo bem.
Parece que tenho um personagem de jogador e, na verdade, até me mostra que é um
objeto neste local de memória.
Então, em nossos computadores, é aqui que o jogador, personagem, jogador um está localizado.
Agora, muito legal, mas o que é essa palavra-chave self e para que serve esse código online?
Esta é uma forma de definirmos o que self self se refere ao personagem do jogador, está dizendo, ei, isso vai se referir a este
personagem do jogador que iremos criar.
Jogador um, e quero que o nome de auto-engano seja igual a qualquer que seja o nome do parâmetro.
Então, se eu tocar o nome da filha dela aqui e clicar em correr.
Eu fico com Cindy e por que Cindy está?
Bem, porque eu dei a ela o personagem de jogador de perímetro e quando instanciei, passei o parâmetro
de nome.
O parâmetro padrão é self quando eu faço nele.
E nas classes você vê aqui que o padrão, sempre o primeiro parâmetro quando estamos definindo um método,
é self.
E agora eu dou meu nome para autodidata, ei, e se eu remover isso aqui e clicar em executar?
Você vê que diz que o objeto não tem nome de atributo.
Porque, para eu dizer, ei, quero que o jogador tenha um nome, preciso dizer autodidata porque self
se refere ao jogador um.
Então, se você se lembra de quando tínhamos uma lista, tínhamos que fazer DOT e então diríamos: acrescentar o que alguém escreveu a
esse código de anexo.
E no código de anexo vai dizer ponto self.
Digamos que adicione à lista e self se refira a tudo o que está à esquerda do ponto.
Assim, permite-nos ter uma referência a algo que ainda não foi criado neste caso.
JOGADOR um E que eles saibam que, ei, quando for criado, quando nós instanciamos, então eu quero
que você tenha certeza de que o Jogador um tem este atributo de nome para que se eu criar outro jogador
e jogador, Tom será o jogador.
Se eu imprimir o nome do jogador e clicar em executar.
Tenho dois jogadores diferentes com dois nomes diferentes.
Consegui usar o mesmo trecho de código, mas têm valores diferentes porque o self, toda vez que instanciar isso,
refere-se ao primeiro jogador um, depois ao primeiro segundo jogador a agora self como uma dessas coisas.
Isso fica muito, muito complicado de entender.
E talvez você precise assistir a este vídeo algumas vezes.
Mas a chave aqui deve ser evidente para você.
Ou seja, consigo escrever código apenas uma vez.
Lembre-se de nosso sorteio principal.
Eu não me repito e sou capaz de torná-lo dinâmico, dizendo que esses dados que vamos criar
para o objeto serão dinâmicos e mudarão com base no que dermos.
Para que eu possa criar diferentes jogadores com diferentes atributos.
Mas ainda use o mesmo código.
Agora, posso ter várias coisas aqui, posso ter H, por exemplo, e mais uma
vez, posso dizer que idade autodidata é igual a idade e então Cindy terá que passar, digamos 44 e Thomas, 21.
De modo que aqui mais uma vez, se eu fizer H.
Eles terão atributos diferentes.
Portanto, lembre-se de que esses são atributos ou propriedades que esses objetos possuem e você pode acessá-los fazendo a
notação de ponto e acessando a própria propriedade.
Você vê que não tenho nenhum colchete aqui porque não é um método.
Não está agindo.
Ele está simplesmente dizendo, ei, desejo acessar este atributo.
Se eu fizer um ponto aqui, meu editor vai me dizer e teremos o símbolo para, ei, você tem acesso
ao atributo, idade e nome.
E na verdade, também tenho acesso para executar o método para que, se eu clicar, execute.
Bem, lembre-se, uma execução é um método, então eu obtenho esse método vinculado, mas ele não está imprimindo nada, não está
realizando a ação.
Portanto, temos que adicionar mais uma vez os colchetes, bater, correr.
E olhe só, sou capaz de correr, então não ganho nenhum, então vinte e um, por que pegamos isso?
Não porque lembre-se de que esta é uma função que não retorna nada quando uma função não retorna
nada.
O que nós temos?
Não entendemos.
Então, talvez eu possa simplesmente dizer "retorne pronto" se clicar e correr.
Ai está.
Corremos Don um.
Agora, uma última coisa antes de terminar este vídeo, o interessante aqui é se eu faço o jogador um e depois o
jogador dois e imprimo isso e clico em executar.
Você verá que entendi o personagem do jogador.
Mas o objeto, cada um desses objetos, o jogador um e o jogador dois estão em um local de memória diferente.
Portanto, posso usar um pedaço de código, um projeto para criar vários jogadores, mas esses jogadores não são
os mesmos.
Eles são criados a partir do mesmo projeto, mas vivem em lugares diferentes na memória.
E isso faz sentido, certo?
Não queremos que Tom e Cindy sejam o mesmo jogador.
Eles são dois jogadores diferentes.
Assim, podemos manter as coisas seguras.
E qualquer coisa que eu adicionar ao jogador dois, por exemplo, digamos que o jogador dois agora pode atacar.
E o ataque vai ser apenas uma propriedade que vai ser 50 agora se eu não atacar aqui, você vê que o jogador também
atacou.
Ataque, mas se eu jogar um ataque Wyandotte.
Eu pego outro.
O objeto não tem ataque de atributo.
Espero que você esteja começando a ver o poder das classes, embora possa ser difícil
de entender no início, o poder se torna evidente quando somos capazes de criar este plano que
podemos usar continuamente para criar nossos próprios objetos .
Vamos explorar mais no próximo vídeo.