【scala】基本介绍与用法（三）

最新推荐文章于 2023-04-30 13:41:16 发布
最新推荐文章于 2023-04-30 13:41:16 发布
阅读量3.7k 收藏 1
点赞数
分类专栏： scala 文章标签： scala 基本介绍与用法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44065303/article/details/105441042
版权

目录

 

二十二、类和对象

创建类和对象

二十三、定义和访问成员变量

二十四、使用下划线初始化成员变量

二十五、定义成员方法

二十六、访问修饰符

二十七、类的构造器

主构造器

辅助构造器

二十八、单例对象

二十九、工具类案例

三十、main方法

定义main方法

实现App Trait来定义入口

三十一、伴生对象

定义伴生对象

private[this]访问权限

二十二、类和对象

scala是支持面向对象的，也有类和对象的概念。我们依然可以基于scala语言来开发面向对象的应用程序。

创建类和对象

object _01ClassDemo {
 // 创建类
 class Person{}
​
 def main(args: Array[String]): Unit = {
   // 创建对象
   val p = new Person()
   println(p)
}
}

object _02ClassDemo {
​
 // 创建类，省略花括号
 class Person
​
 def main(args: Array[String]): Unit = {
   // 创建对象，省略括号
   val person = new Person
}
}

二十三、定义和访问成员变量

一个类会有自己的属性，例如：人这样一个类，有自己的姓名和年龄。在类中定义、和访问成员变量

object _03ClassDemo {
 class Person {
   // 定义成员变量
   var name = ""
   var age = 0
}

 def main(args: Array[String]): Unit = {
   // 创建Person对象
   val person = new Person
   person.name = "zhangsan"
   person.age = 20
​
   // 获取变量值
   println(person.name)
   println(person.age)
}
}

二十四、使用下划线初始化成员变量

scala中有一个更简洁的初始化成员变量的方式，可以让代码看起来更加简洁。

在定义var类型的成员变量时，可以使用_来初始化成员变量

  • String => null
  • Int => 0
  • Boolean => false
  • Double => 0.0
  • ...

val类型的成员变量，必须要自己手动初始化

object _04ClassDemo {
​
 class Person{
   // 使用下划线进行初始化
   var name:String = _
   var age:Int = _
}
​
 def main(args: Array[String]): Unit = {
   val person = new Person
   
   println(person.name)
   println(person.age)
}
}

二十五、定义成员方法

类可以有自己的行为，scala中也可以通过定义成员方法来定义类的行为。

使用def来定义成员方法

  1. 创建一个该类的对象，并调用printHello方法

步骤

  1. 1、创建一个Object，添加main方法
  2. 2、创建Customer类，添加成员变量、成员方法
  3. 3、在main方法中创建Customer类对象，设置成员变量值(张三、男)
  4. 4、调用成员方法
object _05ClassDemo {
​
 class Customer {
   var name:String = _
   var sex:String = _
​
   // 定义成员方法
   def sayHi(msg:String) = {
     println(msg)
  }
}
​
 def main(args: Array[String]): Unit = {
   val customer = new Customer
   customer.name = "张三"
   customer.sex = "男"
   customer.sayHi("你好")
}
}

二十六、访问修饰符

和Java一样，scala也可以通过访问修饰符，来控制成员变量和成员方法是否可以被访问。

定义

可以在成员前面添加private/protected关键字来控制成员的可见性。

scala中，没有public关键字，任何没有被标为private或protected的成员都是公共的

案例

定义一个Person类

 

在main方法中创建该类的对象，测试是否能够访问到私有成员

object _02AccessDemo {
​
 class Person {
   // 定义私有成员变量
   private var name:String = _
   private var age:Int = _
​
   def getName() = name
   def setName(name:String) = this.name = name
   def getAge() = age
   def setAge(age:Int) = this.age = age
​
   // 定义私有成员方法
   private def getNameAndAge = {
     name -> age
  }
}
​
 def main(args: Array[String]): Unit = {
   val person = new Person
   person.setName("张三")
   person.setAge(10)
​
   println(person.getName())
   println(person.getAge())
}
}

二十七、类的构造器

当创建类对象的时候，会自动调用类的构造器。之前使用的都是默认构造器，

主构造器

Java的构造器，有构造列表和构造代码块

class Person {
   // 成员变量
   private String name;
   private Integer age;
​
   // Java构造器
   public Person(String name, Integer age) {
       // 初始化成员变量
       this.name = name;
       this.age = age;
  }
}

