tar -zxvf scala-2.11.8.tgz -C /usr/java

vi /etc/profile
export JAVA_HOME=/usr/java/jdk1.8
export PATH=$PATH:$JAVA_HOME/bin:/usr/java/scala-2.11.8/bin

package cn.itcast.scala
  object VariableDemo {
  def main(args: Array[String]) {
    //使用val定义的变量值是不可变的，相当于java里用final修饰的变量
    val i = 1
    //使用var定义的变量是可变得，在Scala中鼓励使用val
    var s = "hello"
    //Scala编译器会自动推断变量的类型，必要的时候可以指定类型
    //变量名在前，类型在后
    val str: String = "hello"
  }
}

package cn.itcast.scala
  object ConditionDemo {
  def main(args: Array[String]) {
    val x = 1
 
    //判断x的值，将结果赋给y
    val y = if (x > 0) 1 else -1
 
    //打印y的值
    println(y)
 
    //支持混合类型表达式
    val z = if (x > 1) 1 else "error"
 
    //打印z的值
    println(z)
    //如果缺失else，相当于if (x > 2) 1 else ()
    val m = if (x > 2) 1
    println(m)
    //在scala中每个表达式都有值，scala中有个Unit类，用作不返回任何结果的方法的结果类型,相当于Java中的void，Unit只有一个实例值，写成()。
    val n = if (x > 2) 1 else ()
    println(n)
  
    //if和else if
    val k = if (x < 0) 0
    else if (x >= 1) 1 else -1
    println(k)
  }
}

package cn.itcast.scala
  
  object BlockExpressionDemo {
  def main(args: Array[String]) {
    val a = 10
    val b = 20
 
    //在scala中{}中包含一系列表达式，块中最后一个表达式的值就是块的值
    //下面就是一个块表达式
    val result = {
    val c=b-a
    val d=b-c
    d   //块中最后一个表达式的值
}
 //result的值就是块表达式的结果
  println(result)
}
}

package cn.itcast.scala
  object ForDemo {
  def main(args: Array[String]) {
    //for(i <- 表达式),表达式1 to 10返回一个Range（区间）
    //每次循环将区间中的一个值赋给i
   for (i <- 1 to 10)
      println(i)
    //for(i <- 数组)
    val arr = Array("a", "b", "c")
    for (i <- arr)
      println(i)
  
    //高级for循环
    //每个生成器都可以带一个条件，注意：if前面没有分号
    for(i <- 1 to 3; j <- 1 to 3 if i != j)
     print((10 * i + j) + " ")
    println()
  
    //for推导式：如果for循环的循环体以yield开始，则该循环会构建出一个集合
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10) yield i * 10
    println(v)  
  }
}

package cn.itcast.scala
  
  object MethodAndFunctionDemo {
  //定义一个方法
  //方法m2参数要求是一个函数，函数的参数必须是两个Int类型
  //返回值类型也是Int类型
  def m1(f: (Int, Int) => Int) : Int = {
    f(2, 6)
  }
  
  //定义一个函数f1，参数是两个Int类型，返回值是一个Int类型
  val f1 = (x: Int, y: Int) => x + y
  //再定义一个函数f2
  val f2 = (m: Int, n: Int) => m * n
  
  //main方法
  def main(args: Array[String]) { 
    //调用m1方法，并传入f1函数
    val r1 = m1(f1)
   println(r1)
  
    //调用m1方法，并传入f2函数
    val r2 = m1(f2)
    println(r2)
  }
}
 

  package cn.itcast.scala
  import scala.collection.mutable.ArrayBuffer
  object ArrayDemo {
  def main(args: Array[String]) { 
    //初始化一个长度为8的定长数组，其所有元素均为0
    val arr1 = new Array[Int](8)
    //直接打印定长数组，内容为数组的hashcode值
    println(arr1)
    //将数组转换成数组缓冲，就可以看到原数组中的内容了
    //toBuffer会将数组转换长数组缓冲
    println(arr1.toBuffer)
  
    //注意：如果new，相当于调用了数组的apply方法，直接为数组赋值
    //初始化一个长度为1的定长数组
    val arr2 = Array[Int](10)
    println(arr2.toBuffer)
  
    //定义一个长度为3的定长数组
    val arr3 = Array("hadoop", "storm", "spark")
    //使用()来访问元素
    println(arr3(2))
    //变长数组（数组缓冲）
    //如果想使用数组缓冲，需要导入import scala.collection.mutable.ArrayBuffer包
    val ab = ArrayBuffer[Int]()
    //向数组缓冲的尾部追加一个元素
    //+=尾部追加元素
    ab += 1
 
    //追加多个元素
    ab += (2, 3, 4, 5)
    //追加一个数组++=
    ab ++= Array(6, 7)
    //追加一个数组缓冲
    ab ++= ArrayBuffer(8,9)
    //打印数组缓冲ab 
    //在数组某个位置插入元素用insert，从某下标插入
    ab.insert(0, -1, 0)
    //删除数组某个位置的元素用remove  按照下标删除
    ab.remove(0)
    ab -=3
    ab --=Array(1,2)
    println(ab)  
  }
}

