JavaFX Taalfeatures - Kekke serietitel dag 2 nl

Door YopY op donderdag 1 juli 2010 23:00 - Reacties (1)
Categorie: -, Views: 3.839

Dag en deel twee van de kekke serie over kekke dingen, nu met extra leip. In deel 1 van deze te wause serie postte ik een halfbakken inconsistent verhaal over dingen die ik tegen kwam terwijl ik door de eerste pagina's van de JavaFX tutorial kroop, maar aangezien niemand dat wil lezen zal ik bij deze post beter mijn best doen.

In deeltje 1 merkte een observante lezer op dat, voor zover hij aan de hand van mijn post op kon merken, JavaFX eigenlijk een soort Java-met-Javascript-achtige-dingetjes was, met daarbij de suggestie dat het misschien beter was om de JavaFX functionaliteit via een Java API beschikbaar te maken.

En dat vroeg ik mij dus ook af. Dus in deze post poog ik een overzichtje te maken van taalfeatures die echt niet in Java zelf zitten, met daarbij een analyse waarom het beter zou zijn voor de doeltoepassing van JavaFX - rich internet applications, GUIs, dat soort zaken.

Sowieso lijkt het me logisch (van te voren gezegd) dat JavaFX veel minder technisch is, en ook door niet-hardcore Java developers makkelijk op te pakken is. Dus: Minder boilerplate code, minder technisch geneuzel met types, generics en dat soort zaken, minder kennis nodig van verschillende API's en uitgebreide documentatie die daarbij zit, maar gewoon uit je hoofd en een beetje vlot code kloppen. Tenminste, dat zou ik verwachten van een RIA scripttaal - mogelijk zit ik ernaarst, maar met deze blogpost krijgen we daar hopelijk een antwoord op (al dan niet gedeeltelijk).

We beginnen. Bij hoofdstuk 3 welteverstaan, getiteld Using Objects

Object Literals

JavaFX biedt een intuitieve en vlotte manier om objecten te instantiëren. Een class declareer je eigenlijk net zoals in Java, bestandje, public class Nogwat, class variabelen, functies, etc, maar het instantieren kun je door middel van de Object Literal notatie. Noot: Voor degenen die Javascript kennen zal het volgende bekend voorkomen:


code:
1
2
3
4
5
6
7
8
9
10
var customer = Customer {
     firstName: "Henk";
     lastName: "Naecktgeboorhen";
     phoneNum: "0123 456 789";
     address: Address {
        street: "Klaassenstraat 3";
        city: "Pietjendam";
        zip: "1337 XX";
    }
}



Lijkt me logisch, en lekker intuitief - geen geklooi meer met constructors, getters en setters... toch? Even kijken naar de class declaratie zelf :


code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Customer {
     public var firstName: String;
     public var lastName: String;
     public var phoneNum: String;
     public var address: Address;

    public function printName() {
        println("Name: {firstName} {lastName}");
    }

    public function printPhoneNum(){
        println("Phone: {phoneNum}");
    }
}



