Spark记录-Scala类和对象

本章将介绍如何在Scala编程中使用类和对象。类是对象的蓝图(或叫模板)。定义一个类后，可以使用关键字new来创建一个类的对象。通过对象可以使用定义的类的所有功能。

下面的图通过一个包含成员变量(name 和 rollNo)和成员方法(setName()和setRollNo())的Student类的例子来演示类和对象。最后都是类的成员。类是一个模板的东西，而对象是真实存在的。在下图中，Student是一个类，而具体学生：Harini, John, 和 Maria 是学生类的对象，这此对象有是名字和注册号。

类基础

以下是在Scala中定义类的简单语法。这个类定义了两个变量x和y以及一个move方法，它没有返回值。

使用类的名称作为一个类构造函数，构造函数可以使用多个参数。上面的代码定义了两个构造函数参数xc和yc; 它们在类的整个定义中都是可见的。

语法

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

如本章前面所述，您可以使用关键字new来创建对象，然后访问类字段和方法，如下例所示：

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

object Demo {
   def main(args: Array[String]) {
      val pt = new Point(10, 20);

      // Move to a new location
      pt.move(10, 10);
   }
}

将上述程序保存在Demo.scala中，并使用以下命令编译和执行此程序。

D:\software\scala-2.12.3\bin>scalac Demo.scala

D:\software\scala-2.12.3\bin>scala Demo
Point x location : 20
Point y location : 30

D:\software\scala-2.12.3\bin>

扩展类

在Scala中，我们可以扩展一个Scala类，使用与Java中相同的方式设计继承的类(使用extends关键字)，但有两个限制：方法重写需要override关键字，只有主构造函数可以通过参数调用基类构造函数。让我们扩展上面的类，并增加一个类的方法。

例子

让我们使用两个类Point作为一个例子(与上面一样)和Location类，Location类是一个使用extends关键字创建的继承类。这样的“扩展”子句有两个效果：它使得Location类从Point类继承所有非私有成员，并且使类型Location成为Point类类型的子类型。所以Point类被称为超类(父类)，Location类被称为子类。扩展一个类并继承父类的所有功能称为继承，但Scala允许只从一个类继承(不支持多继承)。

注意 - 在Point类中的move()方法和Location类中的move()方法不会覆盖move的相应定义，因为它们是不同的定义(例如，前者采用两个参数，后者采用三个参数)。

参考以下示例程序来实现继承 -

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Point(xc, yc){
   var z: Int = zc

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("Point x location : " + x);
      println ("Point y location : " + y);
      println ("Point z location : " + z);
   }
}

object Demo {
   def main(args: Array[String]) {
      val loc = new Location(10, 20, 15);

      // Move to a new location
      loc.move(10, 10, 5);
   }
}

将上述程序保存在源文件：Demo.scala中，并使用以下命令编译和执行此程序，输出结果如下 -

D:\software\scala-2.12.3\bin>scalac Demo.scala

D:\software\scala-2.12.3\bin>scala Demo
Point x location : 20
Point y location : 30
Point z location : 20

D:\software\scala-2.12.3\bin>

隐性类

当类在范围内时，隐式类允许与类的主构造函数进行隐式对话。隐式类是一个标有'implicit'关键字的类。此功能在Scala 2.10中引入。

语法 - 以下是隐式类的语法。这里，隐式类始终位于对象范围内，所有方法定义都被允许，因为隐式类不能是顶级类。

语法

object <object name> {
   implicit class <class name>(<Variable>: Data type) {
      def <method>(): Unit =
   }
}

例子

下面演示如何使用隐式类，创建一个名称为IntTimes的隐式类，并定义一个times()方法。times()包含一个循环事务，它将按给定的次数执行语句。假设要执行4次println(“”Hello“)语句。

以下是示例程序代码。在这个例子中，使用了两个对象类(Run 和 Demo)，将这两个类保存在不同的文件中，名称如下 -

Run.scala - 将以下程序保存在源文件：Run.scala 中

object Run {
   implicit class IntTimes(x: Int) {
      def times [A](f: =>A): Unit = {
         def loop(current: Int): Unit =

         if(current > 0){
            f
            loop(current - 1)
         }
         loop(x)
      }
   }
}

Demo.scala - 将以下程序保存在源文件：Demo.scala 中 -

import Run._

object Demo {
   def main(args: Array[String]) {
      4 times println("hello")
   }
}

