Los objetos con estado son aquellos objetos que tienen miembros cambiables o miembros mutables, que pueden variar qué transacciones u operaciones se realizaron previamente en el objeto. Para una misma operación realizada muchas veces, el resultado obtenido puede ser diferente del resultado anterior. Es muy común comparar objetos con estado con objetos del mundo real, donde el estado de los objetos cambia con el tiempo.
Sintaxis:
class classname
{
// declaring some states that are mutable
var state1
var state2
def changestate
{
// some operation to change the states of the object
}
}
Cuando los miembros de un objeto cambian su valor en horas extras para ciertas operaciones, que se realizan en el objeto. Debido a esto, cambia el estado del objeto que depende de las operaciones realizadas previamente.
A continuación se muestran algunos ejemplos para comprender el objeto con estado.
Ejemplos #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
}
}
Producción :
water in bottle = 3 water left = 2 water left = 1 water left = 0 waterbottle empty fill water
Como podemos ver en el ejemplo anterior, el estado de w.drinkwater cambia su resultado para la misma operación a «botella de agua vacía llena de agua» hasta que llenamos o actualizamos el agua. El estado mutable depende del agua que es una variable. Por lo tanto, podemos decir que los objetos con estado están hechos de vars y no de val , pero esto no es cierto, una clase puede cambiar su estado sin contener vars.
Para un objeto que cambia su estado a otro estado, el conjunto de operaciones o el camino tomado para llegar a ese estado en particular puede ser diferente, pero al final el estado que se logra debe ser el mismo. Esto también se conoce como equivalencia operativa donde x e y son objetos diferentes pero con los mismos estados al final de diferentes conjuntos de operaciones.
Ejemplos #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)
}
}
Producción :
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
De manera similar, en el ejemplo anterior, podemos decir que el jugador es un objeto con estado sin mirar el funcionamiento interno de la clase. Debido a que la salud no se puede reducir a negativa, el jugador tiene estados mutables ya que la misma operación devuelve una salida diferente en entradas diferentes o iguales.