Kapan menggunakan val atau def pada ciri-ciri Scala?

Saya melihat slide skala yang efektif dan itu menyebutkan pada slide 10 untuk tidak pernah digunakan valdalam traituntuk anggota abstrak dan defsebagai gantinya. Slide tidak menyebutkan secara rinci mengapa menggunakan abstrak valdalam traitbentuk anti-pola. Saya akan sangat menghargai jika seseorang dapat menjelaskan praktik terbaik seputar penggunaan val vs def dalam suatu sifat untuk metode abstrak

A defdapat diimplementasikan oleh a def, a val, a lazy valatau an object. Jadi ini adalah bentuk paling abstrak untuk mendefinisikan anggota. Karena sifat biasanya antarmuka abstrak, mengatakan Anda menginginkan a valberarti mengatakan bagaimana implementasi harus dilakukan. Jika Anda meminta a val, kelas pelaksana tidak dapat menggunakan def.

A valdiperlukan hanya jika Anda membutuhkan pengenal yang stabil, misalnya untuk tipe yang bergantung pada jalur. Itu adalah sesuatu yang biasanya tidak Anda butuhkan.

Membandingkan:

trait Foo { def bar: Int }

object F1 extends Foo { def bar = util.Random.nextInt(33) } // ok

class F2(val bar: Int) extends Foo // ok

object F3 extends Foo {
  lazy val bar = { // ok
    Thread.sleep(5000)  // really heavy number crunching
    42
  }
}

Jika Anda punya

trait Foo { val bar: Int }

Anda tidak akan bisa mendefinisikan F1atau F3.

Oke, dan untuk membingungkan Anda dan jawab @ om-nom-nom — menggunakan abstrak valdapat menyebabkan masalah inisialisasi:

trait Foo { 
  val bar: Int 
  val schoko = bar + bar
}

object Fail extends Foo {
  val bar = 33
}

Fail.schoko  // zero!!

Ini adalah masalah buruk yang menurut pendapat pribadi saya harus hilang di versi Scala mendatang dengan memperbaikinya di kompiler, tapi ya, saat ini ini juga merupakan alasan mengapa seseorang tidak boleh menggunakan abstrak val.

Sunting (Jan 2016): Anda diizinkan untuk mengganti valdeklarasi abstrak dengan lazy valimplementasi, sehingga akan mencegah kegagalan inisialisasi.

Saya lebih suka tidak menggunakan valsifat karena deklarasi val memiliki urutan inisialisasi yang tidak jelas dan tidak intuitif. Anda dapat menambahkan sifat ke hierarki yang sudah berfungsi dan itu akan merusak semua hal yang berfungsi sebelumnya, lihat topik saya: mengapa menggunakan val biasa di kelas non-final

Anda harus mengingat semua hal tentang menggunakan deklarasi val ini yang pada akhirnya mengarahkan Anda ke kesalahan.

Perbarui dengan contoh yang lebih rumit

Tetapi ada kalanya Anda tidak bisa menghindari penggunaan val. Seperti yang telah disebutkan @ 0__ terkadang Anda memerlukan pengenal yang stabil dan defbukan pengenal .

Saya akan memberikan contoh untuk menunjukkan apa yang dia bicarakan:

trait Holder {
  type Inner
  val init : Inner
}
class Access(val holder : Holder) {
  val access : holder.Inner =
    holder.init
}
trait Access2 {
  def holder : Holder
  def access : holder.Inner =
    holder.init
}

Kode ini menghasilkan kesalahan:

 StableIdentifier.scala:14: error: stable identifier required, but Access2.this.holder found.
    def access : holder.Inner =

Jika Anda meluangkan waktu sejenak untuk berpikir Anda akan mengerti bahwa kompilator memiliki alasan untuk mengeluh. Dalam Access2.accesskasus ini tidak bisa mendapatkan tipe pengembalian dengan cara apapun. def holderartinya bisa diimplementasikan secara luas. Itu bisa mengembalikan pemegang yang berbeda untuk setiap panggilan dan pemegang itu akan memasukkan Innerjenis yang berbeda . Tetapi mesin virtual Java mengharapkan jenis yang sama dikembalikan.

Selalu menggunakan def sepertinya agak canggung karena sesuatu seperti ini tidak akan berfungsi:

trait Entity { def id:Int}

object Table { 
  def create(e:Entity) = {e.id = 1 }  
}

Anda akan mendapatkan kesalahan berikut:

error: value id_= is not a member of Entity