一、面向对象
1、Scala 包
1）基本语法2）Scala 包的三大作用（和 Java 一样）3） 包的命名 2、包说明（包语句）
1）说明2）案例实操 3、包对象
1）定义2）说明 4、导包说明
1) 导包说明2）注意 二、类和对象
1、定义类
1）回顾：Java 中的类2）案例实操12）案例实操属性 2、属性
1）基本语法2）案例实操 3、封装4、访问权限
1）说明2）案例实操 5、方法
1）基本语法2）案例实操 6、创建对象
1）基本语法2）案例实操 7、构造器
1）基本语法2）案例实操 8、构造器参数
1）说明2）案例实操 9、继承和多态
1）基本语法2）案例实操 10、抽象类
1）基本语法2）继承&重写 11、匿名子类
1）说明2）案例实操 12、单例对象（伴生对象）
1、单例对象语法1）基本语法2）说明3）案例实操 13、apply 方法
1）说明2）案例实操 14、特质（Trait）15、特质声明
1）基本语法2）案例实操 16、特质基本语法
1）基本语法：2）说明3）案例实操 17 、特质叠加18、特质叠加执行顺序19、特质自身类型
1）说明2）案例实操 20、特质混入21、特质和抽象类的区别22、扩展
1 类型检查和转换1）说明2）案例实操 23、枚举类和应用类
1）说明2）案例实操 24、Type 定义新类型
1）说明2）案例实操 一、面向对象 1、Scala 包 1）基本语法
package 包名
2）Scala 包的三大作用（和 Java 一样）（1）区分相同名字的类（2）当类很多时，可以很好的管理类（3）控制访问范围
3） 包的命名 1）命名规则
只能包含数字、字母、下划线、小圆点.，但不能用数字开头，也不要使用关键字。
2）案例实操
demo.class.exec1 //错误，因为 class 关键字demo.12a //错误，数字开头
3）命名规范
一般是小写字母+小圆点
com.公司名.项目名.业务模块名
4）案例实操
com.atguigu.oa.model com.atguigu.oa.controllercom.sohu.bank.order
2、包说明（包语句） 1）说明Scala 有两种包的管理风格，一种方式和 Java 的包管理风格相同，每个源文件一个包（包名和源文件所在路径不要求必须一致），包名用“.”进行分隔以表示包的层级关系，如com.atguigu.scala。另一种风格，通过嵌套的风格表示层级关系，如下
package com{package atguigu{package scala{} } }
第二种风格有以下特点：
（1）一个源文件中可以声明多个 package
（2）子包中的类可以直接访问父包中的内容，而无需导包
2）案例实操package object chapter06 { var value = "尚硅谷" def commonValue(): Unit = { println(s"我在${value}学习") }}
//用嵌套风格定义包package com { import com.atguigu.scala.Inner //在外层包定义单例对象 object Outer { var out: String = "out" def main(args: Array[String]): Unit = { println(Inner.in) } } package atguigu { package scala { //在内层包中定义单例对象 object Inner { var in: String = "In" def main(args: Array[String]): Unit = { println(Outer.out) Outer.out = "outer" println(Outer.out) } } } }}package aa { package bb { import com.atguigu.scala.Inner object hello { def main(args: Array[String]): Unit = { println(Inner.in) } } }}
3、包对象在 Scala 中可以为每个包定义一个同名的包对象，定义在包对象中的成员，作为其对应包下所有 class 和 object 的共享变量，可以被直接访问。
1）定义package object com{val sharevalue="share"def shareMethod()={}}
2）说明 （1）若使用 Java 的包管理风格，则包对象一般定义在其对应包下的 package.scala
文件中，包对象名与包名保持一致。
（2）如采用嵌套方式管理包，则包对象可与包定义在同一文件中，但是要保证包对象
与包声明在同一作用域中。
//package chapter06////object Test02PackageObject {// def main(args: Array[String]): Unit = {// commonValue()// println(value)// }//}package chapter06 { object Test02PackageObject { def main(args: Array[String]): Unit = { commonValue() println(value) } }}package ccc { package ddd { object Test02_PackageObject { def main(args: Array[String]): Unit = { println(school) } } } //在这school 可以被访问到 package object ddd { val school: String = "atguigu" }}//定义一个包对象 必须和想被访问的包的同一层级目录下就可以访问了package object ddd { val school: String = "atguigu"}
4、导包说明 1) 导包说明1）和 Java 一样，可以在顶部使用 import 导入，在这个文件中的所有类都可以使用。
2）局部导入：什么时候使用，什么时候导入。在其作用范围内都可以使用
3）通配符导入：import java.util._
4）给类起名：import java.util.{ArrayList=>JL}
5）导入相同包的多个类：import java.util.{HashSet, ArrayList}
6）屏蔽类：import java.util.{ArrayList =>,}
7）导入包的绝对路径：new root.java.util.HashMap
package java { package util { class HashMap { } } }
Scala 中的三个默认导入分别是import java.lang._import scala._import scala.Predef._
二、类和对象类：可以看成一个模板对象：表示具体的事物
1、定义类 1）回顾：Java 中的类 如果类是 public 的，则必须和文件名一致。
一般，一个.java 有一个 public 类
注意：Scala 中没有 public，一个.scala 中可以写多个类。
1）基本语法
[修饰符] class 类名 { 类体}
说明
（1）Scala 语法中，类并不声明为 public，所有这些类都具有公有可见性（即默认就是public）
（2）一个 Scala 源文件可以包含多个类
2）案例实操1package com.atguigu.chapter06//（1）Scala 语法中，类并不声明为 public，所有这些类都具有公有可见性（即默认就是 public）class Person {}//（2）一个 Scala 源文件可以包含多个类class Teacher{}
2）案例实操属性 [修饰符] var|val 属性名称 [：类型] = 属性值
注：Bean 属性（@BeanPropetry），可以自动生成规范的 setXxx/getXxx 方法
package chapter06import scala.beans.BeanPropertyobject Test03_Class { def main(args: Array[String]): Unit = { val student = new Student// student.name 私有属性 println(student.age) println(student.sex) student.sex="fam" println(student.sex) }}class Student { private var name: String = "alice" @BeanProperty var age: Int = _ var sex: String = _}
2、属性属性是类的一个组成部分
1）基本语法 [修饰符] var|val 属性名称 [：类型] = 属性值
注：Bean 属性（@BeanPropetry），可以自动生成规范的 setXxx/getXxx 方法
package chapter06import scala.beans.BeanPropertyobject Test03_Class { def main(args: Array[String]): Unit = { val student = new Student// student.name 私有属性 println(student.age) println(student.sex) student.sex="fam" println(student.sex) }}class Student { private var name: String = "alice" @BeanProperty var age: Int = _ var sex: String = _}
3、封装 封装就是把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它
部分只有通过被授权的操作（成员方法），才能对数据进行操作。Java 封装操作如下，
（1）将属性进行私有化
（2）提供一个公共的 set 方法，用于对属性赋值
4、访问权限 1）说明（3）提供一个公共的 get 方法，用于获取属性的值
Scala 中的 public 属性，底层实际为 private，并通过 get 方法（obj.field()）和 set 方法
（obj.field_=(value)）对其进行操作。所以 Scala 并不推荐将属性设为 private，再为其设置
public 的 get 和 set 方法的做法。但由于很多 Java 框架都利用反射调用 getXXX 和 setXXX 方
法，有时候为了和这些框架兼容，也会为 Scala 的属性设置 getXXX 和 setXXX 方法（通过
@BeanProperty 注解实现）。
在 Java 中，访问权限分为：public，private，protected 和默认。在 Scala 中，你可以通
过类似的修饰符达到同样的效果。但是使用上有区别。
（1）Scala 中属性和方法的默认访问权限为 public，但 Scala 中无 public 关键字。
（2）private 为私有权限，只在类的内部和伴生对象中可用。
（3）protected 为受保护权限，Scala 中受保护权限比 Java 中更严格，同类、子类可以
访问，同包无法访问。
2）案例实操（4）private[包名]增加包访问权限，包名下的其他类也可以使用
package com.atguigu.scala.testclass Person { private var name: String = "bobo" protected var age: Int = 18 private[test] var sex: String = "男" def say(): Unit = { println(name) }}object Person { def main(args: Array[String]): Unit = { val person = new Person person.say() println(person.name) println(person.age) }}class Teacher extends Person { def test(): Unit = { this.age this.sex }}class Animal { def test: Unit = { new Person().sex }
5、方法 1）基本语法def 方法名(参数列表) [：返回值类型] = { 方法体}
2）案例实操class Person { def sum(n1:Int, n2:Int) : Int = { n1 + n2 } }object Person { def main(args: Array[String]): Unit = { val person = new Person() println(person.sum(10, 20)) } }
6、创建对象 1）基本语法val | var 对象名 [：类型] = new 类型()
2）案例实操 （1）val 修饰对象，不能改变对象的引用（即：内存地址），可以改变对象属性的值。
（2）var 修饰对象，可以修改对象的引用和修改对象的属性值
（3）自动推导变量类型不能多态，所以多态需要显示声明
class Person { var name: String = "canglaoshi"}object Person { def main(args: Array[String]): Unit = { //val 修饰对象，不能改变对象的引用（即：内存地址），可以改变对象属性的值。 val person = new Person() person.name = "bobo" // person = new Person()// 错误的 println(person.name) } }
7、构造器 和 Java 一样，Scala 构造对象也需要调用构造方法，并且可以有任意多个构造方法。
Scala 类的构造器包括：主构造器和辅助构造器
class 类名(形参列表) { // 主构造器 // 类体 def this(形参列表) { // 辅助构造器 } def this(形参列表) { //辅助构造器可以有多个... } }
说明：
（1）辅助构造器，函数的名称 this，可以有多个，编译器通过参数的个数及类型
来区分。
（2）辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。
（3）构造器调用其他另外的构造器，要求被调用构造器必须提前声明。
（1）如果主构造器无参数，小括号可省略，构建对象时调用的构造方法的小括号也可
以省略。
package chapter06object Test05_Constructor { def main(args: Array[String]): Unit = { val student = new Student1() student.Student1 val name1 = new Student1("张三") val nameAge = new Student1("张三", 30) }}//定义一个类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") } def this(name: String, age: Int) { this(name) //直接调用主构造器 println("3、辅助构造器方法二被调用") this.age = age println(s"name: $name $age") } def Student1: Unit = { println("不是构造方法被调用，就是一个普通方法被调用") }}
8、构造器参数 1）说明 Scala 类的主构造器函数的形参包括三种类型：未用任何修饰、var 修饰、val 修饰
（1）未用任何修饰符修饰，这个参数就是一个局部变量
（2）var 修饰参数，作为类的成员属性使用，可以修改
（3）val 修饰参数，作为类只读属性使用，不能修改
class Person(name: String, var age: Int, val sex: String) {}object Test { def main(args: Array[String]): Unit = { var person = new Person("bobo", 18, "男") // （1）未用任何修饰符修饰，这个参数就是一个局部变量 // printf(person.name) // （2）var 修饰参数，作为类的成员属性使用，可以修改 person.age = 19 println(person.age) // （3）val 修饰参数，作为类的只读属性使用，不能修改 // person.sex = "女" println(person.sex) } }
9、继承和多态 1）基本语法 class 子类名 extends 父类名 { 类体 }
（1）子类继承父类的属性和方法
（2）scala 是单继承
（1）子类继承父类的属性和方法
（2）继承的调用顺序：父类构造器->子类构造器
package chapter06object Test08_DynamicBind { def main(args: Array[String]): Unit = { val student: Person8 = new Student8 println(student.name) student.hello() }}class Person8 { val name: String = "person" def hello(): Unit = { println("hello person") }}class Student8 extends Person8 { //override 重写 override val name: String = "Student" //override 重写 override def hello(): Unit = { println("hello Student") }}
10、抽象类抽象属性和抽象方法
1）基本语法 （1）定义抽象类：abstract class Person{} //通过 abstract 关键字标记抽象类
（2）定义抽象属性：val|var name:String //一个属性没有初始化，就是抽象属性
（3）定义抽象方法：def hello():String //只声明而没有实现的方法，就是抽象方法
案例实操
abstract class Person { val name: String def hello(): Unit}class Teacher extends Person { val name: String = "teacher" def hello(): Unit = { println("hello teacher") } }
2）继承&重写 （1）如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明
为抽象类
（2）重写非抽象方法需要用 override 修饰，重写抽象方法则可以不加 override。
（3）子类中调用父类的方法使用 super 关键字
（4）子类对抽象属性进行实现，父类抽象属性可以用 var 修饰；
子类对非抽象属性重写，父类非抽象属性只支持 val 类型，而不支持 var。
因为 var 修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写
和 Java 一样，可以通过包含带有定义或重写的代码块的方式创建一个匿名的子类。
2）案例实操package chapter06object Test10_AnnoymousClass { def main(args: Array[String]): Unit = { val person: Person10 = new Person10 {// 重写 override var name: String = "张三" override def eat(): Unit = println("person eat") } println(person.name) person.eat() }}//定义抽象类abstract class Person10 { var name: String def eat(): Unit}
12、单例对象（伴生对象） Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概
念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象
来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴
生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。
object Person{val country:String="China"}
2）说明 （1）单例对象采用 object 关键字声明
（2）单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
（3）单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。
package chapter06object Test11_Object { def main(args: Array[String]): Unit = { // val alice = new Student11("alice", 18) // alice.printInfo() val student1 = Student11.newStudent("alice", 18) student1.printInfo() val student2 = Student11.apply("bob", 19) student2.printInfo() //上面简写 val student3 = Student11("bob", 22) student3.printInfo() }}// 写在构造器前面private 私有化构造器class Student11 private(val name: String, val age: Int) { def printInfo(): Unit = { println(s"student: name =${name}, age =$age, school =${Student11.school}") }}object Student11 { var school: String = "atguigu" def newStudent(name: String, age: Int): Student11 = new Student11(name, age) def apply(name: String, age: Int): Student11 = new Student11(name, age)}
package chapter06object Test12_Singleton { def main(args: Array[String]): Unit = { val student1 = Student12.getInstance() student1.printInfo() val student2 = Student12.getInstance() student2.printInfo() println(student1) println(student2) }}class Student12 private(val name: String, val age: Int) { def printInfo(): Unit = { println(s"student: name = ${name}, age= $age, school = ${Student11.school}") }}//饿汉式//object Student12 {// private val student: Student12 = new Student12("alice", 18)//// def getInstance(): Student12 = student//}//懒汉式object Student12 { private var student: Student12 = _ def getInstance(): Student12 = { if (student == null) { //如果没有对象实例的话，创建一个 student = new Student12("alice", 18) } student }}
13、apply 方法 1）说明 （1）通过伴生对象的 apply 方法，实现不使用 new 方法创建对象。
（2）如果想让主构造器变成私有的，可以在()之前加上 private。
（3）apply 方法可以重载。
（4）Scala 中 obj(arg)的语句实际是在调用该对象的 apply 方法，即 obj.apply(arg)。用
以统一面向对象编程和函数式编程的风格。
（5）当使用 new 关键字构建对象时，调用的其实是类的构造方法，当直接使用类名构
建对象时，调用的其实时伴生对象的 apply 方法。
object Test { def main(args: Array[String]): Unit = { //（1）通过伴生对象的 apply 方法，实现不使用 new 关键字创建对象。 val p1 = Person() println("p1.name=" + p1.name) val p2 = Person("bobo") println("p2.name=" + p2.name) } }//（2）如果想让主构造器变成私有的，可以在()之前加上 privateclass Person private(cName: String) { var name: String = cName}object Person { def apply(): Person = { println("apply 空参被调用") new Person("xx") } def apply(name: String): Person = { println("apply 有参被调用") new Person(name)}//注意：也可以创建其它类型对象，并不一定是伴生类对象}
扩展：在 Scala 中实现单例模式
14、特质（Trait）Scala 语言中，采用特质 trait（特征）来代替接口的概念，也就是说，多个类具有相同
的特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明。
Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可
以混入（mixin）多个特质。这种感觉类似于 Java 中的抽象类。
15、特质声明 1）基本语法Scala 引入 trait 特征，第一可以替代 Java 的接口，第二个也是对单继承机制的一种
补充。
trait 特质名 {trait 主体}
2）案例实操trait PersonTrait { // 声明属性 var name:String = _ // 声明方法 def eat():Unit={ } // 抽象属性 var age:Int // 抽象方法 def say():Unit}通过查看字节码，可以看到特质=抽象类+接口
package chapter06object Test13_Trait { def main(args: Array[String]): Unit = { val student = new Student13 student.sayHello() student.study() student.dating() student.play() }}//定义一个类class Person13 { val name: String = "person" var age: Int = 18 def sayHello(): Unit = { println("hello form: " + name) }}//定义一个特质trait Young { //声明抽象和非抽象属性 var age: Int val name: String = "young" def play(): Unit = { println(s"young people $name is playing") } //声明抽象和非抽象的方法 def dating(): Unit}class Student13 extends Person13 with Young { //重写冲突属性 override val name: String = "student" //实现抽象方法 def dating(): Unit = println(s"student $name is dating") def study(): Unit = println(s"student $name is studying") //重写父类方法 override def sayHello(): Unit = { super.sayHello() println(s"hello form: student $name") }}
16、特质基本语法 一个类具有某种特质（特征），就意味着这个类满足了这个特质（特征）的所有要素，
所以在使用时，也采用了 extends 关键字，如果有多个特质或存在父类，那么需要采用 with
关键字连接。
没有父类：class 类名 extends 特质 1 with 特质 2 with 特质 3 …
有父类：class 类名 extends 父类 with 特质 1 with 特质 2 with 特质 3
（1）类和特质的关系：使用继承的关系。
（2）当一个类去继承特质时，第一个连接词是 extends，后面是 with。
（3）如果一个类在同时继承特质和父类时，应当把父类写在 extends 后
（1）特质可以同时拥有抽象方法和具体方法
（2）一个类可以混入（mixin）多个特质
（3）所有的 Java 接口都可以当做 Scala 特质使用
（4）动态混入：可灵活的扩展类的功能
（4.1）动态混入：创建对象时混入 trait，而无需使类混入该 trait
（4.2）如果混入的 trait 中有未实现的方法，则需要实现
trait PersonTrait { //（1）特质可以同时拥有抽象方法和具体方法 // 声明属性 var name: String = _ // 抽象属性 var age: Int // 声明方法 def eat(): Unit = { println("eat") } // 抽象方法 def say(): Unit}trait SexTrait { var sex: String}//（2）一个类可以实现/继承多个特质//（3）所有的 Java 接口都可以当做 Scala 特质使用class Teacher extends PersonTrait with java.io.Serializable { override def say(): Unit = { println("say") } override var age: Int = _}object TestTrait { def main(args: Array[String]): Unit = { val teacher = new Teacher teacher.say() teacher.eat() //（4）动态混入：可灵活的扩展类的功能 val t2 = new Teacher with SexTrait { override var sex: String = "男" } //调用混入 trait 的属性 println(t2.sex) } }
17 、特质叠加 由于一个类可以混入（mixin）多个 trait，且 trait 中可以有具体的属性和方法，若混入
的特质中具有相同的方法（方法名，参数列表，返回值均相同），必然会出现继承冲突问题。
冲突分为以下两种：
第一种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且
两个 trait 之间没有任何关系，解决这类冲突问题，直接在类（Sub）中重写冲突方法。
第二种，一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且
两个 trait 继承自相同的 trait（TraitC），及所谓的“钻石问题”，解决这类冲突问题，Scala
采用了特质叠加的策略。
所谓的特质叠加，就是将混入的多个 trait 中的冲突方法叠加起来，案例如下，
package chapter06object Test15_TraitOverlying { def main(args: Array[String]): Unit = { val student1 = new Student15 student1.increase() //TODO 2、钻石问题特征叠加 val ball = new MyFootBall println(ball.describe()) }}//特质1trait Knowledge15 { var amount: Int = 0; def increase(): Unit = { println("Knowledge increased") }}//特质2trait Talent15 { def singing: Unit def dancing: Unit def increase(): Unit = { println("Talent increased") }}class Student15 extends Person13 with Talent15 with Knowledge15 { override def dancing: Unit = println("dancing") override def singing: Unit = println("singing") //TODO 1、 调用的是最后的特征 Knowledge15 里面的方法 //TODO 2、 解决冲突的特征、跟父类是没有关系的 override def increase(): Unit = { super.increase(); }}//Td 钻石问题二//定义球类特质0trait Ball { def describe(): String = "ball"}//定义颜色特质1trait ColorBall extends Ball { var color: String = "red" override def describe(): String = color + "_" + super.describe()}//定义种类的特征2trait CategoryBall extends Ball { def category: String = "foot" override def describe(): String = category + "_" + super.describe()}//定义一个自定义的球类3//TODO 从右到左开始class MyFootBall extends CategoryBall with ColorBall { override def describe(): String = "my ball is a " + super.describe()}
结果如下：
18、特质叠加执行顺序 思考：上述案例中的 super.describe()调用的是父 trait 中的方法吗？
当一个类混入多个特质的时候，scala 会对所有的特质及其父特质按照一定的顺序进行
排序，而此案例中的 super.describe()调用的实际上是排好序后的下一个特质中的 describe()
方法。，排序规则如下：
结论：
（1）案例中的 super，不是表示其父特质对象，而是表示上述叠加顺序中的下一个特质，
即，MyClass 中的 super 指代 Color，Color 中的 super 指代 Category，Category 中的 super
指代 Ball。
（2）如果想要调用某个指定的混入特质中的方法，可以增加约束：super[]，例如super[Category].describe()。
自身类型可实现依赖注入的功能。
2）案例实操package chapter06object Test16_TraitSelfType { def main(args: Array[String]): Unit = { val user = new RegisterUser("nann", "22") user.insert() }}//用户类class User(val name: String, val password: String)trait UserDao { //TODO 1、可以认为当前的UserDao 他的自身类型定义成了User //TODO 2、可以认为当前操作时候、可以认为当中有一个User _: User => def insert(): Unit = { println(s"insert into db ${this.name} ${this.password}") }}//定义注册用户类class RegisterUser(name: String, password: String) extends User(name, password) with UserDao
20、特质混入package chapter06object Test14_TraitMixin { def main(args: Array[String]): Unit = { val student = new Student14 student.study() student.increase() student.play() student.increase() student.dating() student.increase() println("++++++++++++++++++++++++++++++") //动态混入 //要创建有天赋的特征值时候再把Talent 混入进去 val studentWithTalent = new Student14 with Talent { override def dancing(): Unit = println("student is good at dancing") override def singing(): Unit = println("student is good at dancing") } studentWithTalent.sayHello() studentWithTalent.play() studentWithTalent.study() studentWithTalent.dating() studentWithTalent.dancing() }}//再定义一个特质trait Knowledge { var amount: Int = 0 def increase(): Unit}//trait Talent { def singing(): Unit def dancing(): Unit}class Student14 extends Person13 with Knowledge with Young { //1、重写冲突的属性 override val name: String = "student" //2、实现抽象方法 def dating(): Unit = println(s"student $name is dating") def study(): Unit = println(s"student $name is studying") //重写父类的方法 override def sayHello(): Unit = { super.sayHello() println(s"hello from: student $name ") } override def increase(): Unit = { amount += 1 println(s"student $name knowledge increase : $amount") }}
21、特质和抽象类的区别 1.优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。
2.如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，
而特质不行（有无参构造）。
（1）obj.isInstanceOf[T]：判断 obj 是不是 T 类型。
（2）obj.asInstanceOf[T]：将 obj 强转成 T 类型。
（3）classOf 获取对象的类名。
package chapter06object Test17_Extends { def main(args: Array[String]): Unit = { //1、类型的转换和检测 val student = new Student17("alice", 18) student.study() student.sayHi() val person: Person17 = new Student17("bob", 20) person.sayHi() //类型判断 println("student is Student17: " + student.isInstanceOf[Student17]) println("student is Person17: " + student.isInstanceOf[Person17]) println("person is Person17: " + person.isInstanceOf[Person17]) println("person is Student: " + person.isInstanceOf[Student17]) val person2: Person17 = new Person17("cary", 35) println("person2 is Student17: " + person2.isInstanceOf[Person17]) //类型转换 if (person.isInstanceOf[Student17]) { //如果包含、直接调用asInstanceOf 方法转换 val newStudent = person.asInstanceOf[Student17] newStudent.study() } }}class Person17(val name: String, val age: Int) { def sayHi(): Unit = { println("hi form person " + name) }}class Student17(name: String, age: Int) extends Person17(name, age) { override def sayHi(): Unit = { println("hi form Student " + name) } def study(): Unit = { println("Student study " + name) }}//TODO 2、定义枚举类对象object WorkDay extends Enumeration { val MonDAY = Value(1, "MonDay") val TuesDay = Value(2, "TuesDay")}//应用类object TestApp extends App { println("test app") type myString = String val a: myString = "张三" println(a)}
23、枚举类和应用类 1）说明 枚举类：需要继承 Enumeration
应用类：需要继承 App
object Test { def main(args: Array[String]): Unit = { println(Color.RED) } }// 枚举类object Color extends Enumeration { val RED = Value(1, "red") val YELLOW = Value(2, "yellow") val BLUE = Value(3, "blue")}// 应用类object Test20 extends App { println("xxxxxxxxxxx");}
24、Type 定义新类型 1）说明使用 type 关键字可以定义新的数据数据类型名称，本质上就是类型的一个别名
2）案例实操object Test { def main(args: Array[String]): Unit = { type S=String var v:S="abc" def test():S="xyz" } }