scala 类和对象

最新推荐文章于 2023-10-31 14:42:16 发布

小Huya

最新推荐文章于 2023-10-31 14:42:16 发布

阅读量2.3k

点赞数 1

分类专栏： scala

本文链接：https://blog.csdn.net/weixin_42518541/article/details/108207856

版权

scala 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

类和对象

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

创建类和对象

用法

使用class来定义一个类 new来创建对象

参考代码

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来定义成员方法

示例

创建一个Customer类

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

步骤

1、创建一个Object，添加main方法
2、创建Customer类，添加成员变量、成员方法
3、在main方法中创建Customer类对象，设置成员变量值(张三、男)
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 参数名:类型 = 默认值){
// 构造代码块
}

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

示例

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

参考代码

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(参数名:类型, 参数名:类型) {

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

// 构造器代码

}

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

示例

示例说明

定义一个Customer类，包含一个姓名和地址字段
定义Customer类的主构造器（初始化姓名和地址）
定义Customer类的辅助构造器，该辅助构造器接收一个数组参数，使用数组参数来初始化成员变量
使用Person类的辅助构造器来创建一个"zhangsan"对象
姓名为张三
地址为北京
打印对象的姓名、地址

参考代码

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直接引用成员变量

示例

示例说明

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

参考代码

object _08ObjectDemo {

// 定义一个单例对象

object Dog {

    // 定义腿的数量

    val LEG_NUM = 4

}

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

   println(Dog.LEG_NUM)

}

}

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

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

示例

示例说明

设计一个单例对象，定义一个能够打印分割线（15个减号）的方法
在main方法调用该方法，打印分割线

参考代码

object _09ObjectDemo {

object PrintUtil {

    // 打印分割线

    def printSpliter() = {

      // 字符串乘法，表示返回多少个字符串

      println("-" * 10)

    }

}

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

    PrintUtil.printSpliter()

}

}

工具类案例

需求

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

步骤

定义一个DateUtil单例对象，定义日期格式化方法（format）
使用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()))

}

}