Scala包

  • package 包名

    于Java区别：

    1. //嵌套风格
    2. package com{
    3. package atguigu{
    4.   package scala{
    6.   }
    7. }
    8. }
  1. 一个源文件中可以有多个packge
  2. 子包中的类可以直接访问父包中的内容，无需导包

实例：

  1. package com{
  2.   // 在外层包中定义单例对象
  3.   object Outer{
  4.       var out: String = "out"
  5.     def main(args: Array[String]): Unit = {
  6.       Inner // 不能在外层调用内层对象
  7.       //通过导入包可以访问
  8.       import com.atguigu.scala.Inner
  9.       println(Inner.in)
  10.     }
  11.   }
  13.   package atguigu{
  14.     package scala{
  15.       // 内层包中定义单例对象
  16.       Object Inner{
  17.         val in: String = "in"
  18.         def main(args: Array[String]): Unit = {
  19.           println(Outer.out) // 访问
  20.           Outer.out = "outer" // 更改
  21.         }
  22.       }
  23.     }
  24.   }
  25. }
  27. // 在同一文件中定义多个包
  28. package aaa{
  29.   package bbb{
  30.     import com.atguigu.scala.Inner
  31.     object Test{
  32.       def main(args: Array[String]): Unit = {
  33.         println(Inner.in)
  34.       }
  35.     }
  36.   }
  37. }

包对象

  • 与包同名的对象，定义在包对象中的成员，作为其对应包下所有class和object的共享变量，可以直接访问 ```scala package object chapter{ // 定义当前包共享的属性和方法 val commonValue = “NJU” def commonMethod() = { println(s”我们在${commonValue}学习”) } }

// 在同一个包下可以调用

  2. - 必须在同一层级下调用
  3. <a name="nsa2J"></a>
  4. ### 导包
  6. 1. import可以在顶部使用
  7. 1. 局部导入。作用范围内可以使用
  8. 1. 通配符导入： import java.util._
  9. 1. 给类起名：import java.util.{ArrayList => JL} // 将ArrayList类起别名为JL
  10. 1. 导入相同包的多个类：import java.util.{HashSet, ArrayList}
  11. 1. 屏蔽类：import java.util.{ArrayList => _,_} //导入util下的所有包，不导入ArrayList
  13. Scala中三个默认导入：
  15. 1. import java.lang._
  16. 1. import scala._
  17. 1. import scala.Predef._
  18. <a name="APRqc"></a>
  19. ## 类和对象
  20. <a name="IBmEH"></a>
  21. ### 定义类
  22. **Java中**<br />如果是public的，则必须和文件名一致<br />一般，一个.java有一个public类<br />**Scala**<br />Scala中没有public（默认就是public）<br />一个.scala中可以写多个类<br />**Class没有实现可以不写大括号**<br />**创建对象时如果构造器为空，创建对象时可以不写小括号**<br />val类型必须手动初始化，var类型可以使用_ 指定默认值
  23. ```scala
  24. class Student{
  25.   // 定义属性
  26.   private var name: String = "alice"
  27.   @BeanProperty // 自动创建getter setter...
  28.   var age: Int = 18
  29.   var sex: String = _ // 默认初始值
  30. }
  32. object Test {
  33.   def main(args: Array[String]): Unit = {
  34.     // 创建对象
  35.     val student = new Student()
  36.     // 不能 student.name
  37.     println(student.age)
  38.     student.sex = "female"
  39.   }
  40. }

封装

Scala中的public属性，底层实际为private，并通过get方法和set方法对其进行操作。所以Scala并不推荐将属性设置为private，但由于Java框架都利用反射调用getXXX/setXXX方法，有时候为了兼容，为Scala属性设置getset方法（通过@BeanProperty注解实现）

