Felder sind implizit Serializable

Primitive Datentypen werden beim Serialisierungs-Prozess selbst in den Datenstrom geschrieben. Das gleiche gilt auch für Felder; sie sind automatisch Serializable.

Neben der Methode clone() und dem Attribut length besitzt ein Feld eine zweite wichtige Eigenschaft, die eng mit clone() verbunden ist: Ein Feld lässt sich serialisieren. Dazu muss aber ein Array-Objekt die Schnittstelle java.io.Serializable implementieren, und dies macht es auch versteckt.

Betrachten wir das folgende Programm, so erkennen wir, dass nur bei einer gültigen Referenz auf ein Feld-Objekt dieses Objekt instanceof Serializable ist.

class ArrayIsSerializable
{
  public static void main( String args[] )
  {
    int f1[] = null;
    int f2[] = new int[10];

    Serializable s = (Serializable)f1;

    System.out.println( s );   // null

    boolean b1 = f1 instanceof Serializable;
    boolean b2 = f2 instanceof Serializable;

    System.out.println( b1 );  // false
    System.out.println( b2 );  // true
  }
}

Die abstrakten Basisklassen für Container

Das Designprinzip der Collection-Klassen folgt drei Stufen:

  • Schnittstellen legen Gruppen von Operationen für die verschiedenen Behältertypen fest.
  • Abstrakte Basisklassen führen die Operationen der Schnittstellen auf eine minimale Zahl von als abstrakt deklarierten Grundoperationen zurück, etwa addAll() auf add() oder isEmpty() auf getSize().
  • Konkrete Klassen für bestimmte Behältertypen beerben die entsprechende abstrakte Basisklasse und ergänzen die unbedingt erforderlichen Grundoperationen (und einige die Performance steigernde Abkürzungen gegenüber der allgemeinen Lösung in der Oberklasse).

Es gibt eine Reihe von abstrakten Basisklassen, die den Containern eine Basisfunktionalität geben. Unter ihnen sind:

AbstractCollection

Implementiert die Methoden der Schnittstelle Collection ohne iterator() und size(). AbstractCollection ist Basisklasse von AbstractList und AbstractSet.

AbstractList

Erweitert AbstractCollection und implementiert die Schnittstelle List. Für eine konkrete Klasse müssen lediglich Methoden für get(int index) und size() implementiert werden. Soll die Liste auch Elemente aufnehmen, sollte sie auch set(int index, Object element) implementieren. Andernfalls bewirkt das Einfügen von Elementen nur eine Unsupported OperationException. Die direkten Unterklassen sind AbstractSequentialList, ArrayList und Vector.

AbstractSequentialList

AbstractSequentialList erweitert AbstractList (und damit auch AbstractCollection) und bildet die Grundlage für die Klasse LinkedList. Im Gegensatz zur konkreten Klasse ArrayList bereitet AbstractSequentialList die Klasse LinkedList darauf vor, die Elemente in einer Liste zu verwalten und nicht wie ArrayList in einem internen Array.

AbstractSet

Erweitert AbstractCollection und implementiert die Schnittstelle Set. Die Klasse AbstractSet dient als Basis für die beiden Klassen HashSet und TreeSet. Es überschreibt auch keine Methoden der Oberklasse AbstractCollection, sondern fügt nur die Methode equals(Object) und hashCode() hinzu.

AbstractMap

Implementiert die Schnittstelle Map. Um eine konkrete Unterklasse zu erstellen, muss put() sinnvoll implementiert werden; ohne Überschriebenes put() folgt eine UnsupportedOperationException. Für get(Object) gibt es eine Standard-Implementierung.

Das Wissen um diese Basisimplementierung ist nützlich, wenn eigene Datenstrukturen implementiert werden. Das passiert selten, findet man aber etwa bei Google Guava.

Absolute Koordinaten einer Gui-Komponente

Um die absoluten Koordinaten des Elements am Bildschirm zu bestimmen, können wir folgende Idee einsetzen: Zunächst bestimmen wir die Koordinaten des Elements relativ zum Fenster. Sie sollen in den Variablen x und y stehen. Dann hangeln wir uns von der aktuellen Komponente bis zum aktuellen Fenster durch und fragen das Frame-Objekt über getLocation() nach der absoluten Position. Die Fenster-Koordinaten addieren wir zu den relativen Komponenten-Koordinaten, um die absoluten Koordinaten zu erhalten.

Component c = this;
while ( (c = c.getParent()) != null )
if ( c instanceof JFrame )
break;
if ( c != null )
{
  Point p = ((JFrame) c).getLocation();
  x += p.x;
  y += p.y;
}

Die Methode SwingUtilities.getWindowAncestor(Component) läuft für eine gegebene Komponente selbständig hoch und liefert das Window-Objekt oder null. Um einem Fenster ein Ereignis zum Schließen zu schicken, schreiben wir einfach:

Window w = SwingUtilities.getWindowAncestor( c );
w.dispatchEvent( new WindowEvent(w, WindowEvent.WINDOW_CLOSING) );

Java EE-Beispiele von Apache TomEE

Siehe https://tomee.apache.org/examples-trunk/index.html:

Session Beans
EntityManagers
  • injection-of-entitymanager *
  • jpa-eclipselink
  • jpa-hibernate
  • jpa-enumerated *
  • CDI
    EJB
  • access-timeout *
  • async-methods *
  • schedule-expression *
  • schedule-methods
  • interceptors
  • async-postconstruct
  • REST
  • simple-rest
  • rest-example
  • rest-example-with-application
  • rest-on-ejb
  • rest-xml-json
  • Web Services
  • simple-webservice *
  • webservice-handlerchain *
  • webservice-holder *
  • webservice-attachments
  • webservice-inheritance
  • webservice-security
  • webservice-ws-security
  • JMS and MDBs
  • injection-of-connectionfactory
  • simple-mdb-with-descriptor
  • simple-mdb *
  • Transactions
  • testing-transactions
  • transaction-rollback
  • applicationexception
  • Security
  • testing-security-3
  • testing-security-2
  • testing-security
  • DataSources
  • injection-of-datasource
  • datasource-ciphered-password *
  • dynamic-datasource-routing *
  • resources-declared-in-webapp
  • Referencing EJBs
  • injection-of-ejbs *
  • lookup-of-ejbs-with-descriptor
  • lookup-of-ejbs
  • Environment Entries
  • injection-of-env-entry
  • custom-injection
  • Java EE Connectors
  • quartz-app *
  • Testing Techniques
  • alternate-descriptors *
  • application-composer *
  • testcase-injection
  • ear-testing *
  • Frameworks
  • spring-integration
  • spring-data-proxy
  • struts
  • Meta-Annotations
  • access-timeout-meta *
  • schedule-methods-meta
  • testing-security-meta
  • movies-complete-meta
  • movies-complete
  • Proxy Beans
  • dynamic-dao-implementation *
  • dynamic-implementation
  • dynamic-proxy-to-access-mbean
  • spring-data-proxy
  • EJB Legacy
    Other Features
  • mbean-auto-registration *
  • bean-validation-design-by-contract *
  • telephone-stateful *
  • troubleshooting
  • Misc
  • applet
  • ejb-examples
  • ejb-webservice
  • jsf-cdi-and-ejb
  • jsf-managedBean-and-ejb
  • moviefun
  • helloworld-weblogic
  • polling-parent
  • Google Annotations Gallery: Immer wieder ein Schmunzler

    Siehe https://code.google.com/p/gag/:

    Disclaimer

    • @AhaMoment
    • @BossMadeMeDoIt
    • @HandsOff
    • @IAmAwesome
    • @LegacySucks

    Enforceable

    • @CantTouchThis
    • @ImaLetYouFinishBut

    Literary Verse (new subcategory)

    • @Burma Shave
    • @Clerihew
    • @DoubleDactyl
    • @Haiku (moved to this subcategory)
    • @Limerick
    • @Sonnet

    Remarks

    • @Fail
    • @OhNoYouDidnt
    • @RTFM
    • @Win

    Team (new category)

    • @Blame
    • @Channeling
    • @Fired
    • @HonorableMention
    • @Visionary

    JMapViewer, einfache Komponenten für OpenStreepMap Karte

    Siehe http://wiki.openstreetmap.org/wiki/JMapViewer.

    • Provides integrated zoom controls (slider and buttons) in the left upper corner (can be hidden)
    • Switch between different tile sources: Mapnik, Tiles@Home, Cyclemap, … (other tiled maps can be used, too)
    • Configurable in-memory and file-based caching of loaded map tiles
    • A list of map markers (the yellow circles in the screenshot) can be added. Map markers of different shape can be easily added by implementing the MapMarker interface.
    • Configurable/Extentable/Replaceable controller (code part that manages mouse interaction and how the map reacts to it)
    • Requirement: Java 1.6
    • License: GPL

     

    JMapViewer demo app screenshot

    Apache ODF Toolkit in Release 0.6

    Aus dem Changelog https://www.apache.org/dist/incubator/odftoolkit/CHANGES-0.6-incubating.txt:

    * Added document encryption support

    * Added metadata support

    * Support for OpenDocument-v1.2

    * Additional APIs for Simple API

    Zum Projekt selbst sagt die Homepage:

    The Apache ODF Toolkit is a set of Java modules that allow programmatic creation, scanning and manipulation of Open Document Format (ISO/IEC 26300 == ODF) documents. Unlike other approaches which rely on runtime manipulation of heavy-weight editors via an automation interface, the ODF Toolkit is lightweight and ideal for server use.

    Dokumente sind leicht erstellt, siehe https://incubator.apache.org/odftoolkit/simple/gettingstartguide.html:

    import java.net.URI;
    
    import org.odftoolkit.simple.TextDocument;
    import org.odftoolkit.simple.table.Cell;
    import org.odftoolkit.simple.table.Table;
    import org.odftoolkit.simple.text.list.List;
    
    public class HelloWorld {
        public static void main(String[] args) {
            TextDocument outputOdt;
            try {
                outputOdt = TextDocument.newTextDocument();
    
                // add image
                outputOdt.newImage(new URI("odf-logo.png"));
    
                // add paragraph
                outputOdt.addParagraph("Hello World, Hello Simple ODF!");
    
                // add list
                outputOdt.addParagraph("The following is a list.");
                List list = outputOdt.addList();
                String[] items = {"item1", "item2", "item3"};
                list.addItems(items);
    
                // add table
                Table table = outputOdt.addTable(2, 2);
                Cell cell = table.getCellByPosition(0, 0);
                cell.setStringValue("Hello World!");
    
                outputOdt.save("HelloWorld.odt");
            } catch (Exception e) {
                System.err.println("ERROR: unable to create output file.");
            }
        }
    }

    UML-Diagramme mit ObjectAid für Eclipse

    Von http://www.objectaid.com/:

    The ObjectAid UML Explorer is an agile and lightweight code visualization tool for the Eclipse IDE. It shows your Java source code and libraries in live UML class and sequence diagrams that automatically update as your code changes. The image below is a class diagram of actual source code; click on it to see the editor in the Eclipse Java Perspective

    Ein kleines HOWTO unter http://fuzz-box.blogspot.de/2012/09/how-to-generate-uml-diagrams-from-java.html?m=1.