大数据系列修炼-Scala课程05

• Scala多重继承、构造器的执行顺序、AOP实现

  • 多重继承的trait实现：Scala中接口可以继承具体的类，trait接口可以实现多重继承，并且某个类也可以继承特定的类，在继承后面可以混入，接口的实现
  • 多重继承构造器执行顺序：多重继承构造器执行顺序是从左到右按次序执行，如果前面类以及被继承实现了，后面的类就没有必要去实现，父类只需执行一次

object triatScala {
  def main(args: Array[String]): Unit = {
   val t1 = new PianoTeacher 
   t1.playPiano  
   t1.teach
  }
  
}
//公共父类
class Human{
  println("Human")
}
//继承父类的接口
trait TTeacher extends Human {  
  println("TTeacher")
  def teach 
}
//继承父类的接口，并且拥有自己的方法
trait PianoPlayer extends Human {  
  println("PianoPlayer")
  def playPiano = {println("I’m playing piano. ")} 
}  
//继承父类的类并且混入两个接口实现接口中的方法 实现顺序是按照从左到右
class PianoTeacher extends Human with TTeacher with PianoPlayer {  
  override def teach = {println("I’m training students. ")} 
}

• • 基于trait的AOP代码实现：接口被另外一个接口继承并且在实现父类方法的时候也调用父类中抽象方法，在另外一类中是具体实现该公共接口的方法，这样就可以实现AOP(面向切面编程)

  • //AOP 面向切面编程
    trait Action {  
      def doAction  
    }
    trait TBeforeAfter extends Action {
      //使用抽象方法覆盖父类的接口实现中需要制定父类的方法，这个方法在具体的类中实现
      abstract override def doAction {  
        println("Initialization") 
        super.doAction 
        println("Destroyed") 
      }  
    }
    class Work extends Action{
      //具体实现父类方法
     override def doAction = println("Working...")
    }
    
    object triatScala {
      def main(args: Array[String]): Unit = {
       val work = new Work with TBeforeAfter
       work.doAction
      }
    }

• 包的定义以及包对象、包引用、包的隐式引用实现

  • 包定义：Scala中包的定义是可以在一个公共的包下面创建多个包，需要某个包里的类的实例对象，就可以new这个包下面的对象，包也带上
  • 包对象实现：包对象里面的方法和属性，在其他的包中可以访问他们
  • 包的引用实现:引用某个包中相关类用import后面用{}包括所引用的对象，也可以用java中的包=>用来换用别名,而_表示下面所有包

  • package com.scala.spark  
    package object people {  
      val defaultName = "Scala"  
    }  
    
    package people {  
    class people {  
      var name = defaultName 
    }  
    } 
    
    import java.awt.{Color,Font}
    import java.util.{HashMap=>JavaHashMap}
    import scala.{StringBuilder => _}

     

  • 包隐式引用实现：Scala中有几个隐式包例如java.lang._,scala._,predef_这三个包，好比java中几个公共包一样，也是拥有很多工具方法。

• 关于Scala中包、类、对象、成员、伴生类、伴生对象的访问权限

  • 包、类、对象、成员的访问权限：private[包名]表示该方法、包、类、对象、成员访问权限扩展到该包下面
  • 伴生类、伴生对象访问权限：伴生对象与伴生类可以相互访问

  • package spark{
      package navigation{
        //private[spark]表示该类在spark包下有访问权限
        private[spark] class Navigator{
          //protected[navigation]表示该方法在navigation包下有访问权限
          protected[navigation] def useStarChart() {}
          class LegOfJourney {
            //private[Navigator]表示该常量在navigation包下有访问权限
            private[Navigator] val distance =100
          }
          //private[this]表示该常量在navigation包下有访问权限
          private[this] var speed = 200
        }
      }
      package launch{
        import navigation._
        object Vehicle {
          //private[launch]表示该常量在launch该同级的包可以实例化
          private[launch] val guide = new Navigator
        }
      }
    }

     

• Scala中文件的读写、控制台输入操作

  • 文件的读写实现：文件的读取用source对象中的fromFile方法读取文本中数据也可用fromURL按照url进行读取，而写入用PrintWriter来实现
  • 控制台操作实现：Console.readLine来实现控制台操作，console这在Scala的隐式包中，可以直接使用

　　今天就学到这儿.....

     百度视频地址:http://pan.baidu.com/s/1ntzOmDz

原文：http://www.cnblogs.com/524646016-zhang/p/zhangsh_dt_scala_05.html