Scala 有状态对象

有状态的对象是指那些拥有可改变成员或可改变成员的对象，这些成员可能会改变之前对该对象进行的交易或操作。对于一个多次执行的相同操作，其输出的结果可能与之前的结果不同。将有状态的对象与现实世界中的对象进行比较是非常常见的，在现实世界中，对象的状态会随着时间的推移而改变。

语法

class classname
{
     // declaring some states that are mutable
     var state1
     var state2
     def changestate
     {
          // some operation to change the states of the object
     }
}

当一个对象的成员因某些操作而超时改变其值时，这些操作是在该对象上执行的。由于这个原因，对象的有状态性发生了变化，这取决于之前执行的操作。下面是一些理解有状态对象的例子。

例子 #1 :

// A Scala program to illustrate
// stateful objects
 
// creating a class
class waterbottle
{
    // creating states
    var water: Int = 0
    def drinkwater = {
        if(water > 0)
        {
            water = water-1
            println("water left = "+water)
        }
        else
        {
            println("waterbottle empty fill water")
        }
    }
     
    // Defining method
    def fillwater (c: Int)=
    {
        if(water + c > 5)
        {
            water = 5
        }
        else
        {
            water = water + c
        }
    }
    override def toString= "water in bottle = " + water
}
 
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
        // waterbottle object
        var w = new waterbottle
         
        // calling
        w.fillwater(3)
        println(w)
         
        // Changing state
        w.drinkwater
        w.drinkwater
        w.drinkwater
        w.drinkwater
    }
}

输出:

water in bottle = 3
water left = 2
water left = 1
water left = 0
waterbottle empty fill water

正如我们在上面的例子中所看到的， w.drinkwater 的状态在同一操作中会改变为 “waterbottle empty fill water “，直到我们填充或更新水。可变的状态取决于水，而水是一个变量。因此我们可以说，有状态的对象是由 vars 而不是 val 构成的，但这并不正确，一个类可以改变它的状态而不包含任何vars。对于一个将其状态改变为另一个状态的对象，其操作集或达到该特定状态的路径可能是不同的，但最后达到的状态应该是相同的。这也被称为 操作等价 ，即 x和y 是不同的对象，但在不同的操作集结束时具有相同的状态。

例子#2

// A Scala program to illustrate
// stateful objects
 
// creating player class
class player
{
    // creating states
    var health: Int = 10
    def punch(p: player)
    {
        if(p.health > 0)
        {
            p.health = p.health-2
            println(p + " health is " + p.health)
            if(p.health < 1)
            {
                // checking the state
                dead(p)
            }
        }
        else
        {
            dead(p)
        }
    }
    def kick(p: player)
    {
        if(p.health > 0)
        {
            p.health = p.health-3
            println(p + " health is " + p.health)
            if(p.health < 1)
            {
                // checking the state
                dead(p)
            }
        }
        else
        {
            dead(p)
        }
    }
    def superp(p: player)
    {
        if(p.health > 0)
        {
            p.health = p.health - 5
            println(p + " health is " + p.health)
            if(p.health < 1)
            {
                // checking the state
                dead(p)
            }
        }
        else
        {
            dead(p)
        }
    }
    def dead(p:player)
    {
        println("Game Over")
        println(p +" is dead " + this + " is winner")
    }
}
 
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
        // Creating objects for player
        var p1 = new player
        var p2 = new player
        p1.kick(p2)
        p1.punch(p2)
        p1.superp(p2)
        p1.punch(p2)
 
    }
}

输出:

player@506e1b77 health is 7
player@506e1b77 health is 5
player@506e1b77 health is 0
Game Over
player@506e1b77 is dead player@4fca772d is winner
Game Over
player@506e1b77 is dead player@4fca772d is winner

同样，在上面的例子中，我们不用看类的内部工作就可以知道播放器是一个 有状态的对象 。因为健康状况不能降为负值，所以播放器具有可变的状态，因为同一操作在不同或相同的输入下会返回不同的输出。