Scala快跑系列【面向对象入门】

最新推荐文章于 2024-09-21 22:39:15 发布

张章章Sam

最新推荐文章于 2024-09-21 22:39:15 发布

阅读量4.2k

点赞数

文章标签： scala 面向对象

本文链接：https://blog.csdn.net/qq_16103331/article/details/53212622

版权

Scala中的类

在本节中，你将会学习如何用Scala实现类。如果你了解Java中的类，你不会觉得这有多难，并且你会很享受Scala更加精简的表示法带来的便利。

本节的要点包括：

1. 类中的字段自动带有getter方法和setter方法
2. 你可以用定制的getter/setter方法替换掉字段的定义，而不必修改使用类的客户端，这就是所谓的"统一访问原则"
3. 用@BeanProperty注解来生成JavaBeans的getXxx/setXxx()方法（大家比较熟悉的一种编程方式）
4. 每个类都有一个主要的构造器，这个构造器和类定义"交织"在一起。它的参数直接成为类的字段。主构造器执行类体中所有的语句
5. 辅助构造器是可选的，它们叫做this
6. 嵌套类

一、类中的字段自动带有getter方法和setter方法

1、简单类和无参方法

class PersonOps {
  private var age = 0 //你必须初始化一个字段
  def increment() {age += 1} //方法默认是公有的
  def currentAge() = age
}

1）在Scala中，类并不声明为public。Scala源文件可以包含多个类，所有这些类都具有公有可见性。

2）如何进行调用？

object MainOps{
  def main(args: Array[String]) {
    val personOps = new PersonOps()
    personOps.increment()
    println("currentAge=> " + personOps.currentAge())
  }
}

3)不能用类直接调用age,因为age是私有字段，只能在PersonOps中访问到。

2）无参方法：

println("currentAge=> " + personOps.currentAge())
println("currentAge=> " + personOps.currentAge)

建议：对设置值的时候，即改变对象状态值或者状态时使用()，而对于取值来说（不会改变对象的状态和值）去掉()是个不错的风格，这也是我们事例中的方法。

personOps.increment()
println("currentAge=> " + personOps.currentAge)

3）你可以通过以不带()的方式声明currentAge来强制这种风格：

class PersonOps {
  private var age = 0 //你必须初始化一个字段
  def increment() {age += 1} //方法默认是公有的
  def currentAge = age
}

结果：这样一来在调用时，必须要用不带()的进行方法调用 println(“currentAge=> ” +
personOps.currentAge)

4）带getter和setter的属性

Java中属性定义

public class PersonAge{ //这是Java
    private int age;
    public int getAge() { return age; }
    public void setAge(int age) { this.age=age; }
}

getter和setter方式比共有字段（public）好在什么地方呢？
之所以说getter和setter方法比公有字段更好，是因为它们让你可以从简单的get/set机制出发，并在需要的时候做改进。

5）scala中的getter和setter方法

class PersonA{
var age = 0
}

Scala生成面向JVM的类，其中有一个私有的age字段以及相应的getter方法和setter方法。这两个方法是公有的，因为我们没有将age声明为private。而对私有字段而言，getter和setter方法也是私有的。
字段默认，调用默认set/get方法,如果字段私有，那么默认的getter/setter方法也将会是私有的，无法调用，但是我们可以自定义覆盖掉默认的

1、在任何时候你都可以自己重新定义getter和setter方法。例如：
/**
  * 自定义getter和setter方式实现
  */
class CustPerson{
  private var privateAge =0 // 变成私有并改名
  def age = privateAge
  def age_= (newValue: Int) {
    if (newValue > privateAge)
      privateAge=newValue // 不能变年轻
    }
}
注意事项：在自定义setter方法时，等号左边的方法名称和=之间不应该有空格，负责会出现变量未定义的错误。
调用：
val custPerson = new CustPerson
custPerson.age  = 30
custPerson.age = 21
custPerson.age_=(50)
println("custPersonAge=> " + custPerson.age)

