Apakah kaedah padanan corak dan penukaran tersirat dalam Java Scala?

Padanan corak:

Padanan corak dalam Scala adalah bersamaan dengan menukar dalam Java

di Jawa Kami ada sintaks asas yang terdiri daripada suis dan kes lalai Dalam Scala, kami mempunyai padanan dan kes. adalah Secara lalai,

kes _ dilaksanakan dari kes ini ke kes seterusnya Ini bermakna tiada satu pun situasi di atas berpuas hati

Pelindung corak:

Jika anda. ingin menyatakan data yang sepadan dengan julat tertentu , anda perlu menambah pengawal bersyarat

dalam padanan corak (sebenarnya menambah jika penghakiman dalam kes)

val a=10
    val b=20
    var c='+'
    c match {
      case '+'=> println(a+b)
      case '-'=> println(a-b)
      case _  =>println("错误的运算符")
    }

Jenis padanan:

Bila mentakrifkan fungsi, parameter adalah semua objek Kelas induk Mana-mana

 val x=3.153
    val value: Any = x match {
      case i: Double if i >= 0 => i
      case j: Double if j < 0 => -j
      case _ => "type illegal"
    }

padanan objek

padanan objek adalah lebih rumit Perbandingan mudah adalah untuk membandingkan nilai alamat​ ​daripada kedua-dua pembolehubah pasti berbeza

 def function(x:Any): Unit ={
      x match {
        case s:String =>println("字符串")
        case i:Int=>println("整数")
        case d:Double=>println("小数")
        case _ =>println("其他")
      }
    }

Di sini kami mentakrifkan kaedah unapply dalam objek Kaedah unapply adalah bersamaan dengan aplikasi terbalik kaedah apply menghasilkan objek dalam objek, dan unapply kaedah adalah kaedah pengekstrakan, mengekstrak objek operasi (parameter masuk ialah objek, Ekstrak data mengikut objek dan simpan dalam Beberapa, dan bandingkan dengan data masuk anda sendiri) Kaedah ini juga tidak perlu menulis nama kaedah seperti kaedah apply.

Kaedah ini digunakan terutamanya untuk menghuraikan objek (objek yang sepadan)

Kelas sampel:

Atribut utama dalam kelas sampel secara lalai kepada val , anda perlu melakukannya sendiri. Menganotasi kelas sampel

akan menjana kaedah secara automatik seperti nyahguna pakai dan menggunakan, menyimpan banyak kod

Anotasi kelas dan objek di atas dan buat sampel baharu. kelas: (digunakan secara meluas)

object Test_03MatchObject {
  def main(args: Array[String]): Unit = {
    val sss: person1 = person1("sss", 1)
  sss match {
    case person1("sss",1)=>println("victory")
    case _=>println("defite")
  }
  }
  class person1(val name: String,val age :Int){
  }
  object person1{
    def apply(name: String, age: Int): person1 = new person1(name, age)
    def unapply(arg: person1): Option[(String, Int)] =
      if (arg==null)
      {
        None
      }
      else{
        Some(arg.name,arg.age)
      }  }
}

Fungsi separa:

Singkatan fungsi separa:

Kita boleh terus memanggil fungsi kumpul untuk memanggil parameter fungsi separa dan menulis huruf secara terus + operasi yang anda perlukan

Singkatan Kaedah ini bersamaan dengan meninggalkan padanan, dan kesannya bersamaan dengan penapis+peta

Fungsi separa juga boleh digunakan dalam senario penggunaan peta

Penggunaan fungsi separa:

  case class person1(val name: String,val age :Int)

Penukaran Formula Tersirat:

Takrifan rasmi:

Apabila pengkompil gagal menyusun buat kali pertama, ia akan kelihatan untuk kaedah dalam persekitaran semasa yang boleh membuat kod dikompilasi dengan jayanya, gunakan

Tukar jenis untuk mencapai kompilasi sekunder

Pemahaman peribadi:

Penukaran tersirat ialah apabila ralat berlaku apabila kita memanggil fungsi pada objek yang tiada dalam kelas ia berada. Operasi

fungsi tersirat:

Langkah penukaran tersirat:

(1) Anda perlu tentukan kelas sasaran sekarang dan tentukan kaedah dan logik yang dipanggil dalam kelas

cth: Kami memanggil kaedah yang tidak wujud pada data jenis Int:

    val list = List(List(1, 2, 3, 4), List(1), List(8, 5))
    val list1: List[Int] = list.collect({ case List(x, y, _*) => y })
  println(list1)

(2) Tentukan penukar dalam fungsi utama

akan diperkenalkan pada permulaan ---- tersirat Fungsi penukaran tersirat kemudiannya ditakrifkan

class MyRichInt(val self :Int)
  {
def myMax(int: Int):Int =
    {
      if (int>self)
        int
        else
        self
    }
  }

Apabila kaedah penukaran tersirat adalah sama dan bercanggah dengan kaedahnya sendiri, ia sendiri kaedah akan digunakan (kerana penyusunan tidak akan gagal---takrif rasmi penukaran tersirat)

Parameter tersirat:

Kami sudah mengetahui nilai parameter lalai semasa mentakrifkan fungsi, tetapi kita perlu menambah kurungan apabila memanggilnya

Di sini kami memperkenalkan konsep baharu parameter Formula tersirat

Contoh perbandingan parameter:

 implicit def changeInt(self:Int)  =
    {
new MyRichInt(self)
    }

Nilai lalai parameter hanyalah untuk menambah kurungan selepas fungsi panggilan

Hasil berjalan:

Kelas tersirat:

Tambah kata kunci tersirat di hadapan biasa kelas untuk menukarnya secara automatik kepada kelas tersirat

Jika kelas sasaran penukaran tersirat ditukar kepada kelas tersirat Maka tidak perlu menambah kelas tersirat baharu

dalam fungsi utama , anda boleh terus memanggil fungsi yang dinyatakan

Atas ialah kandungan terperinci Apakah kaedah padanan corak dan penukaran tersirat dalam Java Scala?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!