Scala（六）面向对象

6.1 Scala包

　　1）基本语法

package 包名

　　2）Scala包的三大作用（和Java一样）

　　（1）区分相同名字的类

　　（2）当类很多时，可以很好的管理类

　　（3）控制访问范围

6.1.1 包的命名

　　1）命名规则

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

　　2）案例实操

demo.class.exec1  //错误，因为 class 关键字
demo.12a    //错误，数字开头

　　3）命名规范

#一般是小写字母+小圆点
com.公司名.项目名.业务模块名

　　4）案例实操

com.yuange.oa.model  
com.yuange.oa.controller
com.sohu.bank.order

6.1.2 包说明

　　1）说明

　　　　scala有两种包的管理风格，一种方式和java的包管理风格相同，每个源文件一个包，包名用“.”进行分隔以表示包的层级关系，如com.yuange.scala。另一种风格，通过嵌套的风格表示层级关系，如下：

package com{
    package yuange{
        package scala{
        }
    }
}

　　第二种风格有以下特点：

　　　　（1）一个源文件中可以声明多个package

　　　　（2）子包中的类可以直接访问父包中的内容，而无需导包

　　2）案例实操

package com.yuange.scala.day03{
  //导入子包
  import com.yuange.scala.day03.test.PackageOneOne

  object PackageOne {
    var outer: String = "outer"
    def main(args: Array[String]): Unit = {
      //父包访问子包中的内容需要导包
      println("我是父包，正在调用子包：" + PackageOneOne.inner)
    }
  }

  package test{
    object PackageOneOne {
      var inner: String = "inner"
      def main(args: Array[String]): Unit = {
        //子包访问父包中的内容无需导包
        println("我是子包，正在调用父包：" + PackageOne.outer)
      }
    }
  }
}

package other {
}

6.1.3 包对象

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

　　定义：

package com.yuange.scala

package object day03 {
  var name = "张三"
  def test() = {
    println("包方法")
  }
}

　　　　（1） 若使用java的包管理风格，则包对象一般定义在其对应包下的package.scala文件中，包对象名与包名保持一致。

　　　　（2） 如采用嵌套方式管理包，则包对象可与包定义在同一文件中，但是要保证包对象与包声明在同一作用域中。

package com.yuange.scala

package day03{
  object PackageTwo {
    var outer: String = "outer"

    def main(args: Array[String]): Unit = {
      //调用day03包中的属性和方法
      println(name)
      test()
    }
  }
}

package object day03 {
  var name = "张三"
  def test() = {
    println("包方法")
  }
}

6.1.4 导包说明

　　1）说明

import com.atguigu.Fruit	引入com.atguigu包下Fruit（class和object）
import com.atguigu._	引入com.atguigu下的所有成员
import com.atguigu.Fruit._	引入Fruit(object)的所有成员
import com.atguigu.{Fruit,Vegetable}	引入com.atguigu下的Fruit和Vegetable
import com.atguigu.{Fruit=>Shuiguo}	引入com.atguigu包下的Fruit并更名为Shuiguo
import com.atguigu.{Fruit=>Shuiguo,_}	引入com.atguigu包下的所有成员，并将Fruit更名为Shuiguo
import com.atguigu.{Fruit=>_,_}	引入com.atguigu包下除去Fruit的所有成员

　　2）scala中的三个默认导入分别是

import java.lang._
import scala._
import scala.Predef._

6.1.5 访问权限

　　1）在Java中，访问权限分为：public，private，protected和默认。在Scala中，你可以通过类似的修饰符达到同样的效果。但是使用上有区别。

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

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

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

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

　　2）案例实操

package com.yuange.scala.day03

class Person{
  private var id: Int = 1001
  protected var name: String = "张三"
  private[day03] var sex: String = "男"

  def say(): Unit = {
    println("id=" + id)
  }
}

class Teacher extends Person{
  def test(): Unit = {
    println(this.name)
    println(this.sex)
  }
}

class Animal{
  def test: Unit = {
    println(new Person().sex)
  }
}

object Person {
  def main(args: Array[String]): Unit = {
    var person = new Person()
    person.say()
    println(person.id)
    println(person.name)
    println("----------------------------------------------------")
    var teacher = new Teacher()
    teacher.test()
    println("----------------------------------------------------")
    var animal = new Animal()
    animal.test
  }
}

6.2 类和对象

6.2.1 定义类

　　1）基本语法

[修饰符] class 类名 {
   类体
}

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

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

　　2）案例实操

package com.yuange.scala.day03

//Scala语法中，类并不声明为public，所有的类默认是public
class Cat {
}

