java() { blog; } // für alle Interessierten

In einer Kurzmeldung betont Oracle, mit dem OpenJDK und der OpenJDK Gemeinde so weiter zu arbeiten, wie Sun es getan hat. Das heißt u. a., dass das Java Development Kit (JDK) unter der GNU Public License (GPL) weiter entwickelt wird.
Viel interessanter jedoch ist die Frage, wie Oracle seine Patente bezüglich der virtuellen Maschine verwendet. Wird es möglich sein, eine virtuelle Maschine unter der GPL zu entwickeln, ohne Gefahr zu laufen, Lizenzgebühren an Oracle zu zahlen? Zur Beantwortung dieser Frag müssen wir wohl noch bis zur JavaOne warten, Oracles Java Entwickler Konferenz.

Beim Versuch, auf der Download-Seite für Java 6 EE etwas über das freie und quelloffene Java heraus zu finden, landet man bei einer Fehlermeldung "404 - Page not found". Zeigt das die Einstellung des neuen Besitzers von Java zur OpenSource Community?

Über das Menü "Java" wählt man den Eintrag "Free and Open Source Java"


Man gelangt zu der folgende Seite:

Bei der Implementierung verteilter Software mittels RMI können sehr viele Fehlersituationen auftreten, die durch die entsprechenden Ausnahmen signalisiert werden. Wie man bestimmte Ausnahmesituationen vermeiden kann zeigt die folgende Liste:

AlreadyBoundException
Eine AlreadyBoundException tritt auf, wenn versucht wurde ein Objekt an einen Namen in der Registry zu binden der bereits verknüpft wurde.

Vermeidung: Den Befehl rebind verwenden um einen neuen Eintrag mit dem gleichen Namen hinzu zu fügen oder den alten Namen zu überschreiben, oder
einen anderen Namen verwenden.

ClassNotFoundException
Eine ClassNotFoundException tritt auf, wenn der ClassLoader des Systems oder eine selbst definierte Unterklasse von ClassLoader eine bestimmte Klasse nicht finden konnte, da der Classpath falsch gesetzt wurde.

Vermeidung: Im Interface die Klasse im richtigen Ordner angeben.

UnknownHostException
Eine UnknownHostException tritt auf, wenn das in Form eines Strings (Hostname) oder einer IP Adresse in der Registry angegebene Zielsystem (Host) nicht gefunden wurde.

Vermeidung: Einen gültigen Hostnamen für die Registry angeben.

Port already in use
Tritt beim Starten der Registry auf und bedeutet, das bereits eine Registry gestartet wurde.

Vermeidung: Die Registry nur einmal starten.

NotBoundException
Eine NotBoundException tritt auf, wenn kein Dienst unter dem Namen eines entfernten Objektes, welches als Referenz von lookup angegeben wurde, verfügbar ist.

Vermeidung: Den richtigen Servicenamen als Argument bei lookup angeben.

Connection refused
Die Fehlermeldung Connection refused tritt auf, wenn vor dem Starten des Programms vergessen wurde die Registry zu starten, oder eine Firewall das binden der Registry verhindert.

Vermeidung: Programm beenden erneut ausführen und vorher die Registry starten, oder/und die Einstellungen der Firewall überprüfen.

Möglich wird das durch eine spezielle virtuelle Maschine, welche die aicas GmbH nach der Realtime Specification for Java RTSJ - dem JSR 1 implementiert hat. Sie wird für die Steuerung des von dem EADS entwickelten, unbemannten Militärflugzeugs benutzt.
(mehr bei heise)

Sun hat das Update 5 zur J2se 5.0 herausgegeben. Sie steht zum laden auf http://java.sun.com bereit. Auch Eclipse steht nun in der Version 3.2M1 bereit. Sie wird von http://www.eclipse.org zum laden angeboten. Es ist unbedingt empfehlenswert, nach dem Laden der ursprünglichen Version, den automatischen Software-Update von Eclipse zu starten und sowohl alle neu erhältlichen Features zu installieren, als auch die bereits installierten Features auf dem aktuellen Stand zu halten.
In den Übungen werden wir zukünftig mit den oben genannten Versionen arbeiten.

Da die Version 1.5(5.0) nun schon seit geraumer Zeit offiziell ist, wir uns bisher aber wenig mit den Neuerungen beschäftigt haben, möchte ich hier kurz ein paar der wichtigsten neuen "Features" und Änderungen vorstellen. Im Anhang zu jedem Feature gibt es für Interessierte Links zu ausführlichen Beschreibungen und Tutorials.

