Scala类和对象（Object、class）、循环语句

爱被打了一巴掌 2023-09-26 20:14 173阅读 0赞

**目录**

语言特点及概述

Scala语法：

一、Scala类和对象（Object、class）

二、Scala简单语法——循环语句

--------------------

## 语言特点及概述 ##

[Scala][] 是一门满足现代软件工程师需求的语言；它是一门静态类型语言，支持混合范式；它也是一门运行在 JVM 之上的语言，语法简洁、优雅、灵活。Scala 拥有一套复杂的类型系统，Scala方言既能用于编写简短的解释脚本，也能用于构建大型复杂系统。

# Scala 语言概述：[Scala 语言概述][Scala 1] #

# Scala的变量声明和数据类型详解（Val、Var和数据类型）：[Scala的变量声明和数据类型详解][Scala 2] #

## Scala语法： ##

### 一、Scala类和对象（Object、class） ###

/**
     * Scala:
     * 1.Scala object 相当于java中的单例，object中定义的全是静态的（包括方法、成员变量），
     *    相当于Java的工具类（工具类是直接调用的），调用静态变量：类名.变量名。
     * 2.main方法是静态的，所以main方法一定要在object类型中才能运行
     * 3.scala中定义变量使用var，定义常量使用val，变量可变，常量不可变
     * 4.在scala语言中每行后面都会有分号自动推断机制，不用显示地写出 ”;“
     * 5.在scala中命名建议使用驼峰命名法
     * 6.scala类中可以传参，传参一定要指定类型（参数名 : 类型），类给了参数就有了默认的构造器。
     *   类中的属性默认有getter 和 setter方法，创建的类对象可以直接调用。
     * 7.创建类对象时，Java：Person p = new Person("zhangsan",20);
     *             Scala：val p = new Person("zhangsan",20)
     *   scala有两种创建方式：val 、 var，一般除了定义变量用var之外，其他情况都用val，
     *   因为val定义常量，java有自动回收机制，而变量Java虚拟机不知道什么时候还用不用，所以不会回收。
     * 8.类中重写构造器时，构造器中的第一行必须先调用默认的构造，
     *    如：def this(...){...},而且构造器类名要写this，而不是类名
     * 9.scala语言中，当 new class 时，类中除了方法不执行【除了构造方法，构造器会自动执行】，其他都执行，
     *    比如下面Person类中，在类里面写了println语句，当main方法中初始化person对象时，
          执行了两句println，而且在java的类中是不允许直接写sout的，但scala的类中可以写print；
     * 10.在同一个scala文件中，class名称和Object名称可以一样，当一样时，
     *    这个类叫做对象的伴生类，这个对象叫做这个类的伴生对象，他们之间可以互相访问私有变量。
     * 11.object中不可以传参，当创建一个object时，如果传入参数，
          那么会自动寻找object中的相应参数个数的apply方法。
     */

//6.scala类中可以传参，传参一定要指定类型（参数名 : 类型），类给了参数就有了默认的构造器。
    //    类中的属性默认有getter 和 setter方法，创建的类对象可以直接调用。
    class Person(xname :String,xage :Int){
    //  3.scala中定义变量使用var，定义常量使用val，变量可变，常量不可变
      private val name = xname//不写修饰符则默认是public的，scala跟java一样也可以写权限修饰符
      val age = xage
      var gender = 'M'
    
    //4.在scala语言中每行后面都会有分号自动推断机制，不用显示地写出 ”;“
    //  9.scala语言中，当 new class 时，类中除了方法不执行【除了构造方法，构造器会自动执行】，其他都执行，
    //     比如下面Person类中，在类里面写了println语句，当main方法中初始化person对象时，执行了两句println，
    //     而且在java的类中是不允许直接写sout的，但scala的类中可以写print；
      println("********* Person Class ********")
    
    //  8.类中重写构造器时，构造器中的第一行必须先调用默认的构造，
    //     如：def this(...){...},而且构造器类名要写this，而不是类名
      def this(yname :String,yage:Int,ygender:Char){
        this(yname,yage)
        this.gender = ygender
    
      }
      def sayName()= {
        println("hello world "+Lesson_ClassAndObj.name)
      }
    
      println("======== Person Class ========")
    }
    
    //1.Scala object 相当于java中的单例，object中定义的全是静态的（包括方法、成员变量），
    //     相当于Java的工具类（工具类是直接调用的），调用静态变量：类名.变量名。
    
    //object Person{}
    // 10.在同一个scala文件中，class名称和Object名称可以一样，当一样时，
    // *    这个类叫做对象的伴生类，这个对象叫做这个类的伴生对象，他们之间可以互相访问私有变量。
    object Lesson_ClassAndObj {
      println("######## Person Class ########")
      //object里的全是静态的，所以静态的会首先被加载，这句话会先于main方法中的语句执行
    
      val name = "wangwu"
    
    
      def apply(i:Int,name:String)={
        println("Score is "+i+"name is "+name)
      }
    
      def apply(i:Int)={
        println("Score is "+i)
      }
    
    //  2.main方法是静态的，所以main方法一定要在object类型中才能运行
      def main(args: Array[String]): Unit = {
    
    //    7.创建类对象时，Java：Person p = new Person("zhangsan",20);
    //              Scala：val p = new Person("zhangsan",20)
    //    scala有两种创建方式：val 、 var，一般除了定义变量用var之外，其他情况都用val，
    //    因为val定义常量，java有自动回收机制，而变量Java虚拟机不知道什么时候还用不用，所以不会回收。
        val p = new Person("zhangsan",20)
    
    //    11.object中不可以传参，当创建一个object时，如果传入参数，那么会自动寻找object中的相应参数个数的apply方法。
        Lesson_ClassAndObj(1000)
        Lesson_ClassAndObj(1000,"zhaoliu")
    //    println(p.name)
    //    println(p.age)
    //    p.sayName()
    
    //    val a = 19
    //    println(a)
    
      }
    }