在scala中， 可以使用更简洁的语法来实现。

语法

class 类名(var/val 参数名:类型 = 默认值, var/val 参数名:类型 = 默认值){
   // 构造代码块
}

  1. 主构造器的参数列表是直接定义在类名后面，添加了val/var表示直接通过主构造器定义成员变量
  2. 构造器参数列表可以指定默认值
  3. 创建实例，调用构造器可以指定字段进行初始化
  4. 整个class中除了字段定义和方法定义的代码都是构造代码

示例

  1. 定义一个Person类，通过主构造器参数列表定义姓名和年龄字段，并且设置它们的默认值
  2. 在主构造器中输出"调用主构造器"
  3. 创建"张三"对象（姓名为张三，年龄为20），打印对象的姓名和年龄
  4. 创建"空"对象，不给构造器传入任何的参数，打印对象的姓名和年龄
  5. 创建"man40"对象，不传入姓名参数，指定年龄为40，打印对象的姓名和年龄

scala的主构造器

object _06ConstructorDemo {

  // 定义类的主构造器
  // 指定默认值
  class Person(var name:String = "", var age:Int = 0) {
    println("调用主构造器")
  }

  def main(args: Array[String]): Unit = {
    // 给构造器传入参数
    val zhangsan = new Person("张三", 20)
    println(zhangsan.name)
    println(zhangsan.age)

    println("---")

    // 不传入任何参数
    val empty = new Person
    println(empty.name)
    println(empty.age)

    println("---")

    // 指定字段进行初始化
    val man40 = new Person(age = 40)
    println(man40.name)
    println(man40.age)
  }
}

辅助构造器

除了主构造器之外的构造器称为辅助构造器。

例如：允许通过多种方式，来创建对象，这时候就可以定义其他更多的构造器。

语法

  • 定义辅助构造器与定义方法一样，也使用def关键字来定义
  • 这个方法的名字为this

def this(参数名:类型, 参数名:类型) {

    // 第一行需要调用主构造器或者其他构造器

    // 构造器代码

}

辅助构造器的第一行代码，必须要调用主构造器或者其他辅助构造器

示例

  1. 定义一个Customer类，包含一个姓名和地址字段
  2. 定义Customer类的主构造器（初始化姓名和地址）
  3. 定义Customer类的辅助构造器，该辅助构造器接收一个数组参数，使用数组参数来初始化成员变量
  4. 使用Person类的辅助构造器来创建一个"zhangsan"对象
  5. 姓名为张三
  6. 地址为北京
  7. 打印对象的姓名、地址
object _07ConstructorDemo {
  class Customer(var name:String = "", var address:String = "") {
    // 定义辅助构造器
    def this(arr:Array[String]) = {
      // 辅助构造器必须要调用主构造器或者其他辅助构造器
      this(arr(0), arr(1))
    }
  }

  def main(args: Array[String]): Unit = {
    val zhangsan = new Customer(Array("张三", "北京"))

    println(zhangsan.name)
    println(zhangsan.address)
  }
}

二十八、单例对象

scala中没有Java中的静态成员，若想要定义类似于Java的static变量、static方法，就要使用到scala中的单例对象——object.

定义单例对象

单例对象表示全局仅有一个对象（类似于Java static概念）

  • 定义单例对象和定义类很像，就是把class换成object
  • 在object中定义的成员变量类似于Java的静态变量
  • 可以使用object直接引用成员变量

示例

  1. 定义一个Dog单例对象，保存狗有几条腿
  2. 在main方法中打印狗腿的数量
object _08ObjectDemo {

  // 定义一个单例对象
  object Dog {
    // 定义腿的数量
    val LEG_NUM = 4
  }

  def main(args: Array[String]): Unit = {
    println(Dog.LEG_NUM)
  }
}

在单例对象中定义成员方法

  • 在object中定义的成员方法类似于Java的静态方法

示例

  1. 设计一个单例对象，定义一个能够打印分割线（15个减号）的方法
  2. 在main方法调用该方法，打印分割线
object _09ObjectDemo {
  object PrintUtil {
    // 打印分割线
    def printSpliter() = {
      // 字符串乘法，表示返回多少个字符串
      println("-" * 10)
    }
  }

  def main(args: Array[String]): Unit = {
    PrintUtil.printSpliter()
  }
}

