Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Generics, innere Klassen
10 Die Klassenbibliothek
11 Threads und nebenläufige Programmierung
12 Datenstrukturen und Algorithmen
13 Raum und Zeit
14 Dateien und Datenströme
15 Die eXtensible Markup Language (XML)
16 Grafische Oberflächen mit Swing
17 Grafikprogrammierung
18 Netzwerkprogrammierung
19 Verteilte Programmierung mit RMI und Web–Services
20 JavaServer Pages und Servlets
21 Applets
22 Midlets und die Java ME
23 Datenbankmanagement mit JDBC
24 Reflection und Annotationen
25 Logging und Monitoring
26 Sicherheitskonzepte
27 Java Native Interface (JNI)
28 Dienstprogramme für die Java-Umgebung
Stichwort

Download:
- ZIP, ca. 14,1 MB
Buch bestellen
Ihre Meinung?

Spacer
<< zurück
Java ist auch eine Insel (8. Auflage) von Christian Ullenboom
Programmieren mit der Java Standard Edition Version 6
Buch: Java ist auch eine Insel (8. Auflage)

Java ist auch eine Insel (8. Aufl.)
8., aktual. Auflage, geb., mit DVD
1.475 S., 49,90 Euro
Galileo Computing
ISBN 978-3-8362-1371-4
Pfeil 15 Die eXtensible Markup Language (XML)
Pfeil 15.1 Auszeichnungssprachen
Pfeil 15.1.1 Die Standard Generalized Markup Language (SGML)
Pfeil 15.1.2 Extensible Markup Language (XML)
Pfeil 15.2 Eigenschaften von XML-Dokumenten
Pfeil 15.2.1 Elemente und Attribute
Pfeil 15.2.2 Beschreibungssprache für den Aufbau von XML-Dokumenten
Pfeil 15.2.3 Schema – eine Alternative zu DTD
Pfeil 15.2.4 Namensraum (Namespace)
Pfeil 15.2.5 XML-Applikationen
Pfeil 15.3 Die Java-APIs für XML
Pfeil 15.3.1 Das Document Object Model (DOM)
Pfeil 15.3.2 Simple API for XML Parsing (SAX)
Pfeil 15.3.3 Pull-API StAX
Pfeil 15.3.4 Java Document Object Model (JDOM)
Pfeil 15.3.5 JAXP als Java-Schnittstelle zu XML
Pfeil 15.3.6 DOM-Bäume einlesen mit JAXP
Pfeil 15.4 Serielle Verarbeitung mit StAX
Pfeil 15.4.1 Unterschiede der Verarbeitungsmodelle
Pfeil 15.4.2 XML-Dateien mit dem Cursor-Verfahren lesen
Pfeil 15.4.3 XML-Dateien mit dem Iterator-Verfahren verarbeiten
Pfeil 15.4.4 Mit Filtern arbeiten
Pfeil 15.4.5 XML-Dokumente schreiben
Pfeil 15.5 Serielle Verarbeitung von XML mit SAX
Pfeil 15.5.1 Schnittstellen von SAX
Pfeil 15.5.2 SAX-Parser erzeugen
Pfeil 15.5.3 Operationen der Schnittstelle ContentHandler
Pfeil 15.5.4 ErrorHandler und EntityResolver
Pfeil 15.6 XML-Dateien mit JDOM verarbeiten
Pfeil 15.6.1 JDOM beziehen
Pfeil 15.6.2 Paketübersicht
Pfeil 15.6.3 Die Document-Klasse
Pfeil 15.6.4 Eingaben aus der Datei lesen
Pfeil 15.6.5 Das Dokument im XML-Format ausgeben
Pfeil 15.6.6 Der Dokumenttyp
Pfeil 15.6.7 Elemente
Pfeil 15.6.8 Zugriff auf Elementinhalte
Pfeil 15.6.9 Liste mit Unterelementen erzeugen
Pfeil 15.6.10 Neue Elemente einfügen und ändern
Pfeil 15.6.11 Attributinhalte lesen und ändern
Pfeil 15.6.12 XPath
Pfeil 15.7 Transformationen mit XSLT
Pfeil 15.7.1 Templates und XPath als Kernelemente von XSLT
Pfeil 15.7.2 Umwandlung von XML-Dateien mit JDOM und JAXP
Pfeil 15.8 Java Architecture for XML Binding (JAXB)
Pfeil 15.8.1 Beans für JAXB aufbauen
Pfeil 15.8.2 JAXBContext und die Marshaller/Unmarshaller
Pfeil 15.8.3 Weitere JAXB-Annotationen
Pfeil 15.9 HTML-Dokumente einlesen
Pfeil 15.10 Zum Weiterlesen


