scala动态绑定 接口 集合 0901

动态绑定 & 属性 、方法重写

动态绑定机制 (多态)：
成员方法在执行的时候，JVM将方法和当前调用方法的对象的实际内存进行绑定
方法具有动态绑定机制、而属性没有 在哪里声明就用那个属性

抽象方法重写的时候，override可选的
抽象类中有方法的具体实现的话，那么重写方法需要显示添加override

var声明的属性被重写后 可以使用 _ 做属性值的自动推断
val声明的属性被重写后，不能使用 _ 做属性值的自动推断 ，需要显示的初始化

构造方法（父类构造方法 & 构造方法的参数使用）
父类主构造方法 （1）
子类 主构造方法 （2）
子类 辅助构造方法（3）

接口（特质）

scala中没有接口（interface）的概念、而有特质（trait）的概念
特质可以多混入?? 可以 而且类想混入多个特质 采用with进行连接
类的继承体系中存在类和特质的话？？？
类要写在前 ， 所有的接口都写在后

object Test {
  def main(args: Array[String]): Unit = {
    new User();
  }
}
trait  T1{
  println("T1 code ......")
}
trait T2{
  println("T2 code ......")
}
class Person{
  println("Person code .....")
}
class User extends Person with T2 with T1{
  println("child code ......")
}
结果：
Person code .....
T2 code ......
T1 code ......
child code ......

scala的特质中可以存在直接可执行的代码吗？？？ 可以
scala中可以声明属性和方法吗（抽象、具体） 都可以 ，并且属性的话 var 和 val都可以
特质如果被多次混入的话，那么只会被执行一次
可执行代码的执行顺序是从左向右、方法调用从右向左
super指向的是上一级、但是如果想中途改变顺序super[Operate]
动态混入 ：符合OCP设计原则 ，对功能开放，对修改关闭

 def main(args: Array[String]): Unit = {
    var mysql = new MySql() with Operate
    mysql.insert()
    mysql.delete()
  }
  trait Operate{
    def delete(): Unit ={
      println("删除数据")
    }
  }
  class MySql{
    def insert(): Unit ={
      println("插入数据")
    }
  }

集合

一、scala集合基本介绍
1）集合分类 ： 不可变集合 和 可变的集合
2）Scala默认的话都是不可变集合
3）scala集合的类型：序列（Seq）、Set、映射（Map）
【可变的–mutable 不可变的–immutable】
二、集合初识
集合之所有存在 是因为不同的需求，数据样式不一样（存储）
简单解释：
查询很频繁（数组）–ArrayList
删除和插入数据（链表）–LinkList
序列，指的是一类具有一定长度的可迭代访问的对象，其中每个元素均带有一个从0开始计数的固定索引位置。

案例一：不可变数组
不可变数组 ： 增加、删除、修改、查询、特殊方法
//取值 求长度 遍历
	var arr:Array[Int]=Array(1,2,3)
    println(arr(0))
    println(arr.length)//数组的长度
    println(arr.size)
    println(arr.mkString(","))
    for(i <- arr){   //遍历
      print(s"${i}  ")
    }
    arr.foreach(i=>print(s"${i} ")) //遍历
    arr.foreach(print(_)) //遍历 自动类型推断
//修改 |  不可变引用|内存数据可变的
	var arr:Array[Int]=Array(1,2,3)
    arr(0)=2
    println(arr.mkString(","))
    arr.update(0,2)
    println(arr.mkString(","))
//添加数据方式一
    var arr:Array[Int]=Array(1,2,3)
    println(arr.mkString(","))
    var arr1:Array[Int]=arr:+4
    println(arr1.mkString(","))
    var arr2:Array[Int]=0+:arr
    println(arr2.mkString(","))
案例二： 可变数组 
    var arr :ArrayBuffer[Int]  = ArrayBuffer(1,2,3,4)//.创建可变数组
    println(arr(0))//访问元素
    arr(0)=5//修改元素
    arr=arr+=5
    arr.insert(2,5)//插入数据
    arr.remove(0)//删除元素  从索引为0的位置 进行删除
    var arr1:Array[Int]=arr.toArray //可变数据和不可变数组的转换[了解]

seq相关的集合

案例一：ListBuffer 
    var  list: ListBuffer[Int] = ListBuffer(1,2,3,4)
  // 增删改查  insert update remove drop
    println(list.head) //头元素
    println(list.last) //尾元素
    println(list.tail) //除了头之外的元素
    println(list.init) // 除了尾之外的元素
    println(list(1))//查看
    for(i<- list){
       println(i)
    }
    list.foreach(print)//访问元素
    list += 5//添加元素(尾部)
    var list1: ListBuffer[Int] = ListBuffer(5,6,7,8)
    var nList  = list ++ list1//list(拼接)
    var temp1 =  list :+ 9  // ->
    var temp2 = 9 +: list  // <-
    var temp3 = list.remove(1)  //返回值，是删除的数据
    list.-=(2) //按照值进行删除

案例二 ： Queue  先入先出 【可变集合：Seq】
  var que:mutable.Queue[Int]=new mutable.Queue[Int]()
    que+=0//追加数据
    que.++=(List(1,2,3))
    que.dequeue()//出队列
    que.enqueue(4,5)//追加数据
    println(que.head)//查看头元素
    println(que.last)//查看尾元素
    println(que.tail)//查看除头之外的所有元素
案例三 ： 栈 
    var stack:mutable.Stack[Int]=mutable.Stack(1,2,3)
    println(stack.push(1))//压栈
    println(stack.pop())//出栈
    println(stack.head)//栈的头
    println(stack.tail)//栈除头外的数据

List (常用)[不可变体系]

   var list=List(1,2,3)
    var list1=Nil//空列表
    println(list)
    var list2=4::(5::list)::Nil
// :: 拼接
// ::: 是把一个列表里面的没有元素追加到后面的列表 （从右向左）
//多个List合并用++，也可以用:::(不如++)
    println(list2)
    var temp1 = list :+ 4
    println(temp1)
    var temp2 = 4 +: list
    println(temp2)
    var listA=List(1,2,3)
    var listB=List(4,5,6)
    println(listA++listB)//拼接

二叉树的广度搜索

   def levelOrder(root: TreeNode): List[List[Int]] = {
        if (root == null) return Nil
        var res=new ArrayBuffer[List[Int]]()
        var que=new mutable.Queue[TreeNode]()
        var level=new ArrayBuffer[Int]()
        if (root != null )
        {
        que.enqueue(root)
        }
        while (!que.isEmpty){
        var i:Int=que.size
        level.clear() 
        for (i<-1 to i)
        {
            var node:TreeNode=que.dequeue()
            level.append(node.value)
            if (node.left!=null) que.enqueue(node.left)
            if (node.right!=null) que.enqueue(node.right)
        }
        res.append(level.toList)
        }
        res.toList
    }