访问权限

  1. Scala中属性默认访问权限public，但无该关键字
  2. private为私有权限，只在类的内部和伴生对象中可用
  3. protected为受保护权限，Scala中同类子类可以使用，同包无法使用
  4. private[包名] 增加包访问权限，包名下其它类可以使用
  5. private可以在伴生类伴生对象中互相访问，private[this] 伴生类都不能访问 ```scala package chapter

// 定义一个父类 class Person { private var idCard: String = “3322” protected var name: String = “alice” var sex String = “female” private[chapter] var age: Int = 18

def printInfo(): Unit = { println(s”Person: $idCard $name $sex $age”) } }

// 定义一个子类 class Worker extends Person { override def printlnInfo(): Unit = { // println(idCard) 不能访问 name = “bob” age = 25 sex = “male” println(s”Worker: $name $sex $age”) } }

object Test { def main(args: Array[String]): Unit = { val person: Person = new Person() // person.idCard //error // person.name // error println(person.age) println(person.sex) person.printInfo()

  1. val worker: Worker = new Worker()
  2. worker.printInfo()

} }

  1. <a name="dJlFT"></a>
  2. ### 构造器
  3. Scala类构造器包括主构造器和辅助构造器<br />**主构造器**
  5. - 主构造器参数列表直接定义在类名后面，添加了val/var表示直接通过主构造器定义成员变量
  6. - 构造器参数列表可以有默认值
  7. - 创建实例，调用构造器可以指定字段进行初始化
  8. - 整个class中除了字段定义和方法定义的代码都是构造代码
  9. ```scala
  10. class 类名(形参列表) { // 主构造器
  11.   // 类体
  12.   def this(形参列表) { // 辅助构造器
  13.   }
  14.   def this(形参列表) { // 辅助构造器可以有多个
  15.   }
  16. }
  1. object Test {
  2.   Class Person(val name: String = "张三", val age: Int = 23) {
  3.     println("调用主构造器")
  4.   }
  6.   def main(args: Array[String]): Unit = {
  7.     val person1 = new Person
  9.     val person2 = new Person("李四", 24)
  11.     val person3 = new Person(age =30)

说明：

  1. 辅助构造器，函数名称this，可以有多个，编译器通过参数个数及类型区分
  2. 辅助构造方法不能直接创建对象，第一行代码必须直接或间接调用主构造方法

  3. 构造器调用其它另外的构造器，要求被调用的必须提前声明 ```scala object Test { def main(args: Array[String]): Unit = { val student1 = new Student //可以省略括号 输出：1. 主构造方法调用 student1.Student() // 输出：一般方法被调用

    val student2 = new Student1(“alice”) // 1. 2. 被调用 val student3 = new Student1(“Bob”, 18) // 1.2.3.都被调用 } }

class Student1() { // 括号一般省略 var name: String = //默认null var age: Int = // 默认0

println(“1. 主构造方法调用”)

//辅助构造器 def this(name:String) { this() // 直接调用主构造方法 println(“2. 辅助构造方法”) this.name = name println(s”name: $name age: $age”) }

def this(nameL String, age: Int) { this(name) // 间接调用主构造器 println(“3. 辅助构造方法二被调用”) this.age = age println(s”name: $name age: $age”) }

def Student(): Unit = { println(“一般方法被调用”) } }

  1. <a name="MzXDj"></a>
  2. #### 构造器参数
  4. - Scala类的主构造器形参包括三种类型：未用任何修饰、var修饰、val修饰
  5. 1. 未用任何修饰符，这个参数为局部变量
  6. 1. var，作为类的成员属性使用，可以修改
  7. 1. val，作为类只读属性使用，不能更改
  8. ```scala
  9. class Student1 {
  10.   var name: String = _ //这里必须是var
  11.   var age: Int = _
  12. }
  14. class Student2(var name: String, var age: Int)
  16. // 主构造器参数无修饰符
  17. class Student3(name: String, age: Int)
  19. object Test {
  20.   def main(args: Array[String]): Unit = {
  21.     // 方式一
  22.     val student1 = new Student1
  23.     student1.name = "alice"
  24.     student1.age = 21 
  25.     //如果不想这样设置参数，想像下面一样，就得在类中增加辅助构造器
  26.     println(s"student1: name = ${student1.name}, age = ${student1.age}")
  28.     //方式二
  29.     val student2 = new Student2("Bob", 12)
  30.     println(s"student2: name = ${student2.name}, age = ${student2.age}")
  32.     val student3 = new Student3("xxx",111)
  33.     println(s"student3: name = ${student3.name}, age = ${student3.age}")// 这样就不行，name和age不是student3的属性
  34.   }
  35. }

主构造器+辅助构造器

  1. class Student4(var name: String, var age: Int) {
  2.   var school: String = _
  4.   def this(name: String, age: Int, school: String) {
  5.     this(name,age)
  6.     this.school = school
  7.   }
  9.   def this(arys: Array[String]) {
  10.     this(arys(0), arys(1))
  11. }

apply方法

在Scala中，支持创建对象不写new关键字，对此就要通过伴生对象的apply()方法实现
apply必须在object里

  1. object Test {
  2.     // 定义Person类
  3.   class Person(var name: String = "", var age: Int = 0) {}
  5.   // 定义Person伴生对象
  6.   object person {
  7.     // 定义apply方法
  8.     def apply(name: String, age: Int) = new Person(name,age)
  9.   }
  11.   def main(args: Array[String]): Unti = {
  12.     val p = Person("张三", 23) // 调用apply方法
  13.     println(p.name, p.age)
  14. }

定义时间工具类

  1. object ClassDemo {
  2.   // 定义工具类
  3.   object DateUtils {
  4.     // 定义SimpleDateFormat类型对象
  5.     var sdf: SimpleDateFormat = null
  7.     // 定义date2String方法，用来将日期转化成对应字符串
  8.     def date2String(date: Date, template: String) = {
  9.       sdf = new SimpleDateFormat(template)
  10.       sdf.format(date)
  11.     }
  13.     // 定义string2Date方法
  14.     def string2Date(dataString: String, template: String) = {
  15.       sdf = new SimpleDateFormat(template)
  16.       sdf.parse(dataString)
  17.     }
  18.   }
  20.   def main(args: Array[String]): Unti = {
  21.     println(DateUtils.date2String(new Date(), "HH:mm:ss"))
  22.     println(DateUtils.string2Date("1314年5月22日","yyyy年MM月dd日"))
  23.   }
  24. }

继承和多态

class/object A类 extends B类 {}

  • 类和单例对象都可以有父类 ```scala class Person { var name = “” def sayHello() = println(“Hello, Scala..”) }

object Student extends Person

def main(args: Array[String]): Unit = { Student.name = “张三” println(Student.name) Student.sayHello() }

  2. - 继承的调用顺序：父类构造器->子类构造器
  3. ```scala
  4. object Test {
  5.   def main(args: Array[String]): Unit = {
  6.     val student1 = new Student
  7.   }
  8. }
  10. class Person {
  11.   var name: String = _
  12.   var age : Int = _
  13.   println("1.父类主构造器")
  15.   def this(name: String, age: Int){
  16.     this()
  17.     println("2. 父类辅助构造器调用")
  18.     this.name = name 
  19.     this.age = age
  20.   }
  22.   def printlnInfo(): Unit = {
  23.     println(s"Person: $name $age")
  24.   }
  25. }
  27. class Student(name: String, age: Int) extends Person {
  28.   var stdNo: String = _
  29.   println("3.子类主构造器")
  31.   def this(name: String, age: Int, stdNo: String) {
  32.     this(name, age)
  33.     println("4. 子类的辅助构造器")
  34.     this.stdno = stdNo
  35.   }
  37.   override def printInfo(): Unit = {
  38.     println(s"Person: $name $age $stdNo")
  39.   }
  40. }

多态

在Java中 属性是静态绑定的

  1. // Java
  2. class Person{
  3.   String name = "person";
  4.   public void hello(){
  5.     System.out.println("hello person")
  6.   }
  7. }
  9. class Worker extends Person{
  10.   String name = "worker"
  11.   public void hello(){
  12.     System.out.println("hello worker")
  13.   }
  14.   public void hi(){
  15.     System.out.println("hi worker")
  16.   }
  17. }
  19. public class Test{
  20.   public static void main(String[] args){    
  21.     Person person = new Worker()
  23.     person.name // person 静态绑定
  24.     person.hello() // hello worker 动态绑定
  25.     person.hi() //error
  26.   }
  27. }
  • Scala中更加彻底，属性也是动态绑定 ```scala object Test { def main(args: Array[String]): Unit = {
    1. val student: Person = new Student
    println(student.name) // student student.hello() // hello student } }

class Person { var name: String = “person” def hello(): Unit = { println(“hello person”) } }

class Student extend Person { var name: String = “student” override def hello(): Unit = { println(“hello student”) } }

  2. <a name="zFKy7"></a>
  3. ## 抽象类
  4. 如果类中有抽象字段或抽象方法，那么该类就是一个抽象类
  6. - 抽象字段：没有初始化值的变量
  7. - 抽象方法：没有方法体的方法
  8. <a name="T8RQ7"></a>
  9. ### 抽象类属性和抽象方法
  10. <a name="yVatH"></a>
  11. #### 基本语法
  13. 1. 定义抽象类： abstract class Person()
  14. 1. 定义抽象属性：val name: String //只有抽象属性没有初始化
  15. 1. 定义抽象方法：def hello(): String //只声明没有实现
  16. - 只要出现抽象属性和方法必须是抽象类
  17. - 抽象类可以有具体方法
  18. <a name="zZ7Ub"></a>
  19. #### 重写和继承
  21. 1. 如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需要声明为抽象类
  22. 1. 重写非抽象方法需要用override修饰，重写抽象方法可以不加
  23. 1. 子类中调用父类的方法使用super关键字
  24. 1. 子类对抽象属性进行实现，父类抽象属性可以用var修饰
  26. 子类对非抽象属性进行重写，父类非抽象属性只支持val类型，而不支持var，因为var修饰符为可变变量，子类继承之后就可以直接使用，没有必要重写
  27. ```scala
  28. object Test {
  29.   def main(args: Array[String]): Unit = {
  30.     val student = new Student
  31.     student.eat() // person eat student eat
  32.     student.sleep() //student sleep
  33.   }
  34. }
  36. // 定义抽象类
  37. abstract class Person{
  38.   // 非抽象属性
  39.   val name: String = "person"
  41.   // 抽象属性
  42.   var age: Int
  44.   // 非抽象方法
  45.   def eat(): Unit = {
  46.     println("person eat")
  47.   }
  49.   // 抽象方法
  50.   def sleep(): Unit 
  52.   // 非抽象方法
  53.   def eat(): Unit = {
  54.     println("person eat")
  55.   }
  57. }
  59. class Student extends Person {
  60.   var age: Int = 18
  61.   def sleep(): Unti = {
  62.     println("student sleep")
  63.   }
  65.   // 重写非抽象属性和方法，如果父类是var的，直接改就行了
  66.   override val name: String = "student"
  68.   override def eat(): Unit = {
  69.     super.eat()
  70.     println("student eat") 
  71.   }
  72. }

isInstanceOf & asInstanceOf

  • isInstanceOf 判断是否为指定类型对象
  • asInstanceOf将对象转换为指定类型 ```scala class Person

class Student extends Person { def sayHello(): Unit = { println(“Hello!”) } }

object Test02 { def main(args: Array[String]): Unit = { val person: Person = new Student if (person.isInstanceOf[Student]) person.asInstanceOf[Student].sayHello() } }

  1. <a name="uEPAi"></a>
  2. ### getClass & classOf
  4. - isInstanceOf只能判断出对象是否为指定类型及其子类的对象，而不能精准的判断出对象就是指定类的对象。如果要求精准的判断出指定数据类型，只能使用一下方法
  5. - getClass可以精准获取对象的类型
  6. - classOf[类名] 可以精准获取数据类型
  7. - 使用==操作符可以直接比较类型
  8. ```scala
  9. class Person2
  11. class Student2 extends Person2 {
  12.   def sayHello(): Unit = {
  13.     println("Hello!")
  14.   }
  15. }
  17. object Test03 {
  18.   def main(args: Array[String]): Unit = {
  19.     val person: Person2 = new Student2
  21.     println(person.isInstanceOf[Person2]) //true
  22.     println(person.isInstanceOf[Student2]) // true
  24.     println(person.getClass == classOf[Person2]) //false
  25.     println(person.getClass == classOf[Student2]) //true
  26.   }
  27. }

匿名内部类（抽象类型的子类）

使用场景：

  1. 成员方法只调用一次
  2. 可以作为方法的实际参数传递

如果匿名内部类的主构造器为空，小括号可以不写

  1. object Test {
  2.   def main(args: Array[String]): Unit = {
  3.     // 1
  4.     val person: Person = new Person{
  5.       override var name: String = _
  6.       override def eat(): Unit = println("person eat1")
  7.       }.eat()
  8.     println(person.name)
  10.     // 2
  11.     def show(p:person) = p.eat()
  12.     val person2: Person = new Person{ //实际上是多态
  13.       override def eat(): Unit = println("person eat2")
  14.     }
  15.     show(person2)
  16.   } 
  17. }
  19. // 定义抽象类
  20. abstract class Person {
  21.   var name: String 
  22.   def eat(): Unit 
  23. }

单例对象（伴生对象）

Scala语言完全面向对象，所以没有静态操作。但是为了能够和Java交互，就产生了一种特殊的对象来模拟类对象，该对象为单例对象。单例对象与类名一致，类所有静态内容都可以放置在它的半生对象中声明。

  1. 单例对象采用object关键字
  2. 单例对象对应的伴生类名称一样
  3. 单例对象的属性和方法都可以通过伴生对象名（类名）直接调用访问（private也可以） ```scala Object Test { def main(args: Array[String]): Unit = { val student = new Student(“alice”, 18) student.printInfo() } }

// 定义类 class Student(val name: String, val age: Int) { def printInfo() = { println(s”student: name = ${name}, age = $age, school = $Student.school”) } }

// 伴生对象 object Student { val school: String = “atg” }

  1. <a name="Y1xaw"></a>
  2. #### 伴生对象调用构造方法
  3. ```scala
  4. Object Test {
  5.   def main(args: Array[String]): Unit = {
  6.         val student = Student.newStudent("alice",14)
  7.     val student2 = Student.apply("bob",18)
  8.     val student2 = Student("bob",18) // apply方法可以省略
  9.     student.printInfo()
  10.   }
  11. }
  13. // 定义类
  14. class Student private(val name: String, val age: Int) { //构造器私有化
  15.   def printInfo() = {
  16.     println(s"student: name = ${name}, age = $age, school = $Student.school")
  17.   }
  18. }
  20. // 伴生对象
  21. object Student {
  22.   val school: String = "atg"
  24.   // 定义了一个类的对象实例创建方法,包装好
  25.   def newStudent(name: String, age: Int): Student = new Student(name, age)
  27.   def apply(name: String, age: Int): Student = new Student(name, age)
  28. }
  • 对于伴生对象中的apply() 调用时可以省略 .apply

    使用继承App特质的方式定义程序主入口

    1. object Test extends App{
    2. println("")
    3. }

    单例设计模式

    ```scala class Student private(val name: String, val age: Int) { //构造器私有化 def printInfo() = { println(s”student: name = ${name}, age = $age, school = $Student.school”) } }

// 饿汉式 object Student { private val student: Student = new Student(“alice”,12) def getInstance(): Student = student }

// 懒汉式 object Student2 { private var student: Student2 = _ def getInstance(): Student2 = { if (student == null) { // 如果没有实例的话，创建一个 student = new Student2(“alice”, 18) } student } }

object Test { def main(args: Array[String]): Unit = { val student1 = Student.getInstance() val student2 = Student.getInstance()

  1. // 引用地址完全一样
  2. println(student1)
  3. println(student2)

} }

  2. <a name="e2p75"></a>
  3. ## 特质（Trait）
  4. Scala语言中，采用特质来代替接口，也就是说多个类具有相同特质时，就可以将这个特质独立出来，采用trait声明<br />Scala中trait可以有抽象属性和方法，**也可以有具体的属性和方法**，一个类可以混入多个特质，类似于Java中的抽象类
  5. ```scala
  6. trait 特质名{
  7. }
  8. class 类名 extends 特质1 with 特质2 // 没有父类
  9. class 类名 extends 父类 with 特质1 with 特质2 // 有父类
  1. object Test {
  2.   def main(args: Array[String]): Unit = {
  3.     val student = new Student
  4.     student.sayHello()
  5.     student.study()
  6.     student.dating()
  7.   }
  9. class Person {
  10.   val name: String = "person"
  11.   var age: Int = 18
  12.   def sayHello(): Unit = {
  13.     println("hello from:" + name)
  14.   }
  15. }
  17. trait Young{
  18.   // 声明抽象和非抽象属性
  19.   var age: Int 
  20.   val name: String = "young"
  22.   // 非抽象方法
  23.   def play(): Unit = {
  24.     println("young people is playing")
  25.   }
  26.   // 抽象方法
  27.   def dating(): Unit 
  28. }
  30. class Student extends Person with Young {
  31.   // 重写冲突的属性
  32.   override val name: String = "student"
  34.   def dating(): Unit = println(s"student $name is dating")
  36.   def study(): Unit = println(s"student $name is studying")
  38.   // 重写父类的方法
  39.   override def sayHello(): Unit = {
  40.     super.sayHello()
  41.     println(s"hello froms: student $name")
  42.   }
  43. }

单例对象继承特质

  1. object Test07 {
  2.   def main(args: Array[String]): Unit = {
  3.     ConsoleLogger.log("Success")
  4.     ConsoleLogger.warn("Warning")
  5.   }
  7. }
  9. trait Logger {
  10.   def log(msg: String)
  11. }
  13. trait Waring {
  14.   def warn(msg: String)
  15. }
  17. object ConsoleLogger extends Logger with Waring {
  18.   override def log(msg: String) = println(s"Log: $msg" )
  20.   override def warn(msg: String): Unit = println(s"Warn: $msg")
  22. }

特质的混入

  1. object Test {
  2.   def main(args: Array[String]): Unit = {
  3.     val student = new Student
  4.     student.study()
  5.     student.increase()
  7.     // 动态混入:让某个对象临时可以访问某个特质中的成员
  8.     val studentWithTalent = new Student with Talent {
  9.       override def dancing(): Unit = println("dancing")
  10.       override def singing(): Unit = println("singing")
  11.     }
  12.     studentWithTalen.dancing()
  13.   }
  14. }
  16. trait Talent {
  17.     def singing(): Unit 
  18.   def dancing(): Unit
  19. }
  21. // 再定义一个特质
  22. trait Knowledge {
  23.   var amount: Int = 0
  24.   def increase(): Unit
  25. }
  27. class Student extends Person with Young with Knowledge {
  28.   // 重写冲突的属性
  29.   override val name: String = "student"
  31.   def dating(): Unit = println(s"student $name is dating")
  33.   def study(): Unit = println(s"student $name is studying")
  35.   // 重写父类的方法
  36.   override def sayHello(): Unit = {
  37.     super.sayHello()
  38.     println(s"hello froms: student $name")
  39.   }
  41.   override def increase()L Unit = {
  42.     amount += 1
  43.     println(s"student $name knowledge increase $amount")
  44.   }
  45. }

特质叠加

  1. trait Talent{
  2.   def dancing(): Unit
  3.   def increase(): Unit = println("talent increase")
  4. }
  5. trait Knowledge{
  6.   def dancing(): Unit
  7.   def increase(): Unit = println("knowledge increase")
  8. }
  10. class Student extend Person with Talent with Knowledge {
  11.   override def dancing(): Unit = println("dancing")
  13.   override def increase(): Unit = {
  14.     super.increase() // konwledge increase
  15.   }
  16. }
  • 把最后一个特质中的方法作为调用（从右到左）

    特质和抽象类的区别

  1. 优先使用特质，一个类扩展多个特质是方便的，但只能扩展一个抽象类
  2. 如果需要构造函数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行

    特质自身类型

    ```scala object Test { def main(args: Array[String]): Unit = { var user = new Register(“alice”, 12345) user.insert() } }

class User(val name: String, val password: String)

trait UserDao { // 想要拥有User的属性又不想继承User _: User => // 将自身类指定为User 依赖注入

// 向数据库插入数据 def insert(): Unit = { println(s”insert into db: ${this.name}”) } }

// 定义注册用户类 class RegisterUser(name: String, password: String) extends User(name, password) with UserDao {}

  1. <a name="ND1Kp"></a>
  2. ### 使用trait实现适配器模式
  3. 设计模式是前辈们对代码开发经验的总结，用来提高代码可复用性、可维护性、可读性、稳健性、安全性
  4. <a name="sSC5U"></a>
  5. #### 分类：
  7. 1. 创建型：单例模式，工厂方法
  8. 1. 结构型：类、特质之间的关系架构，适配器模式，装饰模式
  9. 1. 行为型：类能够做什么，模板方法模式，职责链模式
  10. <a name="nAjXu"></a>
  11. #### 适配器模式
  12. 当特质中有多个抽象方法，而我们只需要其中的某一个或某几个方法时，不得不将该特质中的所有抽象方法重写，这样很麻烦。我们可以定义一个抽象类去继承该特质，重写特质中的抽象方法，方法体为空。这时候我们需要哪个方法只需要定义类继承抽象类，重写指定方法即可，这个抽象类就叫做适配器类
  13. ```scala
  14. object Test01 {
  15.   def main(args: Array[String]): Unit = {
  16.     val greenHand = new GreenHand
  17.     greenHand.support()
  18.     greenHand.schoolchild()
  19.   }
  20. }
  22. trait PlayLOL {
  23.   def top()
  24.   def mid()
  25.   def adc()
  26.   def support()
  27.   def jungle()
  28.   def schoolchild()
  29. }
  31. abstract class Play extends PlayLOL {
  32.   override def top(): Unit = ???
  34.   override def mid(): Unit = ???
  36.   override def adc(): Unit = ???
  38.   override def support(): Unit = ???
  40.   override def jungle(): Unit = ???
  42.   override def schoolchild(): Unit
  43. }
  45. class GreenHand extends Play {
  47.   override def support() = {
  48.     println("support")
  49.   }
  51.   override def schoolchild() = {
  52.     println("schoolchild")
  53.   }
  54. }

模板方法

扩展性更强，符合开闭原则

  1. abstract class Template {
  2.   // 记录获取时间
  3.   def code()
  5.   // 具体规则
  6.   def getRuntime() = {
  7.         val start = System.currentTimeMillis()
  8.     code()
  9.     val end = System.currentTimeMillis()
  10.     end - start
  11.   }
  12. }
  14. class ForDemo extends Template {
  15.   override def code(): Unit = for(i <- 1 to 10000) println("say hello")
  16. }
  18. def main(args: Array[String]): Unit = {
  19.   val fd = new ForDemo
  20.   println(fd.getRuntime())
  21. }

样例类

case class 样例类(val/var 成员变量名：类型 …) val/var 如果不写默认是val , 括号不能省
样例类中默认的方法

  • apply() 让我们快速使用类名创建对象，省去new关键字
  • toString() 打印对象属性
  • equals() 可以让我直接用==判断对象成员变量值
  • hasCode() 用来获取对象的哈希值，同一对象哈希值相同

  • copy() 可以快速创建一个属性值相同的实例对象，还可以使用带名参数赋值 ```scala object Test02 { def main(args: Array[String]): Unit = { val p1 = Person(“李四”, 24) // 因为有apply方法所以省略new

    println(p1) // 默认调用类toString方法

    val p2 = Person(“李四”, 24)

    println(p1 == p2) // equals()让我们可以用==比较对象的属性

    // 同一对象哈希值肯定相同，不同对象哈希值一般不同，下面相同 println(p1.hashCode()) println(p2.hashCode())

    // 基于一个对象快速构建另一个对象 val p3 = p2.copy(age = 35) println(p3) } }

case class Person(name: String = “张三”, var age: Int = 23)

  1. ```scala
  2. // 计算器样例
  3. object Test04 {
  4.   def main(args: Array[String]): Unit = {
  5.     val c = Calculate(3, 2)
  6.     println(c.add()) //5
  7.   }
  8. }
  10. case class Calculate(a: Int, b: Int) {
  11.   def add() = a + b
  12.   def subtract() = a - b
  13.   def multiply () = a * b
  14.   def divide() = a / b
  15. }

样例对象

用case修饰，没有主构造器

  1. 当作枚举值使用：固定值用于统一规范
  2. 作为没有任何参数的消息传递 ```scala object Test03 { def main(args: Array[String]): Unit = { val person = Person03(“张三”, Male) println(person.name, person.sex) //(张三,Male) } }

trait Sex {

}

case object Male extends Sex

case object Female extends Sex

case class Person03(var name: String, var sex: Sex)

  1. <a name="DTIjE"></a>
  2. ### trait构造机制
  3. ```scala
  4. trait Logger {
  5.     println("执行Logger构造器")
  6. }
  8. trait MyLogger extends Logger{
  9.     println("执行MyLogger构造器")
  10. }
  12. trait TimeLogger extends Logger {
  13.     println("执行TimeLogger构造器")
  14. }
  16. class Person {
  17.   println("执行Person构造器")
  18. }
  20. class Student extends Person with MyLogger with TimeLogger {
  21.     println("执行Student类构造器")
  22. }
  24. def main(args: Array[String]): Unit = {
  25.   val student = new Student
  26.     /**
  27.   1 执行Person类构造器
  28.   2 执行Logger构造器
  29.   3 执行MyLogger构造器
  30.   4 执行TimeLogger构造器
  31.   5 执行Student类构造器
  32.   */
  33. }

案例：程序员类

  1. class Programeer {
  2.   var name: String = _
  3.   var age: Int = _
  4.   def eat() {}
  5.   def skill() {}
  6. }
  8. trait BigData {
  9.   def learningBigDate() {
  10.         println("learnint bigdata")
  11.   }
  12. }
  14. class JavaProgrammer extends Programmer {
  15.     override eat() {
  16.     println("Java eat")
  17.   }
  19.   override skill() {
  20.     println("Java skill")
  21.   }
  22. }    
  24. class PythonProgrammer extends Programmer {
  25.   override eat() {
  27.   }
  28.   override skill(){
  29.   }
  30. }
  32. class PartJavaProgrammer extends JavaProgrammer with BigData {
  33.   override eat() {
  34.   }
  35.   override skill(){
  36.     super.skill()
  37.     learningBigData()
  38.   }
  39. }
  41. class PartPythonProgrammer extends PythonProgrammer with BigData {
  42.   override eat() {
  43.   }
  44.   override skill(){
  45.     super.skill()
  46.     learningBigData()
  47.   }
  48. }
  50. object Test {
  51.   def main(args: Array[String]): Unit = {
  52.       val jp = new JavaProgrammer
  53.     jp.name = "zhangsan"
  54.     jp.age = 23
  55.     jp.skll()
  56.     jp.eat()
  58.     val pjp = new PartJavaProgrammer
  59.     pjp.name = "666"
  60.     pjp.age = 23
  61.     pjp.skill()
  62.   }
  63. }
  1. Object Test {
  2.   def main(args: Array[String]): Unit = {
  3.     // 创建二维数组
  4.     val array: Array[Array[Int]] = Array.ofDim[Int](2,3)
  6.     // 访问元素
  7.     array(0)(2) = 19
  8.     array(1)(0) = 25
  10.     println(array.mkString(", "))
  11.       for (i <- 0 until array.length; j <- 0 until array(i).length) {
  12.       println(array(i)(j))
  13.     }
  14.     for ( i <- array.length; j <- array(i).indices) {
  15.       print(array(i)(j) + "\t")
  16.       if (j == array(i).length -1) println()
  17.     }
  19.     array.foreach(line => line.foreach(println))
  20.     array.foreach(_.foreach(println))
  21.   }
  22. }