Een ander voordeel is dat je verschillende objecten met de zelfde interface in een List<> of Array[] kan zetten en op deze manier een verzameling van deze interfaces kan maken om te tracken of om via een loop allemaal methods uit te voeren.

// List van ICollactable interfaces
private List<ICollectable> collectables = new List<ICollectable>();

/// <summary>
/// Note: Deze is **niet** Serializable met [SerializeField] 
//  en dus niet zichtbaar te maken in de inspector en moet je dus altijd via code vullen.
/// </summary>

Waarom?

Wanneer je een game aan het maken bent heb je soms classes die erg veel op elkaar lijken maar niets met elkaar te maken hebben. De functionaliteiten van deze verschillende classes kunnen vergelijkbaar zijn maar niet 100% het zelfde.

Voor de onderdelen die vergelijkbaar zijn is het dan verstandig om een of meer interface(s) te gebruiken.

Voorbeeld: Je heb twee verschillende objecten, een health pack en een ammo pack. De een geeft levens de andere geeft ammo hierin zijn ze verschillend. Maar beide object zijn op de zelfde wijze op te pakken, deze functionaliteit kan je dus hergebruiken en daarvoor kan je een interface toepassen, bijvoorbeeld “ICollectable”.

Wat is het?

Een interface is zelf een abstracte class die alleen maar abstract methods(functies) en properties kan bevatten, deze hebben dus geen body { }.

Je kan een interface zien als een afspraak. Wanneer je een interface toepast bij een class verplicht je deze class de onderdelen van de interface te implementeren.

// interface
interface IAnimal 
{
  void animalSound(); // interface method (does not have a body)
}

// Cat "implements" de IAnimal interface
class Cat: **IAnimal** 
{
  public void animalSound() 
  {
    // The body of animalSound() is provided here
    Console.WriteLine("The cat says: meow");
  }
}

In dit voorbeeld zie je het aanmaken en toepassen van een interface. De naam van de interface start altijd met een hoofdletter “i” gevolgd door wat het is/doet. Interfaces wordt meestal gebruik voor een actie van iets, daarom is de code convention vaak I----able, dit ga je in de volgende voorbeelden terug zieSn.

Toepassing

Zoals in het eerder genoemde voorbeeld kan je een interface maken voor object die je kan oppakken “ICollectable”. Deze heeft in een method Collect().

interface ICollectable
{
	void Collect()
}

class HealthPack : **MonoBehaviour**, **ICollectable**
{
	public void Collect()
	{
		//Do what needs to happen when collected!
		health += 10;
	}
}

Een ander voorbeeld kan zijn het krijgen van schade. Er zijn in de game meerder objecten die schade kunnen krijgen, denk aan de player, de enemies, een crate en een barrel. Voor deze situatie kan je heel goed een interface gebruiken. De functionaliteit is namelijk vergelijkbaar maar er is geen relatie tussen een barrel en een Player.

//de interface
interface IDamageable
{
	void Damage(int damage)
}

//Voorbeeld Player class
class Player: MonoBehaviour, IDamageable
{
	int health = 100;
	
	public void Damage(int damage)
	{
		health -= damage;
    // The player was damaged!

    if (health <= 0)
    {
        Destroy(gameObject);
    }
	}
}