//一个.scala源文件可以包含多个类
class dog{
}

6.2.2 属性

　　属性是类的一个组成部分

　　1）基本语法（Bean属性（@BeanPropetry），可以自动生成规范的setXxx/getXxx方法）

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

　　2）案例实操

package com.yuange.scala.day03

import scala.beans.BeanProperty

class Boot{
  var name: String = "英语书"  //定义属性
  var age: Int = _    //_表示给age一个默认值，Int的默认值是0
  @BeanProperty //类似于拥有get/set方法
  var address: String = _
}

object Boot {
  def main(args: Array[String]): Unit = {
    var boot = new Boot()
    println(boot.name)
    println(boot.age)

    boot.setAddress("广东省深圳市宝安区")
    println(boot.getAddress)
  }
}

6.2.3 方法

　　1）基本语法

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

　　2）案例实操

package com.yuange.scala.day03

class Pay{
  def payMoney(name: String,number: Double): Boolean = {
    println(name + "支付了" + number + "元人民币")
    true
  }
}

object Pay {
  def main(args: Array[String]): Unit = {
    var pay = new Pay()
    pay.payMoney("张三",5000.00)
  }
}

6.2.4 创建对象

　　1）基本语法

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

　　2）案例实操

　　　　（1）val修饰对象，不能改变对象的引用（即：内存地址），可以改变对象属性的值。

　　　　（2）var修饰对象，可以修改对象的引用和修改对象的属性值

package com.yuange.scala.day03

class Car{
  var id: Int = _
  var name: String = _
}

object Car {
  def main(args: Array[String]): Unit = {
    //var修饰的对象不能改变对象的引用（内存地址），可以改变对象的属性值
    val car = new Car()
    car.id = 102
    println("car.id:" + car.id)
    println("car.name:" + car.name)
  }
}

6.2.5 构造器

　　和Java一样，Scala构造对象也需要调用构造方法，并且可以有任意多个构造方法。

　　Scala类的构造器包括：主构造器和辅助构造器

　　1）基本语法

class 类名(形参列表) {  // 主构造器
   // 类体
   def  this(形参列表) {  // 辅助构造器
   }
   def  this(形参列表) {  //辅助构造器可以有多个...
   }
} 

　　　　（1）辅助构造器，函数的名称this，可以有多个，编译器通过参数的个数来区分。

　　　　（2）辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。

　　2）案例实操

　　　　（1）如果主构造器无参数，小括号可省略，构建对象时调用的构造方法的小括号也可以省略。

package com.yuange.scala.day03

//若主构造器无参数，小括号可以省略
class Rabbit{
  var id: Int = _
  var name: String = "小白兔"

  def this(id: Int){
    this()
    this.id = id
    println("辅助构造器1")
  }

  def this(id: Int,name: String){
    this(id)
    this.name = name
    println("辅助构造器2")
  }

  println("主构造器")
}

object Rabbit {
  def main(args: Array[String]): Unit = {
    val rabbit = new Rabbit(188)
    println("rabbit.id=" + rabbit.id)
    println("rabbit.name=" + rabbit.name)
    println("------------------------------------------------------")
    var rabbit2 = new Rabbit(199,"大白兔")
    println("rabbit.id=" + rabbit2.id)
    println("rabbit.name=" + rabbit2.name)
  }
}

6.2.6 构造器参数

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

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

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

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

　　2）案例实操

package com.yuange.scala.day03

class Elephant(id: Int,var name: String,val sex: String){

}

object Elephant {
  def main(args: Array[String]): Unit = {
    var elephant = new Elephant(103,"象哥","雄性")
//    println(elephant.id)  //未用修饰符修饰，局部变量
    elephant.name = "大象哥" //使用var修饰，可以作为类成员属性使用且可以修改
    println(elephant.name)
//    elephant.sex = "雌性"   //使用val修饰，只具备只读属性
    println(elephant.sex)
  }
}

6.3 封装

　　封装就是把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。java封装操作如下：

　　（1）将属性进行私有化

　　（2）提供一个公共的set方法，用于对属性赋值

　　（3）提供一个公共的get方法，用于获取属性的值

　　scala中的public属性，底层实际为private，并通过get方法（obj.field()）和set方法（obj.field_=(value)）对其进行操作。所以scala并不推荐将属性设为private，再为其设置public的get和set方法的做法。但由于很多java框架都利用反射调用getXXX和setXXX方法，有时候为了和这些框架兼容，也会为scala的属性设置getXXX和setXXX方法（通过@BeanProperty注解实现）。

6.4 继承

