2023_Spark_实验六：Scala面向对象部分演示（二）（IDEA开发）

7、Scala中的apply方法（）

遇到如下形式的表达式时，apply方法就会被调用：

Object(参数1,参数2,......,参数N)

通常，这样一个apply方法返回的是伴生类的对象；其作用是为了省略new关键字

Object的apply方法举例：

 
 
//object的apply方法
 
class Student5(val stuName:String) {
 
 
 
}
 
 
 
object Student5 {
 
//定义自己的apply方法
 
def apply(stuName: String) = {
 
println("*********Apply in Object **********")
 
new Student5(stuName)
 
}
 
//如果没有这个apply方法，下面创建Mary的时候就会报错
 
 
 
def main(args: Array[String]): Unit = {
 
var s51 = new Student5("Tom")
 
println(s51.stuName)
 
 
 
var s52 = new Student5("Mary")
 
//由于省略了new关键字，创建这个对象的时候，就会在Object找对应的apply方法
 
println(s52.stuName)
 
}
 
}

8、Scala中的继承

Scala和Java一样，使用extends关键字扩展类。

案例一：Employee类继承Person类

 
//演示Scala的维承父类
 
class Person(val name:String,val age:Int) {
 
//定义结果
 
def sayHello():String = "Hello" + name + " and the age is " + age
 
}
 
 
 
//子类
 
class Employee (override val name:String,override val age:Int,val salary:Int) extends Person(name,age){
 
//重新父类的sayHello方法
 
//注意override 是关键字
 
override def sayHello(): String = "子类中的sayHello方法"
 
}
 
 
 
object Demo {
 
//测试程序
 
def main(args: Array[String]): Unit = {
 
//创建一个Employee的对象
 
var p2:Person = new Employee("Mike",25,1000)
 
println(p2.sayHello())
 
 
 
 
 
//使用匿名子类来创建Person对象
 
//这里我们创建了Person的一个匿名子类，并且在该子类中重写了sayHello方法。
 
var p3:Person = new Person("Jerry",26) {
 
override def sayHello(): String = "匿名子类中的sayHello方法"
 
}
 
println(p3.sayHello())
 
}
 
}

案例二：在子类中重写父类的方法

//子类
 
class Employee (override val name:String,override val age:Int,val salary:Int) extends Person(name,age){
 
//重新父类的sayHello方法
 
override def sayHello(): String = "子类中的sayHello方法"
 
}

案例三：使用匿名子类

//使用匿名子类来创建Person对象
 
//这里我们创建了Person的一个匿名子类，并且在该子类中重写了sayHello方法。
 
var p3:Person = new Person("Jerry",26) {
 
override def sayHello(): String = "匿名子类中的sayHello方法"
 
}
 
println(p3.sayHello())

案例四：使用抽象类。抽象类中包含抽象方法，抽象类只能用来继承。

 
//Scala中的抽象类
 
 
 
//父类：抽象类
 
abstract class Vehicle{
 
//定义抽象方法
 
def checkType():String
 
}
 
 
 
//子类
 
 
 
class Car extends Vehicle {
 
//实现checkType 方法
 
override def checkType(): String = {"I am a Car"}
 
 
 
}
 
 
 
class Bycical extends Vehicle {
 
//实现checkType方法
 
override def checkType(): String = {"I am a bike"}
 
}
 
 
 
object Demo2 {
 
//定义两个交通工具
 
def main(args: Array[String]): Unit = {
 
var v1:Vehicle = new Car
 
println(v1.checkType())
 
 
 
var v2:Vehicle = new Bycical
 
println(v2.checkType())
 
}
 
 
 
}

案例五：使用抽象字段。抽象字段就是一个没有初始值的字段

 
package class4
 
//Scala中的抽象字段：就是没有初始值的字段
 
//抽象的父类
 
 
 
abstract class Person{
 
//第一个抽象字段，并且只有get方法
 
 
 
val id:Int
 
//另一个抽象字段，并且有get和set方法
 
var name:String
 
}
 
//子类:应该提供抽象字段的初始值，否则该子类也,应该是抽象的
 
 
 
abstract class Employee1 extends Person {
 
//val id:Int = 1
 
var name:String = "No Name"
 
 
 
}
 
class Employee2(val id:Int) extends Person {
 
var name:String = "No Name"
 
}
 
object Demo3 {
 
def main(args: Array[String]): Unit = {
 
var a:Person = new Employee2(1)
 
 
 
println(a.id,a.name)
 
 
 
 
 
}
 
}

9、Scala中的trait（特质）

trait就是抽象类。trait跟Java抽象类最大的区别：trait支持多重继承

 
package class4
 
 
 
/*
* Scala中的trait
* 1.trait 就是抽象类
* 2.区别：trait 支持多重继承
*/
 
 
 
//第一个trait
 
trait Human {
 
val id:Int
 
val name:String
 
 
 
//方法
 
def sayHello():String = "Hello" + name
 
}
 
 
 
//第二个trait
 
trait Actions {
 
//抽象方法
 
def getActionNames():String
 
}
 
 
 
//子类
 
class Student(val id:Int,val name:String) extends Human with Actions {
 
override def getActionNames(): String = "Action is running"
 
}
 
 
 
object Demo4 {
 
def main(args: Array[String]): Unit = {
 
//创建一个student的对象
 
var s1 = new Student(1,"Tom")
 
println(s1.sayHello())
 
println(s1.getActionNames())
 
}
 
}

10、包的使用

Scala的包和Java中的包或者C++中的命名空间的目的是相同的：管理大型程序中的名称。

Scala中包的定义和使用：

包的定义

包的引入：Scala中依然使用import作为引用包的关键字，例如

而且Scala中的import可以写在任意地方

11、包对象

包可以包含类、对象和特质，但不能包含函数或者变量的定义。很不幸，这是

Java虚拟机的局限。把工具函数或者常量添加到包而不是某个Utils对象，这是

更加合理的做法。Scala中，包对象的出现正是为了解决这个局限。Scala中的包

对象：常量，变量，方法，类，对象，trait（特质）

 
package class4
 
 
 
//Scala中的包对象：常量，变量，方法，类，对象，trait（特质）
 
 
 
//定义一个包对象
 
 
 
package object MyPackageObject {
 
 
 
//常量
 
val x:Int = 0
 
 
 
//变量
 
var y:String = "Hello World "
 
 
 
//方法
 
def sayHelloWorld():String = "Hello World"
 
 
 
//类
 
class MyTestClass {
 
 
 
}
 
 
 
//对象object
 
object MyTestObject {
 
 
 
}
 
 
 
//特质 trait
 
trait MyTestTrait {
 
 
 
}
 
 
 
}
 
 
 
class Demo3 {
 
//测试
 
def method1 = {
 
//导入需要的包对象
 
import class4.MyPackageObject._
 
//定义MyTestClass的一个对象
 
var a= new MyTestClass
 
}
 
}

12、Scala中的文件访问

读取行

 
val source = scala.io.Source.fromFile("e:\\temp\\a.txt")
 
println(source.mkString)
 
val lines = source.getLines()
 
for(l<-lines) println(l.toString)

读取字符

 
val source = scala.io.Source.fromFile("e:\\temp\\a.txt")
 
for(c <-source) println(c)

其实这里的source就指向了这个文件中的每个字符。