A “Java-saga” folytatódik, azaz mi idegesít engem?

A Java 1.4-ig fennálló felsorolás megvalósításának módja még a kivételkezelésnél is jócskán érthetetlenebb a számomra. Főleg annak tudatában, hogy ott állt előttük példaként az igazán jó alapot jelentő C++ nyelvi szintaktika.
 
A felsorolásra írtam egy primitív Java példát:

public class Szinek {
  public static const Piros = 1;
  public static const Feher = 2;
  public static const Zold = 3;
  private int m_csak_egy_szin;
 
  // konstruktor
  public Szinek (int csak_egy_szin) {
    m_csak egy_szin = csak_egy_szin;
  }
 
  // értékadás
  public void SzinBeallit(int csak_egy_szin) {
    m_csak_egy_szin = csak_egy_szin;
  }

  // érték lekérdezés
  public int SzinLekerdez() {
    return (m_csak_egy_szin);
  }
}

És ugyanez C++ , illetve C# nyelveken:

enum Szinek {Piros, Feher, Zold};

Nos, biztos, hogy engem inkább a Java-féle tudna az őrületbe kergetni.
 
No és persze us ugyanez igaz a "struct"-ra, hiszen ez a Java-ban eléggé körülményes lenne, merthogy ilyen nincs is benne, ezért az enum-hoz hasonlóan sajnos azt is csak class-al lehet megvalósítani. Sebaj, ez legyen a legkevesebb, hiszen a struct valójában majdnem egy class.
 
Folytassuk még tovább és nézzük meg a metódusok dinamikus paraméterezési lehetőségeit:
 
Ismét egy ici-pici Java példa:

public class Akarmi {

  public static void ParamSzimulacio(int[] tomb) {
    // itt valami utasítás jönne…
  }
}
 
int[] tomb = {1,3,7,9};
Akarmi.ParamSzimulacio(tomb);

Ugyanaz a példa C#-ban:

public class Akarmi {
 
  public static void ParamSzimulacio(params int[] lista) {
    // itt is valami utasítás jönne…
  }
}
 
Akarmi.ParamSzimulacio(1,3,7,9);

A Java-nál látható egy tömb deklaráció, no és persze mindennel, ami evvel jár. Jó, rendben, ne legyünk kicsinyesek.
 
Végül valami hasonló, de azért mégsem egészen ugyanaz C/C++ -ban:

void ParamSzimulacio(int p1, char p2=’ ‘, char *p3="Izé", float p4=3.1415f);
 
int main() {
  ParamSzimulacio(1); // mindegyik alapértelmezett paraméter érvényre jut
  ParamSzimulacio(3, ‘*’); // a p3 és p4 paraméterek alapértelmezettje működésbe lép
  ParamSzimulacio(7, ‘+’, "Bigyó"); // csak a p4 paraméter alapértelmezése játszik be
  ParamSzimulacio(9, ‘$’, "Valami", 2.38f); // nincs alapértelmezett paraméter felhasználás
  return 0;
}

Nyilván a C++ kicsit (vagy még inkább nagyon) másabb. Rögvest meg is jegyzem, hogy a C++ engem untat egy csöppet, no meg azért valljuk be férfiasan, hogy nem is nagyon értek hozzá (meg úgy általában semmihez sem értek, csak mindenbe beleugatok…)
 
Végül, de nem utolsó sorban példaként hozom fel a nem túl jelentős operátor túlterhelés -operator overloading – témáját, ami a C++ -ban kiváló, de sajnos a Java-ban megint nincs. Valami hasonlót ugyan össze lehet hegeszteni, vagy egy 3. gyártó általi előfeldolgozóval (preprocessor) megreszelni, de mindezt őrületes munkával (a C#-ban is van a C++ -hoz nagyon hasonló operátor túlterhelés).
 
No, akkor erről egyelőre ennyit.
 
A problémám az, hogy a Java-ban a C#-hoz képest néhány dolog csak hosszadalmas munkával és körülményesebben oldható meg. Elég, ha csak az eddigieket idézzük fel. Ez nem hiba, nem is nagy baj, legfeljebb néha kényelmetlen és lassú. A nyelv képes lenne a fejlődésre, de mintha valami visszatartotta volna őket. Csakhogy ez hosszútávon nem jó taktika (mint tudjuk a taktika sokat számit, lásd a Microsoft elhamarkodott Longhorn – Internet Explorer stratégiáját, amit mára már végül felülbíráltak).
 
Erre bizony a Sun is rájött, és talán most,… a Java SE 5.0-ban (az 1.5 csak egy belső verzió) már felébredt végre és néhány olyan dolgot is megcsinált, amit a C++ és a C# igen régóta megoldott. Ezek egyike az eddig leginkább kellemetlen "enum" kérdés vagy a C#-ban meglévő boxing/unboxing technika. Ennél tovább azonban nem is nagyon merészkedtek.

Comparing C# and Java (Budi Kurniawan):
http://www.ondotnet.com/pub/a/dotnet/2001/06/07/csharp_java.html?page=1