Scala OOP（面向对象，抽象类，单例对象，伴生对象，样例类，泛型类，依赖注入）（三）

一.Scala面向对象编程概述

1.Scala 是纯粹的面向对象的语言

以 Java 为例，Java 并不是一门纯面向对象的语言，其允许非对象值的存在，也允许不属于任何对象的静态字段和方法存在。

Scala 是纯粹的面向对象的语言，每个值都是对象，每个操作都是方法调用。

2.Scala 大量重用了 Java 中的类型

Scala 与 Java 完全兼容，Scala 程序会被编译成 Java 字节码，访问 Java 字段，继承 Java 类，实现 Java 接口都不需要特别的语法，实际上 Scala 也使用了大量的Java 库代码。比如 Scala String 类与 java.lang.String 一样。

3.Scala OOP 比较 Java OOP 的主要差异

1）Scala 取消了接口（Interface），新增了类似的特质概念（Trait）。

2）Scala 取消静态字段和方法，新增单例对象的概念（Singleton Object）。

3）Scala 新增了样例类（case class）。

二.类和对象

类是对对象的抽象模板，描述了该类对象可以拥有的属性和方法，而对象是类的具体实例。类和对象最明显的区别：类不占用内存，对象占用内存。

1.类的定义

class 类名(参数列表){
   
辅助构造器
成员变量
成员方法
}

（1）Scala 提出主构造器与辅助构造器的概念，类似 Java 构造方法。
主构造器是“类名(构造参数列表)”，class Book(t: String, a: List[String])
**辅助构造器“this(构造参数列表)”，**辅助构造器类似于 Java 中的构造方法重载，所有构造器都没有返回值。注意辅助构造器必须间接或直接调用主构造器。def this() = {this(" ", List.empty)}

（2）Scala 中，“this”是关键字，用于引用当前对象。可以使用 this 调用实例变量、方法、构造器

（3）Scala 类成员默认为 public，也可修改为 private 和 protected。

（4）Scala 类中无法定义静态成员和方法。因为没有 static 关键字。

package cn.kgc.scala.oop
//1.主构造器：主构造器执行类定义中的所有语句
class Point(xc: Int, yc: Int) {
   
  val z2 = 10 //对象
  //2.成员变量
  var x: Int = xc 
  var y: Int = yc
  def z1 = 10 //方法
  //3.辅助构造器
  def this() = {
   
    //辅助构造器的第一句必须调用其他构造器
    this(0, 0)
  }
  //4.成员方法
  def move(dx: Int, dy: Int) = {
   
    x = x + dx
    y = y + dy
  }
}

2.类的实例化

使用 new 关键字实例化一个类。

object PointMain {
   
  def main(args: Array[String]): Unit = {
   
    val p1 = new Point()
    println(p1.x)
    println(p1.y)
    val p2 = new Point(2, 4)
    println(p2.x)
    println(p2.y)

    p2.move(3, 4)
    println(p2.x)
    println(p2.y)
  }
}

3.类的继承

1）extends 关键字：子类继承父类

2）override 关键字：子类覆盖父类方法

class Person {
    
override def toString = getClass.getName +"name=" 
}
class Employee extends Person {
    
override def toString = super.toString 
}

isInstanceOf[T]判断是否为某一类型，asInstanceOf[T]进行强制类型转换

三.抽象类

使用 abstract修饰类，称为抽象类，未实现的方法称为抽象方法。抽象类不允许实例化

与 Java 不同的是，Scala 中的抽象方法不需要使用 abstract 修饰

子类中的属性（val）要覆盖父类中的属性（val），必须写 override。

注意，无论父类是抽象类还是普通类，使用 override 时不允许重写父类中的变量（var）

package cn.kgc.scala.oop

//定义一个抽象类使用abstract关键字
abstract  class Shape {
   
  //抽象类里可以有未实现的方法，即抽象方法
def draw:Unit
}

class Square extends  Shape{
   
  //子类重新父类的抽象方法时，关键字override可选
  override def draw: Unit = {
   
    println("draw a square")
  }
}
object  SquareMain{
   
  def main(args: Array[String]): Unit = {
   
    val square = new Square
    square.draw
  }
}

四.单例对象

单例对象是一种特殊的类，有且只有一个实例

1.object与 class

Scala 比 Java 更加面向对象的特点之一是，取消了 static 关键字，因为类方法不是对象的方法。取而代之的是单例对象，具体是使用 object 代替 class 即可，object 本身及其任何成员的定义与 class 一致。

单例对象在第一次使用时被创建，单例对象不需要也不能再被实例化，单例对象中的所有成员