Java - HalloWelt Playgames Getfun

• Vorwort
• Programmiersprache Java
• Vergleich mit ähnlichen Bibliotheken und Protokollen
• Unterschiede zu C++

• Sprachsyntax
  • Programmaufbau
  • Lexikalische Elemente
  • Datentypen
  • Variablen
  • Klassen und Interfaces
  • Anweisungen
    • Auswahlanweisungen
    • Iterative Anweisungen
    • Sprunganweisungen
    • Kontrollanweisungen
  • Multitasking in Java
  • Wichtige Packages

• Beispielprogramme
  • Ein einfaches Java-Programm
  • Ein einfaches Java-Applet
  • Einbinden von "Native-Methods"
• WWW-Scriptsprachen
  • JavaScript

Vorwort

Programmiersprache Java

Die Programmiersprache Java ist eine objektorientierte, relativ einfache, plattformunabhängige, interpretative Programmiersprache. Java hat mit Absicht eine C++-ähnliche Syntax gewählt, um den Programmierern den Umstieg auf Java zu erleichtern. Es hat einen eingebaute Garbage Collection Mechanism, um nicht referenzierte Speicherblöcke wieder freizugeben. Java-Programme sind binärkompatibel zwischen den verschiedenen Rechnerplattformen. Sie werden zu Bytecodes kompiliert und so ist die Implementierung der Programme nicht so einfach nachzuvollziehen (Begriff: reverse engineering). Deshalb sind die Urheberrechte bei Java-Programmen besser gesichert, als z.B. bei Smalltalk-Programmen. Außerdem kann man die Bytecodes schneller interpretieren, als reinen ASCII-Text. Die Bytecodes sind eigentlich ebenfalls Maschinenbefehle, die wie normale Maschinenbefehle aussehen (Befehlcode-Modifier-Datenbytes ...), aber sie sind Befehlscodes eines virtuellen Prozessors, den es so nirgendwo gibt. Diese virtuelle Maschine muß auf allen Plattformen emuliert werden. Somit werden alle maschinenspezifische Eigenschaften vor den Java-Programmen verborgen und man gewinnt zusätzlich mehr Sicherheit. Die Java-Programme dürfen keine Systemaufrufe durchführen oder direkt auf irgendwelche Ports zugreifen. Wegen fehlender Zeigerarithmetik können die Java-Programme auch nicht das Java-Laufzeitsystem irgendwie destabilisieren. Somit haben die vierenverseuchten oder schlecht programmierten Java-Programme wenig Chancen, dem Zielsystem Schaden zuzufügen. Die Interpretation der Bytecodes ist fast so schnell, wie die von C oder C++ Code. Für besonders zeitkritische Aufgaben kann man auch den Bytecode vor der Ausführung in direkten Maschinencode des Zielsystems konvertieren.  

Vergleich mit ähnlichen Bibliotheken und Protokollen

Unterschiede zu C++

