Scala基础入门（七）方法、类、对象详解

╰+哭是因爲堅強的太久メ 2022-06-10 07:15 210阅读 0赞

## **Scala 方法(函数)** ##

方法，亦即函数。 一组行为功能的组合，方法是组织程序的最基本形式。

Scala 中， 方法(函数)的定义语法如下:

> **def** methodName(arg1: Type1 arg2: Type2, …): returnType = \{  
>    //some code…  
>    resultValue  
> \}

使用 **def** 关键字定义方法， 后面跟 **方法名** 和 小括号中的 **参数列表** 。 参数列表后面跟一个 **冒号** 和 **方法的返回结果类型**， 返回结果类型后面是一个 **等号**，表示下面是方法体， 方法体用一个 **花括号** 包含。 这和前面的多行表达式一样， 方法体可以看作一个 [**表达式**][Link 1]。

### **Scala 中的程序执行入口 main 方法** ###

Scala 中，程序的执行入口是 main 方法， 其接受字符串数据的参数，无返回值， 其定义如下:

> def main(args: Array\[String\]): Unit = \{  
>  \}

### **自定义方法** ###

遵照 Scala ， 我们自定义一个 对两个整数求和的方法，并调用它输出结果：

package com.byron4j.scala.basic
    
    object MethodDemo {
      def main(args: Array[String]): Unit = {
        println("1 + 2 = " + sum(1, 2))
      }
    
      def sum(arg1: Int, arg2: Int): Int = {
        return arg1 + arg2;
      }
    }

输出：

> 1 + 2 = 3

### **使用断言 assert 测试方法** ###

scala 的 Predef 提供了 断言方法可以用来简单的测试 自定义的方法执行的准确性， assert(布尔表达式, 错误提示语):

>   
> assert(1 > 2, “ERROR: 1 should be less than 2”)

程序运行，断言失败，因为 1 > 2 表达式结果为false， 所以中断程序，并且输出我们指定的错误信息: **ERROR: 1 should be less than 2**

Exception in thread "main" java.lang.AssertionError: assertion failed: ERROR: 1 should be less than 2
        at scala.Predef$.assert(Predef.scala:219)
        at com.byron4j.scala.basic.MethodDemo$.main(MethodDemo.scala:5)
        at com.byron4j.scala.basic.MethodDemo.main(MethodDemo.scala)

这里提示一个测试自定义方法的示例

package com.byron4j.scala.basic
    
    /**
     * Scala 的方法，以及测试自定义方法
     */
    object MethodDemo {
      def main(args: Array[String]): Unit = {
        //assert(1 > 2,  "ERROR: 1 should be less than 2")
        test(1, 2, 3);
        println("Congratulations, 测试通过!");
      }
    
      /**
       * return  arg1 + arg2
       */
      def sum(arg1: Int, arg2: Int): Int = {
        return arg1 + arg2;
      }
    
      /**
       * assert arg1 + arg2 == expectedSum
       */
      def test(arg1: Int, arg2: Int, expectedSum: Int): Unit = {
        var sumVal = sum(1, 2);
        assert(sumVal == expectedSum,
            "Expected " + expectedSum + " but got" + sumVal);
        println(arg1 + " + " + arg2 + " = " + sumVal);
      }
    }

运行，测试OK :

> 1 + 2 = 3  
> Congratulations, 测试通过!

如果测试 test(1, 2, 4); 则程序中断:

> `Exception in thread “main” java.lang.AssertionError: assertion failed: Expected 4 but got3 at scala.Predef$.assert(Predef.scala:219) at com.byron4j.scala.basic.MethodDemo>$.test(MethodDemo.scala:26) at com.byron4j.scala.basic.MethodDemo$.main(MethodDemo.scala:9) at com.byron4j.scala.basic.MethodDemo.main(MethodDemo.scala)`

## **Scala 类、对象** ##

Scala 是面向对象、面向过程的编程语言。

**对象** 包含 存储数据 用 var、val(也叫成员变量、域)，并且使用 **方法**来执行操作。

**类** 定义了域、方法，本质上就是我们定义的数据类型。

每个对象都在内存中独占一块存储。 例如Scala中的 Range（该类可以产生一个序列） 是一个类， 我们创建了2个对象(实例) :

> var range1: Range = Range(0, 10);  
> var range2: Range = Range(10, 0);

对象range1、range2 在内存中存储地址是不同的；因此我们可以说，有一个类Range，有2个对象(实例)range1、range2。

输出结果为：

> range1 = Range 0 until 12  
> 0 1 2 3 4 5 6 7 8 9 10 11  
> 13 14 15 16 17 18 19 20 21 22 23

关于 [Range][] 类的更多细节可以查看 [https://www.scala-lang.org/api/current/scala/collection/immutable/Range.html][Range]

### **创建 Scala 类** ###

上面使用了 **Range** 这样的预定义类来讲述 Scala 中类、对象的含义。 大都时候我们需要自定义类。Scala 中，使用 **class** 关键字来创建类。类的定义语法：

> **class** ClassName\{  
>    // 类体  
> \}

类名应该由多个首字母大写的英文词组合而成： 如 Range、 AlibabaTaobao…

展示一个实例，在ClassDemo.scala 中定义了 Aminal 表示动物的类， 定义了3个 Animal 的子类表示具体的动物 Giraffe 长颈鹿、 熊 Bear、 河马 Hippo； 还使用了 关键字 **extends** 表示继承的关系。

创建类的实例对象的2种方式： **new ClassType()** 、 **new ClassType** ; 创建类的对象时，会执行**类体**。因此该应用运行时会输出 Animal、Giraffe 、 Bear 类中的 print语句：

package com.byron4j.scala.basic
    
    object ClassDemo {
      def main(args: Array[String]): Unit = {
    
        var range1: Range = Range(0, 12);
    
        var range2: Range = Range(13, 24);
    
        println("range1 = " + range1)
    
        for(ele <- range1) print(ele + " ")
        println()
        for(ele <- range2) print(ele + " ")
        println()
    
    
        println("/**************************/")
    
        var giraffe: Giraffe = new Giraffe;
    
        var bear: Bear = new Bear();
    
    
      }
    
    
      class Animal{ 
        print("Animal --> ")
      }
    
      class Giraffe extends Animal{ 
        var name = "Giraffe_BB";
        println("This is a Giraffe.")
      }
    
      class Bear extends Animal{ 
        println("This is a Bear.")
      }
    
      class Hippo extends Animal{ 
        println("This is a Hippo.")
      }
    }

输出:

range1 = Range 0 until 12  
0 1 2 3 4 5 6 7 8 9 10 11  
13 14 15 16 17 18 19 20 21 22 23  
/***\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\****/  
  
Animal –> This is a Giraffe.  
Animal –> This is a Bear.

### **Scala 类中的方法** ###

在类中可以定义类的方法，方法的调用使用 **.**符。我们看如何定义一个小狗类吠的方法:

class Dog{ 
        def bark(): String = {
          "yip!"
        }
      }

调用:

var dog: Dog = new Dog;
    println("dog.bark()执行结果为:" +dog.bark());

输出：

> dog.bark()执行结果为:yip!

[Link 1]: http://blog.csdn.net/zixiao217/article/details/77132027
[Range]: https://www.scala-lang.org/api/current/scala/collection/immutable/Range.html