scala05

scala05课件

辅助构造器的声明

class tobacco(var logo:String,smell:String,price:Double){
       var count:Int = _
        def this(){
          //辅助构造器的第一行内容必须调用构造器
          this(logo,smell,price)
        }
        def this(a:String,b:String,c:Double,d:Int){
          this(a,b,c)
          this.count = d
        }
}

构造器的作用域

class tobacco(var logo:String,smell:String,price:Double){
       println(1)
       var count:Int = _
        def this(){
          //辅助构造器的第一行内容必须调用构造器
          this("","",5.5)
          println(3)
        }
        def this(a:String,b:String,c:Double,d:Int){
          this(a,b,c)
          this.count = d
        }
       println(2)
}

打印顺序是1 2 3 证明辅助构造器的作用域是方法体内，主构造器的作用域范围是整个类

总结：

1. 主构造器只有一个
2. 辅助构造器又多个，并且使用def this()进行声明
3. 主构造器中必须使用var/val进行修饰，不然声明的是参数并不是属性
4. 主构造器必须赋值
5. 主构造器的作用域是整个类，辅助构造器的作用域是方法体内
6. 构造器的参数列表不能完全一致
7. 优先使用主构造器

 

 

类中的访问权限

java中的访问权限 public private protected default friendly

scala public(默认的) private权限修饰符

成员属性 默认就是公有public的，大家都可以使用

private修饰符如果不加限定 是自己和自己的伴生对象中可以使用

private [this] 只有自己可以使用

private [package]定义某一个包中可以使用

class A private (private [this] val id:Int,private val name:String){

}
object  A{
  var a:A = null
  def apply(id:Int,name:String)={
    if(a==null)
      a = new A(id,name)
    a
  }
  def main(args: Array[String]): Unit = {
      val a = new A(1,"zhangsan")
      a.name
  }
}
object  B{
  def main(args: Array[String]): Unit = {
    val a = A(1,"zhangsan")
    val a1 = A(1,"zhangsan")
    val a2 = A(1,"zhangsan")
    println(a)
    println(a1)
    println(a2)
  }
}

 

以上构造器和属性的定义

单例模式

class B private[bw] (val id:Int,val name:String)

在private后面加上包明就可以指定包使用，但是这个包只能是自己所在的根目录以及父目录

 

类上面的修饰符

private class xxx()声明的类的修饰符可以在当前文件中使用，如果加入了指定的包明则可以在另一个文件中使用

 

方法上面的修饰符

private[this/package] def method.....

 

抽象类abstract 接口trait

抽象类中可以定义方法，可以定义抽象方法，定义属性，定义构造器

abstract class Animal(val id:Int,val name:String){
   def run(): Unit ={
     println("我跑的贼快。。。。")
   }

   def eat()
}

class Dog(id:Int,name:String,age:Int) extends Animal(id:Int,name:String){
  override def eat(): Unit = {
    println("i eat very much....")
  }
}

trait Bike{
  var bikeType:String = ""
  def ride()
  def fangqi()={
    println("谁放的气，我真喜欢你！！！！！")
  }
}

trait eleBike{
  def charage(): Unit ={
    println("充电两小时，骑车五分钟。。。。")
  }
}

abstract class che{}

class jieante extends che with Bike with eleBike{
  override def ride(): Unit = println("天天骑车。。。")
}

object testtttt{
  def main(args: Array[String]): Unit = {
    val dog  = new Dog(1,"teddy",7)
    dog.eat()
    dog.run()

    val animal = new Animal(1,"teddy") {
      override def eat(): Unit = println("eat shit...")
    }
    val bike = new Bike {
      override def ride(): Unit = print("骑多了疼。。。")
    }
  }
}

 

val hourse:hourse with fly = new hourse with fly //动态混入特质

 

总结：

1. 抽象类中可以定义构造器
2. 抽象类中定义方法和属性，抽象方法
3. 接口中可以定义属性和抽象方法，带有方法体的方法
4. 抽象类和接口都不能new，只能new接口或者抽象类的实现类
5. 继承或者实现都要使用extends。
6. 单继承多实现，和extends一起使用的时候，第一个位置是extends后续的位置都是with
7. 如果是子类继承父类，父类中的方法如果含有方法体必须加上override关键字，如果没有方法体则不需要加上override
8. 如果类上面没有这个属性，可以在new的时候动态混入特质

 

匹配模式

1. 值得匹配 switch case

def main(args: Array[String]): Unit = {
//    var Array(a,b,c,d,e) = args
//    println(a,b)
//    val name:String = "zhangsan1"
//    name match {
//      case "zhangsan"  =>println("u r asshole")
//      case "lisi"=>println("hello")
//      case _ =>println("i dont know u!!!")
//    }
//   val carrer:Int = 6
//   val salary =   carrer match{
//      case 2=> "10K"
//      case 3=> "11K"
//      case 4=>"12K"
//      case _=>"5K"
//    }
//    println(salary)

    //控制守卫
//    val name="zhangsan"
//    val age = 17
//    name match {
//      case "zhangsan" if(age>=18)=>println("u r employed")
//      case _ =>println("i dont know or u r child.....")
//    }
//类型匹配
//    val name:Any = "zhangsan"
//    name match {
////      case x:String if(x.equals("zhangsan1")) =>println("x is String")
////      case y:Int=>println("y is int")
////      case _=>println("unknow type..")
//      case x=>println(x)
//    }

//    数组得匹配
//    var arr = Array(1,2,3,4)
//    arr match {
////      case x =>println(x)
////      case Array(x,y,z,w)=>println(x)
////      case Array(1,2,3,x)=>println(x)
////      case Array(x,_,_,_)=>println(x)
////      case Array(x,_*)=>println(x)
//    }
  }

 

 