1. Java ist eine interpretative Sprache, C und C++ Compiler generieren den direkten Maschinencode des Zielsystems. Dadurch sind Java-Programme  etwas langsamer als C++ - Programme. Andererseits sind sie besser portierbar. Für Userinterfaces braucht man nicht unbedingt den schnellsten Code und zeitkritische Programmabschnitte kann man vor der Ausführung in direkten Maschinencode konvertieren. Die Bytecodes von Java werden etwas schneller interpretiert, als reine ASCII-Text (Smalltalk, Perl etc.). Es ist ein Kompromiß zwischen Ausführungsgeschwindigkeit und Flexibilität.
2. C++ ist im wesentlichen ein C mit objektorientierten Erweiterungen - eine gemischte Sprache, die nicht unbedingt einen sauberen Programmierstil erzwingt. Java dagegen ist rein objetorientiert. Allerdings existieren in Java auch primitive numerische Typen (int, long, float, char). Alles andere ist aber ein Objekt.
3. Zeichen in Java (char) sind nicht 8-Bit ASCII Zeichencodes, sondern 16-Bit Unicodezeichen. Java-Zeichen können in Arrays zusammengefaßt werden, aber sie sind deshalb noch nicht Strings. Für Strings benutzt man die Java-Klassen String (Zeichenketten konstanter Länge und Inhalt) und StringBuffer (Zeichenketten variabler Länge). Java-Strings werden auch nicht durch ein NULL Zeichen terminiert.
4. Java hat keine Headerdateien und benötigt keinen Precompiler.
5. Java kennt keine impliziten Typumwandlungen, außer der Umwandlung von numerischen Datentypen in den selben Datentyp mit größerer Genauigkeit (z.B int nach long). Würde man jedoch bei der Konvertierung an Genauigkeit verlieren, so muß man eine explizite Typumwandlung vornehmen.
6. Java kennt keine Zeigerarithmetik. Es gibt nur Objekte und Arrays von Objekten. Alles, außer primitiven numerischen Typen, sind Objekte und die Variablen beinhalten Referenzen auf Objekte, nicht die Objekte selbst. Vor einem Zugriff auf ein neues Objekt muß man dieses also vorher immer mit dem new Operator anlegen. Arraygrenzen werden zur Laufzeit überprüft. Ein Array kann nach dem Anlegen nicht mehr vergrößert oder verkleinert werden.
7. Alle Objekte und Arrays muß man explizit mit dem new Operator allokieren. Es gibt aber keinen delete Operator. Speicher wird durch den Garbage-Collector zurückgefordert.
8. Alle primitiven Datentypen in Java haben einen festen Speicherbedarf und eine Genauigkeit, die nicht von der Zielplattform abhängig ist.
9. Es gibt keine Structs, Unions, Typedefs oder Enums, sondern nur Klassen.
10. Es gibt keine vorzeichenlosen Datentypen.
11. Wahrheitswerte lassen sich nicht in numerische (und umgekehrt) umwandeln.
12. Man kann die mathematischen Operatoren nicht überladen.
13. Java enthält direkten Suppert für Threads, kritische Programmmabschnitte und Synchronisierung von Threads.
14. Java enthält keine goto-Befehle, kennt aber Labels. Mit einem break, continue oder throw Befehl wird aus einer verschachtelten Schleife herausgesprungen.
15. Java implementiert eine eigene Form der Mehrfachvererbung.
16. Java benutzt "late binding". Statt Methodenadressen werden Symbole benutzt, die erst während der Laufzeit durch direkte Adressen ersetzt werden.
17. Es gibt keine Funktionen, Prozeduren und globale Variablen.

Sprachsyntax

Programmaufbau

1. Package-Spezifikation: package Name;
   
   
    Legt fest, zu welchem Package diese Klasse gehört. Fehlt die package Anweisung, gehört die Klasse zu einem namenslosen Package. So kann man schnell Klassen implementieren, Testen und später unter einem global eindeutigen Packagenamen freigeben. Die global eindeutigen Packagenamen sollten wie Internetadressen aussehen z.B.
   DE.TU-ILMENAU.PRAKINF.TESTAPP
   . Packages sind wie Bibliotheken in C++. Pro Quelldatei darf nur eine öffentliche Klasse oder Interface deklariert sein, aber mehrere Quelldateien können zu einer Package gehören. 
    
   
2. Import Befehl: import Name;
   
   
    Importiert ein anderes Packages, das diese Klasse verwendet bzw. von dem es abgeleitet ist.
    
   
3. Typdeklarationen und/oder Interfacedeklarationen: Jede Quelldatei kann nur eine öffentliche Klasse oder Interface deklarieren (und implementieren).

Lexikalische Elemente

• /* normaler Kommentar, kann sich auch über mehrere Zeilen erstrecken */
• // Kommentar bis zum Zeilenende
• /** Kommentar für die automatische Generierung von Dokumentationen */

abstract        do              implements      package     

    throw boolean         double          import          private  

       throws break           else            inner           protected   

    transient byte            extends         instanceof      public     

     try case            final           int             rest         

   var cast            finally         interface       return         

 void catch           float           long            short          

 volatile char            for             native          static      

    while class           future          new             super       

    byvalue const           generic         null            switch continue 

       goto            operator        synchronized default         if   

           outer           this

