Scala（第六章 面向对象）

已于 2023-08-11 23:44:31 修改
阅读量520 收藏
点赞数
分类专栏： scala 文章标签： scala 开发语言 后端
于 2023-08-10 09:11:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nlcexiyue/article/details/132201835
版权

文章目录

1、 Scala的面向对象思想和Java的面向对象思想和概念是一致的。
2、Scala中语法和Java不同，补充了更多的功能。

6.1 Scala包

1）基本语法

package 包名

   
   

   
   
  • 1

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

1、区分相同名字的类
2、当类很多时，可以很好的管理类
3、控制访问范围

6.1.1 包的命名

1）命名规则

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

2）案例实操

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

   
   

   
   
  • 1
  • 2

3）命名规范

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

4）案例实操

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

   
   

   
   
  • 1
  • 2
  • 3

6.1.2 包说明（包语句）

1）说明

Scala有两种包的管理风格，一种方式和Java的包管理风格相同，每个源文件一个包（包名和源文件所在路径不要求必须一致），包名用 “.” 进行分隔以表示包的层级关系，如com.atguigu.scala。另一种风格，通过嵌套的风格表示层级关系，如下

package com{
 package atguigu{
  package scala{
  }
 }
}

   
   

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

第二种风格有以下特点：
（1）一个源文件中可以声明多个package
（2）子包中的类可以直接访问父包中的内容，而无需导包

2）案例实操

