Scala类
简介 类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,占用存储空间。类是用于创建对象的蓝图,它是一个定义包括在特定类型的对象中的方法和变量的软件模板。 Scala中的类不声明为public,一个Scala源文件中可以有多个类。 Scala简单实例``` import java.io._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) } } ```