scala学习之面向对象编程

最新推荐文章于 2023-02-08 21:42:48 发布

airleaya

最新推荐文章于 2023-02-08 21:42:48 发布

阅读量387

点赞数

分类专栏：大数据学习笔记文章标签： java 类多态 scala 面向对象编程

本文链接：https://blog.csdn.net/airleaya/article/details/112324698

版权

大数据学习笔记专栏收录该内容

36 篇文章 1 订阅

订阅专栏

scala学习

面向对象编程

scala中的包

scala包的作用与java一样，命名规则也相同
scala的包与java不同的在于，他自有一套不同于java的包管理风格，即通过嵌套的风格表示层级关系：
```
package outPackage{
  package innerPackage{
    
  }
}
```
该风格有如下特点：
- 一个源文件可以有多个package
- 子包中的类可以直接访问父包中的内容而无需导包
包对象：在scala中可以为每个包定义一个同名的包对象，定义在包对象中的成员，作为其对应包下所有class和object的共享变量，可以直接被访问。
- 定义方法：
```
  package object outPackage{
    val shareValue = "share value"
}
```
- 如果使用java包管理风格，包对象应当定义在其对应的包下
- 如果通过嵌套方式管理包，则包对象可与包定义在同一文件中，但是要保证包对象与包声明在同一作用域中

导包说明：

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

scala中默认的三个导包语句为：
- import java.lang._
- import scala._
- import scala.Predef._

访问权限：
- 在java中，访问权限有：public、private、protected和默认。
- 在scala中，访问权限为：默认、private、protected
  - scala中的默认访问权限即java中的public权限，scala没有public关键字
  - private为私有权限，只在类的内部和伴生对象中可用
  - protected为受保护权限，scala的受保护比java的更严格，同类、子类可以访问，但是同包无法访问
  - private[包名]可以增加包访问权限，包名下的其他类也可以使用

类与对象

定义类的语法：【修饰符】 class 类名 { 类体 }
- 在scala中，类不需要声明为public，因为他们默认即为public
- 一个scala源文件可以包含多个类

类的属性：

属性是类的一个组成部分。

定义语法：【修饰符】var属性名【：类型】 = 属性值
scala中有一类通过（@BeanProperty）修饰的属性称为bean属性，该属性可以自动生成getter、setter方法

object TestClass {
  def main(args: Array[String]): Unit = {
    var person = new Person
    println(person.name)
    person.setSex("M")
    println(person.getSex)
  }
}

class Person{
  var name = "Reimi"
  var age = 500
  @BeanProperty var sex = "F"
}
	/*
	 输出结果为：
	 Reimi
	 M
	*/

类的方法
- 定义方法的语法类似定义函数的语法：def 方法名（参数列表）【：返回值类型】={ 方法体 }

创建对象

基本语法：val | var 对象名【：类型】 = new 类型（）
- val 修饰对象，不能再改变该对象的引用
- var 修饰对象，可以改变该对象的引用
- 两者都不妨碍修改对象的属性值

构造器：和java一样，scala构造对象也需要调用构造方法，同样可以拥有任意多个构造方法

scala的构造器分为主构造器和辅助构造器
基本语法：

class 类名（参数列表）{ // 主构造器

def this（形参列表）{} // 辅助构造器

def this（形参列表）{} // 辅助构造器可以有多个

}
辅助构造方法不能直接构建对象，需要直接或间接调用主构造方法
如主构造器无参，可省小括号

object TestClass {
  def main(args: Array[String]): Unit = {
    var person = new Person("AIR",22)
  }
}

class Person{
  var name:String = _
  var age:Int = _
  def this(age:Int) {
    this
    this.age=age
    println("辅助构造器")
  }

  def this(name:String, age:Int) {
    this(age)
    this.name = name
  }

  println("主构造器")
}
	/*
	 输出结果为：
	 主构造器
	 辅助构造器
	*/

构造器参数
- 在scala的主构造器的形参包括三种类型，未用任何修饰、var修饰、val修饰
  - 未使用任何修饰的时候，该参数就是一个居部变量
  - var修饰参数，则作为类得成员属性使用，可以修改
  - val修饰参数，则作为类的只读成员属性使用，不能修改

封装

封装就是把抽象出的数据和对数据的操作封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作才能对数据进行操作。

scala中的public（默认）属性，底层实际为private，并通过getter和setter方法对其进行操作，所以scala并不推荐将属性设为private，然后设置public的setter和getter方法。

但是因为很多java框架都利用反射调用getter、setter方法，有时候为了和这些框架捷荣，也会为scala的属性设置getter和setter方法（通过注解@BeanProperty实现）

继承

基本语法： class 子类名 extends 父类名 { 类体 }
- 子类继承父类的属性和方法
- scala中是单继承
- 继承时构造器的调用顺序：父类构造器–>子类构造器

抽象属性和抽象方法

基本语法：
- 定义抽象类：abstract class 类名{}
- 定义抽象属性： var 属性名：类型 // 当一个属性没有初始化的时候，就是抽象属性
- 定义抽象方法：def 方法名（）：类型 // 只声明而不实现的方法，就是抽象方法

继承与重写

