Quelle est la différence entre les différentes méthodes surchargées en Scala?

Scala permet de remplacer une méthode en deux façons:

Donné super classe:

class A {
  def a = "A"
}

Nous pouvons remplacer la méthode "a" par:

class B extends A {
  override def a = "B"
}

et

class B extends A {
  override def a() = "B"
}

les deux semblent remplacer la méthode "a" correctement. Qu'est-ce que la décision de conception derrière tout cela? Pourquoi permettre "un()" en B pour remplacer "a" dans une?

a() et a sont les deux méthodes nommé a qui ne prennent pas d'arguments, autrement dit, d'arité zéro, c'est à dire qu'ils sont identiques. Pourquoi n'auraient-ils pas le permettre?

OriginalL'auteur platypus | 2012-09-01

  1. 15

    Cela n'a pas toujours été le cas (à partir du journal des modifications de la spécification du langage):

    Scala version 2.0 détend aussi les règles de remplacement à l'égard de
    vide la liste des paramètres. La révision de la définition de les membres correspondant
    (§5.1.3) rend désormais possible de remplacer une méthode explicite,
    mais le vide de la liste des paramètres () avec une méthode sans paramètre, et vice
    versa    .

    Il est exact que ce qui semble comme une étrange conception de la décision, étant donné qu'il existe des différences observables entre sans paramètre des méthodes et des avec vide listes de paramètres. Par exemple, supposons que vous disposez des éléments suivants:

    class A { def a = "A" }
class B extends A { override def a = "B" }
class C extends A { override def a() = "C" }

    Maintenant, nous pouvons écrire la suite, comme prévu:

    scala> (new B).a
res0: java.lang.String = B

scala> (new C).a
res1: java.lang.String = C

    Et ce:

    scala> (new C).a()
res2: java.lang.String = C

    Mais pas cette:

    scala> (new B).a()
<console>:10: error: not enough arguments for method apply: (index: Int)Char in class StringOps.
Unspecified value parameter index.
              (new B).a()

    Scala permet de faire une distinction entre les deux, ce qui évidemment doit être reflétée dans le bytecode. Supposons que nous compilons les suivantes:

    class A { def a = "A" }
class B extends A { override def a = "B" }

    Et de lancer:

    javap -verbose B > noArgList.txt

    Puis modifiez le code:

    class A { def a = "A" }
class B extends A { override def a() = "B" }

    De recompiler et de lancer:

    javap -verbose B > emptyArgList.txt

    Et enfin vérifier les différences:

    <   MD5 checksum 88aeebf57b645fce2b2fcd2f81acdbbd
---
>   MD5 checksum 3733b3e4181b4b2f4993503d4c05770e
32c32
<   #18 = Utf8               }1A!
                                 \t\t!ICaT-9uszaE\r)\"a\tI!!\"1Q!Dg
jiz\"a\tAQ!BY\t!Y                                                  G.Y11bU2bY|%M[3di\")C%1A(
                 /A$H3)!dGYtwMCQM^1\nyI\"AB*ue&tw\r
---
>   #18 = Utf8               }1A!
                                 \t\t!ICaT-9uszaE\r)\"a\tI!!\"1Q!Dg
jiz\"a\tAQ!BY\t!                                                   G.Y11bU2bY|%M[3di\")C%1A(
                /A$H3)!dGYtwMCQM^1\nyI\"AB*ue&tw\r

    Il existe une différence—les deux versions ont des valeurs différentes pour le ScalaSignature annotation.

    À pourquoi le changement a été fait dans Scala 2.0: la spécification des notes qu'il permet:

    class C {
    override def toString: String = ...
}

    Ma conjecture est que la langue concepteurs ne voyais pas de raison d'obliger les utilisateurs à se rappeler qui approche les méthodes de remplacement utilisé dans les cas de ce genre.

    Depuis que je viens juste de commencer à apprendre Scala, pourriez-vous me dire quel est le ScalaSignature annotation est-il utilisé?
    C'est un assez faible niveau implementionation détail que vous ne devriez pas besoin de s'inquiéter pour une longue période de temps, si jamais. Son rôle est de permettre la Scala compilateur de faire des distinctions de ce genre.

    OriginalL'auteur Travis Brown