Scala类
简介
类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。
Scala中的类不声明为public，一个Scala源文件中可以有多个类。
Scala简单实例
class Point(xc: Int, yc: Int) { var x: Int = xc var y: Int = ycdef move(dx: Int, dy: Int) { x = x + dx y = y + dy println ("x 的坐标点: " + x); println ("y 的坐标点: " + y); } }
object Test { def main(args: Array[String]) { val pt = new Point(10, 20);// 移到一个新的位置
pt.move(10, 10);
} } ```
Scala抽象类
抽象类是一种不能被实例化的类，抽象类中包括了若干不能完整定义的方法，这些方法由子类去扩展定义自己的实现。
```abstract class Animal { //抽象字段(域） //前面我们提到，一般类中定义字段的话必须初始化，而抽象类中则没有这要求 var height:Int //抽象方法 def eat:Unit }
//Person继承Animal，对eat方法进行了实现 //通过主构造器对height参数进行了初始化 class Person(var height:Int) extends Animal{ //对父类中的方法进行实现，注意这里面可以不加override关键字 def eat()={ println("eat by mouth") }
}
//通过扩展App创建程序的入口 //App其实是一种trait，它帮助我们定义了main方法。 object Person extends App{ new Person(10).eat() } ```继承
简介
重写一个非抽象方法必须使用override修饰符。
重写超类的抽象方法时，不需要使用override关键字。
只有主构造函数才可以往基类的构造函数里写参数。
继承会继承父类的所有属性和方法，Scala 只允许继承一个父类。
Scala简单实例
```class Point(xc: Int, yc: Int) { var x: Int = xc var y: Int = ycdef move(dx: Int, dy: Int) { x = x + dx y = y + dy println ("x 的坐标点: " + x) println ("y 的坐标点: " + y) } }
class Location(override val xc: Int, override val yc: Int, val zc :Int) extends Point(xc, yc){ var z: Int = zcoverride def move(dx: Int, dy: Int) { x = x - dx y = y - dy println ("x 的坐标点: " + x) println ("y 的坐标点: " + y) }
def move(dx: Int, dy: Int, dz: Int) { x = x + dx y = y + dy z = z + dz println ("x 的坐标点 : " + x) println ("y 的坐标点 : " + y) println ("z 的坐标点 : " + z) } }
object Test { def main(args: Array[String]) { val loc = new Location(10, 20, 15);// 移到一个新的位置
loc.move(10, 10);
loc.move(10, 10, 5);
} } ```
Scala单例对象
简介
在Scala中，是没有static的，但是提供了单例模式的实现方法，那就是使用关键字object。
Scala中使用单例模式时，除了定义的类之外，还要定义一个同名的 object对象，它和类的区别是，object对象不能带参数。
简单实例
object Student { private var studentNo:Int=0; def uniqueStudentNo()={ studentNo+=1 studentNo } def main(args: Array[String]): Unit = { println(Student.uniqueStudentNo()) } }
伴生类与伴生对象
简介
当单例对象与某个类是同一个名称时，单例对象被称作是这个类的伴生对象，类被称为是这个单例对象的伴生类。必须在同一个源文件里定义伴生类和伴生对象。它们可以互相访问其私有成员。
简单实例
```class Student(var name:String,var age:Int){ private var sex:Int=0 //直接访问伴生对象的私有成员 def printCompanionObject()=println(Student.studentNo) }
object Student { private var studentNo:Int=0; def uniqueStudentNo()={ studentNo+=1 studentNo } def main(args: Array[String]): Unit = { println(Student.uniqueStudentNo()) val s=new Student("john",29) //直接访问伴生类Student中的私有成员 println(s.sex) } } ```匿名类
当某个类在程序中只使用一次时，可以将类定义为匿名类。
```//抽象的Person类 abstract class Person(name:String,age:Int){ def walk():Unit }
object demo{ def main(args: Array[String]): Unit = { //下面的代码定义了一个匿名类，并且进行了实例化 //直接new Person("john",18)，后面跟的是类的内容 //我们知道，Person是一个抽象类，它是不能被实例化的 //这里能够直接new操作是因为我们扩展了Person类，只不 //过这个类是匿名的，只能使用一次而已 val s=new Person("john",18){ override def walk()={ println("Walk like a normal Person") } } s.walk() } } ```
多态与动态绑定
简介
多态(Polymorphic)也叫动态绑定(Dynamic Binding)、迟绑定(Late Binding)，指在执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际类型调用其相应的方法。子类的引用可以赋给父类。
简单实例
```//抽象Person类 abstract class Person(var name:String,var age:Int){def walk():Unit //talkTo方法，参数为Person类型 def talkTo(p:Person):Unit }
class Student(name:String,age:Int) extends Person(name,age){ private var studentNo:Int=0 def walk()=println("walk like a elegant swan") //重写父类的talkTo方法 def talkTo(p:Person)={ println("talkTo() method in Student") println(this.name+" is talking to "+p.name) } }
class Teacher(name:String,age:Int) extends Person(name,age){ private var teacherNo:Int=0def walk()=println("walk like a elegant swan")//重写父类的talkTo方法 def talkTo(p:Person)={ println("talkTo() method in Teacher") println(this.name+" is talking to "+p.name) } }
object demo{ def main(args: Array[String]): Unit = {//下面的两行代码演示了多态的使用
//Person类的引用可以指向Person类的任何子类
val p1:Person=new Teacher("albert",38)
val p2:Person=new Student("john",38)
//下面的两行代码演示了动态绑定
//talkTo方法参数类型为Person类型
//p1.talkTo(p2)传入的实际类型是Student
//p2.talkTo(p1)传入的实际类型是Teacher
//程序会根据实际类型调用对应的不同子类中的talkTo()方法p1.talkTo(p2)
p2.talkTo(p1)
} } ```
文章来自：https://www.itjmd.com/news/show-3240.html