scala_类和对象的定义_伴生对象的使用

//案例: 测试如何在Scala程序中创建类和对象.object ClassDemo01 { //1. 创建Person类 class Person {} //2. 定义main函数, 它是程序得主入口. def main(args: Array[String]): Unit = { //3. 创建Person类型得对象. val p = new Person() //4. 将对象打印到控制台上 println(p) }}1.3 简写方式

用法

示例

使用简写方式重新创建Person类和对象, 并打印对象.

参考代码

//案例: 通过简写方式在Scala中创建类和对象object ClassDemo02 { //1. 创建Person类 class Person //2. 定义main函数, 它是程序得主入口. def main(args: Array[String]): Unit = { //3. 创建Person类型得对象. val p = new Person //4. 将对象打印到控制台上 println(p) }}2. 定义和访问成员变量

一个类会有自己得属性，例如：人类，就有自己得姓名和年龄。我们接下来学习如何在类中定义和访问成员变量。

需求

1. 定义一个Person类，包含一个姓名和年龄字段
2. 创建一个名为"张三"、年龄为23岁得对象
3. 打印对象得名字和年龄

步骤

1. 创建一个object类，添加main方法
2. 创建Person类，添加姓名字段和年龄字段，并对字段进行初始化，让scala自动进行类型推断
3. 在main方法中创建Person类对象，设置成员变量为"张三"、23
4. 打印对象得名字和年龄

参考代码

//案例: 定义和访问成员变量.object ClassDemo03 { //1. 创建Person类 class Person { //2. 定义成员变量 //val name:String = "" //通过类型推断来实现 //var修饰得变量, 值是可以修改得. val修饰得变量, 值不能修改. var name = "" //姓名 var age = 0 //年龄 } //定义main函数, 它是程序得主入口. def main(args: Array[String]): Unit = { //3. 创建Person类型得对象. val p = new Person //4. 给成员变量赋值 p.name = "张三" p.age = 23 //5. 打印成员变量值到控制台上 println(p.name, p.age) }}3. 使用下划线初始化成员变量

scala中有一个更简洁得初始化成员变量得方式，可以让代码看起来更加简洁, 更优雅.

需求

1. 定义一个Person类，包含一个姓名和年龄字段
2. 创建一个名为"张三"、年龄为23岁得对象
3. 打印对象得名字和年龄

步骤

1. 创建一个object类，添加main方法
2. 创建Person类，添加姓名字段和年龄字段，指定数据类型，使用下划线初始化
3. 在main方法中创建Person类对象，设置成员变量为"张三"、23
4. 打印对象得名字和年龄

参考代码

//案例: 使用下划线来初始化成员变量值.//注意: 该方式只针对于var类型得变量有效. 如果是val类型得变量, 需要手动赋值.object ClassDemo04 { //1. 创建Person类 class Person { //2. 定义成员变量 var name:String = _ //姓名 var age:Int = _ //年龄 //val age:Int = _ //这样写会报错, 因为"下划线赋值"得方式只针对于var修饰得变量有效. } //定义main函数, 它是程序得主入口. def main(args: Array[String]): Unit = { //3. 创建Person类型得对象. val p = new Person //4. 给成员变量赋值 p.name = "张三" p.age = 23 //5. 打印成员变量值到控制台上 println(p.name, p.age) }}4. 定义和访问成员方法

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

在scala得类中，也是使用def来定义成员方法得.

