类和对象（十五）

版权声明：菲立思教育 https://blog.csdn.net/cold_wolfie/article/details/82555593

类

简介

  类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

  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大数据编程，了解更多技术内容。