Scala:面向对象Object抽象类内部类特质Trait

Posted ChinaManor

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Scala:面向对象Object抽象类内部类特质Trait相关的知识,希望对你有一定的参考价值。

Scala:面向对象、Object、抽象类、内部类、特质Trait

学习目标

  • 掌握scala类与object的用法
  • 掌握继承的用法
  • 掌握trait(特质)的用法

1. 类和对象

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

1.1 创建类和对象

用法

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

示例

创建一个Person类,并创建它的对象

步骤

  1. 创建一个scala项目,并创建一个Object
  2. 添加main方法
  3. 创建类和对象

实现

  1. 在IDEA中创建项目,并创建一个Object(main方法必须放在Object中)
  2. 添加main方法
  3. 创建一个Person类
  4. 在main方法中创建Person类对象

参考代码

object _01ClassDemo {
  // 创建类
  class Person{}

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

1.2 简写方式

用法

  • 如果类是空的,没有任何成员,可以省略{}

  • 如果构造器的参数为空,可以省略()

示例

使用简写方法重新创建Person类和对象

参考代码

object _02ClassDemo {

  // 创建类,省略花括号
  class Person

  def main(args: Array[String]): Unit = {
    // 创建对象,省略括号
    val person = new Person
  }
}

2. 定义和访问成员变量

一个类会有自己的属性,例如:人这样一个类,有自己的姓名和年龄。我们接下来学习在类中定义、和访问成员变量。

用法

  • 在类中使用var/val来定义成员变量
  • 对象直接使用成员变量名称来访问成员变量

示例

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

步骤

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

参考代码

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)
  }
}

3. 使用下划线初始化成员变量

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

用法

  • 在定义var类型的成员变量时,可以使用_来初始化成员变量
    • String => null
    • Int => 0
    • Boolean => false
    • Double => 0.0
  • val类型的成员变量,必须要自己手动初始化

示例

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

步骤

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

参考代码

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)
  }
}

4. 定义成员方法

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

定义

在scala的类中,也是使用def来定义成员方法

示例

  1. 创建一个Customer类

    1557322180244

  2. 创建一个该类的对象,并调用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("你好")
  }
}

5. 访问修饰符

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

定义

Java中的访问控制,同样适用于scala,可以在成员前面添加private/protected关键字来控制成员的可见性。但在scala中,没有public关键字,任何没有被标为private或protected的成员都是公共的

案例

  • 定义一个Person类

    1557664595693

  • 在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())
  }
}

6. 类的构造器

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

6.1 主构造器

我们学习过,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 参数名:类型 = 默认值){
    // 构造代码块
}

[!NOTE]

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

示例

  1. 定义一个Person类,通过主构造器参数列表定义姓名和年龄字段,并且设置它们的默认值
  2. 在主构造器中输出"调用主构造器"
  3. 创建"张三"对象(姓名为张三,年龄为20),打印对象的姓名和年龄
  4. 创建"空"对象,不给构造器传入任何的参数,打印对象的姓名和年龄
  5. 创建"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)
  }
}

6.2 辅助构造器

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

语法

  • 定义辅助构造器与定义方法一样,也使用def关键字来定义
  • 这个方法的名字为this
def this(参数名:类型, 参数名:类型) {
    // 第一行需要调用主构造器或者其他构造器
    // 构造器代码
}

[!DANGER]

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

示例

示例说明

  • 定义一个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)
  }
}

7. 单例对象(Object)

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

7.1 定义单例对象

单例对象表示全局仅有一个对象(类似于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)
  }
}

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

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

示例

示例说明

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

参考代码

object _09ObjectDemo {

  object PrintUtil {

    // 打印分割线
    def printSpliter() = {
      // 字符串乘法,表示返回多少个字符串
      println("-" * 10)
    }
  }

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

7.3 工具类案例

需求

  • 编写一个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()))
  }
}

8. main方法

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

8.1 定义main方法

main方法

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

示例

示例说明

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

参考代码

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

8.2 实现App Trait来定义入口

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

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

示例

示例说明

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

参考代码

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

9. 伴生对象

在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中,要实现类似的效果,可以使用伴生对象来实现。

我们还可以使用伴生对象来实现快速创建对象,例如:

// 无需使用new就可以快速来创建对象
val a = Array(1,2,3)
val b = Set(1,2,3)

9.1 定义伴生对象

一个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()
  }
}

9.2 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]就可以访问了

9.3 apply方法

我们之前使用过这种方式来创建一个Array对象。

