Come viene trattato il pattern POJO/JavaBean in Scala?

Question

Proprio come la domanda. Scala lo promuove allo stesso modo di Java? O è stato evoluto per essere più idiomatico di Scala? O è stato reso irrilevante?

POJO e JavaBeans significato:

1. costruttore che non accetta parametri
2. attributi sono private, getter e setter sono pubblici
3. getter e setter definisce le proprietà, nascondersi attribuisce

---

Inoltre, Scala ha opinioni (mi dispiace, non mi piace usare questo termine) sull'uso del vecchio public, private, protected disegni di attributo che sono rilevanti per questa domanda?

Answer 1

Scala ha anche idiomi simili a POJO ma sono diversi da JavaBeans e Scala pone l'accento su diversi aspetti.

1. Scala ha diverse convenzioni di denominazione:

   def foo: Foo  //Foo getFoo() in Java 
   def foo_=(foo: Foo) //void setFoo(Foo foo) in Java 
   

   questo modo si può sempre scrivere obj.foo e obj.foo = bar anche se si decide di passare da getter/setter per l'accesso campo diretto e viceversa. Questo è chiamato principio di accesso uniforme.

2. Grazie alla interoperabilità di Java, è stato introdotto @BeanProperty annotazione:

   @BeanProperty var foo: Foo = _ 
   

   il codice di cui sopra non solo crea Scala-come getter/setter, ma Java-come pure, in modo che tutti framework Java di lavorare senza problemi.

3. Scala ti costringe a decidere tra le variabili (var) e valori (val), quindi ci si trova molto più spesso utilizzando oggetti immutabili

4. ho davvero preferisco oggetti immutabili e l'inizializzazione di costruttore, che è stato fatto molto facile in Scala:

   class Foo(val age: Int, val name: String) 
   

   o addirittura (val per impostazione predefinita in case classi):

   case class Foo(age: Int, name: String) 
   

   Questo pezzo di codice è brillante nella sua semplicità. Tuttavia, se avete bisogno di cooperare con framework Java, hai ancora bisogno di no-Argu costruttore e setter:

   public class Foo(var age: Int, var name: String) { 
   
       def this() { 
        this(0, "") 
       } 
   
   } 
   

   Nota val di essere sostituito da var.

5. modificatori di accesso a Scala hanno valori predefiniti leggermente migliori rispetto a Java:

   class Foo(var a: Int, x: Int) { 
   
       var b: Int = _ 
   
       private var c: Int = _ 
   
       private[this] var d: Int = _ 
   
       def twisted = a + b + c + d + x 
   
   } 
   

   Variabili a e b diventerà private campi con public getter/setter (i campi sono privati ​​per impostazione predefinita, i metodi sono pubblici). c e d sono anche variabili private. Ma lo private[this] in più rende d accessibile direttamente internamente alla classe anziché tramite getter/setter privato.

   Poiché x viene utilizzato da qualche parte accanto al costruttore, Scala crea automaticamente anche un campo privato per esso. Tuttavia non vengono generati getter/setter, a cui si accede direttamente nel metodo twisted (uguale a d).

UPDATE: Nei commenti si sta chiedendo di rinominare getter/setter. Ecco un esempio ancora più complesso. Getter/setter vengono calcolare il valore in base a due campi contemporaneamente:

class Foo { 

    private[this] var first: Char = _ 
    private[this] var rest: String = _ 

    def fake = first + rest 

    def fake_=(s: String) { 
     first = s.head 
     rest = s.tail 
    } 

} 

sembra complicato dentro, ma dal di fuori sembra come il buon vecchio immobile:

val foo = new Foo() 
foo.fake = "ABC" 
println(foo.fake) 

Proprio come se fosse :

class Foo(var fake: String)