Anonim metódusok
Mivel a NICE megengedi metódusok paraméterként való átadását, illetve visszaadását, ezért számos helyen igény lehet lokális metódusok leírására, amelyek nem szükségesek, hogy teljes értékű, névvel ellátott önálló metódusok legyenek, hiszen felhasználásuk egy helyre korlátozódik. Az ilyen típusú metódusok leírására alkalmasak az anonim metódusok (anonym methods), amelyek az alábbi alakban adhatóak meg:
( paraméterek ) => { törzs }vagy
( paraméterek ) => kifejezés;
Az anonim metódusok visszatérési típusát a fordítóprogram automatikusan állapítja meg (az un. “type inference” segítségével), így azok explicit megadására nincsen szükség/lehetőség.
Példa anonim metódus használatára:
// metódus, amely egy String sorozatot egymás után fűz oly módon,
// hogy a kollekció minden elemére meghív egy anonim metódust,
// amely az aktuális String értékét egy buffer végéhez fűzi:
String concat(Collection strings)
{
StringBuffer buff = new StringBuffer();
strings.foreach(String s => {
buff.append(s);
});
return buff.toString()
}
Metódushívások
A metódushívások általános alakja f( kif1, kif2, …, kifn ), ahol f egy metódus neve, illetve általánosabban egy olyan kifejezés, amely típusára nézve metódus (ilyen lehet például egy lokális változó is). A kif1, …, kifn kifejezések a metódus paraméterei, amelyek átadása alapértelmezett esetben a megfelelő sorrend szerint történik (mint JAVA-ban), azonban lehetőség van a paraméterek névvel történő azonosítására is, ilyenkor tetszőleges sorrendben adhatóak meg (név: érték alakban).
// 3 paraméterű metódus, a harmadik paraméter alapértelmezett értékkel rendelkezik
void f( int e1, int e2, Sting e3 = “defstring” );
f(1, 2, ”S”); // ez a konvencionális forma
f(1, 2); // az alapértelmezett paramétereket nem kötelező megadni
f(e2: 5, e3: “str2”, e1: 1); // név szerinti hivatkozással megadott paraméterek
f(e1: 1, e2: 2); // név szerinti hivatkozás, az alapértelmezett paraméter
// felhasználásával
A fentieken kívül, ha a paraméterlista speciálisan f( e1, e2, .., void->T) alakú, azaz az utolsó paraméter egy metódus típusú változó (azaz egy metódusra adott referencia), lehetőség van az un. blokkszintaxisú metódushívásra:
f( int e1, void->void action );
// az f metódus hívása az e1 => 3 és a blokkban található törzs, mint anonim
// metódusra mutató referencia átadásával
f(3){
// itt az action törzse található
}
A fenti hívás természetesen az anonim metódusok klasszikus szintaxisával is működik, azaz a fentivel ekvivalens a következő:
f(e1: 3, action: () => { // az action törzs });
Ebben az esetben a blokkszintaxis átláthatóbb kódot eredményez.
Multi-metódusok és alkalmazásaik
A NICE programozási nyelvben egy adott metódus meghívásakor a megfelelő implementációt a teljes paraméterlista (kapott paraméterek típusa, sorrendje, száma) határozza meg futási időben (ellentétben a JAVA-val, ahol csak a this mutató értéke segít kiválasztani a megfelelő alternatívát). Ez lehetővé teszi a multi-metódusok használatát.
Az alábbi példa jól szemlélteti, hogy ennek segítségével sokkal egyszerűbben lehet a specializált metódusokat leírni. Itt 2 Person típusú objektum egyenlőségének (equals) a megállapítását végző metódus leírását találhatjuk, először a klasszikus JAVA szerinti módon, illetve ezután a NICE multi metódus segítségével leírható módon:
class Person
{
String name;
int age;
boolean equals(Object that)
{
if(!(that instanceof Person))
return false;
return name.equals(((Person) that).name)
&& age==((Person) that).age;
}
}
A fenti példában látszik, hogy a JAVA-ban nem adható meg explicit minden paraméter kívánt típusa, így futásidejű ellenőrzések sorára lehet szükség, hogy a kívánt eredményt elérjük. A NICE ezzel szemben a multi metódusoknak köszönhetően sokkal tisztább módon képes ekvivalens funkcionalitást nyújtani:
class Person
{
String name;
int age;
}
equals(Person p1, Person p2) =
p1.name.equals(p2.name) && p1.age==p2.age;
A NICE kód sokkal tömörebb és átláthatóbb, hiszen nincs szükség sem az explicit futásidejű típusellenőrzésekre, sem pedig a konverziókra. Itt egyúttal az a lehetőség is látható, ahogyan egy már létező osztályt lehet új metódussal kibővíteni a multimetódusok alkalmazásával.
Operátor túlterhelés
A Java nyelv nagy hiányossága, hogy nem ad lehetőséget az operátorok túlterhelésére, ezt sok programozó bánja. Bár a honlapján nem tüntetik fel, a NICE ezt a hiányosságot is pótolja, lehetőséget biztosít az operátorok túlterhelésére. A következő példa mutatja a szintaxist:
public OpenRange `..`(int begin, ?int end) ...
`..`(int begin, null) { ... }
public override Range `..`(int begin, int end) { ... }