package cn.itcast.scala
  object ForArrayDemo {
  def main(args: Array[String]) {
    //初始化一个数组
    val arr = Array(1,2,3,4,5,6,7,8)
    //增强for循环
    for(i <- arr)
      println(i)  
    //好用的until会生成一个Range
    //reverse是将前面生成的Range反转
    for(i <- (0 until arr.length).reverse)
      println(arr(i))
  }
}

package cn.itcast.scala  
  object ArrayYieldDemo {
  def main(args: Array[String]) {
    //定义一个数组
    val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9)
    //将偶数取出乘以10后再生成一个新的数组
    val res = for (e <- arr if e % 2 == 0) yield e * 10
    println(res.toBuffer)
  
    //更高级的写法,用着更爽
    //filter是过滤，接收一个返回值为boolean的函数
    //map相当于将数组中的每一个元素取出来，应用传进去的函数
    val r = arr.filter(_ % 2 == 0).map(_ * 10)
    println(r.toBuffer)  
  }
}

package cn.itcast.collect
/**
 * 不可变List集合操作
 */
object ImmutListDemo {
  def main(args: Array[String]) {
    //创建一个不可变的集合
    val lst1 = List(1,2,3)
    //补充：另一种定义list方法
    val other_lst=2::Nil
    //获取集合的第一个元素
    val first=lst1.head
    //获取集合中除第一个元素外的其他元素集合,
    val tail=lst1.tail
    //补充：其中如果 List 中只有一个元素，那么它的 head 就是这个元素，它的 tail 就是 Nil；
    println(other_lst.head+"----"+other_lst.tail)
    //将0插入到lst1的前面生成一个新的List
    val lst2 = 0 :: lst1
    val lst3 = lst1.::(0)
    val lst4 = 0 +: lst1
    val lst5 = lst1.+:(0)
   
//将一个元素添加到lst1的后面产生一个新的集合
    val lst6 = lst1 :+ 3
    val lst0 = List(4,5,6)  
    //将2个list合并成一个新的List
    val lst7 = lst1 ++ lst0
    //将lst0插入到lst1前面生成一个新的集合
    val lst8 = lst1 ++: lst0
    //将lst0插入到lst1前面生成一个新的集合
    val lst9 = lst1.:::(lst0)
    println(other_lst)
    println(lst1)
    println(first)
    println(tail)
    println(lst2)
    println(lst3)
    println(lst4)
    println(lst5)
    println(lst6)
    println(lst7)
    println(lst8)
    println(lst9)
  }
}

package cn.itcast.collect
import scala.collection.mutable.ListBuffer
object MutListDemo extends App{
  //构建一个可变列表，初始有3个元素1,2,3
  val lst0 = ListBuffer[Int](1,2,3)
  //创建一个空的可变列表
  val lst1 = new ListBuffer[Int]
  //向lst1中追加元素，注意：没有生成新的集合
  lst1 += 4
  lst1.append(5)
  //将lst1中的元素添加到lst0中， 注意：没有生成新的集合
  lst0 ++= lst1
  //将lst0和lst1合并成一个新的ListBuffer 注意：生成了一个集合
  val lst2= lst0 ++ lst1
  //将元素追加到lst0的后面生成一个新的集合
  val lst3 = lst0 :+ 5
 
  //删除元素,注意：没有生成新的集合
  val lst4 = ListBuffer[Int](1,2,3,4,5)
  lst4 -= 5
 
