door Jose M. Fernández Inhoud: Inleiding Oorsprong Het verkrijgen en installeren van Java Ontwikkelomgeving Eigenschappen Een eerste programma in Java Samenvatting

Java. Deel I

Kort:

Dit is de eerste in een reeks van artikelen over het programmeren in Java. Dit eerste deel beschrijft de programmeertaal Java zelf, zijn belangrijkste eigenschappen en de plaatsen waar men verdere informatie kan vinden.

Inleiding

Het fenomeen Java is ook een beetje hype. Ieder zichzelf respecterend computerblad schrijft erover, een oneindige rij softwarebedrijven verkoopt ontwikkelhulpmiddelen voor Java-applets en iedere website heeft wel één of meerdere van die applets draaien (applet = een kleine of lichte applicatie).

Met deze reeks wil ik proberen wat meer diepgaand de programmeertaal te behandelen. In zijn geheel. Dit is dan wel betrekkelijk eenvoudig voor de basisonderdelen; de constante evolutie van deze taal maakt het echter weer moeilijker.

Het doel van de eerste reeks is om de taal in zijn geheel te beschrijven. Hierdoor zijn we later in staat om speciale onderwerpen met wat meer diepgang te behandelen, zoals: applets, netwerk-gerelateerde programmering, JDBC, beans etc.

Ik moet hier wel benadrukken dat Java een taal is die niet specifiek gemaakt is voor het programmeren van applets op web-pagina's, hoewel het zijn populariteit hier wel aan te danken heeft, maar algemeen inzetbaar is. We kunnen niet bij dit aspect blijven hangen want voor dat doel zijn er nog genoeg alternatieven die misschien zelfs beter geschikt zijn dan Java-applets.

Dit eerste artikel is wat meer theoretisch en wat minder op de praktijk gericht. In het volgende artikel zullen we de eigenschappen van de taal zelf en zijn ontwikkelomgeving bespreken. Pas aan het eind komen er voorbeelden van Java programma's aan de orde.  

Oorsprong

Uit de datums kunnen we concluderen dat Java ongeveer tegelijkertijd met het World Wide Web (WWW) is ontstaan. Tot voor 1991 had Tim Berners Lee de HTML-taal immers nog niet ontwikkeld.

De syntaxis van Java lijkt op C en de objectgeoriënteerde eigenschappen lijken op C++. Java is een coherente en consistente programmeertaal.

De gelijkenis met C en C++ kan de indruk wekken dat Java een versie van C++ is die geschikt is gemaakt voor het Internet. Er zijn echter significante theoretische en praktische verschillen. Vooral omdat Java het objectgeoriënteerde paradigma ten opzichte van C++ verbetert en verfijnt.