二十九、工具类案例

  1. 编写一个DateUtil工具类专门用来格式化日期时间
  2. 定义一个方法，用于将日期（Date）转换为年月日字符串，例如：2030-10-05

步骤

  1. 定义一个DateUtil单例对象，定义日期格式化方法（format）
  2. 使用SimpleDateFormat将日期转换为字符串
object _10ObjectDemo {

  object DateUtils {
    // 在object中定义的成员变量，相当于Java中定义一个静态变量
    // 定义一个SimpleDateFormat日期时间格式化对象
    val simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm")

    // 相当于Java中定义一个静态方法
    def format(date: Date) = simpleDateFormat.format(date)
  }

  // main是一个静态方法，所以必须要写在object中
  def main(args: Array[String]): Unit = {
    println(DateUtils.format(new Date()))
  }
}

三十、main方法

scala和Java一样，如果要运行一个程序，必须有一个main方法。在Java中main方法是静态的，而在scala中没有静态方法。在scala中，这个main方法必须放在一个单例对象中。

定义main方法

main方法

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

    // 方法体

}

示例

创建一个单例对象，在该单例对象中打印"hello, scala"

object Main5 {
  def main(args:Array[String]) = {
    println("hello, scala")
  }
}

实现App Trait来定义入口

创建一个object，继承自App Trait（特质），然后将需要编写在main方法中的代码，写在object的构造方法体内。

object 单例对象名 extends App {

    // 方法体

}

示例

继承App特质，来实现一个入口。同样输出"hello, scala"

object Main5 extends App {
  println("hello, scala")
}

三十一、伴生对象

在Java中，经常会有一些类，同时有实例成员又有静态成员。例如：

public class CustomerService {

    private static String SERVICE_NAME = "CustomerService";

    public void save() {
        // 保存客户
        System.out.println(SERVICE_NAME + ":保存客户");
    }

    public static void main(String[] args) {
        new CustomerService().save();
    }
}

在scala中，要实现类似的效果，可以使用伴生对象来实现。

定义伴生对象

一个class和object具有同样的名字。这个object称为伴生对象，这个class称为伴生类

  • 伴生对象必须要和伴生类一样的名字
  • 伴生对象和伴生类在同一个scala源文件中
  • 伴生对象和伴生类可以互相访问private属性

示例

  1. 编写一个CustomerService类，有一个save方法，打印
  2. 服务类名称:保存客户
  3. 编写一个CustomerService伴生对象，定义一个私有变量，用于保存服务类名称
  4. 创建CustomerService对象，调用save方法
object _11ObjectDemo {

  class CustomerService {
    def save() = {
      println(s"${CustomerService.SERVICE_NAME}:保存客户")
    }
  }

  // CustomerService的伴生对象
  object CustomerService {
    private val SERVICE_NAME = "CustomerService"
  }

  def main(args: Array[String]): Unit = {
    val customerService = new CustomerService()
    customerService.save()
  }
}

private[this]访问权限

如果某个成员的权限设置为private[this]，表示只能在当前类中访问。伴生对象也不可以访问

示例

  1. 定义一个Person类，包含一个name字段
  2. 定义Person类的伴生对象，定义printPerson方法
  3. 测试伴生对象是否能访问private[this]权限的成员
class Person(private[this] var name:String)
 
  object Person {
    def printPerson(person:Person): Unit = {
      println(person.name)
    }
  }
 
  def main(args: Array[String]): Unit = {
    val person = new Person("张三")
    Person.printPerson(person)
  }

上述代码，会编译报错。但移除掉[this]就可以访问了