Generic Types
Die wohl bedeutendste Änderung mit Version 1.5 ist die Einführung von "Generic Types". Jeder kennt und verwendet die Klassen für Datenstrukturen aus dem Paket java.util z.B. List, LinkedList, Hashtable, Hashmap, ArrayList, Vector, usw.
In Java 1.4 sah die Verwendung dieser Klassen in etwa so aus:

List l = new List();

Schickt man diese Zeile jedoch durch einen Java 1.5 Compiler, so erhält man einen Hinweis, wie den folgenden:

Note: xxx.java uses unchecked or unsafe operations.

Der Grund dafür ist, dass angegeben werden sollte, welchen Typ von Objekten die Liste enthalten wird. Die neue, korrekte Schreibweise sieht z.B. folgendermassen aus:

List<String> l = new List<String>();

Es wird eine Liste erzeugt, welche Elemente vom Typ String enthalten wird. Wird dieser Liste im Code bspw. ein Integer zugewiesen, so erhalten wir bereits beim Kompilieren einen Compiler Error. Das komplette Java Collections Framework wurde derartig umgestellt. Dadurch wird die Typsicherheit stark verbessert. Code, der vom 1.5 Compiler ohne Murren durchlaufen wird, ist auch zur Laufzeit Typsicher. Zudem spart man sich in Zukunft eine Menge Casts (vor allem zusammen mit dem neuen Autoboxing/Autounboxing). Und das ist wirklich nur die Spitze vom Eisberg. Generic Types sind ein sehr umfangreiches, neues Sprachkonstrukt, dass wohlgemerkt einen neuen Standard verkörpert. Die alte Schreibweise sollte nurnoch aus Abwärtskompatibilitätsgründen verwendet werden.

Alles Wichtige zu diesem neuen "Feature" hier:
http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

Autoboxing/Autounboxing
Dies lässt sich kurz und knapp an einem Beispiel zeigen (entnommen aus Java in a Nutshell 1.5):

Alt:
List numbers = new ArrayList();
numbers.add(new Integer(-1));
int i = ((Integer)numbers.get(0)).intValue();

Neu:
List<Integer> numbers = new ArrayList<Integer>();
numbers.add(-1); //Boxing int to Integer
int i = numbers.get(0); //Unboxing Integer to int


Enumerated Types
Ebenfalls eine umfangreiche Neuerung, wenn man ins Detail geht. Sehr grob kann man sagen Enumerated Types sind die Ablösung für static final Konstanten. Auch dieses Thema ist so umfangreich, dass ich nicht weiss wo ich anfangen soll. Ich verweise daher lieber auf folgendes Tutorial:

http://www.developertutorials.com/tutorials/java/getting-started-enumerated-types-050422/page1.html


Annotations
Annotations bieten eine Möglichkeit Programmteile mit zusätzlichen (Meta)Informationen zu versorgen.
Es gibt bisher 3 Standard Annotations:

Override: Markiert eine Methode und stellt sicher, dass diese Methode eine Methode aus der Oberklasse überschreibt. Ist dies nicht der Fall (zb weil man sich verschrieben hat) erhält man einen Compilation Error und kann diesen Fehler sofort beheben.
Beispiel: (ebenfalls aus Java in a Nutshell 1.5)