当父类为抽象方法的时候，子类需要将抽象方法和属性实现，否则也需要声明为抽象类
重写非抽象方法需要用override修饰，重写抽象方法则不用
属性重写只支持val类型，不支持var类型
scala中属性和方法都是动态绑定的，而java中只有方法为动态绑定的

//scala中的重写
object TestOverride {
  def main(args: Array[String]): Unit = {
    val person:Person = new Teacher
    val teacher:Teacher = new Teacher
    println(s"person name:${person.name}")
    person.hi
    println(s"teacher name:${teacher.name}")
    teacher.hi
  }
}

class Person{
  val name:String = "Person"
  def hi:Unit = println("hi,person")
}

class Teacher extends Person{
  override val name: String = "Teacher"
  override def hi: Unit = println("hi,teacher")
}
/*
输出的结果为：
person name:Teacher
hi,teacher
teacher name:Teacher
hi,teacher
*/

//java中的重写
public class TestJavaOverride {
    public static void main(String[] args) {
        JavaPerson person = new JavaTeacher();
        JavaTeacher teacher = new JavaTeacher();
        System.out.println("person name:"+person.name);
        person.hi();
        System.out.println("teacher name:"+teacher.name);
        teacher.hi();
    }
}

class JavaPerson{
    String name = "Person";
    void hi(){
        System.out.println("hi,person");
    }
}

class JavaTeacher extends JavaPerson{
    String name = "Teacher";
    void hi(){
        System.out.println("hi,teacher");
    }
}
/*
输出结果为：
person name:Person
hi,teacher
teacher name:Teacher
hi,teacher
*/

可以看到java的属性并没有动态绑定。

匿名子类

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

object TestClass {
  def main(args: Array[String]): Unit = {
    val abclass = new abclass {
      override val name: String = "a class"

      override def hi(): Unit = println("there is a class")
    }
    abclass.hi()
  }
}

abstract class abclass{
  val name:String
  def hi():Unit
}

单例对象（伴生对象）

scala语言是完全面向对象的语言，所以没有静态的操作。

但是为了能够和java语言交互，就产生了一种特殊的对象来模拟类对象，该对象称为单例对象。

如果单例对象名与类名一致，则称该单例对象是这个类的伴生对象，这个类的所有静态内容都可以放置在它的伴生对象中声明

基本语法： object 类名{ }
- 单例对象采用object关键字声明
- 单例对象对应的类称为伴生类，伴生对象的名称应该和伴生类的名称一致
- 单例对象中的属性和方法都可以通过伴生对象名直接调用
```
object TestClass {
  def main(args: Array[String]): Unit = {
    println(Person.sex)
  }
}

object Person {
  val sex = "F"
}

class Person {
  var name = "Alice"
}
```

apply方法

通过伴生对象的apply方法，实现不适用new关键字创建对象
如果要使主构造器变成私有，可以在括号前加private
apply方法同样可以重载
scala中的“类名（参数）”语句其实就是在调用该对象的apply方法，用以统一面向对象编程和函数式编程的风格

object TestClass {
  def main(args: Array[String]): Unit = {
    val a = Person()
    val b = Person("Alice")
    println(s"a.name=${a.name}")
    println(s"b.name=${b.name}")
  }
}

object Person {
  def apply(name:String): Person = new Person(name)
  def apply():Person = new Person("defualt")
}

class Person private(tmpName:String) {
  var name:String = tmpName
}

特质

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

scala中的trait既可以有抽象的方法和属性，也可以有具体的属性和方法，一个类可以混入多个特质。

scala引入trait特征，一方面使为了替代java的接口，另一方面也是对单继承机制的一种补充。

声明： trait 特质名 { 特质体 }

特质的基本语法

一个类据有某种特质，就一位者这个类满足了这个特制的所有要素，所以在使用时，也采用了extends关键字，如果有多个特质或存在父类，就可以用with关键字连接

基本语法：
- 没有父类： class 类名 extends 特质1 with 特质2……
- 有父类： class 类名 extends 父类 eith 特质1 with 特质2……

注：

所有的java接口都可以当作特质使用
动态混入（一种更灵活的扩展类的功能的方法）：
- 创建对象时混入trait，而不需要使类混入该trait，如果混入的trait有未实现的方法，则需要实现之

object TestClass {
  def main(args: Array[String]): Unit = {
    val alice = new Alice()
    val person = new person()
    val helloPerson = new person() with hello {
      override def hello(): Unit = println("hello"+name)
    }
    alice.hello()
    person.hi()
    helloPerson.hello()
  }
}

trait hello{
  def hello()
}

class Alice extends person with hello{
  override val name: String = "Alice"

  def hello():Unit={
    println("hello"+name)
  }
}

class person {
  val name:String = "person"
  def hi(): Unit ={
    println("hi~")
  }
}

airleaya

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
scala学习之面向对象编程

scala学习面向对象编程scala中的包scala包的作用与java一样，命名规则也相同scala的包与java不同的在于，他自有一套不同于java的包管理风格，即通过嵌套的风格表示层级关系：package outPackage{ package innerPackage{ }}该风格有如下特点：一个源文件可以有多个package子包中的类可以直接访问父包中的内容而无需导包包对象：在scala中可以为每个包定义一个同名的包对象，定义在包对象中的成员，
复制链接

扫一扫