Java ME
Description
More details
Other editions
Additional editions
Persons
Content
2 - Vorwort [Seite 12]
3 - 1 Einführung [Seite 18]
3.1 - 1.1 Warum Java? [Seite 18]
3.2 - 1.2 Einschränkungen [Seite 20]
3.3 - 1.3 Java Micro Edition (Java ME) [Seite 20]
3.3.1 - 1.3.1 Weitere Normierungsbestrebungen [Seite 21]
4 - 2 Erste Schritte [Seite 22]
4.1 - 2.1 Das erste Programm [Seite 22]
4.1.1 - 2.1.1 Die Werkzeuge [Seite 22]
4.1.2 - 2.1.2 Entwicklungsschritte [Seite 23]
4.2 - 2.2 Installationsvorbereitungen [Seite 26]
4.2.1 - 2.2.1 Packen [Seite 26]
4.2.2 - 2.2.2 Packen mit Speicherplatzminimierung [Seite 28]
4.3 - 2.3 Simulation der Luftschnittstelle [Seite 28]
4.4 - 2.4 Installation auf einem Gerät [Seite 30]
4.5 - 2.5 Hinter den Kulissen [Seite 32]
5 - 3 Konfigurationen und Profile [Seite 34]
5.1 - 3.1 CLDC [Seite 35]
5.1.1 - 3.1.1 CLDC und Java [Seite 36]
5.1.2 - 3.1.2 Bibliotheken für CLDC [Seite 36]
5.1.3 - 3.1.3 Einschränkungen im Vergleich zur Java SE [Seite 37]
5.2 - 3.2 CLDC 1.1 im Vergleich zu 1.0 [Seite 38]
5.3 - 3.3 CDC [Seite 39]
5.4 - 3.4 MIDP [Seite 39]
6 - 4 MIDlet-Grundlagen [Seite 42]
6.1 - 4.1 Der MIDlet-Lebenszyklus [Seite 42]
6.2 - 4.2 MIDlet- und System-Merkmale [Seite 47]
6.3 - 4.3 Starten externer Anwendungen [Seite 50]
6.4 - 4.4 Zugriff auf Ressourcen [Seite 52]
6.4.1 - 4.4.1 jar-Verzeichnisstruktur [Seite 52]
6.4.2 - 4.4.2 Ressourcen-Datei lesen [Seite 54]
7 - 5 Benutzungsschnittstellen [Seite 58]
7.1 - 5.1 Bildschirmanzeigen verwalten [Seite 59]
7.2 - 5.2 Virtuelle Bildschirme [Seite 60]
7.2.1 - 5.2.1 Alert [Seite 61]
7.2.2 - 5.2.2 TextBox [Seite 65]
7.2.3 - 5.2.3 Choice [Seite 69]
7.2.4 - 5.2.4 List [Seite 71]
7.2.5 - 5.2.5 Form [Seite 75]
7.2.6 - 5.2.6 Ereignisverarbeitung für Displayable-Objekte [Seite 77]
7.3 - 5.3 Items - Komponenten für Formulare [Seite 80]
7.3.1 - 5.3.1 Ereignisverarbeitung für Items [Seite 81]
7.3.2 - 5.3.2 Layout von Items [Seite 81]
7.3.3 - 5.3.3 Ereignisverarbeitung in Form-Objekten [Seite 83]
7.3.4 - 5.3.4 Spacer [Seite 85]
7.3.5 - 5.3.5 StringItem [Seite 85]
7.3.6 - 5.3.6 ImageItem [Seite 86]
7.3.7 - 5.3.7 ChoiceGroup [Seite 88]
7.3.8 - 5.3.8 TextField [Seite 90]
7.3.9 - 5.3.9 DateField [Seite 90]
7.3.10 - 5.3.10 Gauge [Seite 92]
7.3.11 - 5.3.11 CustomItem [Seite 93]
7.4 - 5.4 Canvas [Seite 98]
7.4.1 - 5.4.1 Ereignisverarbeitung [Seite 101]
7.4.2 - 5.4.2 Verarbeitung von Tastaturereignissen [Seite 102]
7.4.3 - 5.4.3 Zeichnen mit paint() und Graphics [Seite 103]
7.5 - 5.5 Software-Muster für spezielleProblemstellungen [Seite 110]
7.5.1 - 5.5.1 Steuerung von Threads [Seite 110]
7.5.2 - 5.5.2 Steuerung von Runnable-Objekten [Seite 113]
7.5.3 - 5.5.3 Synchronisation von AMS und Berechnung [Seite 114]
7.5.4 - 5.5.4 Bildflackern vermeiden mit Double Buffering [Seite 115]
7.5.5 - 5.5.5 Minimierung der Zeichenoperationen [Seite 115]
7.5.6 - 5.5.6 Synchronisation von Anzeige und Berechnung [Seite 116]
7.5.7 - 5.5.7 Anwendungsbeispiel [Seite 117]
7.6 - 5.6 API für Spiele [Seite 123]
7.6.1 - 5.6.1 GameCanvas [Seite 123]
7.6.2 - 5.6.2 TiledLayer [Seite 124]
7.6.3 - 5.6.3 Sprite [Seite 125]
7.6.4 - 5.6.4 LayerManager [Seite 128]
7.6.5 - 5.6.5 Zusammenspiel [Seite 128]
7.6.6 - 5.6.6 Transparenz [Seite 133]
7.6.7 - 5.6.7 Game Builder [Seite 135]
7.7 - 5.7 2D-Grafik mit SVG [Seite 135]
7.7.1 - 5.7.1 Animierte SVG-Grafik [Seite 139]
7.7.2 - 5.7.2 Manipulation von SVG-Grafiken [Seite 141]
8 - 6 Record Management System [Seite 148]
8.1 - 6.1 Klasse RecordStore [Seite 149]
8.2 - 6.2 Benutzungsablauf [Seite 150]
8.3 - 6.3 Operationen auf Datensätzen [Seite 151]
8.3.1 - 6.3.1 Schreiben [Seite 152]
8.3.2 - 6.3.2 Lesen [Seite 153]
8.3.3 - 6.3.3 Löschen, Ändern, Datensatzgröße [Seite 155]
8.4 - 6.4 Enumerationen [Seite 155]
8.4.1 - 6.4.1 Sortierte Verarbeitung [Seite 156]
8.4.2 - 6.4.2 Filter [Seite 157]
8.5 - 6.5 Ereignisverarbeitung [Seite 158]
8.6 - 6.6 Verwaltungsfunktionen [Seite 158]
9 - 7 Dateisystem [Seite 160]
9.1 - 7.1 Dateisystem-Operationen [Seite 161]
9.1.1 - 7.1.1 Speicherkarten einfügen und entfernen [Seite 161]
9.2 - 7.2 Verzeichnis- und Datei-Operationen [Seite 162]
9.3 - 7.3 Sicherheit [Seite 166]
10 - 8 Persönliche Informationen verwalten [Seite 168]
10.1 - 8.1 Aufbau [Seite 168]
10.2 - 8.2 Attribute [Seite 173]
10.3 - 8.3 Einträge verwalten [Seite 174]
10.3.1 - 8.3.1 Neue Einträge [Seite 175]
10.3.2 - 8.3.2 Einträge ändern [Seite 178]
10.3.3 - 8.3.3 Einträge löschen [Seite 178]
11 - 9 Multimedia [Seite 180]
11.1 - 9.1 Konzept [Seite 180]
11.1.1 - 9.1.1 Eigenschaften der Geräte [Seite 182]
11.2 - 9.2 Audio [Seite 183]
11.2.1 - 9.2.1 Einfache Tonerzeugung [Seite 183]
11.2.2 - 9.2.2 Tonfolgen [Seite 185]
11.2.3 - 9.2.3 Wiedergabe von Audio-Dateien [Seite 186]
11.2.4 - 9.2.4 Lautstärke- und andere Einstellungen [Seite 187]
11.2.5 - 9.2.5 MIDI [Seite 189]
11.2.6 - 9.2.6 Aufnahme [Seite 190]
11.3 - 9.3 Video [Seite 190]
11.3.1 - 9.3.1 Kameraaufnahme [Seite 196]
11.3.2 - 9.3.2 Thumbnails [Seite 198]
11.4 - 9.4 Ereignisverarbeitung [Seite 199]
12 - 10 Internet-Anbindung [Seite 200]
12.1 - 10.1 HTTP [Seite 202]
12.1.1 - 10.1.1 Verbindung mit GET [Seite 203]
12.1.2 - 10.1.2 Verbindung mit POST [Seite 207]
12.1.3 - 10.1.3 Cookies [Seite 217]
12.2 - 10.2 HTTPS [Seite 218]
12.3 - 10.3 Socket [Seite 220]
12.4 - 10.4 Datagram [Seite 221]
13 - 11 3D-Grafik [Seite 224]
13.1 - 11.1 Klassen im M3G [Seite 226]
13.1.1 - 11.1.1 Loader und Object3D [Seite 226]
13.1.2 - 11.1.2 Graphics3D [Seite 226]
13.1.3 - 11.1.3 World und Group [Seite 229]
13.1.4 - 11.1.4 Transformable und Node [Seite 232]
13.1.5 - 11.1.5 Camera und Light [Seite 234]
13.2 - 11.2 Ein erstes Beispiel [Seite 235]
13.3 - 11.3 Animation [Seite 240]
13.3.1 - 11.3.1 KeyframeSequence [Seite 240]
13.3.2 - 11.3.2 AnimationTrack und AnimationController [Seite 241]
13.3.3 - 11.3.3 Ein Animationsbeispiel [Seite 243]
13.4 - 11.4 Immediate Mode [Seite 246]
13.4.1 - 11.4.1 VertexBuffer und VertexArray [Seite 247]
13.4.2 - 11.4.2 Rendern im Immediate Mode [Seite 248]
13.5 - 11.5 Mesh [Seite 255]
13.5.1 - 11.5.1 Spezialeffekte [Seite 261]
13.6 - 11.6 Das OpenGL ES API [Seite 262]
13.6.1 - 11.6.1 Initialisierung [Seite 263]
13.6.2 - 11.6.2 3D-Daten [Seite 265]
13.6.3 - 11.6.3 Szene rendern [Seite 267]
14 - 12 SMS senden und empfangen [Seite 272]
14.1 - 12.1 Einfache SMS senden [Seite 273]
14.2 - 12.2 SMS über eine Server-Verbindung senden [Seite 275]
14.3 - 12.3 SMS asynchron empfangen [Seite 277]
14.4 - 12.4 Push-Dienst - MIDlet mit einer SMS wecken [Seite 281]
14.5 - 12.5 Andere Arten, ein MIDlet zu wecken [Seite 281]
14.5.1 - 12.5.1 MIDlet zu einer bestimmten Zeit wecken [Seite 282]
15 - 13 Bluetooth [Seite 284]
15.1 - 13.1 Überblick Bluetooth-Technologie [Seite 286]
15.1.1 - 13.1.1 Netzwerktopologie [Seite 286]
15.1.2 - 13.1.2 Der Bluetooth-Stack [Seite 286]
15.1.3 - 13.1.3 Bluetooth-Profile [Seite 289]
15.2 - 13.2 Java APIs für Bluetooth [Seite 290]
15.2.1 - 13.2.1 Aufsuchen von Geräten [Seite 293]
15.2.2 - 13.2.2 Aufsuchen von Diensten [Seite 306]
15.3 - 13.3 Dienste nutzen [Seite 312]
15.4 - 13.4 Weitere Klassen der JABWT [Seite 316]
15.4.1 - 13.4.1 L2CAP [Seite 316]
15.4.2 - 13.4.2 OBEX [Seite 318]
16 - 14 Location API [Seite 324]
16.1 - 14.1 Lokalisierung [Seite 324]
16.2 - 14.2 Lokalisierung mit dem Location API [Seite 327]
16.2.1 - 14.2.1 Koordinaten [Seite 330]
16.2.2 - 14.2.2 Landmarken [Seite 334]
16.3 - 14.3 Location API-Beispiele mit dem WTK [Seite 335]
16.4 - 14.4 Location API-Beispiele mit realen Geräten [Seite 338]
17 - 15 Web-Services [Seite 344]
17.1 - 15.1 Konzept [Seite 345]
17.2 - 15.2 Technische Grundlagen [Seite 346]
17.2.1 - 15.2.1 Simple Object Access Protocol - SOAP [Seite 347]
17.3 - 15.3 Beispiel: SOAP-Anfrage an Google [Seite 348]
17.4 - 15.4 Automatische Auswertung vonSOAP-Nachrichten [Seite 354]
17.5 - 15.5 Automatische ErzeugungSOAP-Nachrichten [Seite 361]
17.6 - 15.6 Andere Werkzeuge zur SOAP-Unterstützung [Seite 363]
18 - 16 Sicherheit und Signierung [Seite 364]
18.1 - 16.1 Erlaubnisse und Sicherheitsbereiche [Seite 364]
18.2 - 16.2 Signaturen und Zertifikate [Seite 366]
18.2.1 - 16.2.1 Signieren mit dem WTK [Seite 367]
18.2.2 - 16.2.2 Verifizierung [Seite 368]
18.3 - 16.3 Zertifizierung in der realen Welt [Seite 368]
18.3.1 - 16.3.1 Schlüssel für gegebene Hardware erzeugen [Seite 368]
18.4 - 16.4 Java Verified Program [Seite 369]
18.5 - 16.5 Datensicherheit [Seite 369]
18.5.1 - 16.5.1 Verschlüsselung [Seite 370]
19 - 17 JavaFX [Seite 376]
20 - 18 Es funktioniert nicht! - Warum? [Seite 378]
20.1 - 18.1 Was tun? [Seite 378]
21 - 19 Werkzeuge [Seite 380]
21.1 - 19.1 Apache Web-Server - Installation,Einrichtung und Nutzung [Seite 380]
21.1.1 - 19.1.1 Konfiguration [Seite 382]
21.1.2 - 19.1.2 Kontrolle mit dem WTK [Seite 383]
21.2 - 19.2 Tomcat Container [Seite 385]
21.2.1 - 19.2.1 Vorbedingungen [Seite 385]
21.2.2 - 19.2.2 Installation und Start unter Windows [Seite 386]
21.2.3 - 19.2.3 Installation und Start unter Linux [Seite 386]
21.2.4 - 19.2.4 Fehlerbehebung [Seite 386]
21.3 - 19.3 Automatisierte Abläufe mit Ant [Seite 387]
21.4 - 19.4 NetBeans [Seite 396]
21.4.1 - 19.4.1 Java ME-Projekt anlegen und zum Laufen bringen [Seite 396]
21.4.2 - 19.4.2 Over the Air Simulation [Seite 397]
21.5 - 19.5 Web-Server mit Ant einbinden [Seite 397]
21.6 - 19.6 J2ME Polish [Seite 399]
21.7 - 19.7 Gerätespezifische Daten finden [Seite 400]
22 - A Anhang [Seite 402]
22.1 - A.1 Pfad und Systemvariablen einstellen [Seite 402]
22.1.1 - A.1.1 Linux [Seite 402]
22.1.2 - A.1.2 Windows XP [Seite 402]
22.2 - A.2 Mini-Web-Server [Seite 403]
22.3 - A.3 Bluetooth-Beispiele [Seite 405]
22.3.1 - A.3.1 Ein OBEX Beispielprogramm [Seite 405]
22.3.2 - A.3.2 Ein ObjectPush-Beispielprogramm [Seite 414]
22.4 - A.4 JSR-Übersicht [Seite 417]
22.5 - A.5 Übergreifende Spezifikation MSA [Seite 419]
22.6 - A.6 XML Kurzbeschreibung [Seite 421]
22.6.1 - A.6.1 Syntax [Seite 422]
22.6.2 - A.6.2 Dokumenttyp-Definition [Seite 424]
22.6.3 - A.6.3 Namensräume [Seite 424]
22.6.4 - A.6.4 XML-Schema [Seite 425]
22.7 - A.7 Verzeichnis der Beispielprogramme [Seite 426]
23 - Literaturverzeichnis [Seite 430]
24 - Glossar [Seite 436]
25 - Stichwortverzeichnis [Seite 444]
1.1 Warum Java? (S. 17)
Sicher kann man ein schlechtes (oder gutes) Programm in jeder Programmiersprache schreiben, und die Frage, welche die »beste« Programmiersprache ist, bewegt viele Gemüter. Wenn Software effizient entwickelt werden soll, müssen bei der Auswahl einer Programmiersprache verschiedene Kriterien beachtet werden, wie etwa die Verfügbarkeit von Entwicklungsumgebungen. Aus softwaretechnischer Sicht hat C das Manko, dass es die Objektorientierung nicht unterstützt. Java scheint aus folgenden Gründen am besten im Vergleich zum verbleibenden hauptsächlichen Konkurrenten C++ geeignet:
• Verbreitung: Java gibt es auf über 1,8 Milliarden mobilen Endgeräten, und etwa 80 % aller neuen verkauften Handys und PDAs usw. basieren auf Java.
• Portabilität: Java Bytecode ist auf allen JVM lauffähig, und jedes Betriebssystem von praktischer Bedeutung hat eine JVM. Der Aufwand, eine Anwendung auf ein anderes System zu portieren, ist damit sehr klein und oft gleich null.
• Sicherheit: Java hat ein API (Application Programming Interface) für sicherheitsrelevante Abläufe. Dazu gehören Authentifizierung, die Überprüfung von Signaturen und die Vergabe von Rechten (Autorisierung).
• Akzeptanz: Java ist auf diesem Gebiet ähnlich wie C++ sehr weit verbreitet und hat eine große Community. Es gibt Foren für Entwickler bei allen namhaften Herstellern.
• Robustheit: Java-Anwendungen laufen in einer »Sandbox«. Die Java Virtual Machine (JVM) wacht darüber, dass ein Absturz eines Programms keine anderen Anwendungen stört. Darüber hinaus ist der Bytecode vor der Ausführung mit einem Prüfsummenverfahren verifiziert worden, um die Integrität des Codes sicherzustellen. Unbemerkte Veränderungen, zum Beispiel durch ein Virus, werden dadurch deutlich erschwert.
• Garbage Collector: Java hat einen Garbage Collector, sodass keine Speicherlecks auftreten. In C++ können Speicherlecks dagegen nur durch sorgfältige Programmierung vermieden werden.
• De-facto-Standardisierung: Es gibt einen C++-Standard (ISO 14882), aber keinen Java-Standard. Der C++-Standard umfasst nur einen sehr kleinen Anteil von Bibliotheken, zum Beispiel gibt es nichts zu gra.schen Benutzungsoberflächen (GUI - engl. für graphical user interface) – alle derartigen APIs und Bibliotheken sind plattformspezifisch. Java hingegen hat eine reichliche Menge an APIs, nicht nur für grafische Benutzungsoberflächen, sondern für die Vernetzung und anderes. Die Spezifikationen für alle Erweiterungen der Java-Plattform entstehen im von Sun relativ demokratisch gestalteten Java Community Process [JCP]. In diesem Konsortium gibt Sun die Spielregeln vor, nach denen die Expertengruppen neue Spezifikationen austüfteln. JCP-Mitglieder, die ein neues Feature entwickeln, veröffentlichen dabei als Erstes ein JSR (Java Specification Request). Auf der Website www.jcp.org sind viele der JSRs samt der fertig gestellten Spezifikationen für jedermann einsehbar. Auch interessierte Einzelpersonen können am JCP teilnehmen. Weil so gut wie alle wichtigen Softwareunternehmen und auch Open-Source-Organisationen wie die Apache Software Foundation im JCP mitarbeiten, ist eine breite Marktakzeptanz gesichert und damit ein De-facto- Standard gegeben.
Es soll nicht verschwiegen werden, dass der Vorteil der Portabilität auch mit Nachteilen verbunden sein kann. Auf Desktop-PCs sind Java-Programme im Allgemeinen genauso schnell wie C++-Programme, weil die JVM einen Just-intime- Compiler aufruft.