Het Internet heeft Java succes gebracht en algemeen bekend gemaakt. Omgekeerd heeft Java ook een grote invloed gehad op het Internet. Het heeft er voor gezorgd dat er nog meer nuttige dingen over het Internet getransporteerd kunnen worden (dynamische, onafhankelijk executeerbare programma's).  

Het verkrijgen en installeren van Java

Na het uitpakken met gunzip zijn we klaar om verder te gaan.

Normaliter zetten we de distributie in de directory /usr/local waar aldus een subdirectory JDK1.1.3 zal worden aangemaakt. En daarbinnen:

doc Officiële documentatie in HTML formaat.

demo Demo Java programma's

lib Programmabibliotheken

bin Hier staan de juiste ontwikkelhulpmiddelen van de JDK.

In de lib directory zit het bestand classes.zip (laat unzip hier niet op los), hierin zitten alle gecompileerde klassen waar Java gebruik van -kan- maken.

In de startdirectory zit het bestand src.zip. Hierin zit alle broncode uit classes.zip. Deze code kan echter niet worden gecompileerd en is slechts ter lezing ende vermaak meegeleverd.  

Ontwikkelomgeving

Om zonder problemen met de huidige directorystructuur te kunnen werken wordt geadviseerd om het pad /usr/local/JDK1.1.3/bin aan je omgevingsvariabele PATH toe te voegen. Als je het voor alle gebruikers op het systeem wilt doen dan moet je het toevoegen aan het bestand /etc/profile.  

Eigenschappen

Java is een hogere programmeertaal met de volgende eigenschappen (details volgen nog):

• Het is eenvoudig
• Objectgeoriënteerd
• Gedistribueerd
• Geinterpreteerd
• Robuust
• Veilig
• Platform onafhankelijk
• Overdraagbaar
• Multi-threaded (parallel te executeren)
• Dynamisch
• met een hoge resolutie

Dankzij Java kunnen we "slechts één keer broncode schrijven, vervolgens altijd uitvoeren". We kunnen hiermee een Java programma compileren op de ene machine, om het vervolgens uit te voeren op een compleet andere machine met een compleet andere architectuur maar die wel een Java Virtuele Machine (JVM) heeft draaien. Een Java programma kan bijvoorbeeld op een Windows NT machine worden gecompileerd en vervolgens probleemloos (in theorie althans) draaien op een Sun Ultra Solaris.

In het algemeen is een platform de omgeving van hardware en software waarop een applicatie draait. Bij Java echter, is het platform de software omgeving waarin het draait. Ieder Java platform moet op zijn beurt op een echt platform draaien.

Een Java platform bestaat uit twee componenten:

• De Java Virtuele Machine (JVM)
• Een programma interface (Application Programming Interface of API)

Toch moet de virtuele machine niet gezien worden als een pure softwarelaag. Zoals de naam al aangeeft probeert het een volledige machine te zijn. Langzaam maar zeker zullen we Javachips op de markt zien verschijnen die gebruikt zullen worden voor echte (en géén virtuele) Java machines, kredietkaarten, TV decoders etc.

Java's applicatie interface (API) bestaat uit een grote verzameling software componenten die programmeer-hulpmiddelen ter beschikking stellen zoals een grafische gebruikersinterface (GUI). De API is onderverdeeld in bibliotheken (in Java terminologie packages). Dankzij deze packages kunnen we Java gebruiken voor veel meer dan alleen maar het bouwen van applets. We kunnen hiermee bijvoorbeeld Webservers maken, of proxies, mail servers en alles wat verder met Internet te maken heeft.

De onderverdeling van deze bibliotheken is als volgt:

• Basis: objecten, matrices, getallen, invoer en uitvoer, datastructuren, systeemkarakteristieken, datum, tijd etc.
• Applets: verzameling functies en andere hulpmiddelen om Java applets te bouwen.
• Netwerk: URL's, TCP, UDP, sockets, IP-adressering.
• Internationaal: hulpmiddel bij het schrijven van programma's die eenvoudig aan lokale karakteristieken zijn aan te passen en in de lokaal gesproken taal.
• Beveiliging: op laag en hoog niveau met onder andere digitale handtekeningen, openbare sleutels en privé sleutels, toegangsbeveiliging en certificaten.
• Software componenten: Java beans geheten.
• Databases: geeft uniforme toegang tot een groot aantal relationele databases.

Zoals reeds eerder vermeld heeft Java een groot aantal eigenschappen die we nu nader gaan bekijken:

Eenvoud:	Java heeft altijd een beperkt aantal mogelijkheden voor het uitvoeren van een taak. Het heeft alle functionaliteit van een krachtige programmeertaal, maar zonder de minder courante en complexe uitbreidingen die daar normaal gesproken mee gepaard gaan. Java heeft de syntaxis van C/C++ geërfd en veel objectgeoriënteerde mechanismen van C++. Iedere programmeur die bekend is met C/C++ zal geen moeite hebben met het aanleren van Java. Ondanks de overeenkomsten mist Java een aantal C/C++ karakteristieken, zoals: Rekenen met verwijzingen (pointers) Registers (struct) Type definities (typedef) Macro's (define) De verplichting geheugen op te ruimen (free) Geen overerving van meer dan één klasse Geen herdefinities (overload) van operatoren Geen structuren in unions
Objectoriëntatie:	Java is van de grond af nieuw ontworpen. Hierdoor is zijn benadering van objectoriëntatie bruikbaar, praktisch en vrij van vervuiling. Het objectmodel van Java is eenvoudig in het gebruik.
Gedistribueerd:	Men heeft het op grote schaal toepassen van TCP/IP voorzien en hier het ontwerp op afgestemd. Het benaderen van een bestand is net zo makkelijk als het benaderen van informatie op het netwerk.
Robuust:	Java heeft een strikte typering. Hierop kan men reeds tijdens het compileren controleren. Verdere controles worden in run-time uitgevoerd. Het geheugenbeheer is volautomatisch. De interpretator geeft alle geheugen weer vrij van objecten die niet meer gebruikt worden. Java stelt een aantal objectgeoriënteerde uitzonderingen (exceptions) ter beschikking. In een goed geschreven programma handelt het programma zelf alle run-time fouten af.
Platform onafhankelijk:	Het hoofddoel van de ontwerpers van Java was: "slechts één keer broncode schrijven, vervolgens altijd overal uitvoerbaar en op ieder gewenst moment". Java wordt eenmalig naar bytecode gecompileerd. Deze bytecode is machine onafhankelijk. De code is erop ontworpen om op iedere machine uitgevoerd te kunnen worden met een machinespecifiek run-time systeem (interpretator).
Veiligheid:	De noodzaak van gedistribueerde informatie vereist een hoge graad van beveiliging op de client systemen. Java levert reeds beveiliging in zijn run-time omgeving: Een bytecode controle Beschikbaarheid van geheugen tijdens executie Beveiliging op bestandstoegang Hoewel de compiler slechts correcte bytecode aan kan maken wordt nog eens extra gecontroleerd door de interpretator om te zien of code is aangepast (expres of per ongeluk) tussen het moment van compilatie en interpretatie. Verder controleert de interpretator de beschikbaarheid van geheugen. Java is wat dat betreft één van de meest veilige applicaties op een systeem.
Overdraagbaarheid:	Naast de basis overdraagbaarheid van Java, is er nog wel wat meer nodig om ook onafhankelijk te zijn van de architectuur. Hiervoor heeft Java een overdraagbaarheids-standaard: integers zijn altijd integers, de grafische interface is een abstractie van windows en daardoor onafhankelijk van de onderliggende architecturen (Unix, PC of Mac).
Geïnterpreteerd:	Om één van de hoofddoelen van Java te bereiken, platform onafhankelijkheid, genereert de compiler intermediaire code (bytecode). Dit kan op ieder systeem met de juiste interpretator worden uitgevoerd. Dit paradigma geeft bedenkingen over de snelheid van het systeem. Juist vanwege deze bedenkingen zijn de makers bij het ontwerpen van de bytecode uitgegaan van eenvoud en het zo simpel mogelijk kunnen vertalen naar machinecode, zodat de hoogste snelheid in uitvoering kan worden behaald.
Multi-threaded:	Het is heel eenvoudig om applicaties te maken die verschillende taken parallel en betrouwbaar uitvoeren.
Dynamisch:	Java zal niet direct proberen alle modules van een applicatie aan elkaar te linken. Dit gebeurt pas tijdens het uitvoeren van het programma. Hiermee verkrijgt men dynamisch gelinkte code, veilig en gemakkelijk.

Na deze lange "toespraak" (het meeste is terug te vinden in de officiële Java documentatie) kan men zich afvragen hoe het is gesteld met Java in de wereld van GNU/Linux. We hebben het al eerder gehad over de verkrijgbaarheid van JDK onder Linux, wat slechts een commerciële implementatie van Sun is (echter: vrij te distribueren).

Er zijn pakketten als de compiler GUAVAC, te gebruiken met een GPL-licentie die alle Java broncode probleemloos kan compileren. De virtuele machine KAFFE, onder Berkeley-licentie, is ook het vernoemen waard. Deze projecten zijn in een vergevorderd stadium, hoewel ze nog steeds de klassebibliotheken van Sun als aanvulling nodig hebben (die momenteel vrij zijn te distribueren) om een complete ontwikkelomgeving te verkrijgen.

Andere projecten, nog in de beginfase, hebben als doel een snelle en visueel ingestelde ontwikkelomgeving te creëren.

Tenslotte zij het gezegd dat er een enorme beweging op het Internet op gang is gekomen met betrekking tot Java en GNU, waarbij het er om gaat om, onafhankelijk van Sun, een complete, vrij distribueerbare ontwikkelomgeving te creëren. Hiermee is het belang van Java wel aangegeven en als de hype voorbij is, dan ben ik er zeker van dat daar er wat van blijft hangen (sterker nog, ik denk dat er veel zal overblijven).  

Een eerste programma in Java

class Cuadro {
public static void main (String args[]) {
        int l ,a;
        if (args.length == 2) {
            l = Integer.valueOf(args[0]).intValue();
            a = Integer.valueOf(args[1]).intValue();
         }
         else {
          l= 20;
          a= 15;
         }
          for (int i=l; i>0; i--){
            System.out.print("*");
            }
            System.out.print("\n");
            for (int i= a-2; i>0; i--){
             System.out.print("*");
               for(int j=l-2; j>0; j--) {
                  System.out.print(" ");
                  }
                  System.out.print("*\n");
                  }
                for (int i=l; i>0; i--){
                System.out.print("*");
                }
              System.out.print("\n");
           }
}

In het voorbeeld is de naam van het bestand identiek aan de klasse. Dit is geen toeval, alle code moet in een klasse zitten. De conventie schrijft verder voor dat de naam van de klasse overeen moet komen met de naam van het bestand waarin de code staat. Sterker nog, Java maakt zelfs onderscheid tussen hoofd- en kleine letters.

Type het volgende in op de commandoregel om het programma te compileren:

> javac Cuadro.java

De compiler zal, als alles goed gaat, het bestand Cuadro.class aanmaken waarin natuurlijk de bytecode wordt gezet. Het kan nu direct worden uitgevoerd door de interpretator met het commando:

> java Cuadro

Gecompileerde broncode wordt automatisch in een archief geplaatst met dezelfde naam als de klasse, zodat deze naam overeenkomt met de bestandsnaam van het archive.class bestand.

Ondanks de eenvoud van ons voorbeeld programma Cuadro.java, geeft het een inzicht in de basisstructuur van Java en de principes erachter.

Merk allereerst op dat dit voorbeeld geen applet is dat kan worden aangeroepen vanuit een HTML bestand maar een zelfstandig programma, uit de voeren door de interpretator als commando.

De eerste regel van het programma is:

class Cuadro {

De volgende regel:

public static void main (String args[]) {

Het keyword public geeft het bereik aan van de methoden binnen deze klasse. Het zegt dat de methode gebruikt kan worden door code buiten deze klasse. static geeft aan dat de methode direct aangeroepen kan worden. De klasse hoeft niet eerst te worden aangemaakt. void geeft aan dat de methode geen waarde retourneert. Het doorgeven van parameters aan een functie of methode doet men binnen de haken () die achter de naam van de methode staan. In dit geval accepteert main() als parameter een matrix van instanties van de klasse String.

Het is duidelijk dat de code in een methode ook wordt omsloten met accolades {}. Daarna de volgende regel:

 int l, a ;

De verdere code implementeert een klein algoritme dat het volgende doet:

1. Test of het juiste aantal argumenten is gegeven.
   

   If (args.length==2)
   

2. Indien er parameters zijn dan worden ze toegewezen aan integer variabelen:
   

     l = Integer.valueOf(args[0]).intValue();
     a = Integer.valueOf(args[1]).intValue();
   

3. Indien dit niet het geval is dan krijgen de variabelen standaard waarden:
   

     l = 20;
     a = 15;
   

4. De rest van het programma bevat alleen maar instructies, nodig voor het tekenen van het vierkant op het scherm. Hierbij gaat het vooral om:
   

   System.out.print()
   

   Waarbij print() de gegeven parameter afdrukt. System is een reeds gedefinieerde klasse die toegang regelt tot het systeem en out is de uitvoerstroom die verbonden is met het console. De constructie:

   for (int i=l; i>0; i--)
   

   gedraagt zich zoals je zou verwachten indien je ervaring hebt met C/C++ of andere talen.

Samenvatting

Ieder artikel zal vergezeld gaan van een lijst met referenties, publicaties en URL's waarop deze reeks artikelen is gebaseerd.

• JAVA Reference Manual. Patrick Naughton Herbert Schildt. McGraw-Hill.
• Programming with JAVA. Tim Ritchey. Prentice Hall.
• Tutorial de Java. Spaans handboek in HTML formaat te verkrijgen bij www.fie.us.es/info/internet/JAVA. Agustín Froufe.
• The Java Tutorial. Engels handboek in HTML formaat www.javasoft.com. Sun.
• Tutorial van de JDK distributie.

2000-04-11, gemaakt door lfparser versie 1.1