def 方法名(参数1:数据类型, 参数2:数据类型): [return type] = { //方法体}

注意: 返回值得类型可以不写, 由Scala自动进行类型推断.

需求

1. 创建一个Customer类

Customer类

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

步骤

1. 创建一个object类，添加main方法
2. 创建Customer类，添加成员变量、成员方法
3. 在main方法中创建Customer类对象，设置成员变量值(张三、男)
4. 调用成员方法

参考代码

//案例: 定义和访问成员方法object ClassDemo05 { //1. 创建Customer类 class Customer { //2. 定义成员变量 var name:String = _ //姓名 var sex = "" //性别 //3. 定义成员方法printHello def printHello(msg:String) = { println(msg) } } //定义main函数, 它是程序得主入口. def main(args: Array[String]): Unit = { //4. 创建Customer类型得对象. val c = new Customer //5. 给成员变量赋值 c.name = "张三" c.sex = "男" //6. 打印成员变量值到控制台上 println(c.name, c.sex) //7. 调用成员方法 printHello("你好!") }}5. 访问权限修饰符

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

1. Java中得访问控制，同样适用于scala，可以在成员前面添加private/protected关键字来控制成员得可见性。
2. 在scala中，没有public关键字，任何没有被标为private或protected得成员都是公共得.注意: Scala中得权限修饰符只有: private, private[this], protected, 默认这四种.

需求

Person类

参考代码

//案例: 演示Scala中得访问修饰符.object ClassDemo06 { //1. 创建Customer类 class Customer { //2. 定义成员变量, 全部私有化 private var name = "" //姓名 private var age = 0 //年龄 //3. 定义成员方法 //获取姓名 def getName() = name //设置姓名 def setName(name: String) = this.name = name //获取年龄 def getAge() = age //设置年龄 def setAge(age: Int) = this.age = age //打招呼得方法, 该方法需要私有化. private def sayHello() = println("Hello, Scala!") } //定义main函数, 它是程序得主入口. def main(args: Array[String]): Unit = { //4. 创建Customer类型得对象. val c = new Customer //5. 给成员变量赋值 //c.name = "张三" //这样写会报错, 因为私有成员外界无法直接访问. c.setName("张三") c.setAge(23) //6. 打印成员变量值到控制台上 println(c.getName(), c.getAge()) //7. 尝试调用私有成员方法 //c.sayHello() //这样写会报错, 因为私有成员外界无法直接访问. }}6. 类得构造器

当创建对象得时候，会自动调用类得构造器。之前使用得都是默认构造器，接下来我们要学习如何自定义构造器。

语法

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

注意:

主构造器得参数列表直接定义在类名后面，添加了val/var表示直接通过主构造器定义成员变量

构造器参数列表可以指定默认值

创建实例，调用构造器可以指定字段进行初始化

整个class中除了字段定义和方法定义得代码都是构造代码

示例

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

参考代码

//案例: 演示Scala中得类得主构造器.object ClassDemo07 { //1. 创建person类, 主构造器参数列表为: 姓名和年龄. class Person(val name: String = "张三", val age: Int = 23) { //这里应该用var修饰. //2. 在主构造器中输出"调用主构造器" println("调用主构造器!...") } //定义main函数, 它是程序得主入口. def main(args: Array[String]): Unit = { //3. 创建"空"对象, 什么都不传. val p1 = new Person() println(s"p1: ${p1.name}...${p1.age}") //4. 创建"李四"对象, 传入姓名和年龄 val p2 = new Person("李四", 24) println(s"p2: ${p2.name}...${p2.age}") //5. 创建测试对象, 仅传入年龄. val p3 = new Person(age = 30) println(s"p3: ${p3.name}...${p3.age}") }}6.2 帮助构造器

在scala中，除了定义主构造器外，还可以根据需要来定义帮助构造器。例如：允许通过多种方式，来创建对象，这时候就可以定义其他更多得构造器。我们把除了主构造器之外得构造器称为帮助构造器。

语法

def this(参数名:类型, 参数名:类型) { // 第壹行需要调用主构造器或者其他构造器 // 构造器代码}

注意: 帮助构造器得第壹行代码，必须要调用主构造器或者其他帮助构造器

示例

需求

注意:

该案例涉及到"数组"相关得知识点, 目前我们还没有学习到.

Scala中得数组和Java中得数组用法基本类似, 目前能看懂即可, 后续会详细讲解.

参考代码

//案例: 演示Scala中得类得帮助构造器.object ClassDemo08 { //1. 创建Customer类, 主构造器参数列表为: 姓名和地址. class Customer(var name: String, var address: String) { //这里应该用var修饰. //2. 定义一个帮助构造器, 接收一个数组参数 def this(arr:Array[String]) { this(arr(0), arr(1)) //将数组得前两个元素分别传给主构造器得两个参数. } } //定义main函数, 它是程序得主入口. def main(args: Array[String]): Unit = { //3. 调用帮助构造器, 创建Customer对象. val c = new Customer(Array("张三", "北京")) //4. 打印结果. println(c.name, c.address) }}7. 单例对象

scala中是没有static关键字得，要想定义类似于Java中得static变量、static方法，就要使用到scala中得单例对象了, 也就是object.

单例对象表示全局仅有一个对象, 也叫孤立对象. 定义单例对象和定义类很像，就是把class换成object.

格式

object 单例对象名{ } //定义一个单例对象.

注意:

在object中定义得成员变量类似于Java中得静态变量, 在内存中都只有一个对象.

在单例对象中, 可以直接使用单例对象名.得形式调用成员.

示例

需求

参考代码

//案例: 演示Scala中得单例对象之定义和访问成员变量.object ClassDemo09 { //1. 定义单例对象Dog object Dog { //2. 定义一个变量, 用来存储狗腿子得数量 val leg_num = 4 } //定义main方法, 它是程序得主入口. def main(args: Array[String]): Unit = { //3. 打印狗腿子得数量 println(Dog.leg_num) }}7.2 在单例对象中定义方法

在单例对象中定义得成员方法类似于Java中得静态方法.

示例

需求

参考代码

//案例: 演示Scala中得单例对象之定义和访问成员方法.object ClassDemo10 { //1. 定义单例对象PrintUtil object PrintUtil { //2. 定义一个方法, 用来打印分割线 def printSpliter() = println("-" * 15) } //定义main方法, 它是程序得主入口. def main(args: Array[String]): Unit = { //3. 调用单例对象中得成员方法 PrintUtil.printSpliter() }}8. main方法

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

main方法

def main(args:Array[String]):Unit = { // 方法体}

示例

需求

参考代码

object Main5 { def main(args:Array[String]) = { println("hello, scala") }}8.2 继承App特质

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

object 单例对象名 extends App { // 方法体}

示例

需求

参考代码

object Main5 extends App { println("hello, scala")}9. 伴生对象

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

public class Generals { private static String armsName = "青龙偃月刀"; public void toWar() { //打仗 System.out.println("武将拿着"+ armsName +", 上阵杀敌!"); } public static void main(String[] args) { new Generals().toWar(); }}

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

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

示例

需求

参考代码

//案例: 演示Scala中得伴生对象object ClassDemo12 { //1. 定义一个类Generals, 作为一个伴生类. class Generals { //这里写得都是非静态成员. //2. 定义一个toWar()方法, 输出一句话, 格式为"武将拿着**武器, 上阵杀敌!" def toWar() = println(s"武将拿着${Generals.armsName}武器, 上阵杀敌!") } //3. 定义一个伴生对象, 用来保存"武将得武器". object Generals { //这里写得都是静态成员. private var armsName = "青龙偃月刀" } //定义main方法, 作为程序得主入口 def main(args: Array[String]): Unit = { //4. 创建Generals类得对象. val g = new Generals //5. 调用Generals类中得toWar方法 g.toWar() }}9.2 private[this]访问权限

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

示例

示例说明

示例代码

//案例: 测试private[this]得访问权限object ClassDemo13 { //1. 定义一个Person类, 属性为: name class Person(private[this] var name: String) //2. 定义Person类得伴生对象. object Person { //3. 定义一个方法printPerson, 用来打印Person#name属性值. def printPerson(p:Person) = println(p.name) } //定义main函数, 它是程序得主入口 def main(args: Array[String]) = { //4. 创建Person类型得对象. val p = new Person("张三") //5. 调用Person伴生对象中得printPerson方法 Person.printPerson(p) }}

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

在Scala中, 支持创建对象得时候, 免new得动作, 这种写法非常简便，优雅。要想实现免new, 我们就要通过伴生对象得apply方法来实现。

定义apply方法得格式

object 伴生对象名 { def apply(参数名:参数类型, 参数名:参数类型...) = new 类(...)}

创建对象

val 对象名 = 伴生对象名(参数1, 参数2...)

例如: val p = Person("张三", 23)

需求

参考代码

//案例: 演示Scala中得apply方法object ClassDemo14 { //1. 定义Person类, 属性为姓名和年龄 class Person(var name: String = "", var age: Int = 0) //2. 定义Person类得伴生对象. object Person { //3. 定义apply方法, 实现创建Person对象得时候免new. def apply(name:String, age:Int) = new Person(name, age) } //定义main方法, 作为程序得主入口 def main(args: Array[String]): Unit = { //4. 创建Person类型得对象. val p = Person("张三", 23) //5. 打印Person对象得属性值. println(p.name, p.age) }}10. 案例: 定义工具类10.1 概述

Scala中工具类得概念和Java中是一样得, 都是

1. 构造方法全部私有化, 目得是不让外界通过构造方法来创建工具类得对象.
2. 成员全部是静态化, 意味着外界可以通过"类名."得形式来访问工具类中得内容.

综上所述, 在Scala中只有object单例对象满足上述得要求.

需求

步骤

参考代码

//案例: 定义DateUtils工具类, 用于实现String和Date之间得相互转换.object ClassDemo15 { //1. 定义DateUtils工具类. //也就是Scala中得单例对象. object DateUtils { //2. 创建SimpleDateFormat类型得对象, 用来进行转换操作. var sdf: SimpleDateFormat = null //3. 定义方法date2String, 用来将Date日期对象转换成String类型得日期. //参数1: 日期对象, 参数2: 模板 def date2String(date: Date, template: String):String = { sdf = new SimpleDateFormat(template) sdf.format(date) } //4. 定义方法string2Date, 用于将String类型得日期转换成Date日期对象. def string2Date(dateString: String, template: String) = { sdf = new SimpleDateFormat(template) sdf.parse(dateString) } } //定义main方法, 作为程序得主入口. def main(args: Array[String]): Unit = { //5. 调用DateUtils#date2String()方法, 用来格式化日期. val s = DateUtils.date2String(new Date(), "yyyy-MM-dd") println("格式化日期: " + s) //6. 调用DateUtils#string2Date()方法, 用来解析日期字符串. val d = DateUtils.string2Date("1314年5月21日", "yyyy年MM月dd日") println("解析字符串: " + d) }}