(Resolvido) Dúvida sobre escopo do prototype

[Rafael Laurindo]

O prototype, só pode ser usado fora da classe para implementar uma classe, ou poderia implementar, usando o prototype de outra classe?

Exemplo:

Motor = {
      Interface : function()
      {
          this.acelerar = function(valor){}
      }
  }
  
  function Carro()
  {
      Motor.Interface.call(this)
      //implementação do método acelerar da interface motor
      Motor.Interface.prototype.acelerar = function(valor)
      {
          return valor += 10
      }
  }
  
  function test()
  {
      var carro = new Carro()
      alert(carro.acelerar(10))
  }

O que está errado?

Editado Janeiro 27, 2010 por Rafael Laurindo

[Jonathan Queiroz]

Supondo que o prototype fosse aplicado aí, ele iria valor para TODAS as classes que utilizam a interface, ou seja, se você tivesse uma classe "Moto" que utilizasse a interface "Motor", o método "acelerar" estaria igual ao que foi setado na classe "Carro".

Mas ele não é aplicado pelos seguintes motivos:

• O prototype pode inserir métodos, mas não alterar
• Faltou o "=function()" ali

Se o que você quer é implementar o método acelerar derivado da interface Motor na classe Carro (e somente nessa classe), pode fazer assim:

function Carro()
{
    Motor.Interface.call(this)
    //implementação do método acelerar da interface motor
    this.acelerar=function(valor)
    {
        return valor += 10
    }
}

Creio que deve funcionar. Qualquer coisa posta aí !

[Rafael Laurindo]

Mas e se eu não usasse o prototype? A resposta está sendo "undefined".

Motor = {
    Interface : function()
    {
        this.acelerar = function(valor){}
    }
}

function Carro()
{
    Motor.Interface.call(this)
    //implementação do método acelerar da interface motor
    Motor.Interface.acelerar = function(valor)
    {
        return valor += 10
    }
}

function test()
{
    var carro = new Carro()
    alert(carro.acelerar(10))
}

Resolveria também, ou ia setar para outra classe também, por exemplo Moto?

Editado Janeiro 26, 2010 por Rafael Laurindo

[Jonathan Queiroz]

Nesse caso nem funcionaria, pois não dá pra modificar um método que já foi criado. Se você quer sobrecarregar um método, tente fazer como eu falei.

Ou o objetivo é realmente modificar a ação do método em todas as classes ?

[Rafael Laurindo]

Ou o objetivo é realmente modificar a ação do método em todas as classes?

Não. Seria o caso da idéia de interface mesmo. Isso seria herança de comportamento. Eu já havia discutido sobre isso antes, mas eu aprendi o contrário com o kakaroto, eu aprendi a implementar a interface, nesse caso, outras classes usariam esse mesmo método implementado, não podendo sobrecarrega-lo. Eu poderia fazer essa última idéia com o prototype, certo?

Editado Janeiro 26, 2010 por Rafael Laurindo

[Jonathan Queiroz]

Entendi. Como é sobrecarregar o método para apenas uma classe, você pode utilizar o código que postei no post #2.

[Rafael Laurindo]

Vlw. Mais uma coisa. Eu não preciso declarar o método "acelerar" em "Veículo", não?

Editado Janeiro 26, 2010 por Rafael Laurindo

[Jonathan Queiroz]

O que seria "Veículo" ?

Seria outra interface ?

[Rafael Laurindo]

Perdão, é Motor. Eu citei errado.

Editado Janeiro 26, 2010 por Rafael Laurindo

[Jonathan Queiroz]

Não precisa, mas em alguns casos pode ser interessante criar um método "padrão" na interface e, em casos específicos, sobrecarregá-lo em determinada classe.

[Rafael Laurindo]

Agora você chegou onde eu queria. Como implementar "sobrecarga" em js?

Editado Janeiro 26, 2010 por Rafael Laurindo

[Jonathan Queiroz]

Olhe o código do post #2, veja se funciona.

[Rafael Laurindo]

