Valaki elmagyarázná mi a különbség tagváltozó, objektumváltozó és osztályváltozó között?

Én ezeket a magyar elnevezéseket ismerem/használom:

- objektum szintű adattag

- osztály szintű adattag

Gondolom "tagváltozó" = "adattag", tehát az a gyűjtőfogalom, a többit jól tudod. :)

public class A {

... private int x = 0;

... private static int y = 0;

... public int get() {

... ... int tmp = x + y;

... ... this.x++;

... ... y++;

... ... return tmp;

... }

}

A obj1 = new A();

A obj2 = new A();

// változók get elött | print | változók get után

System.out.println(obj1.get()); // x == 0 és y == 0 | output: 0 | x == 1 és y == 1

System.out.println(obj2.get()); // x == 0 és y == 1 | output: 1 | x == 1 és y == 2

System.out.println(obj1.get()); // x == 1 és y == 2 | output: 3 | x == 1 és y == 3

System.out.println(obj2.get()); // x == 1 és y == 3 | output: 4 | x == 1 és y == 4

Itt x és x nem ugyanaz! Ha megnézed, hogy mely objektumból hívtam a .get()-et, akkor látod, ezért is objektum változó, mivel minden példányosítottban külön-külön él.

Statikus y meg osztály változó, tehát bármelyik objektumból eléred. Tehát ha egyik változtat a másik az újat fogja látni. (Persze párhuzamosítás esetén van olyan, hogy synchronized, volatile kulcs szavak, mert ott viccesebb tud lenni)

Statikus másik dolga, hogy példányosítást nem igényel.

Pl.:

public class B {

... private static String msg = "Üzenet";

... public final static String EZ_EGY_KONSTANS = "Konstans";

... public static String getMsg() {

... ... return msg;

... }

}

public class Main {

... public static void main(String[] asd) {

... ... System.out.println(B.getMsg()); // Csak <OsztályNeve>.<Attr vagy Metódus() neve>

... ... System.out.println(B.EZ_EGY_KONSTANS);

... }

}

Először is: ha (pl. Javaban) megírsz egy absztrakt osztály-t, akkor ezt nevezzük osztálynak, és ennek egy példányát nevezzük objektumnak. Nem tudom, hogy hol olvastad ezeket a szavakat, de ha nagyon definiálni szeretnénk őket, akkor az osztályváltozók kizárólag azok a változók, amelyek az osztály absztrakt definíciójában szerepelnek, azaz nem a példányban, csak a megírt osztályban. Majd, ha ebből csinálsz egy objektumot példányosítással, akkor annak lesznek objektumváltozói, és ezek lehetnek olyan változók is, amelyek az osztály definíciójában nem szereplenek, de az általa képzett példányban igen. Ilyen előfordulhat öröklődésnél. Tagváltozó természetesen a képzett objektum elérhető változói, ilyen pl egy tömb (mert ugye az Java-ban objektum) length "tagváltozója". Remélem tudtam segíteni.

Ui: amit írtam az nem szakirodalomból van, csak a tapasztalataim alapján leírtam, hogy én hogy gondolom

Name kell túlbonyolítani.. Van static, meg non-static, előbbi osztályszintű, utóbbi objektum szintű.

Ez mind member, vagyis tag, de javában minden az. Vannak nyelvek, ahol nem minden változó vagy függvény tagja valamelyik class-nak, mert lehet azon kívül is.

Nem*

"ha (pl. Javaban) megírsz egy absztrakt osztály-t, akkor ezt nevezzük osztálynak, és ennek egy példányát nevezzük objektumnak"

Annak a példányát nehezen, esetleg subclass-ét. (jó, jó, is-a meg minden, de akkor is..)