Oi, gente, tudo bem? Eu vou falar hoje para vocês sobre polimorfismo, que é assunto absolutamente fundamental orientação a objetos e vocês vão ver como é assunto importante. A ideia de polimorfismo é quando objeto ou algo apresenta múltiplas formas. Poli muitas, morfismo formas. É dos princípios fundamentais de orientação a objetos, que torna orientação a objetos tão poderosa. Tem diferentes estudiosos que falam que tem dois tipos, quatro tipos, seis tipos, três tipos de polimorfismo, mas pensando na linguagem Java, eu diria que tem três tipos principais de polimorfismo, que a gente pode encontrar Java. O primeiro é aquele polimorfismo que a gente chama de paramétrico, que tem a ver com programação genérica, generics, o segundo tem a ver com sobrecarga de métodos, overloading e o terceiro tem a ver com sobreescrita de métodos ou herança, subtipos, que a gente chama de método overriding. Vamos dar uma olhada nesses três tipos. O primeiro é o polimorfismo paramétrico que tem a ver com programação genérica, que a gente já viu rapidamente nesse curso. É aquela ideia de que se você tem tipo chamado ArrayList, esse tipo ArrayList pode apresentar diferentes formas, se comportar de diferentes formas de acordo com o tipo de objeto que ele está manipulando. e no polimorfismo paramétrico, quando a gente usa generics, a gente passa como parâmetro qual é o tipo que a gente quer naquele determinado caso, levar consideração. Então se eu faço ArrayList<String>, eu estou criando uma lista, que vai ser implementada internamente com Array, por isso se chama ArrayList, que nesse caso, vai conter apenas Strings, então todo o comportamento dele vai se adaptar aos comportamentos de Strings. Mas eu poderia, no mesmo ArrayList, fazer ele funcionar com inteiros, poderia fazer ele funcionar com objetos do tipo animal, onde animal é uma classe que eu defino ou uma lista de músicas também, onde música é uma classe que eu defino. Quem implementou o ArrayList, no caso, o ArrayList já vem implementado na biblioteca padrão de Java, mas quem implementou, implementou tipo genérico, tipo ArrayList genérico, que recebe como parâmetro outro tipo. A gente não viu ainda como fazer isso, mas você poderia criar os seus tipos genéricos, e quando você define uma nova classe, essa classe pode receber como parâmetro outro tipo e você escreve código genérico que funciona com esse outro tipo que você recebe como parâmetro. O nome do tipo passa a ser parâmetro, tem que ter t maiúsculo e você manipula aquele tipo, dessa forma você consegue fazer uma classe que vai funcionar com os diferentes tipos, e só quem está usando aquela classe é que vai passar como parâmetro aquele tipo. Esse é o primeiro tipo de polimorfismo. Você pode criar uma classe que funciona diferentes tipos, esse tipo que essa classe vai tratar é passado como parâmetro. Essa é a ideia de polimorfismo paramétrico. O segundo tipo é quando a gente fala de sobrecarga de métodos ou método overloading. Java, uma classe pode ter dois ou mais métodos com o mesmo nome, a única coisa que diferencia esses métodos é a assinatura dos métodos, ou seja, quais são os tipos dos parâmetros. Se você tem dois métodos com o mesmo nome mas recebe inteiro, o outro recebe double ou recebe inteiro, o outro recebe dois inteiros ou recebe como parâmetro objeto do tipo nave espacial e o outro método recebe como parâmetro objeto do tipo asteroide e o outro do tipo planeta. O fato de variar o tipo daquele objeto, a gente está usando sobrecarga de métodos, a gente está usando outro de polimorfismo. O método é polimórfico porque de acordo com o tipo dos parâmetros que são passados para ele ou a quantidade de parâmetros, ele vai ter comportamentos diferentes, vai ter formas diferentes de ser implementado. A mesma classe podia ter método int mutiplica, int a, int b, na mesma classe float multiplica, float a, float b. Uma versão do multiplica que multiplica números complexos, que recebe dois números complexos, como parâmetro e devolve números complexos ou ainda uma versão do mesmo método, mas que multiplica matrizes. Multiplicação de matrizes é completamente diferente da multiplicação de inteiros, então a implementação desses códigos vai ser completamente diferente. Mas quem está chamando o código, simplesmente, vai chamar multiplique e passa dois parâmetros para aquele método e o próprio sistema de execução de Java vai ver qual é o método que vai chamar de acordo com os tipos que são passados como parâmetros. Esse é outro tipo de polimorfismo, polimorfismo de métodos, que a gente usa a sobrecarga de métodos, método overloading, para implementar. E agora eu vou dizer o terceiro tipo que, na verdade, eu acho que é o tipo mais importante que mais transforma a orientação a objetos uma coisa bem poderosa, que é a sobreescrita de métodos ou método overriding, inglês, e isso tem muito a ver com herança, a ideia de a gente criar tipos ou classes e subtipos, subclasses baixo. Vamos pensar que você tem método de uma classe filha que possui a mesma assinatura que o método da classe mão. Nesse caso, o método da classe filha ela sobreescreve, ela se sobrepõe ao método da classe mãe. Vamos supor que você tem uma classe M, que tem três classes filhas, F1, F2 e F3, classe mãe M com três classes filhas e todas elas, essas quatro classes, têm o método M. Dependendo do tipo do objeto da F1, F2, F3, o método M que vai ser executado é diferente e a gente diz, nesse caso, que F1, F2 e F3 possuem versões polimórficas do método M. O grande poder torno disso é a gente escrever código que todo o código é pensado apenas no fato de que a gente tem alguém do tipo M, a classe mãe e o código manipula com coisas do tipo M, sem saber, exatamente, qual é o tipo específico da subclasse. Esse código, a gente diz que é código polimórfico, porque dependendo do tipo específico que depois alguém vai passar objeto como parâmetro de algum tipo específico. Vai ser ou F1, F2 ou F3, mas quando a gente está escrevendo o código, a gente só pensa na classe mãe e aquele código todo se torna código polimórfico, porque diferentes tipos que são passados para aquele código que manipula vão gerar diferentes comportamentos, particular quando a gente está escrevendo o código que manipula objetos da classe mãe, talvez os métodos das classes filhas ainda nem existam. Pode ser que eu escreva código hoje e daqui a ano alguém vai lá e faz uma subclasse da classe M e, se ele fizer isso direitinho, o meu código, que eu escrevi ano atrás, vai funcionar com essa nova classe que eu nem sabia que seria criada posteriormente. Esse é o poder do polimorfismo, de a gente fazer código genérico e com isso a gente evita bastante reescrita de código. Se você faz bom código genérico, é só eu plugar novas classes filhas, mais quatro, cinco, que ele passa a funcionar com aquele código genérico também. Vamos dar uma olhada num exemplo, que eu escrevi dez minutos antes de começar a gravar, eu achei que ia demorar muito se eu fizesse como parte da gravação, então eu fiz esse exemplo antes. Primeiro, eu fiz uma solução não muito orientada a objetos, muito pouco orientada a objetos e depois eu fiz uma solução usando polimorfismo que ficou bem mais orientada a objetos. Então o que é isso que eu fiz? Eu fiz uma classe Empregado pensando que, por exemplo, uma empresa quer calcular qual vai ser a sua folha de pagamento, quanto é que ela vai ter que pagar no final do mês para todos os seus empregados e pensando que a gente tem três tipos de empregado; empregado mensalista, que ele recebe salário por mês e a empresa tem que pagar alguns encargos trabalhistas nesse salário mensal, ela pode contratar alguém horista, que recebe por hora, então por horas trabalhadas e o empregado avulso, por exemplo, eu vou contratar empregado para fazer determinado serviço e eu pago valor único por aquele pacote, por aquele serviço, e no final, que é a folha de pagamento da empresa, ela tem que somar todos esses tipos de empregados diferentes, mas cada empregado tem comportamento pouquinho diferente. O mensalista tem o salário mensal, o horista tem o salário por hora, o pagamento por hora que ele recebe e assim por diante. Como é que a gente poderia numa primeira modelagem disso, eu pensei na classe empregado e como atributos todos os valores que eu preciso para fazer esses cálculos. Também eu criei aqui enum do TipoEmpregado, que vai dizer quais são os tipos possíveis de empregado. Eu pensei, inicialmente, que teria três tipos, o mensalista, o horista e o avulso. Posteriormente pode ser que apareçam outros tipos de empregado aqui. Para o mensalista eu preciso do salário mensal e eu preciso saber a taxa de encargos trabalhistas que a empresa precisa pagar cima daquele salário mensal. Para o horista preciso saber qual é o pagamento por hora que ele vai receber e também as horas trabalhadas, o número de horas trabalhadas naquele mês. E para o avulso eu preciso saber qual é que é o pagamento a vulso que ele recebe. Deixa eu, como é o último, eu vou copiar isso aqui para cá. Isso, pronto. Além disso, nessa classe empregado eu preciso de saber qual é o tipo. Então eu tenho esse atributo tipo, que é do tipo empregado que vai ter desses três valores aqui que vai definir qual é o tipo daquele empregado. E daí então, por enquanto a classe empregado é só isso e daí eu quis fazer teste de como essas coisas funcionariam numa folha de pagamento. Então o que é que eu fiz? Eu fiz aqui uma lista de empregados e eu chamo essa variável de corpo de trabalho, então o meu corpo de trabalho da minha empresa, o stuff da minha empresa. E é uma new ArrayList. Uma nova ArrayList, ele vai criar ArrayList, como eu deixei aqui vazio, ele vai pegar esse tipo empregado, vai criar ArrayList empregados e vai ser o corpo de trabalho. E daí eu criei três trabalhadores aqui de exemplo, de cada tipo. Então fiz empregado, trabalhador que é o novo empregado salário mensal dele é 5000 reais, a empresa tem que pagar 1.8 de taxa de encargos trabalhistas para esse salário de 5000 reais. Quer dizer, 80%, então é o salário 5000 vai para o próprio empregado. Já 0,8 vezes 5000 são impostos que tem que pagar de encargos trabalhistas, dá 4000 reais, se não engano. E eu estou marcando que o tipo desse empregado aqui é mensalista. E daí eu estou adicionando esse trabalhador ao corpo de trabalho, a essa lista de empregados. O segundo empregado, ele é do tipo horista, o pagamento por hora é 100 reais horas trabalhadas 30 reais e adiciona isso ao corpo de trabalho. E o terceiro é empregado avulso, pelo pacote de trabalho eu estou pagando 7000 reais para ele, dizendo que ele é avulso, coloco esses três. Então essa minha variável corpo de trabalho, vai estar apontando para uma lista de três trabalhadores, nesse caso, de cada tipo. E esse atributo ponto tipo é que define o tipo. E daí eu quero calcular o custo total da minha folha de pagamento daquele mês, então inicializo o custo total com zero e faço for aqui for no estilo antigo, não orientado a objetos de índice indo de zero até dois, menor que três. E eu começo aí, dentro de cada interação eu pego novo trabalhador. Trabalhador vai ser o corpo de trabalho, o iésimo empregado daquele corpo de trabalho. Então isso aqui vai percorrer o zero, o e o dois. Daí eu faço swich dependendo do tipo, então faço corpo de trabalho get i tipo, na verdade aqui poderia ser trabalhador, já tenho aquela variável trabalhador. Trabalhador, a gente sempre acha alguma coisa para melhorar o nosso código. Salvei, não deu nenhum erro, está. Então swich trabalhador ponto tipo, dependendo se for do tipo mensalista como é que eu calculo o custo daquele trabalhador? Vai ser o salário mensal dele vezes a taxa de encargos trabalhistas, então nesse meu exemplo multiplica por 1,.8. No caso que ele é horista, se o tipo for horista, daí o custo desse trabalhador, vai ser o pagamento por hora vezes o número de horas trabalhadas e soma ali no custo total. Já se for avulso, eu simplesmente eu somo o pagamento avulso. E daí depois que eu fiz esse for, passou por todo mundo daí eu faço isso aqui, minha folha de pagamento neste mês vai custar e o custo total. Então vou executar esse código, vamos ver o que aconteceu? Minha folha de pagamento esse mês, vai custar 19000 reais. E é isso mesmo, porque aqui vai ser 5000 vezes 1.8, dá 9000. Aqui vai dar 3000. 3000 mais 7000 10000, com 9000 dá 19000 reais, então está certo o custo ali total da minha folha de pagamento é 19000 reais. Agora esse código está feiozinho, aqui entre nós. Primeiro o main nem cabe na minha tela, tenho que ficar fazendo scroll, up and down, scroll para cima e para baixo, se você tem método que não cabe na tela, já está errado, está? Você tem que refaturar, você tem que reorganizar isso de alguma forma para fazer todos os seus métodos têm que caber numa tela aqui do seu ambiente de programação. Outra coisa que eu não gosto, primeiro esses atributos, dependendo do empregado, alguns atributos fazem sentido outros não fazem sentido e é ruim isso. Se você tem objeto que ele tem atributos que não fazem o menor sentido para aquele objeto, o seu código não está bem organizado se você está fazendo isso. O facto de eu precisar ter uma variável, que essa variável vai dizer qual dos tipos eu estou, isso já é indicativo que tem algo que está cheirando mal e provavelmente a gente tem que fazer alguma refaturação para tirar esse cheiro mau do nosso código. Outra coisa que está ruim é aqui esse swich case. Então swich case é uma coisa bem não orientada a objetos. Eu estou percorrendo uma coleção de trabalhadores e eu tenho que ficar fazendo swich para ver os diferentes tipos e daí diferentes tipos têm diferentes código. Eu estou misturando numa única classe comportamentos diferentes. Eu tenho três comportamentos diferentes, está tudo misturado na mesma classe. Se eu tenho swich por tipo de uma coisa, provavelmente é indicativo que cada item desse swich deveria ser uma subclasse diferente de uma classe. E aí sim, eu vou usar o polimorfismo. Então teria uma única classe trabalhador, com três formas diferentes e daí eu deixo o próprio sistema de execução de Java vai fazer o swich para mim. Porque eu simplesmente vou chamar determinado método para calcular o custo, e dependendo da subclasse ele vai chamar método diferente. Fazendo isso, a gente remove o swich, o código vai ficar muito mais enxuto, provavelmente vai caber numa única tela, essa é a vantagem. Tem uma desvantagem que eu vou precisar dessas outras classes, vai crescer o número de classes, mas cada classe vai ser muito mais simples. No final, o código fica mais organizado, vez de ter poucas classes muito grandes, você vai ter mais classes menores. Tem uma certa desvantagem de ter mais classes, mas o seu código no final fica bem mais organizado. Então eu mesmo já refaturei isso e fiz uma outra versão, que eu chamei de projetinho de polimorfismo aqui. Como é isso? Eu criei uma superclasse empregado, que é uma versão bem simplificada desse aqui, e esse comportamento dessas três classes eu coloquei três subclasses, no empregado avulso, empregado horista, empregado mensalista. Vamos ver a classe empregado na verdade é uma classe super simples e simplesmente ela tem o método abstrato, que é o pagamento do mês. Então eu tenho uma classe empregado e ela vai ter o método pagamento do mês que é abstrato, ou seja, não tem implementação eu estou simplesmente indicando que as minhas subclasses vão ter que implementar esse método de pagamento do mês. E como ele é abstrato eu não vou poder ter instâncias da classe empregado, só vou poder ter instâncias das subclasses concretas, não abstratas que eu tiver. E daí tem main aqui, que fica main, bem pequenininho que é gerenciado, né? Vamos dar uma olhada nesse main? Esse main ele diz o seguinte, opa, eu executei sem querer, vou apagar esse empregado outro, dar uma limpada aqui e pronto, temos aqui empregado. Então como é que ele funciona esse main? Eu tenho de novo uma lista de empregados, aqui não mudou nada, corpo de trabalho recebe newArayList, não mudei nada. Agora eu acrescento esses três. Quando eu acrescento os objetos, o que é que eu estou fazendo aqui? Cada classe eu criei construtor, e o construtor recebe como parâmetro apenas os dados que ele precisa e que faz sentido naquele caso. Então novo empregado horista eu preciso aqui, salário por hora e o número de horas. Então o salário por hora 100, número de horas 30. Já empregado mensalista, o que é que eu preciso? Eu preciso do salário e desse d aqui que é a taxa de encargos. Então o salário 5000, encargos 1.8. E o empregado avulso, é o valor ali do trabalho avulso dele daquele pacote, que é 7000 reais. Então criei esses três, adicionei nessa variável corpo de trabalho e agora posso fazer aquela versão orientada a objetos do for, né? Para todos os trabalhadores no corpo de trabalho, faz-se isso aqui, custoTotal mai igual a trabalhador ponto pagamento do mês. E aqui nós temos o polimorfismo ação. Polymorphism in action! O que é esse polimorfismo ação? Cada subclasse vai implementar esse pagamento do mês de uma forma diferente. Mas na minha classe empregado eu não estou preocupado como é que é a forma específica. São as subclasses que vão definir como é que é o pagamento de cada tipo de trabalho. Daí o código fica muito organizado, porque eu não poluo essa classe empregado com todos os possíveis tipos de pagamento. E daí eu imprimo a minha folha de pagamento nesse mês vai me custar custoTotal. Daí vamos dar uma olhada nas subclasses, como elas implementam? Acho que o mais simples de todos é o empregado avulso, que ele simplesmente tem-se como parâmetro o pagamento e depois o pagamento do mês é simplesmente o pagamento. É o mais simple dos três. Já o empregado horista é pouquinho mais complicado, ele tem dois atributos, salário por hora e horas trabalhadas que eu tenho que Eu tenho que definir quando no meu construtor e, depois, o pagamento do mês é relativamente simples, salário por hora vezes horas trabalhadas. Já empregado mensalista, algo semelhante, recebe como parâmetro o salário mensal e a taxa de encargos trabalhistas, e o pagamento por mês, basta eu multiplicar o salário mensal pela taxa de encargos trabalhistas. Está bem simples. Então, cada uma dessas classes ficou bem simples. Elas são subclasses de empregado e se eu vier aqui... Este código ficou mais simples porque ela delegou, ela distribuiu a complexidade por aquelas três outras classes e, no final, ficaram quatro classes simples. Se eu executar isso aqui, ela vai realmente me imprimir que a minha folha de pagamento nesse mês vai custar 19 mil. Então, está certo. Então, a gente viu exemplo de poliformismo. Eu quero mostrar o que mais de poliformismo a gente pode usar, que é o seguinte. Eu descobri recentemente que se a gente tem uma lista, a gente pode pedir para o Java imprimir aquela lista. Então, se eu fizer system.out.println e a minha lista aqui é o corpoDeTrabalho. Se eu mandar imprimir o corpo de trabalho, o que acontece? Olha que interessante! Ele imprimiu aqui baixo. Primeiro, imprimiu "minha folha de pagamento neste mês vai custar 19 mil". E ele fez isso aqui. Imprimiu os três elementos. O que está acontecendo aqui? O comando println, se a gente passa objeto como parâmetro. O que ele faz? Ele chama naquele objeto, para a gente, o método toString, que é método que, teoricamente, converte aquele objeto string. O corpo de trabalho... Então, o que ele fez? O corpo de trabalho como é uma lista, a implementação do arraylist, ela percorre todos os elementos do arraylist, chama o toString de cada dos elementos e concatena aquele string formando único string. Então, ele primeiro imprime abre colchetes, imprime o toString. O que é devolvido pelo toString do primeiro elemento, imprime vírgula,espaço, toString do segundo elemento; vírgula, espaço, toString do terceiro elemento; e fecha colchetes. Como eu não implementei o método toString nesses empregados horistas, empregados mensalistas, empregados avulsos... O que ele faz? Ele joga para a super classe. A super classe desses aqui, quem é? É o empregado. Empregado também não implementa toString. O que ele faz? Joga para a super classe. Quem é super classe do empregado? Eu não defini nenhuma super classe, então, vai ser o objeto, object, java.lang.Object da linguagem Java. E o object implementa o toString. Como ele implementa o toString? Ele implementa, primeiro, a classe específica daquele objeto, o símbolo de arroba e o endereço da memória onde aquele objeto está gravado. Então, eu estou executando três vezes o toString da classe object com esses diferentes tipos de empregados. Mas, eu posso ir lá e posso implementar o toString. Então, eu posso vir na classe empregado avulso e eu implemento o método toString. E a implementação... Então, como seria string interessante para descrever empregado avulso? Poderia ser algo do tipo: "Sou empregado avulso e cobrei... R$" Vamos dizer quanto que ele cobrou. Ele cobrou o pagamento. Só isso. Compilar aqui. Eu fiz alguma coisa errada. Ele está dizendo que precisa que o método seja público. Esse toString precisa ser público. Tudo bem. Pronto, público. Resolveu o problema. Eu fiz alguma bobagem aqui. Esse parenteses! Deu tudo certo. Então, o empregado avulso já está... Espera, esse aqui não tem. Certo? Pronto. Então, esse meu toString do empregado avulso está bom, eu acho. Vamos no empregadorista também fazer toString. "Eu sou empregado horista, ganho R$ por hora. SalárioPorHora. [SEM_ÁUDIO] Ganho isso e trabalhei... Quantas horas? Horas trabalhadas. Trabalhei... horas trabalhadas. Horas. Então, acho que está bom. Copiar isso e, agora, vamos para o empregado mensalista. Então, o empregado mensalista. "Sou empregado mensalista, ganho salário mensal." SalárioMensal... saio isso. E meu patrão paga... " Vamos dizer quanto ele paga de encargos trabalhistas. Ele paga de encargos trabalhistas o salário mensal vezes a taxa de encargos trabalhistas. É o salário mensal vezes... Na verdade, é menos, porque é o salário. Menos taxa de encargos trabalhistas vezes reais. Podemos colocar o R cifrão. Paga de encargos trabalhistas. Quanto ele paga de encargos trabalhistas? R, cifrão, dá essa conta aqui. Salário mensal vezes menos taxa de encargos trabalhistas. Vamos ver se eu não fiz nenhuma bobagem. Vamos executar de novo agora. Cruzem os dedos! Vamos ver se o polimorfismo vai funcionar. Está vendo que aqui baixo está aparecendo aquela implementação do toString do object? Vamos ver se eu implementei direito o toString cada desses três tipos de objetos. Sou empregadorista, ganho 100 reais e trabalhei 30 horas. O segundo. Sou empregado mensalista, ganho cinco mil reais e meu patrão paga de encargos trabalhistas... Menos quatro mil reais? Eu errei na conta. Menos quatro mil reais, não. E aqui... Sou empregado avulso e cobrei sete mil reais. Por que deu menos? Deixa eu ver... Era 1.8... Na verdade é o contrário, taxa de encargos menos. Porque era 1.8 menos vai virar 0.8. Menos. Rodando de novo. Sou empregado mensalista, ganho cinco mil reais e meu patrão paga de encargos trabalhistas quatro mil reais. Muito bem! Vocês viram que legal o polimorfismo? Então, a gente implementando o toString... Note, eu não mudei nada aqui. 'System.out', 'println', 'corpoDeTrabalho'. E ele está chamando de forma polifórmica diferentes métodos toString e cada objeto, agora, é responsável por se auto descrever. E é importante, isso, porque cada objeto tem atributos diferentes, tem características diferentes. É o objeto que sabe melhor como ele pode se descrever. Então, esse é o poder do polimorfismo. Eu espero que vocês tenham apreciado isso e que usem bastante polimorfismo no futuro. Resumindo, polimorfismo é uma ferramenta poderosa da Orientação a objetos para organizar o nosso código, para especificar diferentes comportamentos nessas diferentes subclasses. A gente, com isso, evita código repetido. A gente evita esse monte de 'if´s' e monte de 'switch/case' que dificultam a leitura e que tornam o código confuso. E a gente promove com isso, então, a clareza do código. Tem uma desvantagem. Primeiro, que a gente vai ter, normalmente, mais classes. Então, a gente vai ter mais arquivos para usar polimorfismo. E outra coisa. Às vezes não é óbvio entender o que o código está fazendo, porque, às vezes, a gente tem método, uma linha, que está usando polimorfismo. Na verdade, o que aquela linha vai fazer não está claro. Depende do que a subclasse vai fazer. Às vezes, a gente tem que olhar no código das subclasses para entender completamente o que o código está fazendo. Mas se está bem organizado, olhando aquela linha, a gente entende mais ou menos. Por exemplo, naquela linha do print, imprimir corpoDeTrabalho. Eu já sei mais ou menos. Ele vai percorrer os objetos e cada objeto vai se auto imprimir como ele se descreve. Eu não sei exatamente o que cada objeto vai fazer, mas tenho uma idéia de que se foi bem implementado, cada vai imprimir. Mas se eu quero saber os detalhes de como vai ser essa impressão, aí sim, eu vou nas subclasses e vejo. Então, tem uma pequena desvantagem, mas tem grandes vantagens que dão bastante poder para a gente. Espero que vocês tenham gostado. Polimorfismo é algo importante. Não se esqueçam! Tá bom? [SEM_ÁUDIO]