A sim, isso seria a sobrecarga? Esse eu já testei. Funciona. Esse é uma coisa lógica, e de fácil compreensão para mim. Só que Motor tem a ver com carro, mas a recíproca nesse caso não é verdadeira, por isso a dúvida. Se eu tentasse usar Motor, eu não poderia usar acelerar em outra classe.

Editado Janeiro 26, 2010 por Rafael Laurindo

[Jonathan Queiroz]

Não entendi muito bem a dúvida. Pode explicar melhor ?

[Rafael Laurindo]

Eu queria saber se isso que implementou é uma pseudaSobrecarga? Caso seja, deixa eu perguntar outra coisa. Se eu quisesse implementar o código para acelerar sem sofrer sobrecarga, claro, eu poderia fazer daquela forma, com o prototype mesmo, na classe Carro. Porque, estou fazendo o seguinte código:

//Heranca -> Class.call(this)
function Veiculo()
{    
    this.freiar = function(valor)
    {
        return valor -= 10
    }
}

//Interface
Motor = {    
    Interface : function()
    {
    this.acelerar = function(valor){//throw}
    }
}

//Carro é um veículo
function Carro()
{
    Veiculo.call(this)
    Motor.Interface.call(this)
    //implementação de um método em Motor
    Motor.Interface.prototype.acelerar = function(valor)
    {
        return valor += 10
    }/**/
    //Carro terá acesso a Veículo, mas a recíproca não é verdadeira
    var tracao=null //private
}

function Moto()
{
    Veiculo.call(this)
}

function teste()
{
    var carro = new Carro()
    alert(carro.acelerar(0))//a resposta é carro.acelerar is not a function
    alert(carro.freiar(20)) //10
}

Editado Janeiro 26, 2010 por Rafael Laurindo

[Jonathan Queiroz]

O que seria uma "pseudo-sobrecarga" ?

Quanto a implementar o método sem fazer sobrecarga (ou seja, deixar como está na interface, sem alterações) você não precisa escrever nada. O código ficaria assim:

function Carro()
{
    Motor.Interface.call(this)
}

[Rafael Laurindo]

A diferença, entre usar prototype e não é que o método não poderia ser sobrecarregado, usando o prototype?

Editado Janeiro 26, 2010 por Rafael Laurindo

[Jonathan Queiroz]

A utilidade do prototype é implementar métodos numa classe já criada independentemente de herança. Ou seja, para sobrecarregar um método você não usa prototype.

[Rafael Laurindo]

Entendi, muito obrigado. Bom. Você pode ver o que está errado com esse código, já que ele retorna carro.acelerar(0) is not a function.

Motor = {
    Interface : function() {}
}

function Carro()
{
    Motor.Interface.call(this)
    Motor.Interface.prototype.acelerar = function(valor)
    {
        return valor += 10
    }/
    var tracao=null //private
}

function Implements()
{
    var carro = new Carro()
    alert(carro.acelerar(20))
}

[Jonathan Queiroz]

O objetivo seria implementar o método "acelerar" na classe Motor e fazer com que ele seja herdado em todas as classes derivadas ?

[Rafael Laurindo]

Exato.

[Jonathan Queiroz]

Nesse caso tente deixar aquele código "Motor.interface.prototype.acelerar=[...]" fora da classe "Carro".

[Rafael Laurindo]

Por que?

[Jonathan Queiroz]

No código que você fez, o que (provavelmente) ocorre é o seguinte:

Na primeira vez que é instanciado um objeto da classe "Carro", ele herda da classe "Motor" e depois implementa o método (ou seja, no momento em que ele herda de "Motor", o método ainda não existe). Além disso, supondo que você tivesse um objeto da classe "Moto" que foi criado antes de instanciar um da classe "Carro", o método não terá sido implementado.

Eu acho que é isso. Tente fazer o teste.

[Rafael Laurindo]

Está certo. Resolvido.

[Jonathan Queiroz]

Ok. Qualquer coisa posta aí !