　　1）基本语法

class 子类名 extends 父类名  { 类体 }

　　　　（1）子类继承父类的属性和方法

　　　　（2）scala是单继承

　　2）案例实操

　　　　（1）子类继承父类的属性和方法

　　　　（2）继承的调用顺序：父类构造器->子类构造器

package com.yuange.scala.day03

class Monkey(name: String){
  var nameMonkey = name
  var ageMonkey: Int = _

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

  println("父类主构造器")
}

class MonkeySon(name: String,age: Int) extends Monkey(name: String,age: Int){
  var idMonkey: Int = _

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

  println("子类主构造器")
}

object Monkey {
  def main(args: Array[String]): Unit = {
    new MonkeySon("小猴子",12,2002)
  }
}

6.5 抽象属性和抽象方法

6.5.1 抽象属性和抽象方法

　　1）基本语法

　　　　（1）定义抽象类：abstract class Person{} //通过abstract关键字标记抽象类

　　　　（2）定义抽象属性：val|var name:String //一个属性没有初始化，就是抽象属性

　　　　（3）定义抽象方法：def hello():String //只声明而没有实现的方法，就是抽象方法

　　　　案例实操：

package com.yuange.scala.day03

abstract class Bear{
  var name: String
  def test(): Unit
}

class BearSon extends Bear {
  override var name: String = "小熊"

  override def test(): Unit = {
    println("test.....and name=" + name)
  }
}

object Bear {
  def main(args: Array[String]): Unit = {
    var bearSon = new BearSon()
    bearSon.test()
  }
}

　　2）继承&重写

　　　　（1）如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类

　　　　（2）重写非抽象方法需要用override修饰，重写抽象方法则可以不加override。

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

　　　　（4）属性重写只支持val类型，而不支持var。 

　　　　（5）scala中属性和方法都是动态绑定，而java中只有方法为动态绑定。

　　　　案例实操(对比java与scala的重写)

　　　　scala：

package com.yuange.scala.day03

class Penguin{
  val name: String = "企鹅"
  def test(): Unit = {
    println("我是一只企鹅")
  }
}

class PenguinSon extends Penguin{
  override val name: String = "小企鹅"
  override def test(): Unit = {
    println("我是一只小小小企鹅")
  }
}

object Penguin {
  def main(args: Array[String]): Unit = {
    val penguinSon: PenguinSon = new PenguinSon()
    println(penguinSon.name)
    penguinSon.test()
    println("---------------------------------------------")
    val penguinSon2: Penguin = new PenguinSon()
    println(penguinSon2.name)
    penguinSon2.test()
  }
}

　　　　java：

package com.yuange.scala;

class Penguin {
    String name = "企鹅";

    public void test(){
        System.out.println("我是一只企鹅");
    }
}

class PenguinSon extends Penguin{
    String name = "小企鹅";
    @Override
    public void test() {
        System.out.println("我是一只小小小企鹅");
    }
}

public class TestPenguin{
    public static void main(String[] args) {
        PenguinSon penguinSon = new PenguinSon();
        System.out.println(penguinSon.name);
        penguinSon.test();
        System.out.println("----------------------------");
        Penguin penguin = new PenguinSon();
        System.out.println(penguin.name);
        penguin.test();
    }
}

6.5.2 匿名子类

　　1）Java一样，可以通过包含带有定义或重写的代码块的方式创建一个匿名的子类。

　　2）案例实操

package com.yuange.scala.day03

abstract class Snake{
  val name: String
  def test(): Unit
}

object Snake {
  def main(args: Array[String]): Unit = {
    var snake = new Snake {
      override val name: String = "眼镜蛇"
      override def test(): Unit = println("我有剧毒，我是蛇王")
    }
    println(snake.name)
    snake.test()
  }
}

6.6 单例对象（伴生对象）

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

6.6.1 单例对象语法

　　1）基本语法

object Person{
    val country:String="China"
}

　　2）说明：

　　　　（1）单例对象采用object关键字声明

　　　　（2）单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。

　　　　（3）单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

　　3）案例实操

package com.yuange.scala.day03

//伴生对象采用object声明
object Loong{
  var name: String = "龙"
  def test(): Unit = {
    println("我是伴生对象")
  }
}

//名称与伴生对象重名的类：伴生类
class Loong{
  var age: Int = 6000
  def test(): Unit = {
    println("我是伴生类")
  }
}

object TestLoong {
  def main(args: Array[String]): Unit = {
    //可以直接通过伴生对象名调用其属性
    println(Loong.name)
    Loong.test()
    println("-------------------------------")
    //通过创建类的实例来调用类的属性
    var loong = new Loong()
    println(loong.age)
    loong.test()
  }
}