class SanMaoScala {
  var name: String ="";
  def getName(): String ={
    name
  }
}
object SanMaoOps{
  def main(args: Array[String]): Unit ={
    var sm = new SanMaoScala;
    sm.name_=("sanmao")
    println(sm.name)
  }
}

字段私有，自己编写set/get方法

class SanMaoScala {
  private var name: String ="";
  def getName(): String ={
    name
  }
  def setName(name: String):Unit = {
    this.name = name
  }
}
object SanMaoOps{
  def main(args: Array[String]): Unit ={
    var sm = new SanMaoScala;
    sm.setName("sanmao")
    println(sm.getName())
  }

}

在Scala中，getter和setter分别叫做age和age_=例如：

val personA = new PersonA
println("startAge=> " + personA.age)
personA.age = 21
println("endAge=> " + personA.age)
Scalac PersonOps.scala
\src\main\scala\tw\tw>javap -p PersonA.class
Compiled from "PersonOps.scala"
public class tw.PersonA {
  private int age;
  public int age();
  public void age_$eq(int);
  public tw.PersonA();
}

正如你看到的那样，编译器创建了age和age_ $eq方法。=号被翻译成$ eq，是因为JVM不允许在方法名中出现=
说明：在Scala中，getter和setter方法并非被命名为getXxx和setXxx，不过它们的用意是相同的。后面会介绍如何生成Java风格的getXxx和setXxx方法，以使得你的Scala类可以与Java工具实现互操作

3、如果字段是val，则只有getter方法被生成

有时候你需要一个只读属性，有getter但没有setter。如果属性的值在对象构建完成后就不再改变，则可以使用val字段：
//定义val声明的变量
val totalCount = 0
调用：custPerson.totalCount = 11（会抛出错误）
结论：Scala会生成一个私有的final字段和一个getter方法，但没有setter。
2和3）的一个小总结：
总结一下，在实现属性时你有如下四个选择：
　　■ var totalCount : Scala自动合成一个getter和一个setter
　　■ val totalCount : Scala自动合成一个getter
　　■ 由你来定义totalCount和totalCount _=方法
　　■ 由你来定义totalCount方法
但在Scala中，你不能实现只写属性，即带有setter但不带getter的属性。当你在Scala类中看到字段的时候，记住它和Java或c++中的字段不同。它是一个私有字段，加上getter方法（对val字段而言）或者getter和setter了法（对var字段而言）

4、私有字段：分为两种，1个是类私有字段，另外一个是对象私有字段

1）在Scala中Java和C++也一样，方法可以访问该类的所有对象的私有字段。例如：

/**
  * 类私有字段和对象私有字段的实现
  */
class PersonCounter{
  private var value = 0
  def increment () {value+=1 }
  // 可以访问另一个对象的私有字段
  def isLess (other: PersonCounter) = value < other.value 
}

2）对象私有字段

如果你不需要任何getter或setter，可以将字段声明为private[this]
private[this] val totalCount = 0

//这是不允许的方式（因为跨实例访问）
  def compareAgeBetweenDiffPersons(personC : PersonCounter): Unit ={
    if(totalAge > personC.totalAge){**//不能应用在别的实例上面，只能应用在此单一的实例上面**
      println("")
    }
  }

三、用@BeanProperty注解

1、Scala对于你定义的字段提供了getter和setter方法。不过，这些方法的名称并不是Java工具所预期的。

把Java属性定义为一对getName/setName方法或者对于只读属性而言单个getName方法。许多Java工具都依赖这样的命名习惯。当你将Scala字段标注为@BeanProperty时，这样的方法会自动生成。例如：

/**
  * 用BeanProperty实现的getter和setter方法
  */
import scala.reflect.BeanProperty
class BeanPropertyPerson{
  @BeanProperty var  name:String = _
}

调用：

val beanPropertyPerson = new BeanPropertyPerson()
beanPropertyPerson.setName("jack")
println("beanPropertyPerson.name=> " + beanPropertyPerson.getName)

