classes internes statiques dans scala

Question

Quel est l'analogue à Scala de le faire en Java:

public class Outer { 
    private Inner inner; 

    public static class Inner { 
    } 

    public Inner getInner() { return inner; } 
} 

Je veux spécifiquement ma classe intérieure pour pas doivent avoir un nom complet - à savoir que je veux Trade.Type, pas TradeType. Ainsi, dans Scala je l'imaginais peut-être quelque chose comme:

class Outer(val inner: Inner) { 
    object Inner 
} 

Mais cela ne semble pas fonctionner: mon scala Inner ne semble pas seulement être visible de l'extérieur de la classe Outer. Une solution serait bien sûr:

class Inner 
class Outer(val inner: Inner) 

Ce qui est OK - mais à cause des noms de mes classes, Inner est vraiment le « type » de la Outer et Outer a en fait un nom long. Donc:

class SomeHorriblyLongNameType 
class SomeHorriblyLongName(myType: SomeHorriblyLongNameType) 

Qui est verbeux et horrible. Je pourrais remplacer SomeHorriblyLongNameType avec juste Type mais il n'y aurait alors aucune connexion évidente entre elle et la classe à laquelle elle était liée. Ouf

Answer 1

Vous pouvez faire quelque chose comme ça si ne pas avoir accès à la classe externe dans la classe interne (que vous auriez pas en Java étant donné que votre classe interne a été déclarée static):

object A{ 
    class B { 
     val x = 3 
    } 
} 
class A { 
    // implementation of class here 
} 
println(new A.B().x) 

Answer 2

From scala-lang:

il n'y a pas de notion de membres 'statiques' à Scala. Au lieu de cela, Scala traite membres statiques de la classe Y en tant que membres de l'objet singleton Y

il semble que vous pourriez donc avoir une classe définie à l'intérieur d'un objet, mais pas une classe statique définie à l'intérieur d'une classe.

Answer 3

Comme d'autres l'ont souligné, les classes "statiques" doivent être placées dans l'objet compagnon. En classe Scala, les classes, les traits et les objets membres d'une classe dépendent du chemin. Par exemple:

class Button { 
    class Click 
} 


val ok = new Button 
val cancel = new Button 

val c1 = new ok.Click 
val c2 = new cancel.Click 

Maintenant c1 et c2 sont des instances de classes -différentes. Une classe est ok.Click, et l'autre est annuler.Cliquez. Si vous vouliez vous référer au type de toutes les classes Click, vous pourriez dire Button # Click.

Answer 4

Je ne suis pas sûr d'avoir bien compris votre cas d'utilisation ... S'il peut vous aider, les objets à l'intérieur des classes sont visibles comme les champs d'une instance, par ex.

case class C(var x: Int) 
class A { case object b extends C(0) } 
val a = new A 
println(a.b.x) 
a.b.x = 2 
println(a.b.x) 

De plus, vous pouvez parfaitement passer outre un val avec l'objet de parent:

case class C(var x: Int) 
class A { val y: C = C(0) } 
class B extends A { override case object y extends C(2) } 
val a: A = new B 
println(a.y.x) 

Answer 5

SCALA si vous avez besoin pour créer une des méthodes statiques vous pouvez utiliser un objet compagnon, avec le même nom de la classe, où vous stockez toutes les méthodes pseudo-statiques.Ex:

class A { 
} 

object A { 
    def xpto // define some pseudo static methods here.. 
} 

Ensuite, vous pouvez simplement utiliser A.xpto. Essayez d'en savoir plus sur les modules compagnons sur scala