  //删除一个集合列表,生成了一个新的集合
  val lst5=lst4--List(1,2)
  //把可变list 转换成不可变的list 直接加上toList
  val lst6=lst5.toList
  //把可变list 转变数组用toArray
  val lst7=lst5.toArray
  println(lst0)
  println(lst1)
  println(lst2)
  println(lst3)
  println(lst4)
  println(lst5)
  println(lst6)
  println(lst7)
}

//定义一个不可变的Set集合
scala> val set =Set(1,2,3,4,5,6,7)
set: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 4)
 
//元素个数
scala> set.size
res0: Int = 7
 
//取集合最小值
scala> set.min
res1: Int = 1
 
//取集合最大值
scala> set.max
res2: Int = 7
 
//将元素和set1合并生成一个新的set，原有set不变
scala> set + 8
res3: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)
scala> val set1=Set(7,8,9)
set1: scala.collection.immutable.Set[Int] = Set(7, 8, 9)
 
//两个集合的交集
scala> set & set1
res4: scala.collection.immutable.Set[Int] = Set(7)
 
//两个集合的并集
scala> set ++ set1
res5: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)
 
//在第一个set基础上去掉第二个set中存在的元素
scala> set -- set1
res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
 
//返回第一个不同于第二个set的元素集合
scala> set &~ set1
res7: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
//计算符合条件的元素个数
scala> set.count(_ >5)
res8: Int = 2
 
/返回第一个不同于第二个的元素集合
scala> set.diff(set1)
res9: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
/返回第一个不同于第二个的元素集合
scala> set1.diff(set)
res10: scala.collection.immutable.Set[Int] = Set(8, 9)
//取子set(2,5为元素位置, 从0开始，包含头不包含尾)
scala> set.slice(2,5)
res11: scala.collection.immutable.Set[Int] = Set(6, 2, 7)
//迭代所有的子set，取指定的个数组合
scala> set1.subsets(2).foreach(x=>println(x))
Set(7, 8)
Set(7, 9)
Set(8, 9)

//导入包
scala> import scala.collection.mutable
import scala.collection.mutable
//定义一个可变的Set
scala> val set1=new HashSet[Int]()
set1: scala.collection.mutable.HashSet[Int] = Set()
//添加元素
scala> set1 += 1
res1: set1.type = Set(1)
 
//添加元素  add等价于+=
scala> set1.add(2)
res2: Boolean = true
scala> set1
res3: scala.collection.mutable.HashSet[Int] = Set(1, 2)
 
//向集合中添加元素集合
scala> set1 ++=Set(1,4,5)
res5: set1.type = Set(1, 5, 2, 4)
//删除一个元素
scala> set1 -=5
res6: set1.type = Set(1, 2, 4)
 
//删除一个元素
scala> set1.remove(1)
res7: Boolean = true
scala> set1
res8: scala.collection.mutable.HashSet[Int] = Set(2, 4)

定义Map集合
1.val map=Map(键 -> 值 , 键 -> 值...)
2.利用元组构建  val map=Map((键，值), (键，值) , (键，值)....)
展现形式：
val  map = Map(“zhangsan”->30,”lisi”->40)
val  map = Map((“zhangsan”,30),(“lisi”,40))
 
3.操作map集合
获取值： 值=map(键)
原则：通过先获取键，在获取键对应值。
 
4.遍历map集合
scala> val imap=Map("zhangsan" -> 20,"lisi" ->30)
imap: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 20, lisi -> 30)
//方法一：显示所有的key
scala> imap.keys
res0: Iterable[String] = Set(zhangsan, lisi)
//方法二：显示所有的key
scala> imap.keySet
res1: scala.collection.immutable.Set[String] = Set(zhangsan, lisi)
//通过key获取value
scala> imap("lisi")
res2: Int = 30
 
//通过key获取value 有key对应的值则返回，没有就返回默认值0，
scala> imap.getOrElse("zhangsan",0)
res4: Int = 20 
 
//没有对应的key，返回默认0
scala> imap.getOrElse("zhangsan1",0)
res5: Int = 0
 
//由于是不可变map,故不能向其添加、删除、修改键值对

//导包
import scala.collection.mutable
//声明一个可变集合
scala> val user =mutable.HashMap("zhangsan"->50,"lisi" -> 100)
user: scala.collection.mutable.HashMap[String,Int] = Map(lisi -> 100, zhangsan -> 50)
 
