Detaillierter Prozess zur Verwendung der Def-Anweisung zum Definieren von Methoden in Python Scala

Dieser Artikel vermittelt Ihnen relevantes Wissen über Python. Er stellt hauptsächlich den detaillierten Prozess der Verwendung von Def-Anweisungen zum Definieren von Methoden in Scala vor. Methoden sind Teil einer Klasse, und eine Funktion ist ein Objekt, das einer Variablen zugewiesen werden kann Schauen Sie es sich gemeinsam an. Ich hoffe, es wird für alle hilfreich sein.

【Verwandte Empfehlung: Python3-Video-Tutorial】

Scala verfügt auch über Methoden und Funktionen wie Java. Eine Scala-Methode ist Teil einer Klasse, während eine Funktion ein Objekt ist, das einer Variablen zugewiesen werden kann. Mit anderen Worten: In einer Klasse definierte Funktionen sind Methoden. In Scala können Funktionen mithilfe von df-Anweisungen und val-Anweisungen definiert werden, während Methoden nur mithilfe von def-Anweisungen definiert werden können. Lassen Sie uns Scalas Methode erklären.

Das Definitionsformat der Scala-Methode lautet wie folgt:

Wie aus dem obigen Code ersichtlich ist, besteht die Scala-Methode wie folgt aus mehreren Teilen.

def functionName([参数列表]):[return type]={
    function body
    return [expr]
}

·def: Scalas Schlüsselwort, und es ist festgelegt. Die Definition einer Methode beginnt mit dem Schlüsselwort def.

·functionName: Der Methodenname der Scala-Methode.

·([Parameterliste]): [Rückgabetyp]: Optionale Parameterliste der Scala-Methode. Jeder Parameter in der Parameterliste hat einen Namen, gefolgt von einem Doppelpunkt und einem Parametertyp.

·Funktionskörper: der Körper der Methode.

·return [expr]: Der Rückgabetyp der Scala-Methode, der jeder zulässige Scala-Datentyp sein kann. Wenn kein Rückgabewert vorhanden ist, ist der Rückgabetyp Unit.

Als nächstes definieren Sie eine Methode add(), um die Addition und Summe zweier Zahlen zu implementieren. Der Beispielcode lautet wie folgt:

def add(a:Int,b:Int):Int={
    var sum:Int =0
    sun =a +b
    return sum
}

Das Format des Scala-Methodenaufrufs ist wie folgt:

//没有使用实例的对象调用格式
functionName(参数列表)
//方法由实例的对象来调用，可以使用类似java的格式（使用”.”号）
[instance.]functionName(参数列表]

Als nächstes in der Klasse Test: Definieren Sie eine Methode addInt( ), die die Addition zweier Ganzzahlen implementiert. Hier erfolgt der Aufruf über „Klassenname. Methodenname (Parameterliste)“. Der Beispielcode lautet wie folgt:

scala>:paste                                 #多行输人模式的命令
// Entering paste mode (ctrl-D to finish)
object Test{
   def addInt(a:Int,b:Int):Int={
       var sum:Int=0
       sum=a+b
       return sum
   }
}
// Exiting paste mode, now interpreting.
defined object Test
scala>Test.addInt(4,5)
res0: Int =9

Wie man val-Anweisungen und def-Anweisungen in Scala verwendet

In diesem Artikel wird „Wie man val-Anweisungen verwendet“ vorgestellt und def-Anweisungen in Scala „def-Anweisung“, viele Menschen werden bei der Ausführung tatsächlicher Fälle auf solche Dilemmata stoßen. Lassen Sie sich als Nächstes vom Editor anleiten, um zu lernen, wie man mit diesen Situationen umgeht! Ich hoffe, dass Sie es sorgfältig lesen und etwas lernen!

In Scala können Sie die Anweisung val zum Definieren von Funktionen und die Anweisung def zum Definieren von Methoden verwenden.

class Test{
  def m(x: Int) = x + 3
  val f = (x: Int) => x + 3}
  
2.Scala 方法声明格式如下：
def functionName ([参数列表]) : [return type]
如果你不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型于是也是一个抽象类型。
3.方法定义
由一个 def 关键字开始，紧接着是可选的参数列表，一个冒号 : 和方法的返回类型，一个等于号 = ，最后是方法的主体。
Scala 方法定义格式如下：
def functionName ([参数列表]) : [return type] = {
   function body  
    return [expr]（默认最后一行）}
    }
 4.函数
 函数默认参数
 cala 可以为函数参数指定默认参数值，使用了默认参数，你在调用函数的过程中可以不需要传递参数，这时函数就会调用它的默认参数值，如果传递了参数，则传递值会取代默认值。实例如下：object Test {
   def main(args: Array[String]) {
        println( "返回值 : " + addInt() );
   }
   def addInt( a:Int=5, b:Int=7 ) : Int = {
      var sum:Int = 0
      sum = a + b      return sum   }}
 函数命名参数
 般情况下函数调用参数，就按照函数定义时的参数顺序一个个传递。但是我们也可以通过指定函数参数名，并且不需要按照顺序向函数传递参数，实例如下：object Test {
   def main(args: Array[String]) {
        printInt(b=5, a=7);
   }
   def printInt( a:Int, b:Int ) = {
      println("Value of a : " + a );
      println("Value of b : " + b );
   }
   }
 函数可变参数
 Scala 允许你指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。
Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。例如：
object Test {
   def main(args: Array[String]) {
        printStrings("Runoob", "Scala", "Python");
   }
   def printStrings( args:String* ) = {
      var i : Int = 0;
      for( arg <- args ){
         println("Arg value[" + i + "] = " + arg );
         i = i + 1;
      }
   }}
   递归函数
   
递归函数意味着函数可以调用它本身。
以上实例使用递归函数来计算阶乘：
object Test {
   def main(args: Array[String]) {
      for (i <- 1 to 10)
         println(i + " 的阶乘为: = " + factorial(i) )
   }
   
   def factorial(n: BigInt): BigInt = {  
      if (n <= 1)
         1  
      else    
      n * factorial(n - 1)
   }}
 匿名函数
箭头左边是参数列表，右边是函数体。使用匿名函数后，我们的代码变得更简洁了。
下面的表达式就定义了一个接受一个Int类型输入参数的匿名函数:
var inc = (x:Int) => x+1
上述定义的匿名函数，其实是下面这种写法的简写：
def add2 = new Function1[Int,Int]{  
    def apply(x:Int):Int = x+1;  
}

【Verwandte Empfehlungen: Python3-Video-Tutorial】

Das obige ist der detaillierte Inhalt vonDetaillierter Prozess zur Verwendung der Def-Anweisung zum Definieren von Methoden in Python Scala. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!