Spark大数据分析与实战笔记（第一章 Scala语言基础-4）

每日一句正能量

若要快乐，就要随和；若要幸福，就要随缘。快乐是心的愉悦，幸福是心的满足。别和他人争吵，别和命运争吵，无计较之心，心常愉悦；尽心之余，随缘起止，随遇而安，心常满足。你随和，愉悦的是自己的心，别人计较，苦闷的是他自己。一天的心情靠随和，一生的幸福靠随缘。

1.4 Scala面向对象的特性

无论是在Scala中还是Java中，类都是对象的抽象，而对象都是类的具体实例；类不占用内存，而对象占用存储空间。由于面向对象的核心是对象，若想要在应用程序中使用对象，就必须得先创建一个类。类是用于描述一组对象的共同特征和行为。

1.4.1 类与对象的特性

创建类的语法格式如下：

class 类名[参数列表] 
1

当类创建好之后，若是想要访问类中的方法和字段，就需要创建一个对象。
创建对象的语法格式如下：

类名 对象名称 = new 类名(); 
1

下面创建一个Point类，并在类中定义两个字段x和y以及一个没有返回值的move( )方法，使Point类的实例对象来访问类中的方法和字段，代码如下所示：

package cn.itcast.scala
//定义类
class Point(xc:Int,yc:Int){
//定义字段
  var x:Int = xc
  var y:Int = yc

  //定义方法
  def move(dx:Int,dy:Int):Unit = {
    x = x + dx
    y = y + dy
    println("x的坐标点："+x)
    println("y的坐标点："+y)
  }
}
object Ch07_ClassTest {
  def main(args: Array[String]): Unit = {
    //定义类对象
    val pt = new Point(10,20)

    //移动到一个新的位置
    pt.move(10,10)
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

结果如下图所示：

1.4.2 继承

• Scala和Java类似，只允许继承一个父类。
• Java只能继承父类中非私有的属性和方法，而Scala可以继承父类中的所有属性和方法。

在Scala子类继承父类的时候，有以下几点需要注意

• 如果子类要重写一个父类中的非抽象方法，则必须使用override关键字，否则会出现语法错误。
• 如果子类要重写父类中抽象方法时，则无需使用override关键字
  下面，创建一个Point类和Location类，并且Location类继承Point类，演示子类Location重写父类Point中的字段，具体代码如下所示：

package cn.itcast.scala
//定义父类:Point类
class Point2(val xc:Int,val yc:Int){
  //定义字段
  var x:Int = xc
  var y:Int = yc

  //定义方法
  def move(dx:Int,dy:Int):Unit = {
    x = x + dx
    y = y + dy
    println("x的坐标点："+x)
    println("y的坐标点："+y)
  }
}

//定义子类:Location类继承Point类
class Location(override val xc:Int,override val yc:Int,zc:Int) extends Point2 (xc,yc){
  var z:Int = zc
  def move(dx:Int,dy:Int,dz:Int): Unit ={
    x = x + dx
    y = y + dy
    z = z + dz
    println("x的坐标点："+x)
    println("y的坐标点："+y)
    println("z的坐标点："+z)
  }
}

object Ch08_ExtendsTest {
  def main(args: Array[String]): Unit = {
    var loc = new Location(10,20,15)
    loc.move(10,10,5)
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

结果如下图所示：

1.4.3 单例对象和伴生对象

在Scala中，没有静态方法或静态字段，所以不能用类名直接访问类中的方法和字段，而是创建类的实例和实例对象对访问类中的方法和字段。但是，Scala中提供了object这个关键字用来实现单例模式，使用关键字object创建的对象为单例对象。

创建单例对象的语法格式如下：

object objectName
1

下面，创建一个单例对象SingletonObject，代码如下示：

package cn.itcast.scala

//创建一个单例对象
object SingletonObject{
  def hello(): Unit ={
    println("Hello,This is Singleton object")
  }
}
object Ch09_Singleton {
  def main(args: Array[String]): Unit = {
    //调用hello 方法
    SingletonObject.hello()
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结果如下图所示：

在一个源文件中有一个类和一个单例对象，若单例对象名与类名相同，则把这个单例对象称作伴生对象（companion object），这个类则被称为是单例对象的伴生类（companion class）。类和伴生对象之间可以相互访问私有的方法和字段。

下面，定义一个伴生对象Dog，演示操作类中的私有方法和字段。具体代码如文件1-10所示。

package cn.itcast.scala

//创建c：Dog
class CH10_Dog {
    val id = 666
    private var name = "二哈"

    def printName(): Unit ={
      //在Dog类中可以访问伴生对象Dog的私有字段
      println(CH10_Dog.CONSTANT + name)
    }
}

//伴生对象
object CH10_Dog {
  //伴生对象中添加私有字段
  private var CONSTANT = "汪汪汪。。。"
  def main(args: Array[String]): Unit = {
    val dog = new CH10_Dog
    dog.name  = "二哈 666"
    dog.printName()
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

结果如下图所示：

1.4.4 特质

在Scala中，Trait（特质）的功能类似于Java中的接口，但Trait的功能却比Java中的接口强大。例如，Trait可以对定义字段和方法进行实现，而接口却不能。Scala中的Trait可以被类和对象(Objects)使用关键字extends来继承。

创建特质的语法格式如下：

trait traitName
1

下面，创建一个特质Animal，演示类继承特质并访问特质中方法的操作。具体代码如下所示。

package cn.itcast.scala
//定义特质
trait Animal{
  //定义一个抽象方法（没有实现的方法）
  def spek()
  
  def listen(): Unit ={

  }
  
  def run(): Unit ={
    println("I'm runing")
  }
}

//定义类，继承特质
class Ch11_People extends Animal {
  override def spek(): Unit = {
    println("I'm speaking English")
  }
}
object Ch11_People {
  def main(args: Array[String]): Unit = {
    val people = new Ch11_People

    people.spek()
    people.listen()
    people.run()
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

结果如下图所示：

注：特质允许继承多个，用with关键字。如下所示：

class Ch11_People extends Animal with A
1

转载自:https://blog.csdn.net/u014727709/article/details/133915097
欢迎start，欢迎评论，欢迎指正