Galileo Computing - Zum Seitenanfang

15.4 Serielle Verarbeitung mit StAX Zur nächsten ÜberschriftZur vorigen Überschrift

Java 6 integriert die Pull-API StAX inklusive Implementierung als Teil der Standard-Bibliothek. (Um die API vor Java 6 nutzen zu können, kann unter http://stax.codehaus.org/ eine Implementierung der API bezogen werden.)

Die allgemeine Vorgehensweise zum Parsen eines XML-Dokuments ist folgende:

  • Erzeuge eine XMLInputFactory.
  • Erzeuge den passenden Parser.
  • Wähle XMLStreamReader für die Cursor-Verarbeitung oder XMLEventReader für die Iterator-Verarbeitung.
  • Erfrage mit next() die nächste Komponente des XML-Dokuments.
  • Ermittle den Typ der Komponente, und verarbeite ihn.

Die Unterschiede zwischen der Cursor- und der Iterator-Verarbeitung sind auf den ersten Blick nicht eindeutig. Im Folgenden werden die Unterschiede kurz vorgestellt.


Galileo Computing - Zum Seitenanfang

15.4.1 Unterschiede der Verarbeitungsmodelle Zur nächsten ÜberschriftZur vorigen Überschrift

Beide Verarbeitungsmodelle bieten ähnliche Methoden, und die Verarbeitung der Inhalte ist auch sehr ähnlich. Der wesentliche Unterschied ist die Art und Weise, wie die Komponenten des XML-Dokuments geliefert werden:

  • Bei der Cursor-Verarbeitung wird die Komponente direkt mit dem Parser-Objekt verarbeitet. Bei der Cursor-Verarbeitung ist die zentrale Klasse der XMLStreamReader, mit dem auch auf die Inhalte der XML-Datei zugegriffen wird. Da diese Klasse ebenso verwendet wird, um auf das nächste Element der XML-Datei zugreifen zu können, steht zu einem Zeitpunkt immer nur eine Komponente des XML-Dokuments zur Verfügung. Der Vorteil ist die hohe Effizienz, da bei der Verarbeitung keine neuen Objekte erzeugt werden.
  • Bei der Iterator-Verarbeitung wird ein XMLEvent-Objekt geliefert, das anderen Methoden übergeben und in einer Datenstruktur gespeichert werden kann.

StAX ist eine symmetrische API, was bedeutet, es gibt Klassen zum Lesen und auch Schreiben von XML-Dokumenten. So wie es für das Lesen die Prinzipien Cursor und Iterator gibt, so bietet die StAX-API die Klassen XMLStreamWriter und XMLEventWriter. Damit ist es möglich, Elemente, die über die Reader gelesen werden, an die Writer zu übergeben und damit Änderungen an den Inhalten zu schreiben.


Galileo Computing - Zum Seitenanfang

15.4.2 XML-Dateien mit dem Cursor-Verfahren lesen Zur nächsten ÜberschriftZur vorigen Überschrift

Zunächst muss ein Parser erzeugt werden, der das XML-Dokument verarbeiten soll.

InputStream     in      = new FileInputStream( "party.xml" ); 
XMLInputFactory factory = XMLInputFactory.newInstance(); 
XMLStreamReader parser  = factory.createXMLStreamReader( in );

Der Parser iteriert über die XML-Datei mit einer Tiefensuche und liefert beim Verarbeiten eine Reihe von Events, die den Typ des XML-Elements anzeigen. Die Eventtypen sind ganzzahlige Werte und als Konstanten in der Klasse XMLStreamConstants festgelegt. Der Parser liefert die folgenden Elemente:

  • START_DOCUMENT: Der Beginn der XML-Datei. Bei diesem Event können Eigenschaften wie das Encoding des Dokuments ermittelt werden.
  • END_DOCUMENT: Hier steht nur die Methode close() zum Schließen der Eingabe zur Verfügung.
  • START_ELEMENT: Liefert den Typ, wenn ein Element beginnt. Die Attribute und der Namensraum eines Elements können hier ausgewertet werden.
  • END_ELEMENT: Wenn das Ende eines Elements erreicht ist.
  • CHARACTERS: Text innerhalb von Elementen. Text kann auf Whitespace getestet werden.
  • ENTITY_REFERENCE: Wenn Entitäten in der XML-Datei auftauchen. Üblicherweise werden Entitäten zuerst aufgelöst und dann als CHARACTERS-Event geliefert.
  • DTD: Mit diesem Event wird die DTD als String geliefert, und es ist möglich, auf Teile der DTD zuzugreifen.
  • COMMENT: Kommentare in der XML-Datei.
  • PROCESSING_INSTRUCTION: Verarbeitungsanweisungen wie Stylesheet-Angaben.

Die Events ATTRIBUTE und NAMESPACE liefert der Parser nur in Ausnahmefällen. Inhalte von Attributen sowie die Namensraumdaten lassen sich beim Event START_ELEMENT erfragen.

Passend zum Event sind verschiedene Methodenaufrufe gültig, etwa getAttributeCount() im Fall eines Elements, das die Anzahl Attribute liefert. Mit einer Schleife und einer switch-Anweisung lassen sich die Inhalte der XML-Datei dann einfach auswerten.

Listing 15.6 com/tutego/insel/stax/XMLStreamReaderDemo.java, Ausschnitt

XMLInputFactory factory = XMLInputFactory.newInstance(); 
XMLStreamReader parser = factory.createXMLStreamReader( new FileInputStream(  
                                                        "party.xml" ) ); 
 
StringBuilder spacer = new StringBuilder(); 
 
while ( parser.hasNext() ) 
{ 
  System.out.println( "Event: " + parser.getEventType() ); 
 
  switch ( parser.getEventType() ) 
  { 
    case XMLStreamConstants.START_DOCUMENT: 
      System.out.println( "START_DOCUMENT: " + parser.getVersion() ); 
      break; 
 
    case XMLStreamConstants.END_DOCUMENT: 
      System.out.println( "END_DOCUMENT: " ); 
      parser.close(); 
      break; 
 
    case XMLStreamConstants.NAMESPACE: 
      System.out.println( "NAMESPACE: " + parser.getNamespaceURI() ); 
      break; 
 
    case XMLStreamConstants.START_ELEMENT: 
      spacer.append( "  " ); 
      System.out.println( spacer + "START_ELEMENT: " + parser.getLocalName() ); 
 
      // Der Event XMLStreamConstants.ATTRIBUTE wird nicht geliefert! 
      for ( int i = 0; i < parser.getAttributeCount(); i++ ) 
        System.out.println( spacer + "  Attribut: " 
                            + parser.getAttributeLocalName( i ) 
                            + " Wert: " + parser.getAttributeValue( i ) ); 
      break; 
 
    case XMLStreamConstants.CHARACTERS: 
      if ( ! parser.isWhiteSpace() ) 
        System.out.println( spacer + "  CHARACTERS: " + parser.getText() ); 
      break; 
 
    case XMLStreamConstants.END_ELEMENT: 
      System.out.println( spacer + "END_ELEMENT: " + parser.getLocalName() ); 
      spacer.delete( (spacer.length() – 2), spacer.length() ); 
      break; 
 
    default: 
      break; 
  } 
  parser.next(); 
}

Dieses Beispiel demonstriert das Lesen einer XML-Datei mit dem Cursor-Verfahren. Das folgende Unterkapitel zeigt die Verarbeitung mit dem Iterator-Verfahren.


Hinweis Der XMLStreamReader liefert beim Parsen keinen Typen XMLStreamConstants.ATTRIBUTE. Dieses Event kann nur im Zusammenhang mit XPath auftreten, wenn der Ausdruck ein Attribut als Rückgabe liefert. Beim Parsen von XML-Dokumenten werden Attribute anhand der Elemente geliefert.



Galileo Computing - Zum Seitenanfang

15.4.3 XML-Dateien mit dem Iterator-Verfahren verarbeiten Zur nächsten ÜberschriftZur vorigen Überschrift

Die Verarbeitung mit der Iterator-Variante der StAX-API ist ein wenig komplizierter, aber auch viel flexibler. Es wird nicht direkt mit dem allgemeinen Parser-Objekt auf die Daten zugegriffen, sondern es wird bei jeder Iteration ein XMLEvent Objekt erzeugt. Mit diesem Objekt kann der Typ des Events ermittelt und ganz ähnlich zur Cursor-API ausgewertet werden.

Am Anfang wird ein Parser vom Typ XMLEventReader erzeugt, und in einer Schleife werden die einzelnen Komponenten ausgewertet:

Listing 15.7 com/tutego/insel/stax/XMLEventReaderDemo.java, main()

InputStream in = new FileInputStream( "party.xml" ); 
XMLInputFactory factory = XMLInputFactory.newInstance(); 
XMLEventReader parser = factory.createXMLEventReader( in ); 
 
StringBuilder spacer = new StringBuilder(); 
while ( parser.hasNext() ) 
{ 
  XMLEvent event = parser.nextEvent(); 
 
  switch ( event.getEventType() ) 
  { 
    case XMLStreamConstants.START_DOCUMENT: 
      System.out.println( "START_DOCUMENT:" ); 
      break; 
    case XMLStreamConstants.END_DOCUMENT: 
      System.out.println( "END_DOCUMENT:" ); 
      parser.close(); 
      break; 
    case XMLStreamConstants.START_ELEMENT: 
      StartElement element = event.asStartElement(); 
      System.out.println( spacer.append("  ") 
                          + "START_ELEMENT: " 
                          + element.getName() ); 
      for ( Iterator<?> attributes = element.getAttributes(); 
            attributes.hasNext(); ) 
      { 
        Attribute attribute = (Attribute) attributes.next(); 
        System.out.println( spacer + "  Attribut: " 
                            + attribute.getName() + " Wert: " 
                            + attribute.getValue() ); 
      } 
      break; 
    case XMLStreamConstants.CHARACTERS: 
      Characters characters = event.asCharacters(); 
      if ( ! characters.isWhiteSpace() ) 
        System.out.println( spacer 
                            + "  CHARACTERS: " 
                            + characters.getData() ); 
      break; 
    case XMLStreamConstants.END_ELEMENT: 
      System.out.println( spacer 
                          + "END_ELEMENT: " 
                          + event.asEndElement().getName() ); 
      spacer.delete( (spacer.length() – 2), spacer.length() ); 
      break; 
    case XMLStreamConstants.ATTRIBUTE: 
      break; 
 
    default : 
      break; 
  } 
}

Diese Form der Verarbeitung sieht auf den ersten Blick komplizierter aus, bietet aber zusätzliche Möglichkeiten, weil die erzeugten Objekte für die weitere Verarbeitung zur Verfügung stehen.


Galileo Computing - Zum Seitenanfang

15.4.4 Mit Filtern arbeiten Zur nächsten ÜberschriftZur vorigen Überschrift

Mit Hilfe von Filtern gibt es die Möglichkeit, nur Teile eines XML-Dokuments zu parsen. Diese Filter werden durch die Implementierung einer der Schnittstellen javax.xml.stream.EventFilter (für die XML-Events) oder javax.xml.stream.StreamFilter (für die XMLStreamReader) programmiert. Es muss lediglich die Methode accept() implementiert und ein boolean-Wert zurückgegeben werden. Als Parameter erwartet diese Methode entweder einen javax.xml.stream.events.XMLEvent bei der Iterator-Variante oder einen XMLStreamReader bei der Cursor-Variante. Dazu ein Beispiel: Ein Filter soll für die Iterator-Variante die schließenden Tags auslassen.

Listing 15.8 com/tutego/insel/stax/PartyEventFilter.java

package com.tutego.insel.stax; 
 
import javax.xml.stream.EventFilter; 
import javax.xml.stream.events.XMLEvent; 
public class PartyEventFilter implements EventFilter 
{ 
  public boolean accept( XMLEvent event ) 
  { 
    return ! event.isEndElement(); 
  } 
}

Der Filter wird beim Erzeugen des Parsers mit der XMLInputFactory und dem vorhandenen XMLEventReader erzeugt. Dazu ein Beispiel zur Erzeugung des Parsers mit dem Event-Filter:

XMLEventReader filteredParser = factory.createFilteredReader( 
                                  parser, new PartyEventFilter() );

Dieses Verfahren der Dekoration wird in ähnlicher Form bei Streams verwendet.

Das Erzeugen eines Parsers mit einem Filter für die Cursor-Variante funktioniert analog. Mit Filtern bietet die API eine einfache Lösung, wenn nur bestimmte Teile des XML-Dokuments verarbeitet werden sollen.


Galileo Computing - Zum Seitenanfang

15.4.5 XML-Dokumente schreiben topZur vorigen Überschrift

Im Gegensatz zu DOM-orientierten APIs, bei denen das gesamte Dokument im Speicher vorliegt und verändert werden kann, ist es bei StAX nicht möglich, die vorhandene XML-Datei zu verändern. Es ist aber trotzdem möglich, XML zu schreiben. Auch hier wird zwischen der Cursor- und der Iterator-Variante unterschieden. Bei der Iterator-Variante werden Event-Objekte geschrieben, die entweder aus einem gelesenen XML-Dokument stammen oder mit einer XMLEventFactory erzeugt werden. Bei der Cursor-Variante wird mit einem XMLStreamWriter die XML-Komponente direkt erzeugt und geschrieben. In beiden Fällen wird über die XMLOutputFactory ein passender Writer erzeugt. Die Reihenfolge, in der die Komponenten geschrieben werden, entscheidet über den Aufbau des zu erzeugenden XML-Dokuments.

XMLStreamWriter

Zuerst zeigen wir, wie mit der Cursor-Variante eine XML-Datei geschrieben werden kann. Dazu erzeugen wir mit der XMLOutputFactory einen XMLStreamWriter, der die Elemente und Attribute direkt in eine XML-Datei schreibt.

Listing 15.9 com/tutego/insel/stax/XMLStreamWriterDemo.java, main()

XMLOutputFactory factory = XMLOutputFactory.newInstance(); 
XMLStreamWriter writer = factory.createXMLStreamWriter(  
                                   new FileOutputStream(  "writenParty.xml" ) ); 
// Der XML-Header wird erzeugt 
writer.writeStartDocument(); 
// Zuerst wird das Wurzelelement mit Attribut geschrieben 
  writer.writeStartElement( "party" ); 
    writer.writeAttribute( "datum", "31.12.01" ); 
 
    // Unter dieses Element das Element gast mit einem Attribut erzeugen 
    writer.writeStartElement( "gast" ); 
      writer.writeAttribute( "name", "Albert Angsthase" ); 
    writer.writeEndElement(); 
  writer.writeEndElement(); 
writer.writeEndDocument(); 
writer.close();

Es werden keine speziellen Objekte erzeugt, sondern direkt geschrieben. Das hat den Nachteil, dass es nicht möglich ist, bereits gelesene XML-Komponenten direkt in einen anderen Stream zu schreiben – und wenn sich Elemente wiederholen, wird Programmcode wiederholt.

Genau wie beim Lesen von XML-Dokumenten wird bei der Iterator-Variante mit Event-Objekten gearbeitet. Diese Objekte können aus einem gelesenen XML-Dokument stammen oder für die Ausgabe erzeugt werden. Das Erzeugen der Event-Objekte und das Schreiben der Objekte sind zwei unabhängige Schritte. Im folgenden Beispiel wird gezeigt, wie Event-Objekte erzeugt und dann mit einem Stream geschrieben werden.

XMLEventWriter

Bei der Iterator-Variante wird ebenfalls die Klasse XMLOutputFactory verwendet. Diesmal wird aber ein Objekt vom Typ XMLEventWriter erzeugt. Für die in diesem Beispiel benutzten Elemente und Attribute wird eine XMLEventFactory verwendet.

Listing 15.10 com/tutego/insel/stax/ XMLEventWriterDemo.java, main()

XMLOutputFactory outputFactory = XMLOutputFactory.newInstance(); 
XMLEventWriter writer = outputFactory.createXMLEventWriter( 
  new FileOutputStream("writenParty.xml" ) ); 
XMLEventFactory eventFactory = XMLEventFactory.newInstance();

Die Klasse XMLEventFactory bietet ähnliche Methoden wie die Klasse XMLStreamWriter an. Hier wird jedoch ein XMLEvent-Objekt erzeugt, und die Reihenfolge beim Erzeugen hat keinen Einfluss auf die Reihenfolge in der Ausgabe.

XMLEvent header = eventFactory.createStartDocument();

Zuerst werden für das Wurzelelement das öffnende und schließende Tag sowie das Attribut datum erzeugt. Hierfür wird die Methode createStartElement() verwendet, weil diese hier am einfachsten einzusetzen ist.

XMLEvent startRoot = eventFactory.createStartElement( "", "", "party" ); 
XMLEvent datumAttribut = eventFactory.createAttribute( "datum", "31.12.01" ); 
XMLEvent endRoot = eventFactory.createEndElement( "", "", "party" ); 
 
XMLEvent startGast = eventFactory.createStartElement( "", "", "gast" ); 
XMLEvent name = eventFactory.createAttribute( "name",  "Albert Angsthase" ); 
XMLEvent endGast = eventFactory.createEndElement( "", "", "gast" ); 
XMLEvent endDocument = eventFactory.createEndDocument();

Um die Elemente zu schreiben, werden sie dem XMLEventWriter übergeben. Hier entscheidet die Reihenfolge über den Aufbau der XML-Datei.

// Schreiben der Struktur 
writer.add( header ); 
writer.add( startRoot ); 
  writer.add(datumAttribut); 
  writer.add( startGast ); 
    writer.add( name ); 
  writer.add( endGast ); 
  writer.add( endRoot ); 
writer.add( endDocument ); 
writer.close();

In diesem Beispiel wurde gezeigt, wie Events erzeugt werden können und wie Events geschrieben werden. Das Schreiben von Elementen aus einer Eingabe funktioniert analog. Falls sich Elemente wiederholen oder aus einer anderen Quelle stammen, können sie hier mit dem Writer geschrieben werden. Dies zeigt deutlich, dass die Iterator-Variante flexibler als die Cursor-Variante ist. Diese Flexibilität wird durch einen etwas höheren Aufwand erkauft.

Der Abschnitt zeigte, wie mit der StAX-API XML gelesen und geschrieben werden kann. Es wurden die Unterschiede zwischen der Cursor- und der Iterator-Variante gezeigt, und es wurden Filter für die Eingabe kurz vorgestellt. Grundsätzlich ist die Iterator-Variante die flexiblere Lösung und in den meisten Fällen performant genug. Sie ist in jedem Fall performanter als eine DOM-basierte Lösung, wenn nicht die gesamte XML-Struktur im Speicher benötigt wird. Die Cursor-Variante sollte gewählt werden, wenn hohe Verarbeitungsgeschwindigkeit und geringer Speicherverbrauch Priorität haben. Diese Variante ist insbesondere für Endgeräte mit wenig Speicher und geringer Rechenleistung die bessere Wahl.

Die Anwendungsgebiete der StAX-API sind die gleichen wie die der SAX-API, weil die Vorteile beider Verfahren Performance und geringer Speicherverbrauch sind. Für die meisten Programmierer ist diese Form der Verarbeitung einfacher als die SAX-Variante, weil der XML-Inhalt direkt gelesen wird. SAX hat den Vorteil, dass es weit verbreitet ist und in vielen Programmiersprachen zur Verfügung steht. Wir stellen SAX im folgenden Unterkapitel kurz vor.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






<< zurück
  Zum Katalog
Zum Katalog: Java ist auch eine Insel





Java ist auch eine Insel
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Tipp
Zum Katalog: Coding for Fun





 Coding for Fun


 Buchempfehlungen
Zum Katalog: Objektorientierte Programmierung





 Objektorientierte
 Programmierung


Zum Katalog: Einstieg in Eclipse 3.4






 Einstieg in
 Eclipse 3.4


Zum Katalog: Java 6 lernen mit Eclipse






 Java 6 lernen
 mit Eclipse


Zum Katalog: NetBeans Platform 6






 NetBeans
 Platform 6


Zum Katalog: Java und XML






 Java und XML


Zum Katalog: Visual C# 2008






 Visual C# 2008


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


Zum Katalog: C++ von A bis Z






 C++ von A bis Z


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Galileo Press 2009
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de