6.6.2 apply方法

　　1）说明

　　　　（1）通过伴生对象的apply方法，实现不使用new方法创建对象。

　　　　（2）如果想让主构造器变成私有的，可以在()之前加上private。

　　　　（3）apply方法可以重载。

　　　　（4）Scala中obj(arg)的语句实际是在调用该对象的apply方法，即obj.apply(arg)。用以同一面向对象编程和函数式编程的风格。

　　2）案例实操

package com.yuange.scala.day03

//在()之前加private表示主构造器私有
class Tiger private(name: String){
  var nameTiger: String = name
}

object Tiger{
  def apply(): Tiger = {
    println("apply 无参")
    new Tiger("老虎")   //实例化类对象
  }

  def apply(name: String): Tiger = {
    println("apply 有参")
    new Tiger(name)   //实例化；类对象
  }
}

object TestTiger {
  def main(args: Array[String]): Unit = {
    //通过伴生对象的apply方法，实现不使用new关键字创建对象
    var tiger = Tiger()
    println("name=" + tiger.nameTiger)
    println("--------------------")
    var tiger2 = Tiger("大老虎")
    println("name=" + tiger2.nameTiger)
  }
}

6.7 特质（Trait）

　　Scala语言中，采用特质trait（特征）来代替接口的概念，也就是说，多个类具有相同的特征（特征）时，就可以将这个特质（特征）独立出来，采用关键字trait声明。

　　Scala中的trait中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（mixin）多个特质。

　　Scala引入trait特征，第一可以替代Java的接口，第二个也是对单继承机制的一种补充。

6.7.1 特质声明

　　1）基本语法

trait 特质名 {
    trait体
}

　　2）案例实操

package com.yuange.scala.day03

trait TestTrait {
  //声明属性
  var id: Int = _
  //声明方法
  def test(): Unit = {

  }
  //抽象属性
  var name: String
  //抽象方法
  def test2(): Unit
}

6.7.2 特质基本语法

　　一个类具有某种特质（特征），就意味着这个类满足了这个特质（特征）的所有要素，所以在使用时，也采用了extends关键字，如果有多个特质或存在父类，那么需要采用with关键字连接。

　　1）基本语法：

没有父类：class  类名 extends  特质1   with    特质2   with   特质3 …
有父类：class  类名  extends  父类   with  特质1   with   特质2  with 特质3…

　　2）说明：

　　　　（1）类和特质的关系：使用继承的关系。

　　　　（2）当一个类去继承特质时，第一个连接词是extends，后面是with。

　　　　（3）如果一个类在继承特质和父类时，应当把父类写在extends后。

　　3）案例实操

　　　　（1）特质可以同时拥有抽象方法和具体方法

　　　　（2）一个类可以混入（mixin）多个特质

　　　　（3）所有的Java接口都可以当做Scala特质使用

　　　　（4）动态混入：可灵活的扩展类的功能

　　　　　　（4.1）动态混入：创建对象时混入trait，而无需使类混入该trait

　　　　　　（4.2）如果混入的trait中有未实现的方法，则需要实现

package com.yuange.scala.day03

trait SnakeTrait{
  //特质可以同时拥有抽象方法和具体方法
  var name: String = _    //声明属性
  var age: Int        //声明抽象属性
  def test(): Unit = {  //声明方法
    println("Snake方法")
  }
  def test2(): Unit   //声明抽象方法
}

trait LoongTrait{
  var id: Int
}

/**
 * 一个类可以实现/继承多个特质
 * 所有的Java接口都可以当做Scala特质使用
 */
class Sheep extends SnakeTrait with java.io.Serializable{
  override var age: Int = 9999
  override def test2(): Unit = {
    println("Sheep方法")
  }
}

object TestTraitTwo {
  def main(args: Array[String]): Unit = {
    var sheep = new Sheep()
    sheep.test()
    sheep.test2()
    println("--------------------------------")
    //动态混入，灵活扩展类的功能
    var loongTrait = new Sheep with LoongTrait{
      override var id: Int = 7801
    }
    //调用混用的trait特质的属性
    println("loongTrait.id=" + loongTrait.id)
    println("loongTrait.name=" + loongTrait.name)
    println("loongTrait.age=" + loongTrait.age)
  }
}

6.7.3 特质叠加

　　由于一个类可以混入（mixin）多个trait，且trait中可以有具体的属性和方法，若混入的特质中具有相同的方法（方法名，参数列表，返回值均相同），必然会出现继承冲突问题。冲突分为以下两种：