依旧ฅ=ฅ
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala(6) -- scala类(成员变量、成员方法、修饰符)和对象
erainm
09-19 1782
1. 类和对象 2. 定义和访问成员变量 3. 下划线初始化成员变量 4. 定义和访问成员变量 5. 访问权限修饰符 6. 类的构造器 7. 单例对象 8. main方法 9. 伴生对象 10. 案例
Python3变量与基本数据类型用法实例分析
12-20
本文实例讲述了Python3变量与基本数据类型用法。分享给大家供大家参考，具体如下： 3.1保留字和标识符 3.1.1保留字  保留字是Python语言中已经被赋予特定意义的一些单词，开发程序时不可以把保留字作为变量、函数、...
openschool-p2-scala:学校用于管理基本管理任务的Web平台
05-08
OpenSchool项目 这是一个面向学校的开放式网络平台。 特征 组织班级和学生 管理研究 管理沟通 用法 该应用程序使用Docker： : 首先，您需要构建一个Docker映像：docker build -t znurgl / openschool。 运行应用程序：docker run -i -t -p 8080：9000 -v {full-path-of-source}：/ src znurgl / openschool 问题 所有与项目相关的任务和错误均在此github页面的“问题”下。 贡献 欢迎任何贡献。 这是标准的分叉请求方法。 该项目基于带有Scala和MongoDB的Play 2.4框架。
【scala】基本介绍与用法（一）
依旧的博客
04-10 4064
一、声明变量 val/var 变量标识:变量类型 = 初始值 val定义的是不可重新赋值的变量 var定义的是可重新赋值的变量 scala中定义变量类型写在变量名后面 scala的语句最后不需要添加分号 二、类型推断定义变量 scala> val name = "tom" name: String = tom scala可以自动根据变量的值来自动推断变量的类型...
【scala】基本介绍与用法（四）
依旧的博客
04-10 3838
目录 三十二、继承 定义语法 示例 | 类继承 示例 | 单例对象继承 三十三、override和super 三十四、类型判断 isInstanceOf/asInstanceOf getClass和classOf 三十五、抽象类 抽象方法 三十六、抽象字段 三十七、匿名内部类 三十八、特质(trait) trait作为接口使用 示例 | 继承单个trait 示...
【scala】基本介绍与用法（二）
依旧的博客
04-10 3756
十三、数组 scala中，有两种数组，一种是定长数组，另一种是变长数组 定长数组 定长数组指的是数组的长度是不允许改变的 数组的元素是可以改变的 // 通过指定长度定义数组 val/var 变量名 = new Array[元素类型](数组长度) ​ // 用元素直接初始化数组 val/var 变量名 = Array(元素1, 元素2, 元素3...) 在scala中，数组的泛型使用[]...
Scala基本数据类型
m0_57697768的博客
04-30 170
是参考了Java的设计思想，可以说Scala是源于Java，同时马丁·奥德斯基也加入了自己的思想，将函数式编程语言的特点融合到JAVA中, 因此，对于学习过Java的同学，只要在学习Scala的过程中，搞清楚Scala和Java相同点和不同点，就可以快速的掌握Scala这门语言。（3）Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于 Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。（多范式，就是多种编程方法的意思。
【Scala 教程】Scala 基本语法与规则
梦家の博客
05-03 480
Scala 的基础语法与 Java 类似，对于计算机专业学过 Java 的同学较为友好！对于 Python 开发者就怕写出 Pythonic Scala，还是简单记录一下吧。 基本语法 Scala 基本语法需要注意以下几点： 区分大小写 Scala是大小写敏感的，这意味着标识Hello 和 hello在Scala中会有不同的含义。 类名 对于所有的类名的第一个字母要大写。如果需要使用几个单词来构...
Scala的基本语法
qq_53276543的博客
03-17 1576
Scala的基本语法
Scala函数定义与使用
XQC_KKK的博客
10-31 895
定义函数最通用的方法是作为某个类或者单例对象的成员，这种函数被称为方法。def 方法名(参数列表) : 结果类型 = {方法体 }函数的输入参数的类型以及返回值的类型一起构成函数类型。当参数只有一个时，圆括号可以省略只有存在多个参数时(不同参数之间用逗号隔开），圆括号才是必须的函数字面量匿名函数，Lambda表达式，不需要给每个函数命名。(参数) => 表达式 //如果参数只有一个，参数的圆括号可以省略匿名函数→赋值→函数类型的变量当Scala可以自动推断变量类型时，不用声明类型。
scala-simple-samples:示例展示了 Scala 语言的基本概念
07-21
FrenchDate：在 Scala 中使用 Java 库 Complex、Complex2 和 ComplexNumbers：定义类和类方法 Tree、TreeAssessor 和 Derivaties：案例类和模式匹配 订单和日期：特征 参考和整数参考：generecity
spark_helper:使用Scala Spark进行数据处理和监视的一系列低级基本方法
05-09
SparkHelper概述API Scaladoc： 该库包含一堆用于使用Scala Spark进行数据处理的低级基本方法。 目标是从spark作业代码中删除最多的高度使用和高度重复的低级代码，并将其替换为经过充分测试的，名称易于说明和可读...
Akka基本知识：本书中的JavaScala示例-Akka Essentials
02-03
您将在Java和Scala中找到Akka的示例，同时讨论一个概念以及一个已解决的问题 ClientServerExample：此示例演示了远程参与者在客户端/服务器模式下的工作方式。 客户端将消息发送到服务器，服务器回复给客户端。 该...
Scala基本语法
laozaoxiaowanzi的博客
01-15 414
数据类型 Scala的数据类型有 byte char short int long float double boolean 和unit 其中unit类型是表示无值，和其他语言中的void相同。可以用作方法无返回值的结果类型，Unit只有一个实例值，写成()。 Scala类的继承层级，Any类型等价于Java中的object类，基本类型都继承于Anyval，其他均属于AnyRef 变量的定义 定义变量使用var或者val关键字 语法：var/val 变量名称=变量值 （不指定数据类型...
【idea】【scala】idea开发scala代码的一些快捷方式
依旧的博客
09-01 5132
一、IDEA编写Scala代码时自动显示变量类型 设置方法： settins -->Editor–> Code Style --> scala --Type Annotations 二、ctrl+/ 自动注释代码时,在代码前添加//,而不是在行首添加// settins -->Editor-->Code Style-->Scala 把Line comment at first column 取消勾选（默认是勾选的） 三、scala自动导包设置 sett
【scala】练习题
依旧的博客
04-10 4732
import scala.collection.mutable.ArrayBuffer object Test_day01 { def main(args: Array[String]): Unit = { // for循环（1-20） //1、请写出for循环，i 表示循环的变量，Range生成0-20的数字，请循环打印出0-19这些数字。 // ...
【idea】【scala】 安装scala开发环境
依旧的博客
04-10 3968
Java程序编译执行流程 Scala程序编译执行流程 scala程序运行需要依赖于Java类库，必须要有Java运行环境，scala才能正确执行 要编译运行scala程序，需要 jdk（jvm） scala编译器（scala SDK） 接下来，需要依次安装以下内容： 安装JDK 安装scala SDK 安装IDEA插件 安装JDK 安装JDK 1.8 64位版本，并配...
【idea】【scala】IDEA使用Scala语言开发maven项目
依旧的博客
09-01 3722
一、安装scala插件请转到idea安装scala插件 二、右击项目名，点击Add Framework Support 三、勾选scala，点击OK 测试
scala中seq基本用法
最新发布
05-26
在Scala中，Seq是一个序列，它是有序的且可重复的。它是一个trait，有许多实现，如List、Array、Vector、Queue等等。 以下是Seq的基本用法： 1. 创建Seq 可以使用以下方式创建一个Seq： ```scala val seq1 = Seq(1, 2, 3) val seq2 = Seq("a", "b", "c") ``` 2. 访问元素 可以使用索引访问Seq中的元素： ```scala val seq = Seq(1, 2, 3) println(seq(0)) // 输出1 println(seq(1)) // 输出2 println(seq(2)) // 输出3 ``` 3. 遍历Seq 可以使用for循环遍历Seq中的元素： ```scala val seq = Seq(1, 2, 3) for (i <- seq) { println(i) } ``` 也可以使用foreach方法： ```scala val seq = Seq(1, 2, 3) seq.foreach(i => println(i)) ``` 4. 追加元素 可以使用:+操作符追加元素到Seq的末尾： ```scala val seq1 = Seq(1, 2, 3) val seq2 = seq1 :+ 4 println(seq2) // 输出Seq(1, 2, 3, 4) ``` 5. 过滤元素 可以使用filter方法过滤Seq中的元素： ```scala val seq = Seq(1, 2, 3, 4, 5) val filtered = seq.filter(_ % 2 == 0) println(filtered) // 输出Seq(2, 4) ``` 6. 转换元素 可以使用map方法转换Seq中的元素： ```scala val seq = Seq(1, 2, 3) val transformed = seq.map(_ * 2) println(transformed) // 输出Seq(2, 4, 6) ``` 7. 合并Seq 可以使用++操作符合并两个Seq： ```scala val seq1 = Seq(1, 2, 3) val seq2 = Seq(4, 5, 6) val merged = seq1 ++ seq2 println(merged) // 输出Seq(1, 2, 3, 4, 5, 6) ``` 以上是Seq的基本用法。Seq还有很多其他的方法可以使用，可以查看Scala官方文档获得更多信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值