### 二、Scala简单语法——循环语句 ###

package com.bjsxt.scala
    
    object fo_while_if {
      def main(args: Array[String]): Unit = {
        /**
         * if...else...
         * sacla的if...else...和java中的用法一样，没有区别
         */
        val age = 20
        if(age <= 20){
          print("age <= 20")
        }else if(age > 20 && age <=30){
          print("age > 20 && age <=30")
        }else{
          print("age > 30")
        }
    
        println()
        println("-------------------------------------------")
    
        /**
         * for 循环
         */
        //1 to 10:代表从1到10（包含10），它返回的是一个集合，与1.to(10)等价
        val a = 1 to 10
        //1.to(10,2):代表从1到10，每个步长为2
        val a1 = 1.to(10,2)
        //1 until 10:代表从1到9(不包含10)，它返回的是一个集合，与1.until(10)等价
        val b = 1 until 10
        //1 until (10,3):代表从1到10，每个步长为3
        val b1 = 1 until (10,3)
        println(a)
        println(a1)
        println(b)
        println(b1)
    
        println("-------------------------------------------")
    
        //写个9×9乘法表格
        for(i <- 1 until 10){
          for(j <- 1 until 10){
            if(i >= j){
              print(s"$j*$i ="+i*j+'\t')
              //此句等价于 println(i+"*"+j+"="+i*j)，
              // 在scala中，可以使用占位符来代替变量，用法：在字符串前用s标明，
              // 字符串中变量前加 $ 标明，注意，这种方式只能代替变量，不能对变量进行运算
            }
            if(i == j){
              println()
            }
          }
        }
    
        println("-------------------------------------------")
    
        //上述for循环方式跟这个for循环等价
        //一个for循环语句中可以进行嵌套，中间用分号";"隔开
        for(i <- 1 until 10 ; j <- 1 until 10){
            if(i >= j){
              print(s"$j*$i ="+i*j+'\t')
            }
            if(i == j){
              println()
            }
        }
    
        println("-------------------------------------------")
    
        //一个for循环语句中也可以加入if条件，条件可以多个，条件之间用分号";"隔开，也可以用空格隔开
        for(i <- 1 until 100 ; if (i > 50);if(i%2==0)){
          print(i+"\t")
        }
    
        println()
        println("-------------------------------------------")
    
        //此句等价于上面这句
        for(i <- 1 until 100 if (i > 50) if(i%2==0)){
          print(i+"\t")
        }
    
        println()
        println("-------------------------------------------")
    
        //此句会返回一个Vector类型的集合
        val result = for(i <- 1 until 100 if (i > 50) if(i%2==0)) yield i
        print(result)
    
        println()
        println("-------------------------------------------")
    
        /**
         * while
         * do...while()
         * 用法和java一样，没什么区别，主要一点是scala中没有自增自减运算符（i++、i——）
         */
        var i = 0
        while (i < 10){
          print(s"第$i 次求婚"+"\t")
          i = i + 1 //注意，scala中没有i++、i——自增自减运算符,支持i += 1
        }
      }
    }

[Scala]: https://so.csdn.net/so/search?q=Scala&spm=1001.2101.3001.7020
[Scala 1]: https://blog.csdn.net/qq_44973159/article/details/105843398
[Scala 2]: https://blog.csdn.net/qq_44973159/article/details/105848189