Változók, tagok és a this kulcsszó

Member / Tag

A tagok olyan “alkatrészei”, egy összetett típusnak (osztály/struktúra), amik a típus egy példányához tartoznak. Ezek lehetnek :

• Field-ek, amik egy objektum belső állapotát tárolják,
• Metódusok, amik műveleteket végrehajtanak az objektummal
• *Property**-k, amik biztonságos és jól szabályozható hozzáférést biztosítanak az objektum belső állapotához.

Lokális és Tagváltozók

Láttuk, hogy létre lehet hozni változókat metóduson belül, Ezen Változókat nevezzük lokális változóknak.

Azt is láttuk, hogy metóduson kívül, de összetett típuson (osztályon vagy struktúrán) belül is létre tudunk, hozni változókat. Ezeket pedig tagváltozóknak, field-eknek, osztály-változónak vagy (legritkábban) mezőnek nevezzük.

using UnityEngine;

class TestClass
{
    int someField;                                // Tagváltozó (Field)
    string someOtherField = "Some default value"; // Tagváltozó (Field)

    void TestMethod(float someParameter)          // A paraméterek is lokális változók
    {                                             
        int someLocalVariable = 5;                // Lokális változó
        string someOtherLocalVariable;            // Lokális változó
    }
}

Egy lokális és egy tagváltozó több mindenben különbözik.

• Lokális változók addig “élnek”, amíg a metódus, amiben létrehozták őket véget nem ér. Ezzel szemben a field addig “elérhető” amíg az osztály.
• Lokális változót a használata előtt kötelező definiálni azaz kezdőértéket adni neki. Ezzel szemben a field-ek kapnak típustól függően egy default (alapértelmezett értéket)
• Lokális változóra csak a definiálása után, de még az adott metóduson belül tudunk hivatkozni.

Összefoglalva

A this kulcsszó

Lehetséges, hogy egy összetett típusban jelen van egy field meg egy metóduson belüli lokális változó ugyanazon a néven. Ebben az esetben ha a metódusból hivatkozunk a változó nevére, akkor az automatikusan mindig a lokális változót takarja.

TestClass t1 = new TestClass();
t1.Add(5);
Console.WriteLine(t1.num);  // 0

class TestClass
{ 
	public int num = 0;

	public void Add(int n)
	{
		int num = 0;
		num += n;  
		// Ez az num egy lokális változó
	}
}

TestClass t1 = new TestClass();
t1.Add(5);
Console.WriteLine(t1.num);  // 5

class TestClass
{ 
	public int num = 0;

	public void Add(int n)
	{
		// int num = 0;
		num += n;
		// Ez az num most egy field
	}
}

Fenti példában az aláhúzás jelzi ugyanazt a változót.

Kintről a . (pont ) operátorral tudtunk hivatkozni egy objektum field-jére. Pl.: t1.num

Hasonlóan hivatkozhatnánk az osztályon belül is az objektum field-jére, ha lenne egy hivatkozásunk az adott objektumra.

Egy tag-metóduson belül a this kulcsszóval tudunk hivatkozni az adott objektumra, amin a metódus épp végrehajtódik.

TestClass t1 = new TestClass();
t1.Add(5);
Console.WriteLine(t1.num);  // 0

class TestClass
{ 
	public int num = 0;  // --------------------->   Ez ugyanaz a num,
                                              //      |
	public void Add(int n)                      //      |
	{                                           //      |
		int num = 0; // Ez ugyanaz a num,         //      |
		num += n;    // mint ez!                  //      |
                                              //      V
		this.num += 5;     // <---------------------   mint ez!
	}
}

Ez gyakran hasznos lehet egy konstruktor esetén is:

class Person
{
	public string name;
	public int age;
	public int height;

	public Person(string name, int age, int height)
	{
		this.name = name;
		this.age = age;
		this.height = height;
	}
}

A this kulcsszót más kontextusban is használhatjuk arra, hogy az objektumra hivatkozzunk, amin a metódus végrehajtódik.

void SomeMethod()
{
  string v1 = "Variable 1";

	if(someCondition)
	{
	  string v2 = "Variable 2";
		while(someOtherCondition)
		{
			string v3 = "Variable 3";
		}															// v3 hatáskörének vége 
	}																// v2 hatáskörének vége 
}																	// v1 hatáskörének vége