Zoals gezegd, lijkt verdacht veel op gewoon Java (alleen heb je vars en staat het type achter de declaratie). Wat hier opvalt is dat er hier gebruik gemaakt wordt van public variabelen - en dat vind ik gek, aangezien mij altijd geleerd is dat public variabelen verschrikkelijk evil zijn en weet ik veel wat. Toegegeven, het alternatief - getters en setters maken - is bijna net zo evil (ook aangezien ze meestal klakkeloos op elke class variabele losgelaten worden, nodig of niet - maar da's een andere discussie).

Ik ben er nog niet achter wat ik hiervan moet vinden. Wat vinden jullie?

Inline expressies in strings

In deeltje één liet ik hiervan al iets zien toen variabelen bijna direct in een string geplaatst werden om de inhoud van deze vars weer te geven, maar het blijkt dat je nog meer in een string kunt doen in JavaFX - eenvoudige conditionals, bijvoorbeeld.


code:
1
2
def mongol = true;
var s = "Zijt ge een mongol? {if (mongol) "Awel!" else "Neen"}";



Dit lijkt me wel handig voor directe feedback aan gebruikers. Het Java equivalent ziet er, om te vergelijken, zo uit:


Java:
1
2
3
4
5
6
7
boolean tarzan = true;
String olioliooo = "Houdt u van apen? " + (tarzan) ? "JOAH!" : "Nein!";

// of, uitgebreider en in dit geval totaal onnodig:
StringBuilder toybox = new StringBuilder("I am Tarzan from jungle, ");
toybox.append((tarzan) ? "You can be my friend" : "I am Jane and I like to ride an elephant");
String fritzl = toybox.toString();



Hier breidt ik later misschien nog eens op uit - de tutorial gaat op dit punt niet verder nog.

het Duration datatype

Binnen JavaFX heb je het standaard rijtje types - Strings, Integers, Booleans, maar ook Void en het Function type (hier later meer over) (mogelijk heb ik het verkeerd met het scharen van Function onder datatypes).

Maar één datatype dat interresant lijkt is het Duration datatype. Omdat JavaFX gericht is op GUI applicaties en, aldus, directe feedback met de gebruiker, maar ook animaties en dergelijke, hebben ze het Duration datatype toegevoegd om zeer direct hieraan gerelateerde waarden mee te geven. Er zijn - voor zover ik na kan gaan - vier verschillende tijdseenheden om een Duration aan te geven - milliseconden, seconden, minuten, of uren.


code:
1
2
3
4
def uurtje = 1h;
def minuutje = 1m;
def seconde = 1s;
def zonet = 1ms;



Als je met Java een tijdseenheid aan wilt geven - bijvoorbeeld hoe lang een bepaalde animatie moet duren - moet je dit meestal in milliseconden aangeven. Op zich is dat niet zo'n grote stap - aangezien je met basisschooniveau tijdsrekenen en de basisrekenfuncties van Java eenvoudig genoeg uit kunt laten rekenen hoeveel milliseconden er in een uur gaan - maar toch vind ik dit wel een interresante toevoeging. Sowieso is het voor de leesbaarheid wel prettig - mits je het verschil tussen ms, s, m en h goed kunt zien.

Functies naar variabelen -> Closures?


code:
1
var funk : function(:Object, :Integer) : String;



Met bovenstaande maak je een variabele funk aan die een functie kan bevatten - het datatype van funk is in bovenstaand voorbeeld Function, maar dan specifiek een functie die een Object en een Integer verwacht, en een String teruggeeft. Je kunt vervolgens een implementatie van een functie aan funk toekennen:


code:
1
funk = function(obj : Object, k : Integer) { "Objectje: {obj}, cijfertje: {k}" }



Vervolgens kun je de functie aanroepen via de variabele:


code:
1
2
println(funk(1m, 1337));
// output: Objectje: 60000.0ms, cijfertje: 1337



Ik zette 'Closures' in de heading van dit hoofdstuk met een vraagteken, omdat ik op dit moment nog niet kan zeggen of dit nu daadwerkelijk closures zijn - ook omdat ik niet echt een specifieke definitie van closures heb, slechts een oppervlakkige kennis. Echter, als dit wél closures blijken te zijn, zou het maar zo kunnen zijn dat je JavaFX als functionele programmeertaal zou kunnen vergelijken. (met de nuance erbij dat ik ook geen goeie definitie heb van een functionele programmeertaal, dus voor hetzelfde zit ik uit m'n nek te lullen).

Een mogelijk doeleinde hiervoor in een grafische omgeving is om gemakkelijker action handlers mee te geven aan GUI elementen. Vroegah, in mijn tijd, had je in Java anonymous (inner) classes, welke veelvuldig toegepast werden in GUI programmeren. Je stelde een ActionHandler in op een GUI element door aan de setActionHandler inline een subclass (of implementatie) van de ActionHandler interface te maken. Echter, hierbij was veel boilerplate nodig - een class defintie, braces, een functie definitie, en de functie zelf. (Als alternatief mocht je natuurlijk ook een volledige 'echte' class schrijven natuurlijk.)

Met deze notatie kun je de class notatie en een deel van de overige boilerplate achterwege laten. Hier moet ik het mijne nog van uitvinden natuurlijk.

End

Ik vind - en mogelijk ook anderen met mij - dat ik behoorlijk lange epistels schrijf, dus voordat jullie gek worden breidt ik er een eind aan voor deze aflevering. Volgende keer meer - en natuurlijk zijn julle opmerkingen altijd welkom!