privé [this] vs privé

Question

En Scala, je vois une telle fonctionnalité comme une variable objet-privé. De par mon expérience Java pas très riche, j'ai appris à tout fermer (rendre privé) et à ouvrir (fournir des accesseurs) si nécessaire. Scala introduit un modificateur d'accès encore plus strict. Dois-je toujours l'utiliser par défaut ? Ou dois-je l'utiliser uniquement dans certains cas spécifiques où je dois explicitement restreindre la modification de la valeur d'un champ, même pour des objets de la même classe ? En d'autres termes, comment dois-je choisir entre

class Dummy {
    private var name = "default name"
}

class Dummy {
    private[this] var name = "default name"
}

La seconde est plus stricte et je l'aime bien, mais dois-je toujours l'utiliser ou seulement si j'ai une bonne raison ?

ÉDITION : Comme je le vois aquí private[this] est juste un sous-cas et au lieu de this Je peux utiliser d'autres modificateurs : "paquet, classe ou objet singleton". Je vais donc le laisser pour un cas particulier.

Answer 1

Il y a un cas où private[this] est nécessaire pour que le code soit compilé. Cela est dû à une interaction entre la notation de variance et les variables mutables. Considérons la classe (inutile) suivante :

class Holder[+T] (initialValue: Option[T]) {
    // without [this] it will not compile
    private[this] var value = initialValue

    def getValue = value
    def makeEmpty { value = None }
}

Cette classe est donc conçue pour contenir une valeur optionnelle, la renvoyer comme une option et permettre à l'utilisateur d'appeler makeEmpty pour effacer la valeur (d'où le var). Comme indiqué, cela ne sert à rien, si ce n'est à démontrer le point.

Si vous essayez de compiler ce code avec private au lieu de private[this] il échouera avec le message d'erreur suivant :

error : covariant type T occurs in contravariant position in type Option[T] of value value_= classe Holder[+T] (initialValue : Option[T]) {

Cette erreur se produit parce que value est une variable mutable sur le type covariant T (+T), ce qui est normalement un problème à moins d'être marqué comme privé à l'instance avec private[this] . Le compilateur dispose d'une manipulation spéciale dans sa vérification de variance pour gérer ce cas particulier.

Donc c'est ésotérique mais il y a un cas où private[this] est nécessaire sur private .

Answer 2

Je ne pense pas que cela ait trop d'importance, puisque tout changement ne touchera qu'une seule classe dans un sens ou dans l'autre. Ainsi, la raison la plus importante de préférer private sur protected sur public ne s'applique pas.

Utilice private[this] où les performances sont vraiment importantes (puisque vous aurez un accès direct aux champs au lieu de méthodes de cette façon). Sinon, il suffit de s'en tenir à un seul style pour que les gens n'aient pas à se demander pourquoi este la propriété est private y que on est private[this] .

Answer 3

private var name est accessible à partir de n'importe quelle méthode de la class Dummy (et son compagnon object Dummy ).

private[this] var name est accessible à partir des méthodes de this uniquement, et non d'autres objets de class Dummy .

Answer 4

Dans la plupart des langages de programmation OOP comme Java, les champs/méthodes privés signifient que ces champs/méthodes privés ne sont pas accessibles à l'extérieur de la classe. Cependant, les instances/objets de la même classe peuvent avoir accès aux champs privés des objets en utilisant l'opérateur d'affectation ou au moyen du constructeur de copie. En Scala, private[this] est un objet privé, ce qui garantit que tout autre objet de la même classe est incapable d'accéder aux membres de private[this].

Exemple

1.Sans privé [this]

object ObjectPrivateDemo {

  def main(args: Array[String]) {
    var real = new User("realUserName", "realPassword")
    var guest = new User("dummyUserName", "dummyPassword")
    real.displayUser(guest)

  }
}

class User(val username:String,val password:String) {
  private var _username=username
  private var _password=password

  def displayUser(guest:User){

         println(" guest username="+guest._username+" guest password="+guest._password)
       guest._username= this._username
    guest._password=  this._password
       println(" guest username="+guest._username+" guest password="+guest._password)

  }
}

2.Utiliser private [this]

class User(val username: String, val password: String) {
  private var _username = username
  private[this] var _password = password

  def displayUser(guest: User) {

    println(this._username)
    println(this._password)

    guest._username = this._username
    // for guest._password it will give this :error  value _password is not member of class User
    guest._password = this._password

  }
}

Ainsi, private[this] garantit que le champ _password n'est accessible qu'avec this.

Answer 5

private[this] (équivalent à protected[this]) signifie que ce "y" est uniquement visible par les méthodes de la même instance. Par exemple, vous ne pourriez pas faire référence à y sur une deuxième instance dans une méthode equals, c'est-à-dire que "this.y == that.y" générerait une erreur de compilation sur "that.y". (source)

ainsi vous pouvez faire privé [ceci] chaque fois que vous voulez mais vous pouvez avoir un certain problème si vous devez le référer