类和对象（十五）
类
简介
类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。
Scala中的类不声明为public，一个Scala源文件中可以有多个类。
简单实例
import java.io._
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 ("x 的坐标点: " + x);
println ("y 的坐标点: " + y);
}
}
object Test {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// 移到一个新的位置
pt.move(10, 10);
}
}抽象类
抽象类是一种不能被实例化的类，抽象类中包括了若干不能完整定义的方法，这些方法由子类去扩展定义自己的实现。
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 只允许继承一个父类。
简单实例
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 ("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 = zc
override 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中，是没有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=0
def 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)
}
}忠于技术，热爱分享。欢迎关注公众号：java大数据编程，了解更多技术内容。