• Ganzahlige Werte: kann man zur Basis 10, 16 (0xnnnn) oder 8 (0nnnn) eingeben. Ganze Zahlen haben einen Wertebereich von -2^31 bis 2^31-1. Lange ganze Zahlen (mit dem Suffix l bzw. L) haben einen Wertebereich von -2^63 bis 2^63-1.
• Gebrochene Zahlen: entweder mit einfacher Genauigkeit (optionales Suffixs f, von 1.40239846e-45f bis 3.40282347e+38f) oder doppelter Genauigkeit (Suffix d, von 4.94065645841246544e-324 bis 1.79769131486231570e+308)
• Wahrheitswerte: true und false.
• Zeichen: sind 16-Bit Unicodezeichen oder Escapes (\b, \t, \n, \r, \", \', \\ und \unnn) und werden in einfache Hochkommata eingeschlossen.
• Zeichenketten: werden in doppelte Hochkommata eingeschlossen und dienen als Werte für Instanzen der Klasse String. Arrays-Zeichen sind keine Zeichenketten. Zeichenketten kann man mit dem + Operator verbinden.

=       >       <       !       ~       ?       : ==      <=      >= 

     !=      &&      ||      ++      -- +       -       *       /    

   &       |       ^       %       <<      >>      >>> +=      -=    

  *=      /=      &=      |=      ^=      %=      <<=     >>=     >>>=

Datentypen

• byte: 8-bit Ganzahl. (von -256 bis 255)
• short: 16-bit Ganzahl (von -32768 bis 32767)
• int: 32-bit Ganzahl (von -2147483648 bis 2147483647)
• long: 64-bit Ganzahl (von -9223372036854775808 bis 9223372036854775807)
• float: 32-bit IEE 754 gebrochene Zahl (von 1.40239846e-45f bis 3.40282347e+38f)
• double: 64-bit IEE 754 gebrochene Zahl (von 4.94065645841246544e-324 bis 1.79769131486231570e+308).
• char: 16-bit Unicode Zeichen
• boolean: Wahrheitswert (true oder false)

Variablen

0.      Host's Packages      

1.      Quelldatei                

2.      Datentyp (Klasse oder Interface Deklaration)               

3.      Parameter der Methode                          

4.      lokaler Block                                

5.      for Befehl

• public: öffentlich
• protected: für die Methoden dieser Klasse und davon abgeleitete Klassen
• private: nur für die Methoden dieser Klasse
• ist nichts angegeben, so kann man auf diese Instanzvariable von allen Klassen in dieser Quelldatei (Package) zugreifen, nicht aber aus anderen Packages.

import java.applet.Applet;      // Importiert die Klasse Applet import java.applet.*;     

      // Importiert alle Klassen und Interfaces                                      

  // aus dem Package java.applet

Klassen und Interfaces

[<Doc-Komment>] [<Klassentyp>] class Klassenname         [extends <Oberklasse>]     

    [implements <Interfaces>]  {      <Felder>};

/** Person */public class Person  {         public String           m_strVorname;    

     public String           m_strNachname; }; /** Programmierer */ class Programmierer 

extends Person implements Arbeitnehmer {         public float    m_fGehalt;        

 public float    HatGehalt() { return m_fGehalt; }};

• abstract: Eine Abstrakte Klasse kann abstrakte Methoden enthalten. Abstrakte Methoden werden in dieser oder einer abstrakten Oberklasse nur deklariert, aber nicht definiert. Eine Klasse, die abstrakte Methoden enthält, muß auch als abstrakt deklariert werden. Von einer abstrakten Klasse kann man keine Instanzen anlegen.
• final: Von dieser Klasse kann man keine Unterklassen ableiten. Eine Klasse darf nicht gleichzeitig als final und abstrakt deklariert sein.
• public: Öffentliche Klasse. Pro Quelldatei darf nur eine öffentliche Klasse oder ein Interface deklariert werden.

A a; B b; a = b; b = (A)a;

[<Doc-Komment>] [<Methodentyp>] [<Rückgabetyp>] <Methodenname>

 [throws <Exceptions>] ([<Parameterliste>]) {       <Methodenkörper> }

class Test extends A {         int             x = 2;         

float           f = 0.34;         String          str = "das ist ein " + "Test";

         int             y;         {                      

 //statischer Initialisierungsblock                 x = 4;       

   //Überschreibt die Anfangswerte.                 f = 3.67;         

        y = "das ist ein".length();         }      

   public Test(int x, float g, String s) {          

       super(s);               //Aufruf des Konstruktors der Basisklasse   

              this.x = x;             

//hier muß man mit this.x die Instanzvariable      

                                   //adressieren, weil der Parameter auch x heißt.    

             f = g;                  //zum dritten Mal initialisieren       

          y = 23;         } };

• volatile: Variable wird möglicherweise in einen Thread geändert, während ein anderer sie ausliest.
• final: statische Variable, muß einen Initialisator haben.
• transient: Diese Eigenschaft ist noch nicht vollständig implementiert. Falls es in der Zukunft OODBMS auf der Basis von Java gibt, so werden mit transient Variablen markiert, die nicht zum persistenten Teil der Objekte gehören, sondern zur Laufzeit ständig unterschiedliche werte besitzen und daher nicht in der DB gespeichert werden. Transiente Variablen dürfen nicht statisch oder final sein.

[<Interfacetyp>] interface <Interfacename>  {         <Felder>};

public interface Arbeitnehmer {         public float    HatGehalt(); };

Anweisungen

Marke1 : while(true) {                 while(true) {                        

 if(<Bedingung>)                                 continue label1;         

        }         }

Auswahlanweisungen

• if ( <Bedingung> ) Anweisung
• if ( <Bedingung> ) Anweisung else Anweisung

  switch ( Anweisung ) {                 case <Konstante Anweisung>: Anweisung                 ...                 default:         }

Iterative Anweisungen

• while ( <Bedingung> ) Anweisung
• do Anweisung while ( <Bedingung> );
• for ( <ForInit>;<Bedingung>;<ForIncr>) Anweisung

Sprunganweisungen

• break [<Labelname>];
• continue [<Labelname>];
• return [<Anweisung>];
• throw [<Anweisung>];

Kontrollanweisungen

• synchronised ( <Anweisung 1> ) 
• try <Block 1> finally <Block n>
• try <Block 1> [catch ( <Argument>) <Block>]+ [finally <Block n>]

Multitasking in Java

// //      SimpleThread.java //  class SimpleThread extends Thread {   

      public SimpleThread(String name) {                 super(name);   

      }         public void run() {                 for(int i = 0; i < 10; i++) {  

                       System.out.println(i + " " + getName());                 

        try {                                 sleep((int)Math.random() * 1000);  

                       } catch(InterruptedException e) {}                 }     

            System.out.println("DONE! " + getName());         } }

