每个面向对象语言都有基本的特征就是多态,但是实际过程中多态用的不是特别的多(自己的低级经历)。

但是在某种特定情况下的多态和动态绑定实际上能够有事半功倍的效果,但是简单的示例是表现不出这种强大的功能。

java的很多包中多态用的实际上比较多(个人感觉)。

 

scala的多态和动态绑定和java没有太大的区别,只是写了个简单的例子,以后需要深入研究再深入的去理解和实现。

 

代码示例



package main.scala.PolymorphicTestPackage

/**
  * Created by postbird on 2016/9/13.
  */
//如果此处不加 var  则不能进行后面的 p.name的访问
abstract class Person(var name:String,var age:Int){
    def walk():Unit
    def talkTo(p:Person):Unit
    //参数是Person的对象
}

class Student(name:String,age:Int) extends Person(name,age){
    val studentNo:Int = 0

    override def walk()={
        println("Student walking....")
    }
    //我个人习惯使用override声明重写的方法,即使可以不用 因为Person是abstract
    override def talkTo(p:Person): Unit ={
        println("Student's talkTo().....")
        println(this.name +" is talking to "+ p.name)
    }
}

class Teacher(name:String,age:Int) extends Person(name,age){
    val teacherNo:Int=0

    override def walk()={
        println("Teacher walking....")
    }

    override def talkTo(p:Person)={
        println("Teacher's talkTo()....")
        println(this.name +" is talking to "+ p.name)
    }
}

object PolymorphicTest {
    def main(args: Array[String]) {

        //多态
        val p1:Person=new Student("postbird",21)
        val p2:Person=new Teacher("ptbird",21)
        //声明 p1 p2 都是 Person类型 但是new对象的时候都是Student 或者是 Teacher
        p1.walk()
        p2.walk()
//        Student walking....
//        Teacher walking....
        //调用p1 和 p2的walk方法的时候,调用的都是各自子类的方法,此时子类对象重写的方法会覆盖父类。
        //从而实现多态

        p1.talkTo(p2)
//        Student's talkTo().....
//        postbird is talking to ptbird
        p2.talkTo(p1)
//        Teacher's talkTo()....
//        ptbird is talking to postbird

        //talkTo方法参数类型为Person类型
        //p1.talkTo(p2)传入的实际类型是Student
        //p2.talkTo(p1)传入的实际类型是Teacher
        //实现动态绑定

    }
}