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())
  }
}

posted on 2021-05-21 20:49 LZ名約山炮阅读(85) 评论(0) 编辑收藏举报

刷新页面返回顶部

LZ名約山炮

公告

6.1 Scala包

6.1.1 包的命名

6.1.2 包说明

6.1.3 包对象

6.1.4 导包说明

6.1.5 访问权限

6.2 类和对象

6.2.1 定义类

6.2.2 属性

6.2.3 方法

6.2.4 创建对象

6.2.5 构造器

6.2.6 构造器参数

6.3 封装

6.4 继承

6.5 抽象属性和抽象方法

6.5.1 抽象属性和抽象方法

6.5.2 匿名子类

6.6 单例对象（伴生对象）

6.6.1 单例对象语法

6.6.2 apply方法

6.7 特质（Trait）

6.7.1 特质声明

6.7.2 特质基本语法

6.7.3 特质叠加

6.7.4 特质叠加执行顺序

6.7.5 特质自身类型

6.8 扩展

6.8.1 类型检查和转换

6.8.2 枚举类和应用类

6.8.3 Type定义新类型