//添加键值对
scala> user +=("wangwu" -> 30)
res0: user.type = Map(lisi -> 100, zhangsan -> 50, wangwu -> 30)
 
//添加多个键值对
scala> user += ("zhangsan0" -> 30,"lisi0" -> 20)
res1: user.type = Map(zhangsan0 -> 30, lisi -> 100, zhangsan -> 50, lisi0 -> 20,wangwu -> 30)
 
//方法一：显示所有的key
scala> user.keys
res2: Iterable[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)
 
//方法二：显示所有的key
scala> user.keySet
res3: scala.collection.Set[String] = Set(zhangsan0, lisi, zhangsan, lisi0, wangwu)
 
//通过key获取value
scala> user("zhangsan")
res4: Int = 50
 
//通过key获取value 有key对应的值则返回，没有就返回默认值0，
scala> user.getOrElse("zhangsan",0)
res5: Int = 50
 
//没有对应的key，返回默认0
scala> user.getOrElse("zhangsan1",0)
res6: Int = 0
 
//更新键值对
scala> user("zhangsan") = 55
scala> user("zhangsan")
res8: Int = 55
 
//更新多个键值对
scala> user += ("zhangsan" -> 60, "lisi" -> 50)
res9: user.type = Map(zhangsan0 -> 30, lisi -> 50, zhangsan -> 60, lisi0 -> 20,wangwu -> 30)
 
//删除key
scala> user -=("zhangsan")
res14: user.type = Map(zhangsan0 -> 30, lisi -> 50, lisi0 -> 20, wangwu -> 30)
 
//删除key
scala>user.remove("zhangsan0")
 
//遍历map 方法一：通过key值
scala> for(x<- user.keys) println(x+" -> "+user(x))
lisi -> 50
lisi0 -> 20
wangwu -> 30
 
//遍历map 方法二：模式匹配
scala> for((x,y) <- user) println(x+" -> "+y)
lisi -> 50
lisi0 -> 20
wangwu -> 30
 
//遍历map 方法三：通过foreach
scala>  user.foreach{case (x,y) => println(x+" -> "+y)}
lisi -> 50
lisi0 -> 20
wangwu -> 30

package cn.itcast.class_demo
  
  /**
* 在Scala中，类并不用声明为public类型的。
  * Scala源文件中可以包含多个类，所有这些类都具有共有可见性。
  */
  class Person {
  //用val修饰的变量是可读属性，有getter但没有setter（相当与Java中用final修饰的变量）
  val id="9527"
  
  //用var修饰的变量都既有getter，又有setter
  var age:Int=18
 
  //类私有字段，只能在类的内部使用或者伴生对象中访问
  private var name : String = "唐伯虎"
  
  //类私有字段，访问权限更加严格的，该字段在当前类中被访问
  //在伴生对象里面也不可以访问
  private[this] var pet = "小强"  
  }
  //伴生对象（这个名字和类名相同，叫伴生对象）
  object Person{
  def main(args: Array[String]): Unit = {
    val p=new Person
    //如果是下面的修改，发现下面有红线，说明val类型的不支持重新赋值，但是可以获取到值
    //p.id = "123"
    println(p.id)
    //打印age
    println(p.age)
    //打印name,伴生对象中可以在访问private变量
    println(p.name)
    //由于pet字段用private[this]修饰，伴生对象中访问不到pet变量
    //p.pet(访问不到)  
  }
}

package cn.itcast.class_demo
  
  /**
  *每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起
  */
  class Student(val name:String,var age:Int) {
  //主构造器会执行类定义的所有语句
  println("执行主构造器")
  private  var gender="male"
  def this(name:String,age:Int,gender:String){
    //每个辅助构造器执行必须以主构造器或者其他辅助构造器的调用开始
    this(name,age)
    println("执行辅助构造器")
    this.gender=gender
  }
}
  
  object Student {
  def main(args: Array[String]): Unit = {
    val s1=new Student("zhangsan",20)    
    val s2=new Student("zhangsan",20,"female")
  }
}