@Override
public String toSting { //Oops. Note the missspelling here!
return "[" + super.toString() + "]";

@Deprecated: Markiert eine Methode/Eigenschaft als veraltet (ähnlich zum Javadoc tag). Bei Verwendung einer so gekennzeichnete Methode erzeugt der Compiler eine "Warning". Der unterschied zum javadoc tag ist: Dieses deprecated ist für den Compiler gedacht. Im Moment warnt der Compiler auch bei vorhandenem javadoc Tag, es ist jedoch nicht klar, wann dieses Verhalten abgestellt wird. Daher sollte man beide Tags verwenden. Das Javadoc Tag für die Dokumentation, und das annotattion tag für den compiler:

/**
* Blabla
* @deprecated Old stuff
*/
@Deprecated public class Blabla { ... }


SuppressWarnings: Möchte man bestimmte Meldungen des Compilers unterdrücken, weil man zb eine externe API verwendet die nur in der Version 1.4 vorliegt und daher "unchecked" Meldungen erzeugt, so kann man dies mit dieser Annotation tun.
Beispiel:

@SuppressWarnings("unchecked")
public void ... {
// Code, der normalerweise unchecked Meldungen hervorruft
}


for|in loop
Mit Version 1.5 ist eine neue, praktische Schleife hinzugekommen:

Struktur: for(Integer i : List<Integer>) { // mach was mit i }

Gelesen wird sie folgendermaßen: for(Element in Collection). Man kann damit also bequem über Daten iterieren.

Hier gibt es alle Features im Überblick, darunter auch einige, welche hier noch nicht erwähnt wurde. Reinschauen lohnt sich.

http://java.sun.com/developer/technicalArticles/releases/j2se15langfeat/

Das soll es erstmal gewesen sein.

In Anbetracht des aktuellen Unterrichtsthemas und um hier mal wieder etwas Leben reinzubringen, habe ich ein sehr gutes Tutorial in Sachen DTDs herausgesucht. Zu erreichen unter der folgenden Adresse:

http://www.w3schools.com/dtd/

Auf w3schools.com findet man im übrigen zahllose, meiner Meinung nach gute, Tutorials in Sachen XML & co. Alles natürlich auf Englisch.

Im Kreiseditor werden die Kreise in dem Raster dargestellt, dass der Bildschirm bietet. Für die Kreise auf unseren Monitoren ist das Raster klar zu erkennen. Die Auflösung kann zwar nicht erhöht werden, aber der Übergang von "Kreis" zu "nicht Kreis" kann künstlich geglättet werden. Diese Technik wird Antialiasing genannt. Der Übergang wird quasi verwischt, was zu deutlich "runderen" Kreisen führt. In Java2D kann diese Glättung über eine Einstellung des grafischen Kontextes Graphics2D in der paint-Methode erreicht werden. Hierzu wird zunächst ein RenderingHints-Objekt erzeugt. ein RenderingHints-Objekt ist eine Map, d. h. eine Tabelle aus Schlüssel-Werte-Paaren. Die Schlüssel sind die möglichen Einstellungen für das Rendering (bspw. KEY_ANTIALIASING), und der dazugehörige Wert ist entweder VALUE_ANTIALIASING_ON oder VALUE_ANTIALIASING_OFF, alles sind Konstanten, die in der Klasse RenderingHints definiert sind. Ein RenderingHints-Objekt kann mit der Nachricht addRenderingHints an den grafischen Kontext als Einstellung übergeben werden. Ein RenderingHint versteht auch die Nachricht add(), falls mehrere Rendering-Einstellungen gesetzt werden sollen.

Graphics2D g2=(Graphics2D)...
RenderingHints hints=new
RenderingHints(RenderingHints.KEY_ANTIALIASING,Rendering
Hints.VALUE_ANTIALIAS_ON);
g2.addRenderingHints(hints);

Sollen die Kreise eine Transparenz aufweisen, d. h. sie sind durchscheinend, so ist dies über eine Einstellung des Composite-Objektes innerhalb des grafischen Kontextes zu erreichen. Das Composite-Objekt dient der Einstellung des Renderings, bei der Mischung der Farben verschiedener Objekte. Die Klasse, welche die Transparenz erzeugen kann ist ein spezielles Composite - ein AlphaComposite. Der Name stammt von dem Alpha-Wert, der die "Transparenz" von Pixeln angibt (0.0 -> unsichtbar, 1.0 -> undurchsichtig). AlphaComposite-Objekte implementieren alle Kompositionsregeln, die von T. Porter und T. Duff in "Compositing Digital Images" (SIGGRAPH 84, 253-259) veröffentlicht wurden.
Die Klasse AlphaComposite besitzt eine sog. Factory-Methode, die als statische Methode (also als Klassen-Methode) mit einem Objekt der Klasse antwortet. Die gemeinte Factory-Methode hat den Namen getInstance(...). Als Parameter wird die Kompositionsregel (hier SRC_OVER) und ein Alphawert übergeben. Ist der Alphawert kleiner als eins, so sind die gezeicheten Flächen ab sofort durchsichtig.

Graphics2D g2=(Graphics2D)...
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float)0.4));


Das Kreiseditor-Projekt ist eine fortlaufende Übung über sechs Semester. Anhand dieser Übung werden auch Themen, wie Serialization, Streams, Thread-Programmierung, RMI, Datenbanken und Web-Applikationen untersucht. die im Rahmen der Ausbildung zum Assistenten für Elektronik und Datentechnik am Lette-Verein in Berlin gelehrt werden.
Zur Veranschaulichung des Modells, das dem Kreiseditor zu Grunde liegt, hier noch einmal das Klassendiagramm. Es zeigt deutlich die Einteilung in die drei Aufgabengebiete model, view, controller.

