Scala：基础知识02

Posted 2021-06-26 Xiao Miao

文章目录

• Scala基础知识
• • 一、函数式编程
  • • 1.map
    • 2.filter
    • 3.排序
    • 4.分组
    • 5.扁平化
    • 6.聚合操作
    • 7.遍历foreach
  • 二、面向对象编程
  • • 1.类的定义
    • 2.Object静态特性
    • 3.构造器
    • 4.Scala访问修饰符
    • 5.继承
    • 6.类型判断与类型转换
    • 7.抽象类
  • 三、Trait

Scala基础知识

一、函数式编程

集合、数组支持函数作为参数

1.map

功能：接收一个函数式参数f 作用于集合中每个元素，返回构成一个新的集合。

def map[B](f:(A)=>B):Array[B] 

2.filter

功能：接收函数式参数p 应用于集合的每个元素，结果为true的保留下来 就是过滤的功能

def filter(p: (T) ⇒ Boolean): Array[T]

3.排序

sorted：不需要传递参数，默认升序排序
sorteBy：接受一个函数式参数f根据f返回的值排序
sortwith：自定义排序规则 根据两个元素比较的结果排序 小于返回true，大于返回false

4.分组

grouped :把几个元素分为一组
groupBy :根据谁把数据分为一组

5.扁平化

flatten：将嵌套数据中里层的集合抹去 扁平化压平操作
flatMap：先进行map操作，操作的结果在进行flateen扁平化

6.聚合操作

reduce
reduceLeft
reduceRight

fold
foldleft
foldRight

7.遍历foreach

二、面向对象编程

1.类的定义

• 使用class定义类 普通的类 必须通过new才能创建实例 多例
• 使用object定义类 特殊的类 不需要new 全局唯一的实例 单例 内部方法属性都是静态的

class Student {
//todo 在scala中不需要显示setter getter方法
//todo 对应val常量 只有getter 对于 var 既有setter 又有getter
//  定义属性和方法
  var id:Int=_  //可以使用_进行初始值
  var name:String=_
  val country:String="China"
  def sayHello=println("Hello")
}


object  Test01{
  def main(args: Array[String]): Unit = {
    val s:Student=new Student
        s.name="zhangsan"
        println(s"${s.country}-->${s.name}")
        s.sayHello
      }
}

2.Object静态特性

• 在scala中，没有static关键字的，但是object定义的类中，方法和属性都相当于静态
• 使用object定义一些通用的方法 作为工具类
• main方法也必须定义在object中

class Session {

}

//todo 使用object定义个工具类
object SessionUtils{

  val session:Session = new Session

  def  getSession:Session = this.session
}

object Test01{
  def main(args: Array[String]): Unit = {

    val s1 = new Session //因为session类是class 必须new才可以创建实例 进而操作里面的方法和属性

    val s2: Session = SessionUtils.session  //对象.属性
    val s3: Session = SessionUtils.getSession  //对象.方法
  }
}

main方法

• 功能和java的main方法一样 都是程序的入口方法

• 因为scala没有static关键字 因此main方法只能定义在object中

• 除了显示定义main方法之外，还可以通过继承APP Trait实现main方法。

object test01 extends App{
  println("Hello")
}

3.构造器

• 构造器又叫做构造方法，其目的在创建对象的时候完成属性赋值。

java中构造器

• 本质都是方法 和类名重名的方法
• 分为有参构造和无参构造 默认拥有一个无参构造
• 当显示定义有参构造的时候 会覆盖掉默认的无参构造 因此还需要在显示定义一下无参构造。

public class Teacher {
    private int ID;
    private String name;

    //java中 默认有一个无参构造器


    public Teacher() {
    }

    public Teacher(int ID, String name) {
        this.ID = ID;
        this.name = name;
    }

    public int getID() {
        return ID;
    }