　　　　第一种，一个类（Sub）混入的两个trait（TraitA，TraitB）中具有相同的具体方法，且两个trait之间没有任何关系，解决这类冲突问题，直接在类（Sub）中重写冲突方法。

　　　　第二种，一个类（Sub）混入的两个trait（TraitA，TraitB）中具有相同的具体方法，且两个trait继承自相同的trait（TraitC），及所谓的“钻石问题”，解决这类冲突问题，Scala采用了特质叠加的策略。

　　　　所谓的特质叠加，就是将混入的多个trait中的冲突方法叠加起来，案例如下，

package com.yuange.scala.day03

trait Ball{
  def describe(): String = {
    "Ball"
  }
}

trait Color extends Ball{
  override def describe(): String = "blue--" + super.describe()
}

trait Category extends Ball{
  override def describe(): String = "foot--" + super.describe()
}

  //第一种情况：先继承Color，再with Category
  class MyBall extends Color with Category{
    override def describe(): String = "My Ball is a" + super.describe()
  }

  //第二种情况：先继承Category，再with Color
//class MyBall extends Category with Color{
//  override def describe(): String = "My Ball is a" + super.describe()
//}

object TestTraitThree {
  def main(args: Array[String]): Unit = {
    println(new MyBall().describe())
  }
}

　　　　第一种情况结果如下：

　　　　 第二种情况结果如下：

6.7.4 特质叠加执行顺序

　　思考：上述案例中的super.describe()调用的是父trait中的方法吗？

　　　　当一个类混入多个特质的时候，scala会对所有的特质及其父特质按照一定的顺序进行排序，而此案例中的super.describe()调用的实际上是排好序后的下一个特质中的describe()方法。，排序规则如下：

　　结论：

　　（1）案例中的super，不是表示其父特质对象，而是表示上述叠加顺序中的下一个特质，即，MyClass中的super指代Color，Color中的super指代Category，Category中的super指代Ball。

　　（2）如果想要调用某个指定的混入特质中的方法，可以增加约束：super[]，例如super[Category].describe()。

6.7.5 特质自身类型

　　1）自身类型可实现依赖注入的功能。

　　2）案例实操

package com.yuange.scala.day03

class User(val name: String,val age: Int)

trait Dao{
  def insert(user: User) = {
    println("插入数据name：" + user.name)
    println("插入数据age：" + user.age)
    println("插入成功")
  }
}

trait App{
  _: Dao =>
  def login(user: User): Unit = {
    println("登录名：" + user.name)
    println("登录年龄：" + user.age)
    insert(user)
  }
}

object MyApp extends App with Dao {
  def main(args: Array[String]): Unit = {
    login(new User("战三",20))
  }
}

6.8 扩展

6.8.1 类型检查和转换

　　1）说明

　　　　（1）obj.isInstanceOf[T]：判断obj是不是T类型。

　　　　（2）obj.asInstanceOf[T]：将obj强转成T类型。

　　　　（3）classOf获取对象的类名。

　　2）案例实操

package com.yuange.scala.day03

class Horse{
}

object Horse {
  def main(args: Array[String]): Unit = {
    val horse = new Horse
    //判断对象是否为某个类型的实例
    val b: Boolean = horse.isInstanceOf[Horse]

    if (b){
      //将对象转换为某个类型的实例
      val horse2: Horse = horse.asInstanceOf[Horse]
      println("horse2=" + horse2)
    }

    //获取类的信息
    val horseInfo: Class[Horse] = classOf[Horse]
    println("horseInfo=" + horseInfo)
  }
}

6.8.2 枚举类和应用类

　　1）说明

　　　　枚举类：需要继承Enumeration

　　　　应用类：需要继承App

　　2）案例实操

package com.yuange.scala.day03

object Color extends Enumeration{
  var RED = Value(1,"红色")
  var YELLOW = Value(2,"黄色")
  var BLUE = Value(3,"蓝色")
}

object TestApp extends App {
  println("应用类继承App")
}

object TestEnumAndApp {
  def main(args: Array[String]): Unit = {
    println(Color.RED)
  }
}

6.8.3 Type定义新类型

　　1）使用type关键字可以定义新的数据数据类型名称，本质上就是类型的一个别名

　　2）案例实操

package com.yuange.scala.day03

object TestType {
  def main(args: Array[String]): Unit = {
    type S = String
    var v: S = "v--S是String类型的别名"
    def test(): S = {
      "test()---S是String类型的别名"
    }
    println(v)
    println(test())
  }
}