Ich bin vor kurzem auf eine nette kleine Einführung zum Thema Model-View-Controller Konzept gestoßen, die ich euch nicht vorenthalten möchte. Vielleicht hilft sie dem einen oder anderen, der bisher im Dunkeln tappte, zu verstehen, was wir in der letzten Zeit im Praktikum mit unserem "Zeichenprogramm" angestellt haben.

Viel Spaß beim Lesen und schöne Ferien

-----------------------------------------------
Das Model-View-Controller-Konzept wird in vielen Bereichen moderner Softwareentwicklung eingesetzt und bedeutet die strikte Aufgabenverteilung bei einer Anwendung. So wird als Model die Datenquelle bezeichnet, die Daten unabhängig vom Erscheinungsbild liefert (also beispielsweise aus einer relationalen Datenbank). Die View zeigt diese Daten dann in passender Art und Weise an (z.B. als Tabelle in einer Java-Applikation) - bestimmt durch den »Look«. Wie diese View die Daten anzeigt wird nicht vom Model beeinflusst...

weiter gehts hier

Bit-Operatoren gibt es in nahezu jeder Programmiersprache und so auch in Java. Sie arbeiten mit binären Zahlen (5 ist z.B. 0101). Auch wenn man dezimale oder hexadezimale Zahlen angibt, wird immer mit den entsprechenden binären Werten gerechnet.

Folgende Operatoren stehen in Java zur Verfügung:

& (AND)
Bits die in beiden Operanden gesetzt sind, werden gesetzt. Beispiel: 0101 & 1011 => 0001

| (OR)
Bits die in einem der beiden Operanden gesetzt sind, werden gesetzt. Beispiel: 0101 | 1011 => 1111

^ (XOR)
Bits die entweder in einem oder in dem anderen Operanden gesetzt sind, werden gesetzt, aber nicht in beiden. Beispiel: 0101 ^ 1011 => 1110

<< n(Verschiebung nach links)
Verschiebung der Bits um n Stellen nach links. Dies kommt einer Multiplikation mit 2(hoch)n gleich. Beispiel: 0010 << 2 => 1000

>> n(Verschiebung nach rechts)
Verschiebung der Bits um n Stellen nach rechts. Dies kommt einer Division mit 2(hoch)n gleich. Beispiel: 1000 >> 2 => 0010

~ (Komplement-Operator)
Sämtliche Bits werden invertiert. Beispiel: ~ 00001000 => 11110111

Auch bei den Bitweisen Operatoren können die üblichen Kurzformen verwendet werden: z.B. &=, |=, ^=, <<=, >>=.

Bitweise Arithmetik wird im Wesentlichen zum Setzen und Testen einzelner Bits und Kombinationen einzelner Bits innerhalb einer Variablen benutzt (so auch bei unserem Beispielprogramm zum speichern von RGB Farbwerten in einer Integer-Variablen). Die wichtigsten Gründe zur Benutzung bitweiser Operatoren betreffen die direkte Kommunikation mit Hardwarekomponenten oder die Arbeit mit Komprimierungsprozessen bzw. Verschlüsselungsoperationen. Das wahrscheinlich wichtigste Argument ist, dass bestimmte Vorgänge bei der Arbeit auf Bitebene bezüglich der Performance verbessert werden können. So ist "8 << 3" oft geringfügig schneller als "8 * 8" allerdings geht dies auf Dauer zu lasten der Lesbarkeit des Codes und sollte daher mit Bedacht eingesetzt werden.

Quellen zum Nachlesen:
http://www.selfjava.de/java0109.htm
http://www.informit.de/books/java2_komp/data/kap07.htm
http://www.boku.ac.at/javaeinf/jein1.html

Wie der Heise Newsticker meldet, investieren die drei großen Mobilfunkanbieter T-Mobile, Vodafone sowie Orange ca. 40 Mio USD in SavaJe, den Hersteller einer unabhängigen Java-Plattform für Handys und Handhelds. Es wird vermutet, das sich die Anbieter von monopolistischen Anbietern unabhängiger machen wollen. Interessant in diesem Zusammenhang ist auch, dass etwa zur gleichen Zeit die führenden Mobilfunkbetreiber ein Standardisierungsforum gründen, das Rahmenbedingungen für Geräteanbieter sowie Softwarefirmen definieren soll.

Einleitung