用于以下命令编译和执行这两个程序，输出结果如下 -

D:\software\scala-2.12.3\bin>scalac Demo.scala

D:\software\scala-2.12.3\bin>scala Demo
hello
hello
hello
hello

D:\software\scala-2.12.3\bin>

注 -

隐式类必须在另一个类/对象/特征中定义(不在顶层)。
隐式类在其构造函数中只能使用一个非默认参数。
隐式类作用域中不可以具有与隐式类相同名称的的任何方法，成员或对象。

单例对象

Scala比Java更面向对象，因为在Scala中不能拥有静态成员，Scala它使用单例对象。单例是一种只能有一个实例的对象。使用object关键字对象而不是类关键字创建单例。由于无法实例化单例对象，因此无法将参数传递给主构造函数。下面列出Scala使用单例对象的所有示例。

以下是实现单例的示例程序 -

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
   }
}

object Demo {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println ("Point x location : " + point.x);
         println ("Point y location : " + point.y);
      }
   }
}

将上述程序保存在源文件：Demo.scala 中，使用以下命令编译和执行此程序，输出结果如下 -

D:\software\scala-2.12.3\bin>scalac Demo.scala

D:\software\scala-2.12.3\bin>scala Demo
Point x location : 10
Point y location : 20

Scala单例和伴生对象

单例(Singleton)对象是一个通过使用object关键字而不是使用class关键字声明的对象。其它对象不需要调用在单例对象中声明的方法。

在scala中，没有静态的概念。所以scala创建一个单例对象来为程序的执行提供入口点。
如果不创建单例对象，代码也会成功编译，但不会产生任何输出。单例对象中声明的方法可以全局访问。单例对象可以扩展类和性状。

Scala单例对象示例

object Singleton{  
    def main(args:Array[String]){  
        SingletonObject.hello()         // No need to create object.  
    }  
}  


