scala基础之二 scala相关语法类，对象，特征和修饰符（二）

标签（空格分隔）： hadoop

---

简介

在scala的一中我们已学了了部分的scala特有语法，这里再坐下完善。scala的类啊之类的一些概念做下介绍，同时用scala写一些小demo。

scala基础语法

scala与java有很多相似之处，以下我们来看下这之中的相似之处
首先： scala既然是面向对象与函数式编程的集成，那么scala的面向对象又如何体现呢。
对象：scala以 object为关键字声明对象，对象中有属性和行为，所以其有属性和方法。其实我们可以把对象类比java的静态类更加贴切。
类：scala与java一致以class为关键字做声明，类是对象的抽象。
属性：对象的属性通过给字段赋值来创建。
方法：方法就是行为了这没什么可说的。
另外scala在书写时，由于追求极致编程所以每句话的；都不写，如果多句话放到一起可以以此作为分割。
闭包： 闭包其实就是一个函数，只不过这个函数可以作为变量在另一个函数中使用 比如 val m = (i:Int) = > i * 10

访问修饰符

private protect public 默认就是public访问级别

修饰符	描述
private	私有修饰符，仅在包含了成员定义的类或对象内部可见，就是内部可见外部不可见，即使外部类中访问内部类的私变量也是不允许的
protect	只限定继承类可访问，java还可允许同包可访问
public	默认级别所有课访问
private[package]	对限定的包可访问，protect也有这个机制

类和对象

类

前面说了类是对象的抽象概念，那么类其实就是对象创建的蓝图，是包含了特点对象的方法和属性的软件模板。（就是1对多，鸡生蛋的概念）
scala类可不声明public 类可以有一个主构造器，可以有多个辅构造器，辅构造器必须先调用主构造器。而且主构造器可以直接在类后面定义如：

  /**
  * Created by： luo
  * date: 2019/8/5.
  * desc：
  */
class ConstructClass(val x: Int,var y: Int) {//主构造器
  val xc:Int = x
  private var yc:Int = y
  var z:Int = _
  //辅构造器
  def this(x: Int,y: Int,z:Int){
    this(x,y)
    this.z = z;
  }

  //方法 放回值默认为Unit 即()
  def move(x: Int ,y: Int): Unit ={
      println(x)
      println(y)
  }

}

类继承：
1、重写一个非抽象方法必须使用override修饰符。
2、只有主构造函数才可以往基类的构造函数里写参数。
3、在子类中重写超类的抽象方法时，你不需要使用override关键字

实例

scala中类是不占内存的，对象需要占用内存，另外，scala中由于没有static关键字，所以对象里面的方法其实都是static滴，反编译可以一看。object修饰的就是对象，人家也用这个来提供了单例对象，使用object修饰的对象与类同名叫做伴生对象，伴生对象与类的定义区别在于人家木有参数可以定义。类和它的伴生对象可以互相访问其私有成员。

//类和它的伴生对象可以互相访问其私有成员
object ConstructClass{
  val a = 1
  def printlnCC(cc: ConstructClass): Unit ={
    println(cc.xc +"" + cc.yc)//yc为私有变量
  }
  def main(args: Array[String]): Unit = {
    val cc = new ConstructClass(1,3);
    cc.move(4,5);
    printlnCC(cc)
  }
}
//apply方法可使用对象(prama...)来完成构造某个类的对象 
def apply(x: Int,y:Int): ConstructClass ={
 new ConstructClass(x,y)
}

类检查与转换

scala	java
obj.isInstanceOf[C]	obj instanceof C
obj.asInstanceOf[C]	©obj
classOf[C]	C.class

trait(特征 scala特征与java的接口一致（jdk1.8之后可以有实现）)

如下为对象继承实现，
package com.lcy.hello.extends

/**
  * Created by：luo
  * date: 2019/8/5.
  * desc：
  */
abstract class Parents {
   def isNotImplI();

}

abstract class Parents2 {

  def isNotImplI2();
}
trait inter1{
  def isEqual(x :Any): Boolean ;
  def isNotEqual(x :Any): Boolean ={
    !isEqual(x)
  }
}

trait inter2{
  def declare;
}
class Children extends inter1 with inter2{

  override def isEqual(x: Any): Boolean = {
    x==1;
  }

