大数据知识:快学Scala(一)Scala的类、对象和继承。

简介

    上一章，我们知道了Scala中的方法、函数以及这里面的Scala，方法我们使用关键字def定义，我们可以使用下划线来将方法转化为函数，函数可以作为参数传递到方法中；在Scala中的数据结构中，有常用的Array、List、Set、Map和Tuple，当然这里的数据结构分为可变的和不可变的。如果对于这些不清楚的，可以看到上一章大数据知识:快学Scala(一)Scala的函数、方法和数据结构。这一章，将会介绍面向对象的相关性质。

Scala中的类

类

    Scala的声明中，不用使用public来修饰类。使用val修饰变量，编译出来的是一个final修饰变量；对于特殊的下划线，我们在上一次使用中，我们使用下划线将方法转化为函数；对于类的变量或者类，可以使用[]中来指定他们的访问权限范围。

package cn.edu.hust

import scala.io.Source

//这里指明这个类的使用范围只能在hust包及其子包中被访问，后面的private私有化构造器
private[hust] class Person private {
    //编译出来是一个final修饰的变量
    val id="5927"
    //可以改变
    var name:String="华安"
    //定义一个年龄，这里使用private来修饰，只能在伴生对像中被访问
    private var age:Int=19
    //可以使用下划线对于变量不初始化
    private var Class:String=_
    //只能在本类中被使用，伴生对象也不能被使用
    private[this] val province:String="湖北"
    //给外界提供访问这个变量的接口
    def getProvince:String={
      province
    }
    //在创建对象的时候，需要执行类里面的代码，这里执行伴生对象的对象
    println(Person.word)
    //读取文件后进行打印文件内容，只要使用构造器将会执行代码
    try {
      val content=Source.fromFile("/Users/youyujie/Downloads/word.txt").toString()
      println(content)
    } catch {
      case e:Exception => e.printStackTrace()
    } finally {
      println("finally")
    }
}
//这里主构造器将会和类在一起，可以给默认的值，，对于val的默认值，可以在构造器中修改
class Student(private val name:String,private var age:Int,val id:String,val Class:String="01")
{


  //添加辅助的构造器,辅助构造器一定要先调用主构造器
  //def this()
  //{
    //this(name,age,id,Class)
  //}
}
//person的绊生对象,这是一个单例对象，可以和Person类共享变量，里面的方法和变量全部都是static
object Person
{
  //如果使用Person()获取，将会执行apply方法，如果有多个参数将会对应具体的apply方法
  def apply(): Unit =
  {
    println("执行apply方法")
  }
  val word:String="hello,scala"
  def main(args: Array[String]): Unit = {
    val list1=List(1,2,3,4)
    val list2=List(3,4,5,6)
    //计算两个list的并集
    println(list1.union(list2))
    //计算两个list的交集
    println(list1.intersect(list2))
    //计算两个list的差集
    println(list1.diff(list2))
    //使用并行的计算和值
    println(list1.par.reduce(_+_))
    val p=new Person
    println(p.id+":"+p.name)
    //不允许改变
    //p.id="sdfas"
    //改变名字
    p.name="唐伯虎"
    println(p.id+":"+p.name)
    //改变年龄
    p.age=22
    println(p.age)
    println(p.getProvince)

    val t=Person()
    val s=new Student("liming",18,"1")
    println(s.id)
    println(s.Class)

  }
}

    对于构造器，Scala的主构造器是和类的声明在一起的，例如上述代码中的Student类，主构造器是Student后面声明；和Java中一样，可以定义多个构造器，不过在scala中，其他构造器，里面必须又主构造器；

伴生对象

    在Scala中，又一个特殊的对象，使用object来声明，上述代码中，类Person的伴生对象是Person，伴生对象和类同名；伴生对象，是一个单例对象，可以和类共享变量，在伴生对象中，变量和方法都是static修饰的；伴生对象有一个特殊的方法apply；在数据结构的使用中，我们也使用过，例如我们使用这样的代码val lists=List(1，2，3，4，5，6，7),这样的代码就是使用了伴生对象。

单例对象

     在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的

        1.存放工具方法和常量

        2.高效共享单个不可变的实例

        3.单例模式

package cn.edu.hust.scala

import scala.collection.mutable.ArrayBuffer

object SingletonDemo {
  def main(args: Array[String]) {
    //单例对象，不需要new，用【类名.方法】调用对象中的方法
    val session = SessionFactory.getSession()
    println(session)
  }
}

object SessionFactory{
  //该部分相当于java中的静态块
  var counts = 5
  val sessions = new ArrayBuffer[Session]()
  while(counts > 0){
    sessions += new Session
    counts -= 1
  }

  //在object中的方法相当于java中的静态方法
  def getSession(): Session ={
    sessions.remove(0)
  }
}

class Session{

}

继承

trait关键字

    trait关键字相当于Java中的结构，在Java8中的，可以指定默认的方法；Scala中的trait关键字也可以指定方法的实现。

package cn.edu.hust.`extends`
//相当于java8的接口
trait Animal {
  def run()
  def eat():Unit=
  {
    println("eat something")
  }
}

abstract关键字

    Scala也有Java中的Abstract的修饰，这里和Java中的差不多。

package cn.edu.hust.`extends`

abstract class Human {
  def say()
}

重写

    在Scala中，一样的使用extends和with进行多继承。

package cn.edu.hust.`extends`
//可以继承多个类和接口.对于基类实现的方法一定要使用override关键字
class Chinese extends Human with Animal{
  override def run(): Unit = {
      println("Chinese run...")
  }

  override def say(): Unit ={
    println("Say Chinese")
  }
}
//对于object可以集成App主要用来测试
object Chinese extends App{
  val c=new Chinese()
  c.run()
  c.say()
  c.eat()
}