// 创建一个Array对象
val a = Array(1,2,3,4)

这种写法非常简便,不需要再写一个new,然后敲一个空格,再写类名。我们可以通过伴生对象的apply方法来实现。

定义

定义apply方法

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

创建对象

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

示例

示例说明

  • 定义一个Person类,它包含两个字段:姓名和年龄
  • 重写apply方法,使用Person类名就可以创建对象
  • 在main方法中创建该类的对象,并打印姓名和年龄

参考代码

object _12ApplyDemo {
  class Person(var name:String = "", var age:Int = 0)

  object Person {
    // 定义apply方法,接收两个参数
    def apply(name:String, age:Int) = new Person(name, age)
  }

  def main(args: Array[String]): Unit = {
    // 使用伴生对象名称来创建对象
    val zhangsan = Person("张三", 20)
    println(zhangsan.name)
    println(zhangsan.age)
  }
}

10. 继承

scala语言是支持面向对象编程的,我们也可以使用scala来实现继承,通过继承来减少重复代码。

10.1 定义语法

  • scala和Java一样,使用extends关键字来实现继承
  • 可以在子类中定义父类中没有的字段和方法,或者重写父类的方法
  • 类和单例对象都可以从某个父类继承

语法

class/object 子类 extends 父类 {
    ..
}

10.2 类继承

  • 定义一个Person类,再定义一个Student类,继承自Person类

    1557324172277

  • 创建一个Student类对象实例,并设置name为“张三”

  • 打印姓名

参考代码

class Person {
  var name = "super"

  def getName = this.name
}

class Student extends Person

object Main13 {
  def main(args: Array[String]): Unit = {
    val p1 = new Person()
    val p2 = new Student()

    p2.name = "张三"

    println(p2.getName)
  }
}

10.3 单例对象继承

示例说明

  • 创建一个Student单例对象,让单例对象继承示例1中的Person类
  • 设置单例对象的名字为"张三",调用Student单例对象的getName方法
class Person {
  var name = "super"

  def getName = this.name
}

object Student extends Person

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

    println(Student.getName)
  }
}

10.4 override和super

类似于Java语言,我们在子类中使用override需要来重写父类的成员,可以使用super来引用父类

用法

  • 子类要覆盖父类中的一个方法,必须要使用override关键字
  • 使用override来重写一个val字段
  • 使用super关键字来访问父类的成员方法

示例

示例说明

  • 定义一个Person类,包含
    • 姓名字段(不可重新赋值)
    • 获取姓名方法
  • 定义一个Student类
    • 重写姓名字段
    • 重写获取姓名方法,返回"hello, " + 姓名
  • 创建Student对象示例,调用它的getName方法

参考代码

class Person {
  val name = "super"

  def getName = name
}

class Student extends Person {
  // 重写val字段
  override val name: String = "child"

  // 重写getName方法
  override def getName: String = "hello, " + super.getName
}

object Main13 {
  def main(args: Array[String]): Unit = {
    println(new Student().getName)
  }
}

11. 类型判断

有时候,我们设计的程序,要根据变量的类型来执行对应的逻辑。

1557152463629

在scala中,如何来进行类型判断呢?

有两种方式:

  • isInstanceOf
  • getClass/classOf

11.1 isInstanceOf/asInstanceOf

在Java中,我们可以使用instanceof关键字来判断类型、以及(类型)object来进行类型转换,在scala中如何实现呢?

scala中对象提供isInstanceOf和asInstanceOf方法。

  • isInstanceOf判断对象是否为指定类的对象
  • asInstanceOf将对象转换为指定类型

用法

// 判断对象是否为指定类型
val trueOrFalse:Boolean = 对象.isInstanceOf[类型]
// 将对象转换为指定类型
val 变量 = 对象.asInstanceOf[类型]

示例

示例说明

  • 定义一个Person类
  • 定义一个Student类继承自Person类
  • 创建一个Student类对象
  • 判断该对象是否为Student类型,如果是,将其转换为Student类型并打印该对象

参考代码

class Person3
class Student3 extends Person3

object Main3 {
  def main(args: Array[String]): 以上是关于Scala:面向对象Object抽象类内部类特质Trait的主要内容,如果未能解决你的问题,请参考以下文章

Scala 学习 面向对象

21.scala的抽象类型

Java学习总结——面向对象(下)(接口,抽象类,内部类,String类等)

2021年大数据常用语言Scala(三十一):scala面向对象 特质(trait)

大数据Scala系列之特质

scala