public

abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„A Java keyword used in a class declaration to
specify that a class may be inherited but not
instantiated. An abstract class can have both
implemented and abstract methods, which are not
implemented in the abstract class, but in a subclass.“
Von abstrakten Klassen können keine Objekte
gebildet werden. Sonst verhalten sie sich wie normale
Klassen. Sie enthalten die gleichen Eigenschaften
und können auch selbst von anderen Klassen erben.
Sie dienen hauptsächlich als super-Klasse, um allen
erbenden Klassen eine gemeinsame Basis
aufzuzwingen.
in Kürze
20.05.2003
java.lang.reflect.Modifier
1
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
Beispiel: Eine abstrakte Klasse Kleidung ist die Oberklasse für
konkrete Kleidungsstücke.
abstract class Kleidung{
public abstract void wasche();
}
Mit dieser abstrakten Klasse drücken wir aus, dass es eine
allgemeine Klasse ist, die selbst kein Kleidungsstück darstellt. Es
macht also keinen Sinn, davon ein Objekt zu bilden. Das zeigt,
dass Oberklassen allgemeiner gehalten sind, und die Unterklassen
weiter spezialisieren.
in Kürze
20.05.2003
java.lang.reflect.Modifier
2
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
in Kürze
20.05.2003
abstract class Kleidung
{
boolean gewaschen;
public abstract void wasche();
}
class Socken extends Kleidung
{
/** Creates a new instance of Socken */
public Socken() {
wasche();
System.out.println(gewaschen);
}
/** Implementierung von wasche() */
public void wasche(){
System.out.println("Sauber: ");
}
}
java.lang.reflect.Modifier
3
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
in Kürze
20.05.2003
abstract class Kleidung
{
boolean gewaschen;
Variablen
dürfen nicht
abstract sein
public abstract void wasche();
}
abstracte Methode, muss
implementiert werden
class Socken extends Kleidung
{
/** Creates a new instance of Socken */
public Socken() {
wasche();
gibt false
System.out.println(gewaschen);
aus
}
/** Implementierung von wasche() */
public void wasche(){
System.out.println("Sauber: ");
}
}
java.lang.reflect.Modifier
4
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„A Java language keyword that defines an entity
which cannot be changed or derived from later. A final
class cannot be subclassed, a final method cannot be
overridden, and a final variable cannot be changed
from its initialized value.“
in Kürze
20.05.2003
java.lang.reflect.Modifier
5
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
Bei Variablen:
1.
2.
3.
Der Inhalt von final-Variablen kann nicht
geändert werden.
 Müssen bei Deklaration auch initialisiert