// //      TwoThreadsTest.java //  class TwoThreadsTest {      

   public static void main(String args[]) {                

 new SimpleThread("Jamaica").start();                

 new SimpleThread("Fiji").start();         } }

  

// //      Producer.java //  class Producer extends Thread {         private CubbyHole 

      cubbyhole;         private int number;          public Producer(CubbyHole c, int number) { 

                cubbyhole = c;                 this.number = number;         }     

     public void run() {           for(int i = 0; i < 10; i++) {           

  cubbyhole.put(i);             System.out.println("Producer #" + this.number + " put: " + i); 

            try {               sleep((int)(Math.random() * 100));             } 

catch(InterruptedException e) {}           }         } }

// //      Consumer.java //  class Consumer extends Thread {        

 private CubbyHole       cubbyhole;         private int number;      

    public Consumer(CubbyHole c, int number) {                 cubbyhole = c;   

              this.number = number;         }          public void run() {     

      int value = 0;           for(int i = 0; i < 10; i++) {         

   value = cubbyhole.get(i);            System.out.println("Consumer #" + this.number +

 " got: " + value);           }         } }

// //      CubbyHole.java //  class CubbyHole {         private int seq;   

      private boolean available = false;          public synchronised int get()

 {                 while(available == false) {                         try { 

                                wait();                         } 

catch(InterruptedException e) {}                 }              

   available == false;                 return seq;         }    

      public synchronised void put(int value) {               

  seq = value;                 available = true;                 notify();         } }

// //      ProducerConsumerTest.java //  class ProducerConsumerTest {         public static void main(String args[]) {    

             CubbyHole c = new CubbyHole();                 Producer p1 = new Producer(c, 1);          

       Consumer c1 = new Consumer(c, 1);                  p1.start();                 c1.start();         } }

Wichtige Packages

• java.lang: Allgemeine Klassen für Java: Runnable, Boolean, System usw. Dieses Package wird als einziges immer implizit importiert.
• java.util: Hilfsklassen: Date, Vector, Hashtable
• java.io: E/A Klasse: File, InputStream, OutputStream
• awt: Abstract Window Toolkit: Benutzerinterfaceklassen
• net: Netzwerkspezifische Klassen
• applet: enthält die Klassen Applet und AudioClip für Audioanwendungen.

Beispielprogramme

Ein einfaches Java-Programm

// //      TestApp.java //  class TestApp {         public static void main(String args[])

 {                 System.out.println("Test App!");         } }

Ein einfaches Java-Applet

