目录
二十二、类和对象
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来定义成员方法
- 创建一个该类的对象，并调用printHello方法
步骤
|
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，打印对象的姓名和年龄
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(参数名:类型, 参数名:类型) {
// 第一行需要调用主构造器或者其他构造器
// 构造器代码
}
辅助构造器的第一行代码，必须要调用主构造器或者其他辅助构造器
示例
- 定义一个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()))
}
}三十、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属性
示例
- 编写一个CustomerService类，有一个save方法，打印
- 服务类名称:保存客户
- 编写一个CustomerService伴生对象，定义一个私有变量，用于保存服务类名称
- 创建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]，表示只能在当前类中访问。伴生对象也不可以访问
示例
- 定义一个Person类，包含一个name字段
- 定义Person类的伴生对象，定义printPerson方法
- 测试伴生对象是否能访问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]就可以访问了
