Quelles sont les méthodes de correspondance de modèles et de conversion implicite dans Java Scala ?

Correspondance de modèles :

La correspondance de modèles en Scala équivaut à un commutateur en Java # 🎜🎜#

En Java, nous avons la syntaxe de base de switch case default. En Scala, nous avons match et case Le rôle de default est remplacé par case

Syntaxe de base comme suit : #🎜 🎜#

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

Dans Scala, il est exécuté de ce cas au cas suivant par défaut

case _ signifie qu'aucune des situations ci-dessus n'est remplie

. Garde de modèle :

Si vous souhaitez exprimer des données correspondantes dans une certaine plage, vous devez ajouter une garde conditionnelle

(en ajoutant en fait un jugement dans le cas)# 🎜🎜#

 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"
    }

Correspondance de type :

Lors de la définition de la fonction, le paramètre est la classe parent de tous les objets Any

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

Correspondance d'objet

La correspondance des objets est plus compliquée. La simple comparaison est la valeur d'adresse comparée des deux variables.

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)
      }  }
}

Ici, nous définissons la méthode de désapplication dans l'objet. équivaut à apply L'application inverse de la méthode, la méthode apply crée un objet dans l'objet et la méthode unapply est une méthode d'extraction, extrayant l'objet de l'opération (le paramètre entrant est l'objet, extrayant les données en fonction de l'objet et le stocker dans Some, et le faire avec vos propres données entrantes (Comparer) Cette méthode n'a pas non plus besoin d'écrire le nom de la méthode comme la méthode apply.

Cette méthode est principalement utilisée pour analyser des objets (objets correspondants)

Exemple de classe :

L'attribut principal de l'exemple de classe est par défaut val if Si vous devez utiliser var, vous devez le marquer vous-même

L'exemple de classe générera automatiquement des méthodes telles que désappliquer et appliquer, économisant ainsi beaucoup de code

Annoter ce qui précède classe et objet et créez un nouvel exemple de classe : (utilisé largement)

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

Fonction partielle :

Abréviation de fonction partielle :

Nous pouvons directement appelez la fonction de collecte pour appeler la fonction partielle Paramètres écrivez directement cas + l'opération dont vous avez besoin

La méthode d'abréviation équivaut à omettre la correspondance, et l'effet est équivalent à filtre+carte

#🎜 🎜#Vous pouvez également utiliser partial dans le scénario d'utilisation de la fonction map

Utilisation de la fonction partielle :

    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)

Conversion implicite :

Définition officielle :

Quand le compilateur Lorsqu'une compilation échoue, il recherchera une méthode dans l'environnement actuel qui peut permettre au code de passer, et utilisera

pour convertir le type à réaliser une deuxième compilation

personal Compréhension :

La conversion implicite est l'opération que l'on effectue lorsqu'une erreur se produit lors de l'appel d'une fonction sur un objet qui n'est pas dans la classe dans laquelle il se trouve.

Fonction implicite : #🎜🎜 #

Étapes pour la conversion implicite :

(1) Vous devez définir une classe cible maintenant et définir les méthodes et la logique appelées dans la classe

eg : On appelle une méthode inexistante sur des données de type Int :

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

(2) Définir le convertisseur dans la fonction principale

#🎜 🎜# A présenter au début ---- conversion implicite implicite La fonction est ensuite définie

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

Lorsque la méthode de conversion implicite est la même et entre en conflit avec sa propre méthode, sa propre méthode sera utilisée (car la compilation n'échouera pas --- la définition officielle de la conversion implicite)#🎜 🎜#

Paramètres implicites :

Nous connaissons déjà les valeurs des paramètres par défaut lors de la définition de la fonction, mais lors de l'appel, nous devons ajouter des parenthèses

Ici, nous introduisons un nouveau concept Paramètres implicites

Exemple de comparaison de paramètres :

   implicit val name:String="lisi"
    def sayhi(implicit name: String="sd"): Unit =
    {
      println(s"hi $name")
    }
   sayhi
   sayhi()

La valeur par défaut du le paramètre consiste simplement à ajouter un crochet après la fonction appelante 🎜🎜# Ajouter le mot-clé implicit devant une classe normale la convertira automatiquement en classe implicite# 🎜🎜#

Si la classe cible de la conversion implicite est convertie en classe implicite, il n'est pas nécessaire de créer un nouvelle classe implicite dans la fonction principale

Vous pouvez appeler directement la fonction spécifiée

.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!