Scala语言进阶（一）

                

目录

• 1. 关于SCALA包​​​​​​​
• 1.1包命名规则
• 1.2 包对象
• 1.3 导包说明
• 2.关于CLASS类
• 2.1 定义语法
• 2.2 属性
• 3. 封装
•  3.1 访问权限
• 3.2 方法
• 3.3 创建对象
• 3.4 构造器
• 3.5 关于构造器
• 4.继承和多态
• 4.1 基本语法
•  4.2 关于构造器调用顺序的分析
• 4.3 动态绑定
• 5.抽象类
• 5.1 基本语法
• 5.2 匿名对象
• 5.3 单例对象
• 5.4 特质（Trait）

---

相关SCALA可以参考：

Scala基础语法（一）本文涉及scala环境的配置，scala插件的安装，scala语言的基本语法操作。。。。https://blog.csdn.net/baidu_41833099/article/details/124726767?spm=1001.2014.3001.5501Scala基础语法（二）目录1. 函数基础语法1.1. 函数与方法的区别1.2 函数的定义1.3 关于函数的参数1.4 函数至简原则1.5 函数高阶用法（1）作为值进行传递（2）作为参数传递（3）函数可以作为函数返回值返回1.6匿名函数1.7 高阶函数案例1.8 函数柯里化和闭包闭包和柯里化案例如下：1.9 关于递归1.10 自定义while循环1.11 惰性加载首先，Scala 语言是一个完全面向对象编程语言。万物皆对象。其本质与JAVA一致。其次，S..https://blog.csdn.net/baidu_41833099/article/details/124792893?spm=1001.2014.3001.5501

---

1. 关于SCALA包

1.1 包命名规则

只能包含数字、字母、下划线、小圆点.，但不能用数字开头，也不要使用关键字。

一般是小写字母+小圆点 com.

域名.公司名.项目名.业务模块名

1.2 包对象

在 Scala 中可以为每个包定义一个同名的包对象，定义在包对象中的成员，作为其对 应包下所有 class 和 object 的共享变量，可以被直接访问。

在包对象中可以定义，在这个包内可以共享的内容

1.3 导包说明

注意：

Scala 中的三个默认导入分别是

import java.lang._

import scala._

import scala.Predef._

2.关于CLASS类

2.1 定义语法

定义语法与JAVA差不多，没有public关键字

//（1）Scala 语法中，类并不声明为 public，所有这些类都具有公有可见性（即默 认就是 public），加上public就报错了

         class Person { }

//（2）一个 Scala 源文件可以包含多个类

        class Teacher{ }

注意：不管是定义类也好，定义变量也好，什么都不加就是为public

2.2 属性

基本语法

[修饰符] var|val 属性名称 [：类型] = 属性值

注：Bean 属性（@BeanPropetry），可以自动生成规范的 setXxx/getXxx 方法

object test01 {
  def main(args: Array[String]): Unit = {
    val person = new Person
    person.setAge(13)
    person.setName("alice")
    
    person.age = 45
    person.name = "MAKI"
    println(person.getName + "-" + person.getAge)
  }
}


class Person {
  //@BeanProperty 使属性自动添加get/set方法
  @BeanProperty var name: String = "bobo"
  @BeanProperty var age: Int = _ // _表示给一个默认值
}

3. 封装

 3.1 访问权限

（1）Scala 中属性和方法的默认访问权限为 public，但 Scala 中无 public 关键字。

（2）private 为私有权限，只在类的内部和伴生对象中可用。

（3）protected 为受保护权限，Scala 中受保护权限比 Java 中更严格，同类、子类可以 访问，同包无法访问。

（4）private[包名]增加包访问权限，包名下的其他类也可以使用

3.2 方法

def 方法名(参数列表) [：返回值类型] = {

        方法体

}

class Person {
  //@BeanProperty 使属性自动添加get/set方法
  @BeanProperty var name: String = "bobo"
  @BeanProperty var age: Int = _ // _表示给一个默认值
  def sum(n1: Int, n2: Int): Int = {
    n1 + n2
  }
}

