‫Nesta lição, você aprenderá a criar e implementar suas próprias interfaces com um exemplo concreto e terá
‫uma ideia de por que as interfaces são usadas, especialmente quando nossas classes não têm um relacionamento entre
‫si e, portanto, não t compartilham uma classe base.
‫Portanto, a herança como tal não é uma opção.
‫Imagine que estamos trabalhando em um videogame onde o jogador pode destruir coisas, mas tudo o que
‫destruímos terá um comportamento diferente dependendo do que for destruído.
‫Por exemplo, destruir uma cadeira irá reproduzir algum som de destruição e irá gerar partes destruídas da cadeira.
‫Mas destruir um carro irá reproduzir um som de explosão, criará fogo e destruirá outros objetos próximos.
‫Para o nosso jogo, temos as seguintes classes, uma cadeira que herda do mobiliário da classe e o carro que
‫herda do veículo da classe.
‫Então, vamos dar uma olhada nessas classes bem rápido.
‫Então temos essa cadeira que herda de móveis, e a cadeira só tem um construtor simples aqui
‫onde definimos a cor e também o material com base no que é dado ao objeto que é criado.
‫Mas agora, é claro, essa classe é herdada de móveis, e é por isso que temos essas propriedades aqui,
‫cor e material que acabamos de usar na aula de cadeira.
‫E então temos o construtor aqui, que é o construtor padrão, onde esses valores serão definidos
‫por padrão.
‫Portanto, a cor e o material serão brancos e seriam por padrão.
‫E também temos um construtor simples que usa a cor e também o material para defini-los por
‫padrão.
‫OK, então não há nada muito sofisticado, mas é claro que também temos um carro e queremos destruir a cadeira
‫e o carro, como afirmei antes.
‫Então, vamos olhar para o carro bem rápido.
‫Portanto, aqui temos a mesma história, um carro de subclasse que estende o veículo, onde definimos a velocidade do carro, bem como
‫a cor.
‫Portanto, agora estamos usando, a propósito, um construtor simples, como fazemos aqui.
‫Mas é claro que poderíamos ter usado o baseado aqui também, passando a velocidade e também a cor.
‫OK, então essa também é uma opção válida e não teríamos que usar isso aqui.
‫Portanto, há duas maneiras diferentes, é claro, de fazer isso.
‫OK, então este carro é herdado de um veículo onde, é claro, a velocidade e a cor devem ser definidas.
‫Então, vamos dar uma olhada na classe do veículo.
‫E podemos ver aqui que este veículo da classe base tem uma velocidade, uma cor, um construtor padrão, que define esses
‫dois valores de velocidade com 120 quilômetros por hora e a cor com branco.
‫E então temos que o construtor simples definiria a velocidade e a cor com base nos
‫valores que são dados ao objeto do veículo.
‫Além disso, é claro, para o objeto de herança, como um carro, por exemplo.
‫OK, agora que temos todas essas classes diferentes e vimos como elas estão estruturadas, vamos examinar
‫o recurso de destruição real.
‫Então, qual é a melhor abordagem para criar esse recurso de destruição?
‫Se pensarmos sobre isso, não podemos adicionar uma classe para fazer nossas classes herdarem dela porque esta é uma
‫linguagem de herança única e não uma linguagem de herança múltipla que já herdamos de uma classe.
‫Portanto, o carro já herda do veículo e a cadeira já herda do mobiliário.
‫Portanto, não pode herdar de outra coisa.
‫Como, por exemplo, o veículo aqui que você vê C Sharp não permite isso porque não pode ter várias classes
‫de base.
‫Uma classe não pode ter várias classes básicas em dó sustenido.
‫Além disso, não há nenhuma relação concreta entre um carro e uma cadeira para compartilhar uma classe base de qualquer maneira, porque
‫eles são totalmente diferentes de duas coisas, certo?
‫Se implementarmos métodos normais chamados de método destroy, por exemplo, em cada uma das classes
‫que temos aqui, será difícil manter.
‫E se decidirmos mudar o sistema de destruição totalmente ou adicionar efeitos visuais aos nossos objetos
‫destrutíveis no futuro, será uma dor realmente passar por cada classe e modificá-la.
‫Porque neste caso, nós só temos duas subclasses, por assim dizer, certo, mas imagine que você tem 50
‫ou até 100 classes diferentes, 100 tipos diferentes de objetos em seu jogo, então você teria que passar
‫por cada um deles e ajuste o código de acordo.
‫Isso é realmente um fardo e não queremos passar por isso.
‫É por isso que precisamos encontrar uma solução melhor.
‫O que precisamos é uma maneira de impor nosso comportamento destrutível em cada classe que o usa, assim como um
‫contrato.
‫E se você já assistiu ao nosso vídeo sobre interfaces, sabe que são contratos que podemos criar.
‫Portanto, a melhor abordagem neste caso é usar uma interface e vamos chamá-la de destruível.
‫E qualquer classe que implemente essa interface será forçada a seguir nossos requisitos de destruição
‫e personalizá-la ao mesmo tempo, dependendo da própria classe.
‫Então, vamos prosseguir e criar essa interface, portanto, você pode ir aqui para o seu projeto, adicionar um novo
‫item e selecionar interface aqui e dar um nome a ela.
‫Então, vou chamá-lo de I.
‫D stroy Elbo para que você possa ver ao usar interfaces, você adiciona o AI no início do nome do
‫arquivo para indicar que vai ser uma interface.
‫Então, vamos adicionar essa interface.
‫Então essa interface terá apenas uma propriedade para armazenar o arquivo de áudio que será executado assim que executarmos
‫a destruição, que será o som de destruição, e então teremos apenas um método que destruirá um objeto
‫e vamos chamar isso método destroy.
‫Não vai devolver nada.
‫Isso apenas destruirá algo.
‫Assim, poderia, por exemplo, retornar os gráficos que você possui.
‫Assim, os objetos de IA que você deseja exibir assim que o item for destruído, por exemplo, o carro ou a cadeira
‫serão destruídos e assim por diante.
‫Portanto, vamos agora ter certeza de que nossas classes vão de fato implementar essa interface e, em seguida, é claro, implementar o conteúdo da
‫interface, ou seja, o som de destruição e também o método de destruição.
‫Como podemos fazer isso?
‫Bem, vamos ao nosso carro, por exemplo.
‫E aqui nosso carro vai precisar adicionar uma vírgula aqui no topo da classe, definição no topo e
‫usar essa interface destruível como.
‫Portanto, agora, se você adicionar isso, poderá ver que obtém um erro que diz que o carro não implementa som de
‫destruição de membro da interface, bem como destruir.
‫Assim, podemos mostrar possíveis correções e implementar todos os membros.
‫Por exemplo, isso criará esse código automático para nós.
‫Portanto, isso criará o vazio destrutível e criará o som de destruição para nós.
‫Então essa seria a versão gerada automaticamente.
‫Mas também podemos fazer isso manualmente.
‫Não há problema nisso.
‫Então aqui, por exemplo, podemos implementar o som de destruição.
‫E então o que eu quero fazer é ter uma propriedade para armazenar os objetos destruíveis
‫próximos.
‫Portanto, quando um carro é destruído, ele também deve destruir o objeto próximo.
‫E essa lista também será destruível do Tipo I, o que significa que ela pode armazenar qualquer objeto que implemente
‫essa interface e só podemos acessar propriedades e métodos nessa interface.
‫Então, para criar isso, vou criar uma lista pública de objetos altamente destrutíveis e
‫vou chamá-los de destruíveis nas proximidades.
‫Agora podemos prosseguir e estender nosso construtor; por um lado, queremos ter certeza de que inicializamos o
‫som para ter certeza de que temos um som de explosão.
‫Por exemplo, digamos que temos este som chamado som de explosão do carro e três, e então queremos
‫inicializar a lista de objetos destruíveis.
‫Portanto, esta será, por exemplo, apenas uma nova lista de objetos destruíveis.
‫E então precisamos também implementar o método destroy.
‫Então isso eu destruí aqui no topo, você pode ver que ainda não está feliz.
‫Ele ainda espera que implementemos o método destroy.
‫Então você vê, quando você implementa uma interface, você precisa implementar seus membros porque a
‫interface aqui tem dois membros.
‫Precisamos implementar os dois.
‫OK, isso significa que precisamos voltar aqui e realmente implementar o método destroy.
‫Então, vamos fazer isso rapidamente para fazer isso.
‫O que quero acrescentar aqui serão, em primeiro lugar, duas afirmações.
‫Vou apenas usar as instruções da linha certa.
‫Vou mantê-lo simples porque não estamos criando um jogo aqui, mas apenas tentando entender
‫os conceitos de interfaces.
‫Portanto, quando um carro é destruído, devemos tocar o som de destruição e criar um efeito de fogo.
‫Então, aqui estamos apenas imitando como se fosse realmente tocar o som e dirá apenas, OK, tocando
‫a explosão do carro e três sons, e então criamos o fogo.
‫Então, tudo está pegando fogo.
‫Tudo está queimando porque o carro está destruído.
‫Portanto, agora vamos examinar cada um dos itens destrutíveis nas proximidades e realmente destruí-lo.
‫Então, aqui vamos examinar cada objeto destruível I que está dentro de nossa lista de paredes destruídas
‫nas proximidades.
‫Nós o chamamos de destruível para que cada item seja destruível, que é basicamente apenas um nome
‫de variável local.
‫Portanto, dizemos, OK, o objeto destruível que implementará a interface destruível será apenas denominado destruível em nosso
‫for each loop.
‫Então, iteramos por meio dele, o que significa que iteramos por meio da coleção destruível próxima,
‫que é uma lista de objetos destruíveis de IA, basicamente objetos que a implementam, interface destruível
‫de IA e então apenas chamamos o método destroy.
‫Então, basicamente, criamos uma reação em cadeia aqui, destruindo tudo ao redor de tudo que é destruído e que também é
‫um carro e assim por diante.
‫Então, neste caso, digamos que temos dois carros próximos um do outro e eles têm um monte de cadeiras um ao lado
‫do outro.
‫Assim, os carros chamarão esse método de destruição, em que destruirão os itens próximos porque, bem, é uma
‫grande explosão, certo?
‫Ouve-se um som e cada item cria um som.
‫Agora, você poderia, é claro, criar um cronômetro de que ele precisa até que a explosão real aconteça depois que
‫algo pegar fogo.
‫Mas vamos mantê-lo simples aqui.
‫OK, então estamos destruindo os outros carros, mas também os outros vivas para que cada carro infecte outros itens ao seu
‫redor que estão por perto.
‫E isso poderia ser, digamos, tudo que está a 10 metros ou a cinco metros de distância ou a
‫quantos centímetros de distância se você quiser tomar o sistema americano aqui.
‫Mas é basicamente isso o que vai acontecer.
‫Agora, vamos olhar para as cadeiras, porque as cadeiras terão que passar por uma abordagem semelhante, porque também queremos ter
‫certeza de que uma cadeira pode ser destruída, mas a destruição de uma cadeira será
‫muito diferente.
‫OK, então aqui também adicionaremos a interface.
‫Portanto, a interface destruível da IA e, claro, precisamos implementar o som de destruição
‫e essa será uma destruição muito diferente porque a cadeira vai desmoronar e será madeira estilhaçada
‫que você ouve.
‫Portanto, será um som muito diferente aqui.
‫OK, e claro, queremos definir o som de destruição dentro do nosso construtor também.
‫Portanto, vou dizer que o som de destruição da cadeira deve ser reproduzido.
‫Sempre será o mesmo.
‫É por isso que não estou adicionando aqui na declaração da mesa.
‫Portanto, estou mantendo as coisas simples aqui.
‫Claro, você poderia ter cadeiras diferentes com sons de explosão diferentes, então você
‫adicionaria aqui no topo como um parâmetro para seu construtor.
‫OK, agora vamos implementar o método destroy.
‫E nesse caso, o que vai acontecer é que vamos destruir alguma coisa e vamos, antes de tudo, destruir a cadeira colorida com
‫base na cor que a cadeira tem, vamos escrever isso.
‫Em seguida, tocaremos o som de destruição e, finalmente, iremos gerar as partes da cadeira.
‫OK, então, em nosso caso, estamos apenas gravando no console.
‫Mas imagine em um jogo real como você faria isso, porque a melhor maneira de destruir algo em um videogame
‫não é realmente fazer a coisa física onde você faz toda a destruição, o que
‫é muito difícil de construir, especialmente se.
‫Não tenha uma grande equipe que faça todos os tipos de coisas, então você basicamente
‫faria uma grande explosão ou animação de destruição e então geraria as partes destruídas das partes individuais que estão ao
‫redor.
‫Portanto, você vê aqui que não há reação em cadeia proveniente desse método de destruição.
‫Portanto, a implementação do método destroy para a cadeira é muito diferente da implementação do veículo,
‫mas ambos herdam da interface destruível da IA e têm que implementar o método destroy e podem fazer isso
‫do seu próprio jeito.
‫Então, basicamente as interfaces nos permitem algum tipo de herança múltipla, embora não seja realmente uma herança
‫múltipla.
‫OK, agora vamos prosseguir e ir para os nossos programas.
‫sim.
‫E realmente usar nossas classes recém-criadas porque.
‫Bem, caso contrário, é chato.
‫Direito.
‫Portanto, vamos criar duas cadeiras.
‫Temos uma cadeira de escritório que será marrom e de plástico e uma cadeira de jogos que será
‫vermelha e de madeira.
‫E então também vamos criar um novo carro.
‫Portanto, este carro terá uma velocidade de 80 e será azul e será um carro danificado.
‫E então vamos adicionar as duas cadeiras próximas a este carro danificado.
‫Então, nós os adicionamos como destruíveis perto de nosso carro danificado.
‫Portanto, a cadeira do escritório, assim como a cadeira do jogo, estarão agora, se olharmos para ela aqui como algo destruível, está
‫próximo, porque ao criar um carro, essa lista estará vazia.
‫Mas então podemos, é claro, porque é uma lista pública aqui, podemos adicionar itens a ela, o que fazemos.
‫Nós adicionamos itens destrutíveis a ele.
‫E por que podemos adicionar cadeiras ao nosso destruível próximo?
‫Bem, porque uma cadeira implementa essa interface.
‫O fato de termos chamado I destruível significa que uma cadeira agora será aceita como um objeto destruível do Tipo II,
‫o que significa que agora podemos adicioná-la como nosso destruível próximo.
‫Agora podemos ir em frente e destruir o carro.
‫Então, vamos chamar o método destroy do nosso carro danificado para que a explosão possa participar, o som da explosão
‫possa começar e todas as coisas boas.
‫Então, vamos executar isso.
‫E, claro, este será mais um jogo de aventura e não tanto um jogo onde você verá gráficos 3D reais
‫ou algo assim.
‫Então tocamos o som da destruição, o som da explosão do carro.
‫Nós criamos o fogo.
‫A cadeira marrom foi destruída.
‫Estamos tocando o som de destruição da cadeira, som de destruição e B3.
‫Em seguida, estamos girando as partes da cadeira para nossa cadeira marrom.
‫Então a cadeira vermelha foi destruída.
‫Estamos tocando o som de destruição da cadeira, destruição, som e fúria e, em seguida, respondendo às partes
‫da cadeira por nossa cadeira vermelha.
‫Então você vê, é basicamente isso.
‫É assim que você pode criar suas próprias interfaces e usá-las.
‫E espero que agora você entenda o que as interfaces podem fazer por você e as vantagens das interfaces.
‫Portanto, um nó importante aqui por interfaces são usados para comunicação entre duas classes semelhantes ou não semelhantes
‫que não se importam com um tipo de classe implementando a interface, assim como nosso carro se comunicou com a
‫cadeira para chamar o método destroy, tudo porque eles apenas implementou a mesma interface que
‫afirmei anteriormente.
‫Portanto, embora as interfaces possam parecer difíceis de entender, à primeira vista, elas nos fornecem grandes vantagens.
‫Essas vantagens são chamadas de legibilidade.
‫Portanto, uma interface constitui uma declaração sobre intenções, portanto, define a capacidade de sua classe.
‫Então, o que sua classe é capaz de fazer?
‫Se você implementar o classificável I, por exemplo, estará declarando claramente que os objetos de sua classe podem
‫ser classificados, então a semântica do código.
‫Ao fornecer interfaces e implementá-las, você está separando conceitos ativamente e a interface define um modelo comportamental,
‫uma definição do que um objeto pode fazer.
‫E separar esses conceitos mantém a semântica do seu código muito mais clara.
‫Então você tem o código.
‫As interfaces de manutenção ajudam a reduzir o acoplamento e permitem que você troque facilmente implementações para o
‫mesmo conceito sem que o código subjacente seja afetado.
‫E então temos padrões de design.
‫É o panorama do uso de contratos, abstração e interfaces essenciais para a programação orientada a
‫objetos.
‫Portanto, compreensão humana e arquitetura de sistema complexa.
‫Então, basicamente, é apenas para entendê-lo melhor como ser humano e, em seguida, herança múltipla.
‫Portanto, as interfaces podem ser nossa porta de entrada para usar herança múltipla em C sustenido.
‫Então, suponha que você escreva uma biblioteca e queira que ela seja modificável pelos usuários.
‫Você escreve a interface e sua implementação de classe.
‫Outros desenvolvedores que usarão sua biblioteca ainda podem escrever suas próprias classes de implementação, que
‫podem usar diferentes tecnologias ou algoritmos que alcançam o mesmo resultado.
‫É também por isso que encontramos tantas interfaces em bibliotecas.
‫Usamos, mas raramente sentimos a necessidade de escrever nossas próprias interfaces, porque não escrevemos bibliotecas nós mesmos.
‫Em uma nota final, o importante é entender como as interfaces são implementadas neste ponto.
‫É claro que, à medida que passarmos por diferentes tecnologias, como WP e AP dot net
‫e a classe C master, começaremos a usar mais interfaces, o que ajudará você a entendê-las melhor no futuro.
‫Tudo bem.
‫Então, muito obrigado por assistir este vídeo.
‫Te vejo no próximo.