Scala入门笔记三

Scala是一种纯粹的面向对象语言,面向对象语言有两个重要的概念:类和对象。

Scala类

其中，类是对象的抽象，也可以把类理解为模板，对象才是真正的实体。一般定义类的格式如下所示。类名命名习惯和其他语言一样，不赘述。定义类的格式如下：
Class className(参数列表) extends t { }
与Java等语言不同的是，Scala的类不声明为public，一个Scala类中可以有多个源文件，并且Scala类可以有参数。
下面是示例：

package ScalaTest
//定义一个类来计算二维坐标移动后的坐标
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 + dx
    println("x的坐标点为：" + x)
    println("y的坐标点为：" + y)
  }
}

package ScalaTest

object PointTest {
  def main(args: Array[String]): Unit = {
    new Point(1,2).move(2,3)
  }
}

运行main函数，结果如下：

package ScalaTest
//类继承示例
//Scala只允许继承一个父类，并且继承父类的所有属性和方法。
class Location(val xc:Int,val yc:Int,val zc:Int) extends Point(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)
  }
}

子类继承（用Java里的话叫重写吧）父类中已经实现的方法需要使用关键字"override"，子类继承父类中未实现的方法则不需要。这里为了偷懒，便不写示例。

Scala对象

Scala中没有static关键字，因此Scala的类中不存在静态成员。但是Scala可以使用“object”关键字实现单例模式。
Scala中使用单例模式时需要使用object定义一一个单例对象( object对象),单例对象在整个程序中有且只有一个实例。object对象与类的区别在于object对象不能带参数。定义单例对象的语法如下所示。
Object objectName {…}
包含main方法的object对象可以作为程序的入口点（这也是入门笔记一中运行程序的方式）。另外，当单例对象与某个类共同一个名称时，单例对象被称作是这个类的伴生对象，类被称为是这个单例对象的伴生类。类和它的伴生对象可以互相访问其私有成员。需要注意的是，必须在同一个源文件里定义类和它的伴生对象。下面是示例：

package ScalaTest

class Person private(val name:String){
  private def getSkill()=name + "'s skill is:" + Person.skill
}
object Person{
  private val skill = "programming"
  private val person = new Person("Tom")
  def printSkill = println(person.getSkill())
  def main(args:Array[String]):Unit={
    Person.printSkill
  }

Scala类与继承练习：

package ScalaTest

class Person(){
  var name:String=""
  var sex:String=""
  var age:Int=0

  def setName(name:String): Unit ={this.name = name}
  def setSex(sex:String): Unit ={this.sex = sex}
  def setAge(age:Int): Unit ={this.age = age}
  def getName():String=name
  def getSex():String=sex
  def getAge():Int=age
  def print(): Unit ={println("name:"+this.getName()+",sex:"+this.getSex()+",age:"+this.getAge())}
}

class Student() extends Person(){
  var school:String=""
  var studentID:Int=0
  
  def setSchool(school:String): Unit ={this.school = school}
  def setStudentID(studentID:Int): Unit ={this.studentID = studentID}
  def getSchool: String =school
  def getStudentID: Int =studentID
  override def print(): Unit = {println("Name:"+this.getName()+",sex:"+this.getSex()+",age:"+this.getAge()+",school:"+school+",studengtID:"+studentID+".")}
}

object Test{
  def main(args: Array[String]): Unit = {
    var student = new Student()
    student.setName("Tom Cat")
    student.setSex("男")
    student.setAge(4)
    student.setSchool("加里顿大学")
    student.setStudentID(20200310)
    student.print()
  }
}

输出

总结

哇，学到这里，我的脑子里一团麻。
在Java中类是对象的抽象，对象是类的具体存在。而在Scala中Class和Object有Java中的Class的概念，而二者却又有不同。
Scala的Class可以带参数，没有public和static，但有private，有继承的概念。
Scala的Object不能带参数，包含main方法的object对象是程序的入口点。二者已知（就我而言）的区别在于object对象不能带参数。