3.3 创建对象

与JAVA创建对象一致

val | var 对象名 [：类型] = new 类型()

比如：val person = new Person() 或者定义一个变量  var person= new Person()

3.4 构造器

scala的构造器分为主构造器，和辅助构造器。如下所示。

比较推荐的方式是，直接在类定义的时候传入参数：

class Student1(var name: String, var age: Int)

object Test02_Construct {
  def main(args: Array[String]): Unit = {
    val student = new Student1("蓝兔")
    val student1 = new Student1("虹猫",14)
  }
}

class Student1() {
  //  定义属性
  var name: String = _
  var age: Int = _
  println("1. 主构造方法被调用")

  //  声明辅助构造方法
  def this(name: String) {
    this() //    直接调用柱构造器
    println("2. 辅助构造器被调用")
    this.name = name
    println(s"name: ${name} age:${age}")
  }

  def this(name: String, age: Int) {
    this() //调用柱构造器
    println("3. 辅助构造器被调用")
    this.name = name
    this.age = age
    println(s"name: ${name} age:${age}")
  }

  def Student1()() = {
    println("一般方法调用")
  }
}

3.5 关于构造器

Scala 类的主构造器函数的形参包括三种类型：未用任何修饰、var 修饰、val 修饰

（1）未用任何修饰符修饰，这个参数就是一个局部变量

（2）var 修饰参数，作为类的成员属性使用，可以修改

（3）val 修饰参数，作为类只读属性使用，不能修改

4.继承和多态

4.1 基本语法

 4.2 关于构造器调用顺序的分析

   先调用父类构造器，再调用子类构造器

object Test03_Inherit {
  def main(args: Array[String]): Unit = {
    val bob = new Student03("BOB", 12)
    val alice = new Student03("alice", 12, "123456")
    println(bob.name)
    println(s"${bob.name} ${bob.age}")
    println(s"${alice.name} ${alice.age} ${alice.stdID}")
  }
}

class Person03() {
  var name: String = _
  var age: Int = _

  def this(name: String, age: Int) {
    this()
    this.name = name
    this.age = age
    println("调用父类辅助构造器")
  }

  println("调用父类构造器")
}

class Student03(name: String, age: Int) extends Person03 {
  var stdID: String = _

  def this(name: String, age: Int, stdID: String) {
    this(name, age)
    this.stdID = stdID
    println("调用子类辅助构造器")
  }
}

4.3 动态绑定

Scala 中属性和方法都是动态绑定，而 Java 中只有方法为动态绑定。

在方法中父类引用指向子类对象，子类重写方法后调用的是子类的方法。

在Scala中更进一步是，属性也可以重写，子类重写属性后调用的是子类的属性值

5.抽象类

5.1 基本语法

注意：

（1）如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明 为抽象类 （2）重写非抽象方法需要用 override 修饰，重写抽象方法则可以不加 override。

（3）子类中调用父类的方法使用 super 关键字

（4）子类对抽象属性进行实现，父类抽象属性可以用 var 修饰； 子类对非抽象属性重写，父类非抽象属性只支持 val 类型，而不支持 var。 因为 var 修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写

5.2 匿名对象

与JAVA一致

5.3 单例对象

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概 念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象 来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴 生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

（1）单例对象及语法

案例： 

// 饿汉单例模式
object Cat{
  private val cat: Cat = new Cat("小红", 2)
  def getINS(): Cat ={
     cat
  }
}

//懒汉单例模式
object Cat {
  private var cat: Cat = _

  def getinstance(): Cat = {
    if (cat == null){
      cat = new Cat("小白",1)
    }
    cat
  }
}

5.4 特质（Trait）

Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可 以混入（mixin）多个特质。这种感觉类似于 Java 中的抽象类。 Scala 引入 trait 特征，第一可以替代 Java 的接口，第二个也是对单继承机制的一种补充。