• void init(): Initialisierung von Applet. Laden der WWW-Seite.
• void start(): Aktivierung von Applet. Anzeigen der WWW-Seite.
• void stop(): Deaktivierung von Applet. Verlassen der WWW-Seite.
• void destroy(): Terminierung von Applet. Verlassen des Browsers.
• void paint(Graphics): Zeichnet den Bereich, der dem Applet zugewiesen wurde.

// //      TestApplet.java //  import java.awt.Graphics;      

 //graphische Klassen import java.applet.Applet;     

 //Deklaration der Klasse Applet  public class TestApplet extends Applet {   

      public void init()                 { resize(150, 25); }        

 public void paint(Graphics g)              

   { g.drawString("Ausgabe von Test Applet!", 50, 25); } }

// // ThreadApplet.java //  import java.awt.*; import java.applet.Applet; 

 public class ThreadApplet extends Applet implements Runnable {      

   Thread  testThread = null;         int     count = 0;        

 String  meldung = null;          public void run() {            

     while(true) {                         sleep(100);            

             count++;                         meldung = "Schleifenzähler: " + count;  

                       repaint();                 }         }       

   public void paint(Graphigc g) {                

 g.clearRect(0,0,size().width-1, size().height-1);        

         g.drawString(meldung, 5, 15);         }       

   public void init() { resize(500, 20); }          public void start() {             

    if(testThread == null) {                        

 testThread = new Thread(this, "Test Thread");            

             testThread.start();                 }         }  

        public void stop() {                 testThread.stop();   

              testThread = null;         } }

Einbinden von "Native-Methods"

// //  HelloWorld.java //  class HelloWorld {        

 public native void displayHelloWorld(); //native Methode deklarieren  

        static {                 System.loadLibrary("hello");  

  //DLL mit implementierung laden         }        

  public static void main(String args[]) {       

 //Hauptprogramm                 displayHello();         } }

javah HelloWorld                //erzeugt HelloWorld.h

// //      HelloWorld.c //  #include  #include "HelloWorld.h" #include 

  void HelloWorld_displayHelloWorld(struct HHelloWorld *this) {     

    printf("Hello World!\n");         return; }

WWW-Scriptsprachen

JavaScript

Grundlegende Sprachelemente des JavaScript stammen von Suns Java. JavaScript arbeitet mit den Inhalten der HTML-Dokumente. Die Elemente eines HTML-Dokuments werden als Objekte behandelt, die Methoden und Instanzvariablen (Properties) haben. JavaScript kennt nur feste Objekte, die der Benutzer nicht ändern kann. Sie sind in folgender Hierarchie angeordnet:

  

• Window: ist der Bereich, in dem Netscape den Text darstellt, nicht aber das Netscape Fenster selbst. Ab Version 2.0 unterstützt der Netscape Browser mehrere Fenster (Frames). Die Methoden der Windows können Warnungen und sonstige Texte in einem kleinen Fenster anzeigen (alert) und Benutzer um eine Bestätigung bitten (confirm). Die Methode confirm liefert true oder false, je nach der Reaktion des Benutzers.
• Location: hat Properties, die den URL der aktuellen WWW-Seite und seiner Komponenten (Protokoll, Host usw.) enthalten.
• History: bietet den Zugriff auf die URLs der bisher gelesenen Seiten. Mit seinen Methoden kann man sich innerhalb dieser URLs bewegen.
• Document: hat Methoden für die Textausgabe und viele Properties, die den Titel und andere Komponenten des Dokuments enthalten. Unter anderem hat es auch Arrays von Formularen, Links und Anchors.
• Forms: sind die Inhalte der HTML-Dokumente. Sie haben folgende untergeordnete Elemente: Text Fields, Text Areas, Check Boxes, Radio Button, Selections, Buttons. Die Properties dieser Elemente enthalten die Namen und Inhalte (Text bei Textfeldern und boolesche Werte bei den Buttons). Man kann für die Elemente Ereignis-Handler definieren.
• Links und Anchors: sind Verweise auf andere HTML-Dokumente oder Dateien. Links entstehen durch das HTML-Element href und Anchors durch das Element name.
• Plug-Ins, Applets, Elements: sind in der Version 2.0 (beta 5) des Netscape Browsers noch nicht implementiert. Plug-Ins sind eine Schnittstelle für Fremdformate wie z.B. Postscript oder PDF. Verschiedene Firmen (z.B. Adobe) entwickeln zur Zeit solche Plug-Ins.