package com {
 import com.atguigu.Inner //父包访问子包需要导包
	 object Outer {
	 val out: String = "out"
	 def main(args: Array[String]): Unit = {
	   println(Inner.in)
	 }
	 }
 package atguigu {
	 object Inner {
	 val in: String = "in"
	 def main(args: Array[String]): Unit = {
	   println(Outer.out) //子包访问父包无需导包
	 }
	 }
	 }
}
package other {
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

6.1.3 包对象

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

1）定义

package object com{
 val shareValue="share"
 def shareMethod()={}
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4

2）说明

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

在这里插入图片描述

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

package com {
	 object Outer {
	 val out: String = "out"
	 def main(args: Array[String]): Unit = {
	   println(name)
	 }
	 }
}
package object com {
  val name: String = "com"
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

6.1.4 导包说明

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 {
  }
 }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

说明：
在这里插入图片描述
2）注意：

Scala中三个默认导入分别是：
import java.lang._
import scala._
import scala.Predef._

6.2 类和对象

类：可以看成一个模板
对象：表示具体的事物

6.2.1 定义类

1）回顾：Java中的类

如果类是public的，则必须和文件名一致。
一般，一个.java有一个public类
注意：Scala中没有public，一个.scala中可以写多个类。

2）基本语法

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

 
 

 
 
  • 1
  • 2
  • 3

说明：
1、Scala语法中，类并不声明为public，所有这些类都具有共有可见性（即默认就是public）
2、一个Scala源文件可以包含多个类

3）案例实操

package com.atguigu.chapter06
//（1）Scala 语法中，类并不声明为 public，所有这些类都具有公有可见性（即默认就是 public）
class Person {
}
//（2）一个 Scala 源文件可以包含多个类
class Teacher{
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

6.2.2 属性

属性是类的一个组成部分

1）基本语法

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

 
 

 
 
  • 1

注：Bean 属性（@BeanPropetry），可以自动生成规范的 setXxx/getXxx 方法

2）案例实操

package com.atguigu.scala.test
import scala.beans.BeanProperty
class Person {
 var name: String = "bobo" //定义属性
 var age: Int = _ // _表示给属性一个默认值
 //Bean 属性（@BeanProperty）
 @BeanProperty var sex: String = "男"
//val 修饰的属性不能赋默认值，必须显示指定
}
object Person {
 def main(args: Array[String]): Unit = {
	 var person = new Person()
	 println(person.name)
	 person.setSex("女")
	 println(person.getSex)
 }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

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.3.1 访问权限

1）说明

再java中，访问权限分为：public，private，protected和默认。在Scala中，你可以通过类似的修饰符达到同样的效果。但是使用上有区别。
1、Scala中属性和方法的默认访问权限为public，但Scala中无public关键字。
2、private为私有权限，只在类的内部和伴生对象中可用。
3、protected为受保护权限，Scala中受保护权限比Java中更严格，同类、子类可以访问，同包无法访问。
4、private[包名]增加包访问权限，包名下的其他类也可以使用

2）案例实操

package com.atguigu.scala.test
class 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
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

6.3.2 方法

1）基本语法

def 方法名（参数列表）[: 返回值类型] = {
   方法体
}

 
 

 
 
  • 1
  • 2
  • 3

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

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

6.3.3 创建对象

1）基本语法

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

 
 

 
 
  • 1

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)
 }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

6.3.4 构造器

1、和Java一样，Scala构造对象也需要调用构造方法，并且可以有任意多个构造方法。
2、Scala类的构造器包括：主构造器和辅助构造器

1）基本语法

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

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

说明：
1、辅助构造器，函数的名称this，可以有多个，编译器通过参数的个数及类型来区分。
2、辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。
3、构造器调用其他另外的构造器，要求被调用构造器必须提前声明。

2）案例实操

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

//（1）如果主构造器无参数，小括号可省略
//class Person (){
class Person {
 var name: String = _
 var age: Int = _
 def this(age: Int) {
 this()
 this.age = age
 println("辅助构造器")
 }
 def this(age: Int, name: String) {
	 this(age)
	 this.name = name
 }
 println("主构造器")
}
object Person {
 def main(args: Array[String]): Unit = {
  val person2 = new Person(18)
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

6.3.5 构造器参数

1）说明

Scala类的主构造器函数的形参包括三种类型：未用任何修饰、var修饰、val修饰
1、未用任何修饰符修饰，这个参数就是一个局部变量
2、var修饰参数，作为类的成员属性使用，可以修改
3、val修饰参数，作为类只读属性使用，不能修改

2）案例实操

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

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

6.4 继承与多态

1）基于语法

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

 
 

 
 
  • 1

1、子类继承父类的属性和方法
2、scala是单继承

2）案例实操

1、子类继承父类的属性和方法
2、继承的调用顺序：父类构造器 -> 子类构造器

class Person(nameParam: String) {
 var name = nameParam
 var age: Int = _
 def this(nameParam: String, ageParam: Int) {
	 this(nameParam)
	 this.age = ageParam
	 println("父类辅助构造器")
 }
 println("父类主构造器")
}
class Emp(nameParam: String, ageParam: Int) extends 
Person(nameParam, ageParam) {
 var empNo: Int = _
 def this(nameParam: String, ageParam: Int, empNoParam: Int) {
	 this(nameParam, ageParam)
	 this.empNo = empNoParam
	 println("子类的辅助构造器")
 }
 println("子类主构造器")
}
object Test {
 def main(args: Array[String]): Unit = {
   new Emp("z3", 11,1001)
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

3）动态绑定

Scala中属性和方法都是动态绑定，而Java中只有方法为动态绑定。

案例实操（对比Java和Scala的重写）
Scala

class Person {
 val name: String = "person"
 def hello(): Unit = {
 println("hello person")
 }
}
class Teacher extends Person {
 override val name: String = "teacher"
 override def hello(): Unit = {
  println("hello teacher")
 }
}
object Test {
 def main(args: Array[String]): Unit = {
 val teacher: Teacher = new Teacher()
 println(teacher.name)
 teacher.hello()
 val teacher1:Person = new Teacher
 println(teacher1.name)
  teacher1.hello()
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

Java

class Person {
 public String name = "person";
 public void hello() {
 System.out.println("hello person");
 }
}
class Teacher extends Person {
public String name = "teacher";
 @Override
 public void hello() {
   System.out.println("hello teacher");
 }
}
public class TestDynamic {
public static void main(String[] args) {
 Teacher teacher = new Teacher();
 Person teacher1 = new Teacher();
 System.out.println(teacher.name);
 teacher.hello();
 System.out.println(teacher1.name);
   teacher1.hello();
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

结果对比
在这里插入图片描述

6.5 抽象类

6.5.1 抽象属性和抽象方法

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

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

2）继承&重写

1、如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需要声明为抽象类。
2、重写非抽象方法需要用override修饰，重写抽象方法则可以不加override。
3、子类中调用父类的方法使用super关键字
4、子类对抽象属性进行实现，父类抽象属性可以用var修饰；子类对非抽象属性重写，父类非抽象属性只支持val类型，而不支持var；因为var修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写。

6.5.2 匿名子类

1）说明：

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

2）案例实操

abstract class Person {
 val name: String
 def hello(): Unit
}
object Test {
 def main(args: Array[String]): Unit = {
 val person = new Person {
 override val name: String = "teacher"
 override def hello(): Unit = println("hello teacher")
 }
 }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

6.6 单例对象（伴生对象）

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

6.6.1 单例对象语法

1）基本语法

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

 
 

 
 
  • 1
  • 2
  • 3

2）说明

1、单例对象采用object关键字声明
2、单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
3、单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

3）案例实操

//（1）伴生对象采用 object 关键字声明
object Person {
 var country: String = "China"
}
//（2）伴生对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
class Person {
 var name: String = "bobo"
}
object Test {
 def main(args: Array[String]): Unit = {
 //（3）伴生对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。
  println(Person.country)
 }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

6.6.2 apply方法

1）说明

1、通过伴生对象的apply方法，实现不使用new方法创建对象
2、如果想让主构造器变成私有的，可以在()之前加上private。
3、apply方法可以重载
4、Scala中obj(arg)的语句实际是在调用该对象的apply方法，即obj.apply(arg)。用以统一面向对象编程和函数式编程的风格。
5、当使用new关键字构建对象时，调用的其实是类的构造方法，当直接使用类名构建对象时，调用的其实是伴生对象的apply方法。

2）案例实操

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）如果想让主构造器变成私有的，可以在()之前加上 private
class 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)
 //注意：也可以创建其它类型对象，并不一定是伴生类对象
}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

扩展：在Scala中实现单例模式

6.7 特质（Trait）

1、Scala语言中，采用特质trait（特征）来代替接口的概念，也就是说，多个类具有相同的特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字trait声明。
2、Scala中的trait中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（mixin）多个特质，这种感觉类似于Java中的抽象类。
3、Scala引入trait特征，第一可以替代Java的接口，第二个也是对单继承机制的一种补充。

6.7.1 特质声明

1）基本语法

trait 特质名{
  trait 主体
}

 
 

 
 
  • 1
  • 2
  • 3

2）案例实操

trait PersonTrait {
 // 声明属性
 var name:String = _
 // 声明方法
 def eat():Unit={
 }
 // 抽象属性
 var age:Int

// 抽象方法
def say():Unit
}
//通过查看字节码，可以看到特质=抽象类+接口

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

6.7.2 特质基本语法

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

1）基本语法

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

 
 

 
 
  • 1
  • 2

2）说明

1、类和特质的关系：使用继承的关系。
2、当一个类去继承特质时，第一个连接词是extends，后面是with。
3、如果一个类在同时继承特质和父类时，应当把父类写在extends后。

3）案例实操

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

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

6.7.3 特质叠加

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

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

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

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

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()
 }
}
class MyBall extends Category with Color {
 override def describe(): String = {
 "my ball is a " + super.describe()
 }
}
object TestTrait {
 def main(args: Array[String]): Unit = {
 println(new MyBall().describe())
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

结果如下：
在这里插入图片描述

6.7.4 特质叠加执行顺序

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

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

结论：
1、案例中的super不是表示其父特质对象，而是表示上述叠加书匈奴中的下一个特质，即，MyClass中的super指代Color，Color中的super指代Category，Category中的super指代Ball。
2、如果想要调用某个指定的混入特质中的方法，可以增加约束：super[]，例如super[Category].describe()。

6.7.5 特质自身类型

1）说明

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

2）案例实操

class User(val name: String, val age: Int)
trait Dao {
 def insert(user: User) = {
 println("insert into database :" + user.name)
 }
}
trait APP {
 _: Dao =>
 def login(user: User): Unit = {
 println("login :" + user.name)
 insert(user)
 }
}
object MyApp extends APP with Dao {
 def main(args: Array[String]): Unit = {
 login(new User("bobo", 11))
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

6.7.6 特质和抽象类的区别

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

6.8 扩展

6.8.1 类型检查和转换

1）说明

（1）obj.isInstanceOf[T]：判断 obj 是不是 T 类型。
（2）obj.asInstanceOf[T]：将 obj 强转成 T 类型。
（3）classOf 获取对象的类名。

2）案例实操

class Person{
}
object Person {
 def main(args: Array[String]): Unit = {
 val person = new Person
 //（1）判断对象是否为某个类型的实例
 val bool: Boolean = person.isInstanceOf[Person]
 if ( bool ) {
 //（2）将对象转换为某个类型的实例
 val p1: Person = person.asInstanceOf[Person]
 println(p1)
 }
 //（3）获取类的信息
 val pClass: Class[Person] = classOf[Person]
 println(pClass)
 }
}

 
 

 
 

  
  
 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

6.8.2 枚举类和应用类

1）说明

枚举类：需要继承Enumeration
应用类：需要继承App

2）案例实操

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");
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

6.8.3 Type定义新类型

1）说明

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

2）案例实操

object Test {
 def main(args: Array[String]): Unit = {
	 type S=String
	 var v:S="abc"
	 def test():S="xyz"
 }
}

 
 

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

下一章（第七章） 集合

某科学的南条
关注
专栏目录
第六章 scala面向对象学习总结
材料狗转行的博客
06-05 126
scala 第六章 面向对象学习总结
Scala第六天——面向对象编程——类
你怎么回事
10-24 259
Scala第六天——面向对象编程 自己的话：漆黑的黑夜 表示着威胁 我选择诙谐 工作在堆叠 没兑现归结于那些理解 Scala定义类、构造方法、内部类 一、简单类和无参方法 1.简述： （1）函数：类外边定义的def （2）方法：类内定义的def （3）注意：如果定时的def后的方法名没加()，在调用的时候就不能加();定义def的方法名加了()调用时，可以加()也可以不加() // 定义类，...
Scala第六天——面向对象编程——对象
你怎么回事
10-24 256
本文部分参考自：https://blog.csdn.net/dataiyangu/article/details/98482587 Scala第六天——面向对象编程 自己的话：漆黑的黑夜 表示着威胁 我选择诙谐 工作在堆叠 没兑现归结于那些理解 Scala对象之单例对象、伴生对象、Apply 方法、应用程序对象、枚举 一、单例对象 1.简述： （1）object，相当于class的单个实例，...
第 6 章 Scala面向对象
我的笔记
02-07 229
大数据自学笔记——Scala学习笔记
Scala核心编程 第六章—Scala面向对象编程（一）
热门推荐
星星的博客
09-19 1万+
佛家有云：一花一世界，一叶一菩提，而我们所学的Java就是一个以面向对象为基础的程序语言，在Java中是万物皆为对象，但是在Scala中万事万物皆为对象，由此引出了Scala面向对象编程，接下来，让我带你们走进Scala对象中 1.类与对象 （1）Scala语言是面向对象的 Java是面向对象的编程语言，由于历史原因，Java中还存在着非面向对象的内容:基本类型 ，null...
【scala】第六章—— 面向对象
无邪的博客
11-26 98
1）回顾：Java 中的类如果类是 public 的，则必须和文件名一致。一般，一个.java 有一个 public 类注意：Scala 中没有 public，一个.scala 中可以写多个类。1）基本语法[ 修饰符 ] class 类名 {类体 }说明（1）Scala 语法中，类并不声明为 public，所有这些类都具有公有可见性（即默认就是public）（2）一个 Scala 源文件可以包含多个类2）案例实操。
Scala基础6——第6章：面向对象
qq_35556504的博客
08-19 378
第6章、面向对象 6.1 Scala包 （1）基本语法 ​ package 包名 （2）包的三大作用（和java一样） ​ ① 区分相同名字的类 ​ ② 当类很多，可以很好的管理类 ​ ③ 控制访问范围 6.1.1 包的命名 1）命名规则 ​ 值包含数字、字母、下划线。不能以数字开头，也不要使用关键字 2）命名规范 ​ 小写字母+小圆点 ​ com.公司名.项目名.业务名 6.1.2 包说明 ​ 包名和源文件不需要在同一个地址 ​ 用.来分割表示包的层级关系 ​ scala的包可以使用Java
Scala面向对象
zhongmingyu
03-21 965
注意：Scala中没有public，一个.scala中可以写多个类，Scala 语法中，类并不声明为public，所有这些类都具有公有可见性（即默认就是public）[修饰符] class 类名 {类体//（1）Scala 语法中，类并不声明为 public，所有这些类都具有公有可见性（即默认就是 public）//（2）一个 Scala 源文件可以包含多个类val|var name:String //一个属性没有初始化，就是抽象属性//只声明而没有实现的方法，就是抽象方法。
Scala 面向对象编程
m0_72168501的博客
12-29 1163
Scala 面向对象编程
第四课 尚硅谷Scala语言学习-面向对象
QnHyn
10-17 175
面向对象
Scala学习笔记：Scala面向对象基础
lrxcmwy2的博客
08-29 411
Scala面向对象基础 1.面向对象的基本概念 2.面向对象的特征 3.如何定义一个类 4.内部类 5.类的构造器  6.单例对象（object） 单例模式 7.应用程序对象 8.apply方法 9.类的继承  10.抽象类 11.特质（Trait） 12.包的使用
Scala入门指南之面向对象编程基础
123
02-21 215
对于有Java基础的同学来说，基本的语法就不再介绍了，直接从面向对象编程还是讲起。 在讲之前，先说几条通用的规则： 第一，Scala编程时，不再需要每一行后面写分号(;)了； 第二，所有的基本类型都是开头大写，比如int要写作Int； 第三，定义变量时，类型写在变量名之后，用冒号分隔，并且需要在前面加上var（代表变量）或者val（代表常量）关键字，如var name:String，就代表定义了一个name字符串变量； 第四，创建数组时，写法不同了，如var arr = Array(1,2)，Sc
Scala面向对象编程
一盏小灯的博客
12-06 720
一.基本概念 (一).面向对象的三大特性 ①封装:把属性、方法封装到一个类中 ②继承:父类和子类之间(属性和方法可以重写的) ③多态:父类引用指向子类对象 比如父类Animal,子类Dog 一个多态:Animal animal = new Dog( ) 包含了父类的Animal animal 引用指向子类对象的new Dog( ) (二).类和对象 比如好朋友们可以看成一个类，名字、年龄、学号可以看成属性，爱好可以看成方法； 每一个好朋友可以看成一个对象，那么每个对象都是由名字、年龄、
2. Flink快速上手
howard2005的专栏
10-29 284
通过今天的实战，您应该已经了解了如何快速上手Apache Flink，并进行简单的批处理和流处理操作。希望这些内容能够帮助您在实际项目中更好地使用Flink。
记本地第一次运行seatunnel示例项目
大尾猴的博客
10-30 477
静态源码编译通过：https://blog.csdn.net/u011924665/article/details/143372464。
2024年，Rust开发语言，现在怎么样了?
LiangGang365的专栏
10-27 1174
Rust到底好不好用，最终还是要看具体的业务场景应用。比如，目前用Rust来编写纯UI的前端，可能还不是很成熟。但在内存管理、安全性和性能优化等领域，Rust无疑是一种非常优秀的语言选择。国内华为、字节、百度、阿里、美团等在通用组件、基础平台系统都在使用rust，其他国内数据库厂商、交易所、理想汽车、小鹏汽车等，以及大量在区块链、游戏行业提供的远程职位
Vue项目中动态路由与权限控制：router.beforeEach的使用及无token重定向登录页
Jiaberrr的博客
10-31 587
本文将详细介绍在Vue项目中如何使用router.beforeEach钩子函数动态添加权限路由，并在没有token时重定向到登录页，从而实现路由权限控制。
Nginx安装配置详解
最新发布
qq_40851623的博客
11-01 643
轻量级的Web服务器，主要有反向代理、负载均衡的功能。能够支撑5万的并发量，运行时内存和CPU占用低，配置简单，运行稳定。
Scala编程指南：面向对象与函数编程的融合
该书由ARTIMA出版社出版，旨在帮助读者理解和掌握Scala的多范式编程特性，结合了面向对象和函数编程的精华。书中涵盖了Scala的基础知识，如语言结构、类和对象、基本类型和操作，以及更高级的主题，如特质、包和引用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值