    public void setID(int ID) {
        this.ID = ID;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


public class Test01 {
    public static void main(String[] args) {
        Teacher t = new Teacher();  //通过无参构造创建实例
        t.setID(1);
        t.setName("miao");

        System.out.println(t.getName());

        Teacher t2 = new Teacher(2, "张三");
        System.out.println(t2.getName());
    }
}

scala中构造器

• scala中构造器从功能上来讲和java一样，分为主构造器和辅助构造器

• 主构造器和类的定义交织在一起

class 类名(var/val 参数名:类型 = 默认值, var/val 参数名:类型 = 默认值){
	// 构造代码块
}

辅助构造器是名字叫做this的方法。

def this(参数名:类型, 参数名:类型) {
// 第一行需要调用主构造器或者其他构造器
// 构造器代码
}

/**
 *   todo 1、scala中类的主构造器是和类的定义交织在一起的：
 *             类名的后面参数列表就是主构造器的列表
 *        2、主构造器的参数会自动成为类的成员属性 不需要在类中重复定义了
 *        3、类中除了方法和属性之外 其他都是主构造器的一部分
 */
class Teacher(var id:Int,var name:String) {
  
  println("主构造器执行01")
  val country:String ="China"

  def sayHello = println("hello!!")

  println("主构造器执行结束了01")
}


object Test01{
  def main(args: Array[String]): Unit = {
//    val t = new Teacher
//    t.id =1
//    t.name="miao"
//    println(t.name+"---"+t.id)

    val m = new Teacher1(1, "miao") //通过主构造器创建的对象实例 同时完成属性赋值
    m.sayHello
  }
}

4.Scala访问修饰符

public 公共的 都可见
protected 自己及子类可见
private 仅自己可见

#Scala中默认不写 修饰符都是public

修饰符作用域 可以更加精准的实现控制

 private[this] var age:Int =18 

//除了this 其他都是private。

 private[com] var age:Int =18 
//除了com包下面的 其他都是private。

伴生

//todo  在同一个.scala文件中 如果class名字和object的名字一样 就说两者之间形成了伴生关系
//todo  class叫做伴生类  object叫做伴生对象
//todo  伴生关系最大的好处 可以互相访问对象的私有属性
class Student{
  var id:Int =1
  var name:String="miao"
  private[this] var age:Int =18 //私有属性 只有自己可见
}

//object Test01{
//  def main(args: Array[String]): Unit = {
//    val s = new Student
//    println(s.id+"--->"+s.name)
    s.age
//  }
//}

object Student{
  def main(args: Array[String]): Unit = {
    val s = new Student
    println(s.id+"--->"+s.name)
//    println(s.age)
  }
}

5.继承

继承基本语法

• 继承功能出现 避免重复写代码 提高代码复用率
• 关键字也是extends

class Person {
    //todo 只有常量才可以override 变量可以直接修改
    var id:Int = 1
    var name: String = "张三"
  //todo final修饰的 子类无法重写
  //todo private修饰的 子类无法重写  子类连看都看不见
//    final val country:String = "China"
//    private val country:String = "China"
    val country:String = "China"

    def sayHello = println("你好！")
}

//todo scala继承也是extends关键字
class Student extends Person {
  //子类可以定义自己的属性和方法
  var score :Double =_
  def sayHDD = println("打游戏")

  //子类也可以对继承于父类的属性和方法进行重写
  override val country: String = "korea"
  name = "정수 연"
  //super在子类中调用父类的方法
  override def sayHello: Unit = println("안녕하세요")
}

object Student{
  def main(args: Array[String]): Unit = {
    val s = new Student
    println(s.name)
    println(s.country)
    s.sayHello
  }
}

6.类型判断与类型转换

object Student{
  def main(args: Array[String]): Unit = {

    val s: Person = new Student

    //todo 类型判断于类型转换
    if(s.isInstanceOf[Student]){
      println("类型已经转换")
      s.asInstanceOf[Student]
    }

    //todo isInstanceOf 可以进行类型判断 但是不精准  只能判断对象是否为指定类以及其子类的对象
    println(s.isInstanceOf[Person])
    println(s.isInstanceOf[Student])
    println(s.isInstanceOf[String])

    //todo 如果需要精准判断  使用getClass ClassOf
    println(s.getClass == classOf[Person])
    println(s.getClass == classOf[Student])
    println(s.getClass == classOf[String])
  }
}

7.抽象类

• 抽象方法
• 抽象属性
• 抽象类

//对于class来说 如果有抽象的属性 或者抽象方法  这个类叫做抽象类 需要使用关键字abstract
abstract class Person {
    var name:String  //如果变量没有初始值 叫做抽象变量 抽象属性
    def sayHello //如果方法没有方法体 叫做抽象方法
}

//子类继承抽象类  要么继续抽象  要么实现抽象
//todo 实现抽象类或者接口方法的快捷键  ctrl+i
class Student extends Person {
  override var name: String = "miao"

  override def sayHello: Unit = println("你好")
}

匿名内部类

直接new 抽象类或者接口 进行实现

//对于class来说 如果有抽象的属性 或者抽象方法  这个类叫做抽象类 需要使用关键字abstract
abstract class Person {
    var name:String  //如果变量没有初始值 叫做抽象变量 抽象属性
    def sayHello //如果方法没有方法体 叫做抽象方法
}

//子类继承抽象类  要么继续抽象  要么实现抽象
//todo 实现抽象类或者接口方法的快捷键  ctrl+i
class Student extends Person {
  override var name: String = "miao"

  override def sayHello: Unit = println("你好")
}

object Test01{
  def main(args: Array[String]): Unit = {
   val p = new Person {
     override var name: String = "james"

     override def sayHello: Unit = println("你好！")
   }

    p.sayHello
  }
}

三、Trait

Trait：特质 特征

• 相当于java中接口，比接口功能的更加强大。

功能1：当成和java接口一样使用 定义抽象方法

//todo scala中 对应Trait的实现也是使用extends关键字
//todo 类实现多个Trait 第一个使用extends 后面的使用with关键字
class Student1 extends HelloTrait with ByeTrait with Serializable {
  override def sayBye: Unit = println("再见")

  override def sayHello: Unit = println("你好")
}

object Student{
  def main(args: Array[String]): Unit = {
    val s = new Student1
    s.sayHello
    s.sayBye
  }
}

功能2：定义具体的方法 当成通用的工具类

trait LoveUTrait {
  //下面这个方法有方法体  叫做具体的方法
 def sayLove =println("Ｉ　ＬＯＶＥ　ＹＯＵ！"）
}

功能3：字段属性也是类似 既可以定义抽象的 也可以定义具体的

• 如果Trait中是抽象的 继承的时候就需要实现
• 如果trait中是具体的 继承的时候可以直接使用

功能4：实例混入trait

• 让同一个对象的不同实例 拥有不同的能力 在new对象获取实例的时候继承混入trait

class Student{

}
//todo 正常情况下 类继承trait之后 类的所有的实例当然具有了trait里面的方法
//todo 要求类的不同实例有不同的trait
object Student{
  def main(args: Array[String]): Unit = {
    val s1 = new Student with LoveUTrait  //实例混入了一个trait
    s1.sayLove

    val s2 = new Student  with ByeTrait {
      override def sayBye: Unit = println("bye")
    }
    s2.sayBye
  }
}

构造机制与顺序

如果类既继承class 又实现trait 。构造顺序：先父类。再trait 。最后是自己。

class Person {
  println("Person主构造器执行了01")
}

//todo 如果类需要同时继承class和trait 先继承类再继承trait
class Student extends Person with LoveUTrait{
  println("Student主构造器执行了01")
}

object Student{
  def main(args: Array[String]): Unit = {
    val s = new Student
  }
}