Object Oriented Programming Basics – Arma Reforger

From Bohemia Interactive Community
Revision as of 10:17, 19 May 2022 by Lou Montana (talk | contribs) (Text replacement - "lang="cpp">" to "lang="C#">")
Jump to navigation Jump to search

Class vs Object

A class is a definition of an object; it can be seen as the blueprint for an object's creation. An object is an instance of a class, as in an entity created following the class' specifics.

An object can hold values, known as member variables, and functions, known as methods.

A class can have variables and methods too, known as static variables and methods.


Member Variable

A member variable is a variable scoped to that object instance. It is usually protected but can be private (see Visibility); a public member is usually a bad practice - it is best to use Getters and Setters.

See Arma Reforger:Scripting: Values for naming prefixes. 

class MyClass
{
	private int m_iValue = -1; // -1 is undefined value

	void MyClass(int value)
	{
		m_iValue = value;
	}
}


Method

A method is an object's function or a class' (static) function - it can be seen as a "member function".

A method has a signature, i.e a return type, a name and a parameters list - e.g: 

int GetNumber(bool canBeNegative)

.

Two methods can be named identically as long as they differ by their parameters. 

class MyClass
{
	void MyMethod()
	{
		Print("MyMethod without arguments");
	}

	int MyMethod() // error: only the return type differs
	{
		return 42;
	}

	void MyMethod(int a)
	{
		Print("MyMethod with 1 int argument");
	}

	void MyMethod(string a)
	{
		Print("MyMethod with 1 string argument");
	}

	void MyMethod(bool a, string b)
	{
		Print("MyMethod with 1 bool, 1 string argument");
	}

	static int MyStaticMethod()
	{
		return 33;
	}
}

MyClass instance = new MyClass();				// creates an instance of MyClass
int result = instance.MyMethod();				// returns 42
instance.MyMethod(10);							// prints "MyMethod with 1 int argument"
instance.MyMethod("hello");						// prints "MyMethod with 1 string argument"
instance.MyMethod(false, "hey");				// prints "MyMethod with 1 bool, 1 string argument"

delete instance;								// deletes instance - instance variable value is now null

int staticResult = MyClass.MyStaticMethod();	// without instance usage, staticResult is 33

Getter and Setter

A Getter describes a method that gets the value of a property;

A Setter describes a method that sets it. 

class MyClass
{
	public int Health = 100; // bad
}

class MyClass
{
	private int m_iHealth;

	void MyClass() // constructor method
	{
		m_iHealth = 100;
	}

	int GetHealth() // health getter
	{
		return m_iHealth;
	}

	void SetHealth(int health) // health setter
	{
		m_iHealth = health;
	}
}

// because health could be implemented another way - and if it is, we do not want to have to go through old code to change calls

class MyClass
{
	private int m_iHeadHealth;
	private int m_iBodyHealth;

	void MyClass() // constructor method
	{
		m_iHeadHealth = 100;
		m_iBodyHealth = 100;
	}

	int GetHealth() // health getter
	{
		return m_iHeadHealth * 0.75 + m_iBodyHealth * 0.25; // head damage counts thrice
	}

	void SetHealth(int health) // health setter
	{
		if (health > 100 || health < 0)
		{
			return;
		}

		m_iHeadHealth = health * 0.75;
		m_iBodyHealth = health * 0.25;
	}
}

Constructor

A constructor method is a specific one: it is a method that is automatically called on object instanciation, and can be with or without arguments.
There can be zero to one constructor.

A constructor is declared as a method having the same name as its class.

ⓘ
  • The parent class constructor (see the Inheritance chapter below) is automatically called. Inheriting class can only add new arguments to those accepted by the base class constructor.
class MyClass
{
	int m_iValue;

	void MyClass()
	{
		PrintFormat("Instance created");
		m_iValue = 50;
	}
};

MyClass instance = new MyClass();	// instance.m_iValue = 50

class MyClass
{
	int m_iValue;

	void MyClass(int value)
	{
		m_iValue = value;
		PrintFormat("Instance created with value %1", m_iValue);
	}
};

MyClass instance = new MyClass(42);	// prints "Instance created with value 42"
MyClass instance = new MyClass();	// errors: argument is missing

Destructor

A destructor method is a specific one: it is a method that is automatically called on object destruction, and exists only without arguments. There can be zero to one destructor.

A destructor is declared as a method having the same name as its class, starting with a tild. 

class MyClass
{
	void ~MyClass()
	{
		Print("I am being destroyed!");
	}
}

MyClass instance = new MyClass();
delete instance; // prints "I am being destroyed!";


Visibility

Visibility is the accessibility of an object's or class' method/variable from the "outside" of that object/class.

public

This is the default visibility - the member is accessible from inside as well as outside the object. As the default visibility, it does not need a keyword. 

class ParentClass
{
	int Health = 100; // while a bad practice, a public member is PascalCase-named
}

class ChildClass : ParentClass
{
	void ChildClass()
	{
		Health = 200; // stronger child
	}
}

ParentClass parent = new ParentClass();
parent.Health = 10;	// OK

ChildClass child = new ChildClass();
child.Health = 10;	// OK

protected

This is a "hierarchy" visibility - the member is accessible from the object and objects of inheriting classes. It uses the protected keyword.

⚠
It is important to keep visibility to protected for modding purpose - an inherited class can then expand or reuse these methods.
class ParentClass
{
	protected int m_iHealth = 100;
}

class ChildClass : ParentClass
{
	void SetHealth(int health)
	{
		m_iHealth = health;
	}
}

ParentClass parent = new ParentClass();
parent.m_iHealth = 10;	// error: cannot access from the outside
parent.SetHealth(10);	// error: the SetHealth method is a member of ChildClass, not ParentClass

ChildClass child = new ChildClass();
child.m_iHealth = 10;	// error: cannot access from the outside
child.SetHealth(10);	// OK - the child can internally edit the inherited member

private

This is the strictest visibility - only the object can access this member. This is useful to e.g cut code in smaller methods and not clutter the list of available methods on this object from the outside. It uses the private keyword. 

class ParentClass
{
	private int m_iHealth = 100;
}

class ChildClass : ParentClass
{
	void SetHealth(int health)
	{
		m_iHealth = health; // error: ChildClass does not know m_iHealth
	}
}

ParentClass parent = new ParentClass();
parent.m_iHealth = 10;	// error: cannot access from the outside
parent.SetHealth(10);	// error: the SetHealth method is a member of ChildClass, not ParentClass


Inheritance

Inheritance is the transmission of parent properties to a child class. Class inheritance is written with :. A class can only inherit from one class. 

class ParentClass
{
	void ParentMethod()
	{
		Print("Parent Method");
	}
}

class ChildClass : ParentClass
{
	void ChildMethod()
	{
		Print("Child Method");
	}
}

ParentClass parent = new ParentClass();
parent.ParentMethod();	// outputs "Parent Method"
parent.ChildMethod();	// error: ChildMethod is not a member of ParentClass, only ChildClass

ChildClass child = new ChildClass();
child.ParentMethod();	// outputs "Parent Method"
child.ChildMethod();	// outputs "Child Method"

override

A non-private (protected or public) inherited method can be overridden thanks to the override keyword: 

class ParentClass
{
	void TheMethod()
	{
		Print("Parent Method");
	}
}

class ChildClass : ParentClass
{
	override void TheMethod()
	{
		Print("Child Method");
	}
}

ParentClass parent = new ParentClass();
parent.TheMethod();	// outputs "Parent Method"

ChildClass child = new ChildClass();
child.TheMethod();	// outputs "Child Method"

super

An inherited object can call its parent's non-private (protected or public) method: 

class ParentClass
{
	void MethodA()
	{
		Print("Parent MethodA");
	}
}

class ChildClass : ParentClass
{
	void MethodB()
	{
		super.MethodA();
		Print("Child MethodB");
	}
}

ParentClass parent = new ParentClass();
parent.TheMethod();	// outputs "Parent MethodA"

ChildClass child = new ChildClass();
child.TheMethod();	// outputs "ParentMethodA" then "Child MethodB"

It can even call an overriden one: 

class ParentClass
{
	void TheMethod()
	{
		Print("Parent Method");
	}
}

class ChildClass : ParentClass
{
	override void TheMethod()
	{
		super.TheMethod();
		Print("Child Method");
	}
}

ParentClass parent = new ParentClass();
parent.TheMethod();	// outputs "Parent Method"

ChildClass child = new ChildClass();
child.TheMethod();	// outputs "Parent Method" then "Child Method"


Casting

Casting is the act of "presenting" a value as another type. For example, if a class hierarchy is Animal > Dog > Cocker, a dog is an animal, a cocker is a dog (that is an animal), but a dog is not especially a cocker. 

class Animal {}
class Dog : Animal {}
class Cocker : Dog {}
class Labrador : Dog {}

Upcasting

Upcasting means seeing the class as one of its parents: 

void Method()
{
	Cocker cocker = new Cocker();
	Animal animal = cocker;			// OK, as a cocker is an animal
	string sentence = cocker;		// error: cocker does -not- inherit from string
};

Downcasting

Downcasting means seeing a parent class as a specific child - this must be done by manually casting: 

void Method(Dog dog)
{
	Cocker cocker1 = dog;				// error: "Dog" is too generic to be casted as Cocker - it could be e.g a Labrador
	Cocker cocker2 = Cocker.Cast(dog);	// OK: manual casting tells the code "the developer knows what he is doing"
										// if 'dog' is not castable as a Cocker, null is returned - the code does not crash

	Cocker cocker3;
	cocker3.Cast(dog);					// alternative method
}

Manual Casting

void Method()
{
	float value1 = 4.9;
	int value2 = value1;						// value2 = 4 as integer casting -truncates- the value, not rounds it
	string value3 = "result = " + (bool)value2;	// "result = true", as a non-zero integer is true when casted to bool
}
Retrieved from "https://community.bistudio.com/wiki?title=Arma_Reforger:Object_Oriented_Programming_Basics&oldid=321697"