werden.
Bezeichner von final-Variablen werden als
Konvention komplett in Großbuchstaben
geschrieben.
in Kürze
20.05.2003
java.lang.reflect.Modifier
6
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
Bei Variablen:
final-Variablen werden oft verwendet, um Zustände
zu kodieren
final
final
final
final
final
int
int
int
int
int
FILE_NEW = 1;
FILE_OPEN = 2;
FILE_SAVE = 3;
FILE_SAVEAS = 4;
FILE_QUIT = 5;
in Kürze
20.05.2003
java.lang.reflect.Modifier
7
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
•
Als final deklarierte Methoden können nicht mehr
überschrieben werden
•
Von final-Klassen kann nicht geerbt werden
in Kürze
20.05.2003
java.lang.reflect.Modifier
8
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„Interface Definition Language (IDL) provides
interoperability and connectivity capabilities with
CORBA (Common Object Request Broker
Architecture) for the J2EE platform, enabling J2EE
applications to invoke operations on remote network
services using the Object Management Group (OMG)
IDL and Internet Inter-Orb Protocol (IIOP).“
in Kürze
20.05.2003
java.lang.reflect.Modifier
9
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
Ein interface gibt an, was eine Klasse, die sie
implementiert, tun muß, aber nicht, wie sie es tun
muß.
Interfaces und ihre Methoden sind entweder public
oder default (siehe ‚in Kürze‘). Methoden werden nur
deklariert, sie haben keinen Körper (ähnlich wie bei
abstract). Variablen sind implizit final und static, d.h.
ihr Wert muß bei der Deklaration angegeben werden
und kann zur Laufzeit nicht mehr verändert werden.
Klassen können über ihr Interface angesprochen
werden.
in Kürze
20.05.2003
java.lang.reflect.Modifier
10
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
in Kürze
20.05.2003
Bsp.:
public interface BerechneIF{
//IF (=interface)  NamensKonvention
int berechne(int a, int b); //kein Körper
}
public class Summe implements BerechneIF{
public int berechne(int a, int b){
return a + b;
//berechnen der Summe
}
}
public class Produkt implements BerechneIF{
public int berechne(int a, int b) {
return a * b; //berechnen des Produktes
}
}
java.lang.reflect.Modifier
11
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
in Kürze
20.05.2003
public class Rechnen {
//Methode erwartet Interface-Typ
public void ausrechnen(BerechneIF rechnen){
System.out.println(rechnen.berechne(5, 10));
}
}
public class Mathe {
public static void main(String[] args){
//RechnenObjekt instanziieren
Rechnen rechnen = new Rechnen();
//Methode bekommt Klassenobjekt, daß das
//Interface implementiert hat
rechnen.ausrechnen(new Summe());
//-> 15
rechnen.ausrechnen(new Produkt());
//-> 50
}
}
java.lang.reflect.Modifier
12
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„A Java language keyword used in method declarations
to specify that the method is implemented in another
source file and in another programming language.“
Mit native werden Methoden gekennzeichnet, die in
einer anderen Programmiersprache, typischerweise
C/C++ oder Assembler, geschrieben sind.
Solche Methoden müssen ähnlich wie bei abstrakten
Methoden deklariert, in einer DLL geschrieben und dann
mit dem Java-Code verbunden werden.
Bsp.:
public native int meth(); //Methodendeklaration
in Kürze
20.05.2003
java.lang.reflect.Modifier
13
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
Hinweise:
• Sicherheitsrisiko:
Nativer Code ist nicht auf die Java-VirtualMachine
beschränkt (Zeiger-Problematik). Daher können
Applets keine nativen Methoden verwenden. Auch
das Laden von DLLs kann eingeschränkt sein.
• Verlust der Portabilität:
Auf dem System, das den Java-Code ausführt, muss
die DLL vorhanden und kompatibel sein.
in Kürze
20.05.2003
java.lang.reflect.Modifier
14
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„A Java language keyword used in a method or
variable declaration to signify that the method or
variable can only be accessed by other elements of
its class.“
Wenn ein Member einer Klasse private ist, dann kann
auf dieses Member durch allen klasseneigenen
Code zugegriffen werden.
Innere Klassen haben Zugriff auf private-Member der
umgebenen Klasse.
in Kürze
20.05.2003
java.lang.reflect.Modifier
15
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„A Java language keyword used in a method or
variable declaration and signifying that the method or
variable can only be accessed by elements residing
in its class, subclasses, or classes in the same
package.“
Wenn ein Member einer Klasse protected ist, dann
kann auf dieses Member durch Code innerhalb des
package und außerhalb, sofern es sich um
Unterklassen handelt, zugegriffen werden.
(Packages kapseln mehrere Klassen. Ein package ist eine
weitere Ebene, um Java-Code zu strukturieren und Zugriffe
zu kontrollieren.)
in Kürze
20.05.2003
java.lang.reflect.Modifier
16
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„A Java language keyword used in a method or
variable declaration and signifying that the method or
variable can be accessed by elements residing in
other classes.“
Wenn ein Member einer Klasse public ist, dann kann
auf dieses Member durch allen anderen Code im
Programm zugegriffen werden.
 public static void main(String[] args){
in Kürze
20.05.2003
java.lang.reflect.Modifier
17
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„A Java language keyword used to define a variable
as a class variable. A class maintains a single copy of
class variables which are shared by all instances of
the class. The static keyword can also be used to
define a method as a class method, which is invoked
using the class, instead of a specific instance, and
can only operate on class variables“
in Kürze
20.05.2003
java.lang.reflect.Modifier
18
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
Normalerweise kann auf ein Klassen-Member
(Variable oder Methode) nur in Verbindung mit einem
Objekt zugegriffen werden.
Wenn ein Member als static deklariert ist, kann darauf
zugegriffen werden, bevor irgendwelche Objekt
seiner Klasse erzeugt wurden.
static-Variablen sind im wesentlichen global. Alle
Instanzen einer Klasse teilen sich dieselbe staticVariable.
in Kürze
20.05.2003
java.lang.reflect.Modifier
19
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
in Kürze
20.05.2003
Bsp.:
System.out.println() ist static und kann daher aufgerufen
werden, ohne das ein Objekt der Klasse PrintStream *
instanziiert werden muß.
* (public final static PrintStream out in der Klasse System)
java.lang.reflect.Modifier
20
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
Einschränkungen von static-Methoden:
•
Sie können nur andere static-Methoden aufrufen
•
Sie dürfen nur auf static-Variablen zugreifen
•
Sie können nicht auf this und super verweisen
in Kürze
20.05.2003
java.lang.reflect.Modifier
21
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
in Kürze
20.05.2003
Das Design Pattern (bewährte Lösungen für typische
Problemstellungen) ‚Singleton Pattern‘.
Heutige Software ist modularisiert:
Oberfläche
Systemkern
Datenbank
Speicher
java.lang.reflect.Modifier
22
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
Nur die Datenbank-Klasse darf Daten schreiben und
lesen. Gäbe es mehrere Objekte dieser Klasse,
würde das zu Kollisionen führen.
Naive Lösung:
Datenbank-Objekt bei Programmstart erstellen und
an alle Klassen des Systemkerns per Konstruktor
weiterreichen.
 Funktioniert, ist aber sehr unübersichtlich und führt
zu überfüllten Konstruktoraufrufen
in Kürze
20.05.2003
java.lang.reflect.Modifier
23
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
Form des Singleton Patterns:
class DatenbankManager{
static DatenbankManager dm;
//default-Wert = null
public static DatenbankManager getInstance(){
if(dm == null)
//nur beim ersten Aufruf
dm = new DatenbankManager();
//Objekt erstellen
return dm;
//ObjektVerweis zurückgeben
}//end getInstance
//Name getInstance nach Konvention
...
}
in Kürze
//Klassen holen sich den Verweis so:
DatenbankManager dm =
DatenbankManager.getInstance();
20.05.2003
java.lang.reflect.Modifier
24
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„The strictfp keyword, added in the Java 2 SDK,
forces floating point calculations in methods to
operate in strict mode. [It] permit the exponent portion
of intermediate results to be wider than the 32- or 64bit size of the end result of the operation.“
• Da unter Windows default-mäßig nicht im strictModus gerechnet wird, kann strictfp hier die Laufzeit
verbessern.
• In den meisten Fällen ist das Ergebnis einer strictRechnung gleich dem einer nicht-strict-Rechnung.
• Eher für wissenschaftliche Rechnungen gedacht.
in Kürze
20.05.2003
java.lang.reflect.Modifier
25
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„A Java language keyword that, when applied to a
method or statement block, guarantees that only one
thread at a time executes that code.“
Wenn mehrere Threads gleichzeitig dieselbe
Methode ausführen, kann es zu Problemen kommen.
Mit synchronized gekennzeichnete Methoden stellen
sicher, das immer nur ein Thread Zugriff hat. Erst,
wenn dieser Thread die Methode verlassen hat, kann
ein anderer Zugriff erhalten.
in Kürze
20.05.2003
java.lang.reflect.Modifier
26
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„A keyword in the Java language that indicates that a
field is not part of the serialized form of an object, i.e.
the specified field is not written to persistent storage.“
transient-Attribute (Variablen) einer lese- /
schreibfähigen Klassen, typischerweise für
Drag&Drop oder Copy&Paste benutzt, werden nicht
abgespeichert.
Der Datenstrom ist also kleiner.
in Kürze
20.05.2003
java.lang.reflect.Modifier
27
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
„A Java language keyword used in variable
declarations specifying that the variable is modified
asynchronously by concurrently running threads.“
int kopie = 5;
volatile int master = 15;
Ein Thread
kopie = 10, master = 15
Noch ein Thread
kopie = 20, master = 15
Die Variable master ist volatile, damit haben alle
Threads stets den gleichen Wert für master.
Der Wert von kopie ist lokal, kann also abweichen.
in Kürze
20.05.2003
java.lang.reflect.Modifier
28
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
• abstract
Garantiert in Klassenhierarchien eine gemeinsame
Basis aller erbenden Klassen
• final
Sorgt dafür, daß sich Werte und Methoden zur
Laufzeit nicht verändern
• interface
Javas Form der ‚Mehrfachvererbung‘
• static
Klassenattribut, unabhängig von Klassenobjekten
in Kürze
20.05.2003
java.lang.reflect.Modifier
29
abstract
final
interface
native
private
protected
public
static
strictfp
synchronized
transient
volatile
• Zugriffskontrolle
private
default
protected public
Selbe Klasse
Ja
Ja
Ja
Ja
Selbes Paket,
Unterklasse
Nein
Ja
Ja
Ja
Selbes Paket,
nicht Unterklasse
Nein
Ja
Ja
Ja
Anderes Paket,
Unterklasse
Nein
Nein
Ja
Ja
Anderes Paket,
nicht Unterklasse
Nein
Nein
Nein
Ja
in Kürze
20.05.2003
java.lang.reflect.Modifier
30