package cn.itcast.object_demo
import scala.collection.mutable.ArrayBuffer
class Session{}
object SessionFactory{
  //该部分相当于java中的静态块
   val session=new Session
  //在object中的方法相当于java中的静态方法
  def getSession(): Session ={
    session
  }
}
object SingletonDemo {
  def main(args: Array[String]) {
    //单例对象，不需要new，用【单例对象名称.方法】调用对象中的方法
    val session1 = SessionFactory.getSession()
    println(session1)
    //单例对象，不需要new，用【单例对象名称.变量】调用对象中成员变量
val session2=SessionFactory.session
    println(session2)
  }
}

package cn.itcast.object_demo
//伴生类
class Dog {
  val id = 1
 
  private var name = "itcast"
  def printName(): Unit ={
    //在Dog类中可以访问伴生对象Dog的私有属性
    println(Dog.CONSTANT + name )
  }
}
//伴生对象
object Dog {
  //伴生对象中的私有属性
  private val CONSTANT = "汪汪汪 : "
  def main(args: Array[String]) {
    val p = new Dog
    //访问私有的字段name
    p.name = "123"
    p.printName()
  }
}
//执行结果 汪汪汪 : 123

package cn.itcast.object_demo
/**
 *  Array 类的伴生对象中，就实现了可接收变长参数的 apply 方法，
 * 并通过创建一个 Array 类的实例化对象，实现了伴生对象的构造函数功能
 */
// 指定 T 泛型的数据类型，并使用变长参数 xs 接收传参，返回 Array[T] 数组
// 通过 new 关键字创建 xs.length 长的 Array 数组
// 其实就是调用Array伴生类的 constructor进行 Array对象的初始化
//  def apply[T: ClassTag](xs: T*): Array[T] = {
//    val array = new Array[T](xs.length)
//    var i = 0
//    for (x <- xs.iterator) { array(i) = x; i += 1 }
//    array
//  }
object ApplyDemo {
  def main(args: Array[String]) {
    //调用了Array伴生对象的apply方法
    //def apply(x: Int, xs: Int*): Array[Int]
    //arr1中只有一个元素5
    val arr1 = Array(5)
    //new了一个长度为5的array，数组里面包含5个null
    var arr2 = new Array(5)
    println(arr1.toBuffer)
  }
}

package cn.itcast.object_demo
//1.在object中定义main方法
object Main_Demo1 {
  def main(args: Array[String]) {
    if(args.length > 0){
      println("Hello, " + args(0))
    }else{
      println("Hello World!")
    }
  }
}
//2.使用继承App Trait ,将需要写在 main 方法中运行的代码
// 直接作为 object 的 constructor 代码即可，
// 而且还可以使用 args 接收传入的参数。
object Main_Demo2 extends App{
    if(args.length > 0){
      println("Hello, " + args(0))
    }else{
      println("Hello World!")
    }
}

package cn.itcast.extends_demo
class Person {
  val name="super"
  def getName=this.name
}
class Student extends Person{
  //继承加上关键字
  override
  val name="sub"
 
  //子类可以定义自己的field和method
  val score="A"
  def getScore=this.score
}

package cn.itcast.extends_demo
class Person1 {
  private val name = "leo"
  val age=50
  def getName = this.name
}
class Student extends Person1{
  private val score = "A"
 
  //子类可以覆盖父类的 val field,使用override关键字
  override
  val age=30
  def getScore = this.score
  //覆盖父类非抽象方法，必须要使用 override 关键字
  //同时调用父类的方法，使用super关键字
  override def getName = "your name is " + super.getName
}

package cn.itcast.extends_demo
class Person3 {}
class Student3 extends Person3
object Student3{
    def main (args: Array[String] ) {
    val p: Person3 = new Student3
    var s: Student3 = null
 
    //如果对象是 null，则 isInstanceOf 一定返回 false
    println (s.isInstanceOf[Student3])
    // 判断 p 是否为 Student3 对象的实例
  if (p.isInstanceOf[Student3] ) {
    //把 p 转换成 Student3 对象的实例
      s = p.asInstanceOf[Student3]
  }
  println (s.isInstanceOf[Student3] )
  }
}

package cn.itcast.extends_demo
class Person4 {}
class Student4 extends Person4
object Student4{
  def main(args: Array[String]) {
    val p:Person4=new Student4
    //判断p是否为Person4类的实例
    println(p.isInstanceOf[Person4])//true
    //判断p的类型是否为Person4类
    println(p.getClass == classOf[Person4])//false
    //判断p的类型是否为Student4类
    println(p.getClass == classOf[Student4])//true
  }
}