  override def declare: Unit = ???
}

class Children1 extends Parents2 with inter1{

  override def isEqual(x: Any): Boolean = {
    x==1;
  }

  override def isNotImplI2(): Unit = ???
}

特征可以有抽象方法也可以有已经实现的方法，类可以通过extends和with完成多重继承。

模式匹配

模式匹配，模式匹配与java的的swith类似，但scala的匹配花样更多点而已。可以匹配字符串，匹配数组 元组，列表等，还可以匹配样例类，可谓多种多样，以下是我写的一些小demo可以看下。

package com.lcy.hello.matching

import com.lcy.hello.ConstructClass

import scala.util.Random

/**
  * Created by：luo
  * date: 2019/8/5.
  * desc：
  */
object MatchDemo01 extends App {
  //匹配字符串
  val arr = Array("one","tow","other")
  val num = arr(Random.nextInt(arr.length))
  val result = num match {
    case "one" => 1
    case "tow" => 2
    case _ => 3
  }
  println(result)
  //模式匹配的方法
  def matchMethod(x: String): Int = x match{
    case "one" => 1
    case "tow" => 2
    case _ => 3 //匹配上其他任意类型的返回3
  }
  //匹配类型
  val arr1 = Array(1,"one",2.0)
  val ty = arr1(Random.nextInt(arr1.length))
  ty match{
    case x: Int => println("i am int")
    case y: String => println("i am String")
    case z: Double => println("i am Double")
  }

  /**
    * 匹配数组，元组，列表（其实是看元素里面的内容能否匹配上）
    */

//  val array = Array(1,2,3)
//  val array = Array(1)
  val array = Array(0,1,2,3,4)
//  val array = Array(1,2,3,4)
  array match {
    case Array(1,x,y) => println(s"匹配上了 x=$x,y=$y")
    case Array(1) => println("only 1")
    case Array(0,_*) => println("0....")
    case _ => println("something else")
  }
//在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。
  //如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))
//  val lst1 = List(1,-1)
  val lst1 = List(0)
  lst1 match {
    case 1:: Nil => println("就一个元素") //Niu 表示空列表 ，另外::是右结合的
    case 0:: tail => println("0....")
    case x:: y:: Nil => println("两个元素")
    case _ => println("匹配上其他的了")
  }

//匹配元组
//  val tuple = (1,2,3)
  val tuple = (0,2,3)
  tuple match {
    case (1,x,y) => println(s"匹配上了 x=$x,y=$y")
    case (_,z,3) => println("匹配上了z")
    case _ => println("匹配上了其他")
  }
}

以下为可能更加常用的案例类

package com.lcy.hello.matching

import scala.util.Random

/**
  * Created by：luo
  * date: 2019/8/8.
  * desc：
  */
class MatchClass {

}
//样例类
case class SubmitTask(id: Long,name: String)
//样例类
case class HeartBeat(id: Long ,name: String)
//样例类
case object CheckOutObject;

object MatchClass{
  def main(args: Array[String]): Unit = {
    val arr = Array(CheckOutObject, HeartBeat(12333l,"检测任务"),SubmitTask(12333l,"提交任务"))
    val v = arr(Random.nextInt(arr.length))
    v match {
      case CheckOutObject => {
        println("检出匹配")
      }
      case HeartBeat(id,name) => println(s"心跳任务$id,$name")
      case SubmitTask(id,name) => println(s"$id,$name")
    }
  }
}

//模式匹配之偏函数补充

package com.lcy.scalabasic.matching

/**
  * Created by luo on 2019/8/11.
  */
class MatchDemo {

  /**
    * 偏函数案例
    * @return
    */
  def func1: PartialFunction[String,Int] = {
    //被包在花括号内没有match的一组case语句是一个偏函数，它是PartialFunction[A, B]的一个实例，A代表参数类型，B代表返回类型，常用作输入模式匹配
    case "one" => 1
    case "two" => 2
    case _ => -1
  }
  //匹配方法 之前的与
  def func2(input: String) : Int= input match{
    case "one" => 1
    case "two" => 2
    case _ => -1
  }
}

object MatchDemo{
  def main(args: Array[String]): Unit = {
    val md = new MatchDemo
    println(md.func1("one"))
    println(md.func2("one"))

  }
}