scala（2）

1.父类和子类的继承关系

父类：
class Person(val name:String,val city:String)（这是主构造器）{

    println("Person 进来了")

   println("Person 出去了")
  }
  
  
 子类继承父类：
 object BigTree {
  def main(args: Array[String]): Unit = {
  
    //new 子类 ==》会先触发new 父类
    val bigTree=new BigTree("大树","上海",10000f)
  }


}

class BigTree(name:String,city:String,money:Float) extends Person(name,city){
 
 println("Big Tree 进来了")

  println("Big Tree 出去了")
}

结果：
Person 进来了
Person 出去了
Big Tree 进来了
Big Tree 出去了

从结果可以看出，new 子类的时候必然先出发父类。

2.子类重写父类的方法

//在子类中写一个方法
def toString()="toString来了"

//发现这个方法报错了，原因时因为 Object类中有toString方法
//所以我们必须要在前面加一个修饰词：override（表示重写方法）
 
override def toString()="toString来了"

    
// 重要：如果子类没有重写这个方法，那么调用的是父类的方法，如果子类重写了这个方法，那么调用的就是子类重写的方法

3.抽象类 abstract

// 抽象类 没有方法体
//抽象类不能 new实例，但是可以通过子类来new，但是子类不能是抽象类
abstract class A{
  val name:String
  def Abstract()
}

4.trait 相当于接口

trait和abstract 一样，不能new实例，没有方法体。
如果既想继承 abstract又想继承trait，

//第一个必须要用 extend
class 类名 extend （abstract类名）with（trait类名）

5.高阶函数

 object Function {
      
  def main(args: Array[String]): Unit = {
    //List 集合
    val l=List(1,2,3,4,5,6,7,8,9)

    //每个元素都做同一个操作 用 map方法
    l.map((x:Int)=>x*2)
	//也可以写成：
	l.map(_*2)  //  _ 表示前面l里面的每一个元素
        
        
    //过滤
     //filter 求出 >10的元素
    l.map(_*2).filter(_ >10)
  }
    
    //take 表示取前几个
    l.map(_*2).filter(_ >10).take(2)
	
    //两两相加 1+2+3+4+5+6
    //1+2=3
    //3+3=6
   // l.reduce((x:Int,y:Int)=>x+y) 
    l.reduce(_+_)
        
    //两两相减   1-2-3-4-5-6
    l.reduce(_-_)
        
    //fold()  给一个初始值，两两相加
     
        
     //测试方法  要 学会这种方法，看 x，y
     l.fold(10)((x:Int,y:Int) =>{
      println(x+","+y)
      x+y
          
    } )
      
        
     l.fold(10)(_+_)
        
}

    //求最大值
    scala> l.max
    res0: Int = 9
        
    //求最小值
    scala > l.min
    res1: Int = 1
        
    //求和
    scala> l.sum
    res2: Int = 45
        
    //求大于3的数有几个
    scala> l.count(_>3)
    res3: Int = 6

    //flatten 表示将所有的嵌套集合都展开放到一个集合中  
    scala> val a=List(List(1,2),List(3,4),List(5,6))
    scala> a.flatten
    res5: List[Int] = List(1, 2, 3, 4, 5, 6)

    //flatMap  表示将嵌套集合压扁 然后再map
    scala> a.flatMap(_.map(_*2))
    res6: List[Int] = List(2, 4, 6, 8, 10, 12)

6.MySQL JDBC编程

1)步骤

2）编程

//生产上很少用这种方法，都是借助于框架实现的
object Jdbc {
  def main(args: Array[String]): Unit = {
      
      //Class.forName("com.mysql.jdbc.Driver")   这个时java中加载驱动的方法
      
  生产上需要加： classOf[com.mysql.jdbc.Driver]   //scala 中建议这么写
      
      
    val url="jdbc:mysql://192.168.137.130:3306/test?characterEncoding=UTF-8"
    val user="root"
    val pass="123456"
    val sql="select * from user"
    //通过连接池获取连接
    val connection=DriverManager.getConnection(url,user,pass);
    val statment=connection.createStatement()
        //通过statment来拿到一个结果集
   val rs= statment.executeQuery(sql)//执行一个sql语句
           
      while(rs.next()){      //判断下一个是否有结果，有就输出出来
      var a=rs.getInt("id")
      var b=rs.getString("name")
      var c=rs.getInt("age")
      println(a+"===="+b+"===="+c)
    }
    
  }

}

结果：
1====xiaoqiang====25
2====xiaogong====18
3====lizi====15
4====mingren====20
5====zuozhu====38
6====qiya====30