package cn.itcast.extends_demo
class Person5 {}
class Student5 extends Person5
object Student5{
  def main(args: Array[String]) {
    val p:Person5=new Student5
    p match {
      // 匹配是否为Person类或其子类对象
      case per:Person5 => println("This is a Person5's Object!")
      // 匹配所有剩余情况
      case _  =>println("Unknown type!")
    }
  }
}

package cn.itcast.extends_demo
class Person6{
  protected var name:String="tom"
 
  protected[this] var hobby:String ="game"
  protecteddef sayBye=println("再见...")
}
class Student6 extends Person6{
  //父类使用protected 关键字来修饰 field可以直接访问
  def  sayHello =println("Hello "+name)
  //父类使用protected 关键字来修饰method可以直接访问
  def  sayByeBye=sayBye
  def makeFriends(s:Student6)={
    println("My hobby is "+hobby+", your hobby is UnKnown")
  }
}
object Student6{
  def main(args: Array[String]) {
    val s:Student6=new Student6
    s.sayHello
    s.makeFriends(s)
    s.sayByeBye
  }
}

package cn.itcast.extends_demo
class Person7(val name:String,val age:Int){
  var score :Double=0.0
  var address:String="beijing"
  def this(name:String,score:Double)={
    //每个辅助constructor的第一行都必须调用其他辅助constructor或者主constructor代码
    //主constructor代码
      this(name,30)
      this.score=score
  }
  //其他辅助constructor
  def this(name:String,address:String)={
      this(name,100.0)
      this.address=address
  }
}
class Student7(name:String,score:Double) extends Person7(name,score)

package cn.itcast.extends_demo
abstract class Person9(val name:String) {
  //必须指出返回类型，不然默认返回为Unit
  def sayHello:String
  def sayBye:String
}
classStudent9(name:String) extends Person9(name){
  //必须指出返回类型，不然默认
  def sayHello: String = "Hello,"+name
  def sayBye: String ="Bye,"+name
}
object Student9{
  def main(args: Array[String]) {
    val s = new Student9("tom")
    println(s.sayHello)
    println(s.sayBye)
  }
}

package cn.itcast.extends_demo
abstract class Person10 (val name:String){
//抽象fields
    val age:Int
}
class Student10(name: String) extends Person10(name) {
   val age: Int = 50
}

package cn.itcast.triat
trait HelloTrait {
  def sayHello(): Unit
}
trait MakeFriendsTrait {
  def makeFriends(c: Children): Unit
}
//多重继承 trait
class Children(val name: String) extends HelloTrait with MakeFriendsTrait with Cloneable with Serializable{
  def sayHello() =println("Hello, " + this.name)
  def makeFriends(c: Children) = println("Hello, my name is " + this.name + ", your name is " + c.name)
}
object Children{
  def main(args: Array[String]) {
    val c1=new Children("tom")
    val c2=new Children("jim")
    c1.sayHello()//Hello, tom
    c1.makeFriends(c2)//Hello, my name is tom, your name is jim
  }
}

package cn.itcast.triat
/**
 * 比如 trait 中可以包含很多子类都通用的方法，例如打印日志或其他工具方法等等。
 * spark就使用trait定义了通用的日志打印方法；
 */
trait Logger {
  def log(message: String): Unit = println(message)
}
class PersonForLog(val name: String) extends Logger {
  def makeFriends(other: PersonForLog) = {
    println("Hello, " + other.name + "! My name is " + this.name + ", I miss you!!")
    this.log("makeFriends method is invoked with parameter PersonForLog[name = " + other.name + "]")
  }
}
object PersonForLog{
  def main(args: Array[String]) {
    val p1=new PersonForLog("jack")
    val p2=new PersonForLog("rose")
    p1.makeFriends(p2)
    //Hello, rose! My name is jack, I miss you!!
    //makeFriens method is invoked with parameter PersonForLog[name = rose]
  }
}

package cn.itcast.triat
trait PersonForField {
  val  age:Int=50
}
//继承 trait 获取的field直接被添加到子类中
class StudentForField(val name: String) extends PersonForField {
  def sayHello = println("Hi, I'm " + this.name + ", my  age  is "+ age)
}
object StudentForField{
  def main(args: Array[String]) {
    val s=new StudentForField("tom")
    s.sayHello
  }
}