object SingletonObject{  
    def hello(){  
        println("Hello, This is Singleton Object")  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
Hello, This is Singleton Object

Scala伴生对象

在scala中，当有一个与单例(singleton)对象同名的类时，它被称为伴生(companion)类，单例(singleton)对象调用伴生对象。

伴生类及其伴随对象必须在同一个源文件中定义。

Scala伴生对象示例

class ComapanionClass{  
    def hello(){  
        println("Hello, this is Companion Class.")  
    }  
}  
object Demo{  
    def main(args:Array[String]){  
        new ComapanionClass().hello()  
        println("And this is Companion Object.")  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
Hello, this is Companion Class.
And this is Companion Object.

Scala Case类和对象

Scala Case类只是常规类，默认情况下是不可变的，可通过模式匹配可分解。它使用相等(equal)方法在结构上比较实例。它不使用new关键字实例化对象。默认情况下，case类中列出的所有参数默认使用public和immutable修辞符。语法

case class className(parameters)

Scala Case类示例

case class CaseClass(a:Int, b:Int)  

object Demo{  
    def main(args:Array[String]){  
        var c =  CaseClass(10,10)       // Creating object of case class  
        println("a = "+c.a)               // Accessing elements of case class  
        println("b = "+c.b)  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
a = 10
b = 10

Case类支持模式匹配。所以，可以在模式中使用它。以下是Case类和模式的示例。

Scala Case类和模式匹配示例

没有参数的case类将被声明为case对象而不是case类。默认情况下，case对象是可序列化的。

trait SuperTrait  
case class CaseClass1(a:Int,b:Int) extends SuperTrait  
case class CaseClass2(a:Int) extends SuperTrait         // Case class  
case object CaseObject extends SuperTrait               // Case object  
object Demo{  
    def main(args:Array[String]){  
        callCase(CaseClass1(10,10))  
        callCase(CaseClass2(10))  
        callCase(CaseObject)  
    }  
    def callCase(f:SuperTrait) = f match{  
        case CaseClass1(f,g)=>println("a = "+f+" b ="+g)  
        case CaseClass2(f)=>println("a = "+f)  
        case CaseObject=>println("No Argument")  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
a = 10 b =10
a = 10
No Argument

Scala构造函数

在scala中，构造函数不是特殊的方法。Scala提供主要和任意数量的辅助构造函数。我们将在下面的例子中逐一个详细解释。

Scala默认主构造函数

在scala中，如果不指定主构造函数，编译器将创建一个主构造函数的构造函数。所有类的主体的声明都被视为构造函数的一部分。它也被称为默认构造函数。Scala默认主构造函数示例

class Student{  
    println("Hello from default constructor");  
}

Scala主要构造函数

Scala提供了一个类的主构造函数的概念。如果代码只有一个构造函数，则可以不需要定义明确的构造函数。它有助于优化代码，可以创建具有零个或多个参数的主构造函数。Scala主构造函数示例

class Student(id:Int, name:String){  
    def showDetails(){  
        println(id+" "+name);  
    }  
}  

object Demo{  
    def main(args:Array[String]){  
        var s = new Student(1010,"Maxsu");  
        s.showDetails()  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
1010 Maxsu

Scala次要(辅助)构造器

可以在类中创建任意数量的辅助构造函数，必须要从辅助构造函数内部调用主构造函数。this关键字用于从其他构造函数调用构造函数。当调用其他构造函数时，要将其放在构造函数中的第一行。Scala二次构造函数示例

class Student(id:Int, name:String){  
    var age:Int = 0  
    def showDetails(){  
        println(id+" "+name+" "+age)  
    }  
    def this(id:Int, name:String,age:Int){  
        this(id,name)       // Calling primary constructor, and it is first line  
        this.age = age  
    }  
}  

object Demo{  
    def main(args:Array[String]){  
        var s = new Student(1010,"Maxsu", 25);  
        s.showDetails()  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
1010 Maxsu 25

Scala示例：构造器重载

在scala中，可以重载构造函数。下面我们来看一个例子。

class Student(id:Int){  
    def this(id:Int, name:String)={  
        this(id)  
        println(id+" "+name)  
    }  
    println(id)  
}  

object Demo{  
    def main(args:Array[String]){  
        new Student(101)  
        new Student(100,"Minsu")  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
101
100
100 Minsu

Scala方法重载

Scala提供了方法重载功能，使我们能够定义相同名称但使用不同参数或数据类型的方法。它有助于优化代码。Scala方法通过使用不同的参数重载示例在下面的例子中，定义了两个具有不同数量的参数但具有相同数据类型的add方法。

class Arithmetic{  
    def add(a:Int, b:Int){  
        var sum = a+b  
        println(sum)  
    }  
    def add(a:Int, b:Int, c:Int){  
        var sum = a+b+c  
        println(sum)  
    }  
}  

object Demo{  
    def main(args:Array[String]){  
        var a  = new Arithmetic();  
        a.add(10,20);  
        a.add(10,20,30);  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
30
60

Scala通过使用不同的数据类型方法重载示例在下面的例子中，创建了一个使用两个相同数量的参数但是不同的数据类型的add方法。

class Arithmetic{  
    def add(a:Int, b:Int){  
        var sum = a+b  
        println(sum)  
    }  
    def add(a:Double, b:Double){  
        var sum = a+b  
        println(sum)  
    }  
}  
object Demo{  
    def main(args:Array[String]){  
        var b = new Arithmetic()  
        b.add(10,20)  
        b.add(10.0,20.1)  

    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
30
30.1

Scala this关键字

在scala中，this是一个关键字，用于引用当前对象。可以使用this关键字调用实例变量，方法，构造函数。

Scala this示例

在以下示例中，这用于调用实例变量和主要构造方法。

class ThisExample{  
    var id:Int = 0  
    var name: String = ""  
    def this(id:Int, name:String){  
        this()  
        this.id = id  
        this.name = name  
    }  
    def show(){  
        println(id+" "+name)  
    }  
}  

object Demo{  
    def main(args:Array[String]){  
        var t = new ThisExample(1010,"Maxsu")  
        t.show()  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
1010 Maxsu

Scala构造函数使用this关键字调用在下面的例子中，使用this关键字来调用构造函数。它演示了如何从其他构造函数调用构造函数。必须确保this必须放在构造函数中的第一个语句，同时调用其他构造函数，否则编译器会抛出错误。

class Student(name:String){  
    def this(name:String, age:Int){  
        this(name)  
        println(name+" "+age)  
    }      
}  

object Demo{  
    def main(args:Array[String]){  
        var s = new Student("Maxsu",1000)  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
Maxsu 1010

Scala继承

继承是面向对象的概念，用于代码的可重用性。可以通过使用extends关键字来实现继承。为了实现继承，一个类必须扩展到其他类，被扩展类称为超类或父类。扩展的类称为派生类或子类。示例

class SubClassName extends SuperClassName(){  
    /* Write your code  
     *  methods and fields etc. 
     */  
 }

继承的简单例子

Scala单继承示例

class Employee{  
    var salary:Float = 11100  
}  

class Programmer extends Employee{  
    var bonus:Int = 5100  
    println("Salary = "+salary)  
    println("Bonus = "+bonus)  
}  

object Demo{  
    def main(args:Array[String]){  
        new Programmer()  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
Salary = 11100.0
Bonus = 5100

Scala继承类型

Scala支持各种类型的继承，包括单一，多层次，多重和混合。可以在类中使用单一，多层次和层次结构。多重和混合只能通过使用特征来实现。在这里，通过使用图形表示所有类型的继承。

class A{  
    var salary1 = 10000  
}  

class B extends A{  
    var salary2 = 20000  
}  

class C extends B{  
    def show(){  
        println("salary1 = "+salary1)  
        println("salary2 = "+salary2)  
    }  
}  

object Demo{  
    def main(args:Array[String]){
        var c = new C()  
        c.show()  

    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
salary1 = 10000
salary2 = 20000

Scala方法覆盖

class SubClassName extends SuperClassName(){  
    /* Write your code  
     *  methods and fields etc. 
     */  
 }

继承的简单例子

Scala单继承示例

class Employee{  
    var salary:Float = 11100  
}  

class Programmer extends Employee{  
    var bonus:Int = 5100  
    println("Salary = "+salary)  
    println("Bonus = "+bonus)  
}  

object Demo{  
    def main(args:Array[String]){  
        new Programmer()  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
Salary = 11100.0
Bonus = 5100

Scala继承类型

class A{  
    var salary1 = 10000  
}  

class B extends A{  
    var salary2 = 20000  
}  

class C extends B{  
    def show(){  
        println("salary1 = "+salary1)  
        println("salary2 = "+salary2)  
    }  
}  

object Demo{  
    def main(args:Array[String]){
        var c = new C()  
        c.show()  

    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
D:\software\scala-2.12.3\bin>scala Demo
salary1 = 10000
salary2 = 20000

Scala final关键字

final是一个关键字，用于防止超类成员继承为派生类。也可以声明final变量，方法和类。

Scala final变量示例

不能覆盖子类中的final变量，我们来看下面一个例子。Scala单继承示例

class Vehicle{  
     final val speed:Int = 60  
}  
class Bike extends Vehicle{  
   override val speed:Int = 100  
    def show(){  
        println(speed)  
    }  
}  

object Demo{  
    def main(args:Array[String]){  
        var b = new Bike()  
        b.show()  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
Demo.scala:5: error: overriding value speed in class Vehicle of type Int;
 value speed cannot override final member
   override val speed:Int = 100
                ^
one error found

Scala final方法

在父类中的final方法声明不能被覆盖。如果不想让它被覆盖，则可以把方法定义成为final。尝试覆盖final方法将导致编译时错误。Scala final方法示例

class Vehicle{  
     final def show(){  
         println("vehicle is running")  
     }  
}  
class Bike extends Vehicle{  
   //override val speed:Int = 100  
    override def show(){  
        println("bike is running")  
    }  
}  
object Demo{  
    def main(args:Array[String]){  
        var b = new Bike()  
        b.show()  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
Demo.scala:8: error: overriding method show in class Vehicle of type ()Unit;
 method show cannot override final member
    override def show(){
                 ^
one error found

Scala final类示例也可以定义final类，final类不能继承。如果定义了一个类为final类，那就不能进一步扩展了。

final class Vehicle{  
     def show(){  
         println("vehicle is running")  
     }  

}  

class Bike extends Vehicle{  
       override def show(){  
        println("bike is running")  
    }  
}  

object Demo{  
    def main(args:Array[String]){  
        var b = new Bike()  
        b.show()  
    }  
}

将上面代码保存到源文件：Demo.scala中，使用以下命令编译并执行代码 -

D:\software\scala-2.12.3\bin>scalac Demo.scala
Demo.scala:8: error: illegal inheritance from final class Vehicle
class Bike extends Vehicle{
                   ^
one error found

posted @ 2017-10-25 14:54 信方阅读(1445) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

信方互联网硬汉

行走互联，硬汉信方

Spark记录-Scala类和对象

类基础

扩展类

隐性类

单例对象

Scala单例和伴生对象

Scala伴生对象

公告