Unterlagen zu Kap. 1 (pdf-Datei)
Werbung
HOCHSCHULE MUENCHEN
FAKULTÄT FÜR ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 100 – 00 – TH – 03
-----------------------------------------------------------------------------------
Programmieren in Java
Kapitel 1
1. Einführung
1.1.
Entwicklung von Java
1.2.
Nichtimplementierte C/C++-Eigenschaften
1.3.
Schlüsselworte und Identifier
1.4.
Operatoren
1.5.
Wesentliche neue mit dem JDK 5.0 eingeführte Eigenschaften (Überblick)
FACHHOCHSCHULE MUENCHEN
FAKULTÄT FÜR ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 111 – 00 – TH – 05
------------------------------------------------------------------------------------
Entwicklung von Java
• Der Weg zu Java
► 1990 (Dez.)
Patrick Naugthon, Fa SUN Microsystems, kritisiert die von seiner Fa eingesetzte und vertriebene Hard- und Software
als nicht mehr zeitgemäss.
Als Folge wird eine Arbeitsgruppe eingesetzt, die zukünftige Entwicklungstrends in Hard- und Software erkennen,
untersuchen und realisieren sollte. späterer Name Green Project
Mitglieder waren – neben Patrick Naughton – James Gosling und Mike Sheridan
Entwicklung eines Prototypen zur Steuerung und Integration von Haushaltgeräten
► 1991 (Juni)
James Gosling beginnt im Rahmen des Green Projects die Arbeit an der portablen Interpretersprache Oak, die später
in Java umbenannt wird
► 1992
Vorstellung des entwickelten Geräts (*7, Star Seven), das einem heutigen Palm-Computer glich.
Hauptbestandteile : neben diversen Hardwarekomponenten ein Betriebssystem (Green-OS), die Interpretersprache Oak
und ein Graphiksubsystem (Aspen).
In der Folgezeit wird versucht, das Gerät zur Serienreife zu entwickeln (Gründung der Fa. First Person Inc)
1994
Der Versuch zur kommerziellen Verwendung von Star Seven scheitert endgültig.
Einsatz der neuen Programmiersprache Oak (Java) zur Entwicklung von Applets und eines WEB-Browsers zum
Herunterladen und Ausführen derselben (WebRunner, später umbenannt in HotJava)
Arthur van Hoff (seit Sept. 1993 im Green Project tätig) implementiert einen Java-Compiler in Java.
► 23.5.1995
Vorstellung von Java und HotJava auf der SunWorld '95
Offizieller Geburtstag der Sprache Java.
Ankündigung von Netscape, Java für den Einsatz in seinem Browser zu lizenzieren.
• Java-Development Kits
Werden von Sun als "offizielle Java-Versionen" zum Download bereitgestellt.
Enthalten Compiler, Interpreter (Java Virtual Machine, JVM), weitere Dienstprogramme und Standard-Bibliothek
► 1996 (Jan.) Freigabe des Java Development Kits 1.0 (JDK 1.0)
► 1997 JDK 1.1
► 1998 JDK 1.2, kurze Zeit später umbenannt in Java 2 Platform
► 2000 JDK 1.3 (Offizieller Name : Java2 System Development Kit 1.3 ,J2SDK 1.3)
► 2002 JDK 1.4 (J2SDK 1.4)
► 2004 JDK 1.5 (JDK 5.0)
► 2006 JDK 1.6 (JDK 6.0)
• Java2-Plattformen
► Java2 Standard Edition (J2SE)
► Java2 MicroEdition (J2ME), eingeschränkter Sprachstandard für den Einsatz in Geräten wie Mobiltelefonen, PDAs usw
► Java2 Enterprise Edition (J2EE), zusätzliche Komponenten zur Entwicklung unternehmensweiter verteilter
Anwendungen (u.a. Enterprise Java Beans, EJB)
• Wurzeln von Java
► C/C++
► Einflüsse weiterer objektorientierter Programmiersprachen wie Oberon, Ada, Eiffel, Objective-C
HOCHSCHULE MUENCHEN
FAKULTÄT FÜR ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 121 – 00 – TH – 05
-----------------------------------------------------------------------------------
In Java nicht implementierte C/C++-Eigenschaften
• Syntax und Semantik von Java entsprechen weitgehend der Syntax und Semantik von C/C++.
• Zahlreiche fehleranfällige oder redundante Bestandteile /Eigenschaften von C/C++ wurden jedoch nicht implementiert.
Wo sinnvoll und erforderlich sind diese durch "bessere" Konzepte ersetzt.
Im wesentlichen fehlen :
▻ Pointer und Pointerarithmetik
▻ Funktionspointer
▻ Speicherklassen (auto, register, extern)
▻ Globale Variable
▻ freie Funktionen
▻ inline-Funktionen
▻ die strukturierten Typen struct und union
▻ Bitfelder
▻ Datentyp long double
▻ vorzeichenlose Datentypen (kein unsigned und damit auch kein signed)
▻ Äquivalenz zwischen logischen (bool) und ganzzahligen Werten (keine Konvertierung zwischen bool und int)
▻ Einführung neuer Typnamen mittels typedef
▻ Sprunganweisung goto
▻ sizeof-Operator
▻ Komma-Operator
▻ Preprozessoranweisungen (Textersatz (Makros), bedingte Kompilierung)
▻ Header-Dateien
▻ Extern- und Vorwärtsreferenzen
▻ Dynamische Allokation von Variablen einfacher Datentypen
▻ Datentypen long long, _Bool, sowie komplexe und imaginäre Datentypen
reine C- Eigenschaft (C99)
▻ Datentyp wchar_t (in C ein in Headerdateien ,mittels typedef definierter Typ)
▻ Statische Allokation von Objekten
▻ explizite Freigabe dynamisch allozierten Speichers (kein delete-Operator)
▻ Default-Parameter von Funktionen
▻ Destruktoren
▻ Explizites Überladen von Operatoren (Operatorfunktionen)
▻ Mehrfachvererbung
▻ Templates
(ab JDK 5.0 gibt es zwar generische Datentypen und generische Methoden, die aber nicht
100%ig C++-Klassen-(und Funktions-)Templates entsprechen)
▻ Explizite Referenzen
▻ Befreundete Funktionen und Klassen (kein Schlüsselwort friend)
• Die folgenden Eigenschaften von C/C++ wurden erst mit dem JDK 5.0 eingeführt :
▻ Aufzählungstypen (enum),
▻ Variable Parameterliste bei Funktionen
reine
C++-Eigenschaften
HOCHSCHULE MUENCHEN
FAKULTÄT FÜR ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 131 – 00 – TH – 04
-----------------------------------------------------------------------------------
Vergleich der Schlüsselworte und Identitifier von Java, C und C++
• Schlüselworte (key words)
reine C-Schlüsselworte
restrict
_Bool
_Complex
_Imaginary
C- u. C++Schlüsselworte,
die nicht in Java
enthalten sind
auto
extern
inline
register
signed
sizeof
struct
typedef
union
unsigned
reine C++Schlüsselworte,
die nicht in Java
enthalten sind
asm
bool
const_class
delete
dynamic_cast
explicit
export
friend
mutable
namespace
operator
reinterpret_cast
static_cast
template
typeid
typename
using
virtual
wchar_t
catch
class
false
new
private
protected
public
this
throw
true
try
break
case
char
const
*)
continue
default
do
double
else
enum
float
for
goto
if
int
long
return
short
static
switch
void
volatile
while
abstract
assert
boolean
byte
extends
final
finally
implements
import
instanceof
interface
native
package
Schlüsselworte, die
die in C++und
Java enthalten
sind
Schlüsselworte, die
in C, C++und Java
enthalten sind
*) in Java reserviert,
aber nicht
verwendet
neue
Schlüsselworte
von Java
**)
*)
C
C++
**)
null
**)
strictfp
super
synchronized
throws
transient
**) genau genommen handelt es sich hierbei in Java nicht um ein Schlüsselwort,
sondern um eine Konstante (literal)
• Identifier
◇ Identifier (Namen) in Java werden nach den gleichen Regeln wie in C gebildet :
▻ Sie bestehen aus Buchstaben, dem Underscore ('_') und Ziffern
▻ Sie müssen mit einem Buchstaben oder dem Underscore ('_') beginnen
▻ Groß- und Klein-Buchstaben sind unterschiedlich
▻ Sie dürfen nicht wie ein reserviertes Wort (einschliesslich false, true und null) lauten
◇ Zusätzlich dürfen Java-Identifier das Dollarzeichen ('$') enthalten.
Dieses wird wie ein Buchstabe behandelt (Beginn mit '$' ist zulässig)
◇ Als Buchstaben sind alle Unicode-Buchstaben (also auch andere als im lateinischen Alphabet) zulässig
◇ Java-Identifier dürfen aus beliebig vielen Zeichen bestehen.
C
Java
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 141 – 00 – TH – 03
-----------------------------------------------------------------------------------
Operatoren von Java
• Operator-Hierarchie von Java
Priorität
Operator
Operation
1
[]
()
.
++ (Postfix)
-- (Postfix)
Indizierung
Funktionsaufruf
Komponentenzugriff
Increment
Decrement
lr
2
++ (Prefix)
-- (Prefix)
+
!
~
Increment
Decrement
Identität
Negation (arithmetisch)
Negation (logisch)
bitweises Komplement
lr
3
new
(type)
Objekterzeugung
Typkonvertierung (Cast)
lr
4
* / %
Multiplikation / Division / Modulus
lr
5
+
-
Addition bzw Konkatenation (Strings)
Subtraktion
lr
6
<<
>>
>>>
Linkssschieben
Rechtsschieben, Nachschieben des Vorzeichens
Rechtsschieben, Nachschieben von 0
lr
7
< <=
> >=
instanceof
Vergleich (kleiner / kleiner gleich)
Vergleich (größer / größer gleich)
Typprüfung
lr
8
== !=
Vergleich (gleich / ungleich)
lr
9
&
bitweises UND
lr
10
^
bitweises EXOR
lr
11
|
bitweises ODER
lr
12
&&
logisches UND
lr
13
||
logisches ODER
lr
14
?:
bedingte Auswertung
lr
15
=
*=
+=
<<=
&=
Zuweisung
Zuweisung mit Verknüpfungsoperation
lr
/= %=
-=
>>= >>>=
^= |=
Assoziativität
FACHHOCHSCHULE MUENCHEN
FAKULTÄT FÜR ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 151 – 00 – TH – 02
------------------------------------------------------------------------------------
Wesentliche neue mit dem JDK 5.0 eingeführte Java-Eigenschaften (Überblick)
• Neue Spracheigenschaften
▻ Generische Datentypen und Methoden (Generics)
Sie erlauben eine von konkreten Datentypen unabhängige Implementierung von Algorithmen (ähnlich den Klassenund Funktions-Templates von C++)
Sie werden vor allem im Zusammenhang mit der Container-Bibliothek (collection framework) eingesetzt.
▻ Automatische Umwandlung zwischen einfachen Datentypen und ihren Wrapper-Klassen
(Autoboxing/-unboxing)
Dies ermöglicht die direkte Verwendung von Werten einfacher Datentypen in Situationen, in denen Objekte benötigt
werden.
▻ Vereinfachte for-Anweisung (Enhanced for Loop, For-Each Loop)
Sie ermöglicht eine einfachere Iteration über alle Elemente eines Arrays oder Containers ohne den expliziten Einsatz von
Indexvariablen bzw Iteratoren.
▻ Aufzählungstypen (Typesafe Enums)
Sie dienen zur Definition von typsicheren Konstanten
Aufzählungstypen sind als besondere Klassen implementiert. Dadurch besitzen sie erweiterte Eigenschaften gegenüber
den C/C++-Aufzählungstypen.
▻ Variable Parameterliste bei Funktionen (Varargs)
Funktionen lassen sich so definieren, dass sie mit einer unterschiedlichen Anzahl von Parametern unterschiedlicher
Typen aufgerufen werden können
▻ Import aller statischen Komponenten einer Klasse (Static Import)
Hierdurch lassen sich statische Klassenkomponenten wesentlich einfacher verwenden (ohne Qualifikation mit dem
Klassennamen)
▻ Metadaten (Metadata, Annotations)
Metadaten sind zusätzliche Informationen, mit denen Java-Code versehen werden kann. Diese Informationen beeinflussen die Semantik eines Programms nicht direkt. Sie können aber von Codegeneratoren, anderen Tools und
Bibliotheken ausge wertet werden und sich dadurch auf deren Arbeitsweise auswirken, was indirekt wieder Auswirkungen auf die Semantik eines laufenden Programms haben kann.
• Verbesserungen an der Virtuellen Maschine
Die JVM (Java Virtual Machine) wurde mit eine Reihe neuer Fähigkeiten versehen, die im wesentlichen eine Beschleunigung der Programmabarbeitung bewirken sollen.
• Ergänzungen/Neuerungen in der Java-Klassen-Bibliothek
Eine Reihe von Klassen, die bereits in früheren JDK-Versionen vorhanden waren, wurden um zusätzliche Funktionalitäten erweitert.
Darüberhinaus wurde die Bibliothek um zahlreiche neue Klassen und um weitere Teilbibliotheken ergänzt.
Einzelheiten müssen der API-Dokumentation entnommen werden.
Einige Beispiele :
▻ Formatierte Ausgabe analog zu C/C++ (Methode printf(), Klasse java.util.Formatter)
▻ Klasse zur Erleichterung der formatierten Eingabe (java.util.Scanner)
▻ Verbesserungen/Erweiterungen durch Einsatz der neuen Spracheigenschaften (vor allem Generics, Enhanced for Loop,
Autoboxing/-unboxing, Enums), insbesondere in der Container-Bibliothek (Collection Framework)
▻ Bessere Unterstützung von Mulithreading und Multiprocessing (Teilbibliothek java.util.concurrency,
Änderungen in der Klasse java.lang.Thread, neue Klasse java.lang.ProcessBuilder zur einfacheren
Erzeugung von Kindprozessen)
▻ Überarbeitung der Teilbibliotheken zur Programmierung graphischer Benutzeroberflächen
