Set/get Members In An Object Oriented Class

-- Closure function
function Class()
  local _privateVariable = 1
  local self = {}
  self.getVariable = function()
	return _privateVariable
  end
  return self
end

-- Create an instance of Class
object = Class()
print(object.getVariable()) --> 1
print(type(object._privateVariable)) --> nil

-- Closure function
function Class()
  local _members = { }
  -- Returns the instance
  return setmetatable( { },
  {
	__newindex = function(self, k, v)
	  if k=="_member" then
		assert(type(v)=="table", "Invalid member")
		assert(v.key~=nil, "Invalid member")[/size]
		_members[v.key]={get=v.get, set=v.set}[/size]
	  elseif _members[k] == nil then[/size]
		rawset(self,k,v)[/size]
	  else
		assert(_members[k].set~=nil,"Attempt to write to a read-only member: ",k)
		_members[k].set(v)
	  end
	end,
	__index = function (self, k)
	  if _members[k]~= nil then
		if _members[k].get~=nil then
		  return _members[k]:get()
		end
	  end
	end
  })
end
instance = Class()
instance._member = {key="type", get=function() return "class" end}
print(instance.type) --> class
instance.type = "something else" --> crashes.

return setmetatable( { },
{

local self = {}
return self

__newindex = function(self, k, v)

if k=="_member" then
  assert(type(v)=="table", "Invalid member")
  assert(v.key~=nil, "Invalid member")
  _members[v.key]={get=v.get, set=v.set}

elseif _members[k] == nil then
  rawset(self,k,v)

  else
	assert(_members[k].set~=nil,"Attempt to write to a read-only member: ",k)
	_members[k].set(v)
  end
end,

__index = function (self, k)
  if _members[k]~=nil then
	if _members[k].get~=nil then
   return _members[k]:get()
end

function InheritedClass()
  local self = Class()
  local _privateVariable = 3
  local function _privateVariableSetter(v)
	_privateVariable = 2 * v
  end
  Class._member = { key="var",
					set=_privateVariableSetter,
					get=function() return _privateVariable end }
  return self
end

Molinko, on 31 August 2013 - 02:23 PM said:

I've recently been learning lua OOP even though im not experienced i keep hearing "Its not real OOP". I cant really understand why its seen that way.. Im curious to ask, why would you need an object to have private fields and why would you use a get and set system instead of just querying the field itself?? <– noobie question… Thanks for any explanation. Nice work BTW.

Molinko, on 31 August 2013 - 02:23 PM said:

I've recently been learning lua OOP even though im not experienced i keep hearing "Its not real OOP". I cant really understand why its seen that way.. Im curious to ask, why would you need an object to have private fields and why would you use a get and set system instead of just querying the field itself?? <– noobie question… Thanks for any explanation. Nice work BTW.

Player = { health = 100 }

Enemy = {}
function Enemy:onHit(player)
  player.health = player.health - 10
end

Spikes = {}
function Spikes:onHit(player)
  player.health = player.health - 10
  --# maybe the spikes retract or break after being hit?
end

Lava = {}
function Lava:onHit(player)
  player.health = player.health - 10
  --# maybe the lava spawns a couple of nice particles?
end

Player = { health = 100 }
function Player:damage(n)
  self.health = self.health - n
  self:getPushed()
  self:flash()
  self:doWhatever()
end

private int _health
int health
{
  get
  {
	return this._health
  }
  set
  {
	if (val < this._health)
	  // Flash to show damage
	else
	  // Make cheezy hearts float up from your head
	this._health = val
	// Do some other stuff to update the character, I.E. you
	// could change textures depending on health level
   }
}[/size]

player.health = 22

assert(type(val)=="number","Invalid health value")

Kingdaro, on 31 August 2013 - 03:33 PM said:

Adding getters and setters specifically for the purpose of them existing is a shitty idea.

function Class()
    local privateVar
    function method()
        self.globalVar = 3
        print("method!")
    end
end

Kingdaro, on 31 August 2013 - 02:41 PM said:

Molinko, on 31 August 2013 - 02:23 PM said:

I've recently been learning lua OOP even though im not experienced i keep hearing "Its not real OOP". I cant really understand why its seen that way.. Im curious to ask, why would you need an object to have private fields and why would you use a get and set system instead of just querying the field itself?? <– noobie question… Thanks for any explanation. Nice work BTW.

From what I've read, using getters and setters instead of accessing the method directly allows you to make changes in the code more easily.

This isn't a good explanation (as I'm only scraping the surface of OOP myself), but here's an example. Let's say you have a game with a Player object, and that player has a health property. Wherever the player gets damaged, you would simply decrease the health. Maybe we have an enemy that damages the player, along with lava or spikes. (I've made comments in some of the methods to explain why we would need to rewrite them like that.)

Player = { health = 100 }

Enemy = {}
function Enemy:onHit(player)
  player.health = player.health - 10
end

Spikes = {}
function Spikes:onHit(player)
  player.health = player.health - 10
  --# maybe the spikes retract or break after being hit?
end

Lava = {}
function Lava:onHit(player)
  player.health = player.health - 10
  --# maybe the lava spawns a couple of nice particles?
end

And that's that. But what if we need to do something else after the player gets damaged? Perhaps push the player away from the obstacle, or turn the player red for a second. In that case, we would need to add multiple lines of code for each instance we decrease the player's health.

In this case, it's better to use a method to change the player's health, rather than change the behavior of many objects that do the same thing.

Player = { health = 100 }
function Player:damage(n)
  self.health = self.health - n
  self:getPushed()
  self:flash()
  self:doWhatever()
end

That way, the damaging behavior is easily implemented wherever we need, and we can make changes here without having to go through the rest of the code.

public class Person {
	private boolean alive;

	Person() {
		alive = true;
	}
}

public class Person {
	private boolean alive;

	Person() {
		alive = true;
	}

	public boolean isAlive()
	{
		return alive;
	}

	public void setAlive(boolean newValue)
	{
		alive = newValue;
	}
}

public class Person {
	private int hitPoints;

	Person() {
		hitPoints = 100;
	}

	public int getHitPoints()
	{
		return hitPoints;
	}

	public void setHitPoints(int hp)
	{
		hitPoints = hp;
	}
}

public class Person {
	private boolean alive;

	Person() {
		alive = true;
	}

	public boolean isAlive()
	{
		return alive;
	}

	public void kill()
	{
		alive = false;
	}
}

public class Person {
	private int hitPoints;

	Person() {
		hitPoints = 100;
	}

	public boolean isAlive()
	{
		return hitPoints > 0;
	}

	public void kill()
	{
		hitPoints = 0;
	}
}

public class Person {
		private boolean alive;

		Person() {
				alive = true;
		}

		public boolean isAlive()
		{
				return alive;
		}

		public void setAlive(boolean newValue)
		{
				alive = newValue;
		}
}

public class Person {
		private int hitPoints;

		Person() {
				hitPoints = 100;
		}

		public int getHitPoints() 
		{
				return hitPoints;
		}

		public boolean isAlive()
		{
				return (hitPoints>0); //If he's not dead, he's alive. Maintains the old function call.
		}

		public void setHitPoints(int hp)
		{
				hitPoints = hp;
		}

		public void setAlive(boolean alive)
		{
				 hitPoints=(alive)?100:0; //Sets hitPoints to 100 if alive, 0 otherwise. Maintains the old function call.
		}
}

BigTwisty, on 01 September 2013 - 10:34 AM said:

-snip-

public class Window {
	public boolean visible;

	Window() {
		visible = true;
	}

	public void hide() {
		visible = false;
		// do anything else appropriate to hide it, maybe redraw?
	}

	public void show() {
		visible = true;
	 // do anything else appropriate to show it, maybe redraw?
	}

	public boolean isVisible() {
		return visible;
	}
}

MudkipTheEpic, on 01 September 2013 - 10:56 AM said:

-snip-

public class x {
  private int[] x = {};

  public int[] getX(){
    return x.clone();
   }

  public void addX( int newValue ){
     // checking if newValue is valid for our purpose (which we dont really have)
     x[ x.length  ] = newValue;
  }
}

public class GUI {
    private int xMin;
    private int xMax;
    private int yMin;
    private int yMax;

   public int[] getValues(){
      int[] values = new int[4];
      values[0] = xMin;
      values[1] = xMax;
      values[2] = yMin;
      values[3] = yMax;
      return values;
   }

   // every setter looks like this:
   public boolean set_xMin( int value ){
      // checks
      if(!( value < 0 &amp;&amp; value > width_of_screen)){
         this.xMin = value;
         return true;
      }
      return false
   }

}

Engineer, on 01 September 2013 - 11:56 AM said:

-snip-

bool Player::move(int xOffset, int yOffset) {
  x += xOffset;
  y += yOffset;

  if (!currentWorld->isValidPosition(x, y)) {
	x -= xOffset;
	y -= yOffset;
	return false;
  }

  return true;
}

player->move(-1, 0);

player->move(0, 1);

player->move(1, -1);

#include "Player.h"

Player::Player(World *world, int startX, int startY) {
  currentWorld = world;
  x = startX;
  y = startY;
  alive = true;
};

int* Player::getPosition() {
  return new int[2]{x,y};
}

int Player::isAlive() {
  return alive;
}

void Player::kill() {
  alive = false;
}

bool Player::move(int xOffset, int yOffset) {
  x += xOffset;
  y += yOffset;

  if (!currentWorld->isValidPosition(x, y)) {
	x -= xOffset;
	y -= yOffset;
	return false;
  }

  return true;
}

string Player::validMoves() {
  string dirs = "";

  if (currentWorld->isValidPosition(x, y-1)) {
	dirs = dirs.append(", N");
  }

  if (currentWorld->isValidPosition(x, y+1)) {
	dirs = dirs.append(", S");
  }

  if (currentWorld->isValidPosition(x+1, y)) {
	dirs = dirs.append(", E");
  }

  if (currentWorld->isValidPosition(x-1, y)) {
	dirs = dirs.append(", W");
  }

  return dirs;
}