Es gibt in der Programmiersprache Java Sprachkonstrukte, die ähnlich wie Klassen verfügbar sind bzw. verfügbar gemacht werden können. Diese Konstrukte heissen Interfaces (Schnittstellen)
Im Gegensatz zu Klassen sind die Methoden von Interfaces jedoch nicht ausprogrammiert (also implementiert ).
Die Methoden von Interfaces stellen nur die Signaturen von Methoden zur Verfügung.
Wer ein solches Interface benutzen will, muss daher alle Methoden des Interfaces implementieren und zwar genau nach dem Muster der Methodensignatur.
Die Benutzung von Interfaces hat den Vorteil der Vereinheitlichung von Code :

Ein Interface sieht für alle Benutzer gleich aus.

Das Interface Comparable bespielsweise bietet eine Methode mit der Signatur int compareTo(Object o); an.

Es wird aus naheliegenden Gründen von vielen Java-Klassen, für deren Objekte nämlich Vergleiche sinnvoll sind, benutzt oder wie man sagt implementiert. Z.B von Double, Integer, String .

Zur Technik

1. Soll eine Klasse ein vorhandenes Interface implementieren, so schreibt man
   
   public class Klassenname inplements Interface-Name
   
   Z. B. public class Apfel implements Comparable
2. Danach muß die entsprechende Klasse z.B. die Apfelklasse die Methode int CompareTo(Object o) implementieren.
3. Ist die Methode implementiert und man will ein Apfelobjekt erzeugen, dann sind folgende Möglichkeiten dazu gegeben:
   
   
   • Apfel a=new Apfel(1,120);
   • Comparable b=new Apfel(3,20);
4. Bei der Implementierung der Methode CompareTo(Object o) tritt jedoch ein Problem auf :
   
   Der Parameter Object o, verfügt nicht über die Eigenschaften eines Apfels: Also Gewicht( gew ) und Güteklasse gue. Dem kann jedoch dadurch abgeholfen werden, dass man das Objekt o in ein Objekt vom Typ Apfel umcastet. ((Apfel)o).gew stellt das Gewicht gew des in einen Apfel umgecasteteten Objektes o dar.
   Ein Cast ( übersetzt : Gipsverband ) hat folgende allgemeine Syntax : (Typ)Ausdruck. Ein cast führt eine expizite (vom Programm erzwungene ) Typumwandlung durch.
   Nach Anwendung eines castes stellt diese Konstruktion den Wert Ausdruck mit dem Datentyp Typ dar.
   Nach float f=(float)4/3 hat f den Wert 1.33... und nicht den Wert 0. ,welchen es ohne cast hätte.
   (float)4 hat den Datentyp float.( 4 ist int)

Vererbung ist ein Mechanismus in der objektorientierten Programmierung, bei der eine bestehende Klasse,
um zusätzliche Eigenschaften und Verhaltensweisen in Form einer neuen Klasse erweitert wird.
Die neue Klasse enthält nun zusätzlich zu ihren eigenen Attribute und Methoden auch alle Attribute und Methoden der bestehenden Klasse. Die bestehende Klasse bezeichnet man als Oberklasse oder Basisklasse und die neue Klasse
als Unterklasse oder abgeleitete Klasse. Man sagt auch die Unterklasse erbt von der Oberklasse.

Mit dem Schlüsselwort „extends“ erbt die im folgenden Beispiel dargestellte Klasse „Unter“ von der Klasse „Ober“
Um ein Objekt der Unterklasse zu erzeugen , muss auch zwingend ein Objekt der Oberklasse erzeugt werden. Dabei aktiviert der Konstruktor der Unterklasse zuerst einen Konstruktor der Oberklasse. Dies geschieht z.B. mit dem Schlüsselwort „super“

 public class Ober
 {
    //Attribute
    //Methoden
 }

 public class Unter extends Ober
 {
    super();
    //weitere Attribute
    //weitere Methoden
 }

Eine Klasse „Unter“ sollte nur von einer Klasse „Ober“ erben wenn „Unter“ auch alle Eigenschaften von „Ober“ benötigt.
Durch die Wiederverwendung bereits existierender und bewährter Klassen , die eine Software ausmachen, wird eine gewisse Zuverlässigkeit der Software garantiert.
Voraussetzung für die häufige Wiederverwendung von Klassen ist deren möglichst große Allgemeingültigkeit.

Java unterstützt einfache Vererbung, d.h. eine Unterklasse kann nur genau von einer Oberklasse erben.
Mehrfachvererbung wie z.B. in C++ ist nicht möglich, jedoch gibt es den Mechanismus der Interfaces, die ein ähnliches Verhalten ermöglichen.
Umgekehrt jedoch können von einer Oberklasse beliebig viele Unterklassen erben.

Alle Klassen erben implizit von der Klasse Object.