作业题：

site1,user1,2018-03-01 02:25:25

site1,user1,2018-03-01 03:25:25

site1,user1,2018-03-01 04:25:25

site1,user2,2018-03-01 02:25:25

site1,user2,2018-03-01 03:25:25

site1,user2,2018-03-01 04:25:25

site1,user2,2018-03-01 05:25:25

site1,user2,2018-03-01 06:25:25

site2,user1,2018-03-01 02:25:25

site2,user3,2018-03-01 03:25:25

site2,user3,2018-03-01 04:25:25

site2,user3,2018-03-01 02:25:25

site2,user2,2018-03-01 03:25:25

site2,user2,2018-03-01 04:25:25

site2,user2,2018-03-01 05:25:25

site2,user2,2018-03-01 06:25:25

site4,user5,

site3,,

site1,user1,2018-03-02 02:25:25

site1,user1,2018-03-02 03:25:25

site1,user1,2018-03-02 04:25:25

site1,user2,2018-03-02 02:25:25

site1,user2,2018-03-02 03:25:25

site1,user2,2018-03-03 04:25:25

site1,user2,2018-03-03 05:25:25

site1,user2,2018-03-03 06:25:25

site2,user1,2018-03-04 02:25:25

site2,user3,2018-03-04 03:25:25

site2,user3,2018-03-05 04:25:25

site2,user3,2018-03-06 02:25:25

site2,user2,2018-03-05 03:25:25

site2,user2,2018-03-06 04:25:25

site2,user2,2018-03-05 05:25:25

site2,user2,2018-03-06 06:25:25

1. 清洗数据，将其中的两条数据清洗掉
2. 求出每个网站的每天的pv uv
3. 求出每个网站的每天的每个小时的访问 pv  uv

 

作业题第二题：

根据ratings表和movies表中的数据

两个表关联，只求每个用户最喜欢的电影类型

可以将一个小的表放入到本地的map集合中（key=mid,values.....）

 

scala中的匹配

  val (x,y) = getMaxMin(Array(1,2,3,4,5,6,7))
  println(x,y)
}
//元组的匹配
def getMaxMin(arr:Array[Int])={
  (arr.max,arr.min)
}

 val tp = ("zhangsan",20,"男")
    tp match {
//      case (x,y) =>println(x,y)
//      case x=>println(x)
//      case (x,_)=>println(x)
//      case (_,v)=>println(v)
//      case (x,_*)=>println(x)
    }

 val list = List(1,2,3,4)
    list match {
//      case List(a,b,c,d) =>println(a,b,c,d)
//      case List(x,_*)=>println(x)
//      case x::y::z::w=>println(y)
//      case x::y::z=>println(z)
//      case x::y::z::w::Nil=>println(w)
      case x::y::Nil=>println(y)
    }

大括号的使用规则

arr.map(_*10)

arr.map{

x=>x*10

} 这种代表匹配模式

 

样例类和样例对象

case class case object

用case修饰的类就是样例类  用case修饰的对象就是样例对象

（样例类和样例对象包含所有的普通的类和普通的对象所有的功能并且携带很多其他功能）

scala> case class A

<console>:1: error: case classes without a parameter list are not allowed;

use either case objects or case classes with an explicit `()' as a parameter list.

case class A

            ^

 

scala> case class A()

defined class A

 

scala> val a = new A

a: A = A()

 

scala> val b = new B

<console>:11: error: not found: type B

       val b = new B

                   ^

 

scala> val a1 = new A

a1: A = A()

 

scala> a1 == a

res6: Boolean = true

 

scala> class B

defined class B

 

scala> val b = new B

b: B = B@532dacf5

 

scala> val b1 =new B

b1: B = B@8b41ad

 

scala> b == b1

res7: Boolean = false

 

scala> print(b)

$line15.$read$$iw$$iw$B@532dacf5

scala> print(a)

A()

 

scala> a.hashCode()

res12: Int = 65

 

scala> a1.hashCode()

res13: Int = 65

 

scala> b.hashCode()

res14: Int = 1395502325

 

scala> b1.hashCode()

res15: Int = 9126317

 

scala> val a = new A

a: A = A()

 

scala> val a1 = A

a1: A.type = A

 

scala> val a1 = A()

a1: A = A()

1. 样例类在声明的时候必须加上参数列表
2. 样例类中重写了equals hashcode toString
3. 声明样例类的时候默认带了一个伴生对象，并且存在apply方法
4. 样例类在使用的时候可以不new
5. 样例类实现了序列化接口

在spark中集群模式运行，集群中就会分为多个角色worker master

 

样例对象：

声明的时候case object obj

样例对象和普通的对象的区别就是一个实现了序列化接口一个没有实现

 

样例类的匹配

def main(args: Array[String]): Unit = {
  var arr = Array(Regist2Master("001","2g",3),RegistSuccess,HeartBeat("001","good"),CheckTimeOut,new ShutDown("001"),shutSuccess)
  val random = new Random()
  val index = random.nextInt(4)
  arr(5) match {
    case Regist2Master(id,memory,cores)=>println(id,memory,cores)
    case RegistSuccess=>println("registSuccess")
    case HeartBeat(id,status)=>println(id,status)
    case CheckTimeOut => println("checkTimeOut")
    case x:ShutDown =>println(x.id)
    case y:shutSuccess.type =>println(shutSuccess)

  }
}

object shutSuccess
class ShutDown(val id:String)
case class Regist2Master(id:String,memory:String,cores:Int)
case object RegistSuccess
case class HeartBeat(id:String,status:String)
case object CheckTimeOut

样例类和样例对象最适合做匹配模式