beanPropertyPerson.name = "Garry"
println("scala.beanProperty.person.name=> " + beanPropertyPerson.name)

将会生成四个方法：
　　■ name:String
　　■ name_=(newValue: Strmg):Unit
　　■ getName():String
　　■ setName(newValue: String): Unit

一、Scala单例对象

1、Scala没有静态方法或静态字段，你可以用object这个语法结构来达到同样目的。对象定义了某个类的单个实例，包含了你想要的特性。例如

object PersonSingle{
  private var personNumber = 0
  def newUniquePersonNumber:Int = {
    personNumber+=1
    personNumber
  }
}

object ObjectOps {
  def main(args: Array[String]) {
    println(PersonSingle.newUniquePersonNumber)
    println(PersonSingle.newUniquePersonNumber)
  }
}

二、Scala伴生对象

在Java或C++中，你通常会用到既有实例方法又有静态方法的类。在Scala中，你可以通过类和与类同名的”伴生”对象来达到同样的目的。例如：

class PersonSingle{
  val personId = PersonSingle.newUniquePersonNumber
  private var personBalance:Double =0
  def personDeposit (amount: Double) { personBalance += amount }
}

类和它的伴生对象可以相互访问私有特性。它们必须存在于同一个源文件中。这说明了类的伴生对象可以被访问，但并不在作用域当中。举例来说， PersonSingle类必须通过

PersonSingle.newUniquePersonNumber
而不是直接用newUniqueNumber来调用伴生对象的方法。

三、对象可以扩展类或特质

1、一个object可以扩展类以及一个或多个特质，其结果是一个扩展了指定类以及特质的类的对象，同时拥有在对象定义中给出的所有特性。

abstract class PersonAccount (val accountName: String) {
  def unRegisterPersonAccount() : Unit
  def reRegisterPersonAccount() : Unit
}
object PersonAccountImpl extends PersonAccount("AccountName") {
  override def unRegisterPersonAccount (): Unit = {
    println("===start to logger======")
  }
  override def reRegisterPersonAccount (): Unit = {
    println("===end to logger=========")
  }
}
调用：PersonAccountImpl.reRegisterPersonAccount()

四、Apply方法（object和class）

1、我们通常会定义和使用对象的apply方法。当遇到如下形式的表达式时，apply方法就会被调用：

object（参数1，…，参数N）
通常，这样—个apply方法返回的是伴生类的对象

class PersonApplyTest{
  private var balance = 0
  def apply() = println("your person apply class test")

  def initPersonNumber:Int = {
    balance += 1
    balance
  }
}
object PersonApplyTest{
  def apply () = {
    println("Please init your person information")
    new PersonApplyTest
  }
}
调用：
1、val personApplyTest =  PersonApplyTest()
    println(personApplyTest.initPersonNumber)

2、val personApplyTest = new PersonApplyTest
    println(personApplyTest.initPersonNumber)
    personApplyTest()

五、扩展App类的特征

1、除了每次都提供自己的main方法外，你也可以扩展App特质，然后将程序代码放人构造器方法体内：

object ObjectOps extends  App{
  if (args.length > 0)
    println("Hello, "+args (0))
  else
    println("Hello, World! ")
}

六、枚举Enumeration

1、Scala并没有枚举类型。不过，标准类库提供了一个Enumeration助手类，可以用于产出枚举。定义一个扩展Enumeration类的对象并以Value方法调用初始化枚举中的所有可选值。

2、枚举定义的初始化

object PersonClothesColor extends Enumeration{
val Red,Yellow,Green = Value
}

3、枚举引用

1）定义完成后，你就可以用PersonClothesColor.Red、PersonClothesColor.Yellow等来引用枚举值了。
2）需要注意的是：枚举的类型是PersonClothesColor.Value而不是PersonClothesColor，后者是握有这些值的对象。有人推荐增加一个类型别名：