Java

Links und Literatur

• Java ist auch eine Insel
• Java in 21 Tagen
• Handbuch der Java-Programmierung
• Angelika Langer: JAVA
• Java Classpath
• Effective Java von Joshua Bloch

Java Aufruf

Java mit mehr Speicher starten

java -Xmx512m

Bestimmte Java Version erzwingen

java -version:1.4

Java Programm compilieren und ausführen

Achtung, das Trennzeichen unter Windows ist nicht ":" sondern ";".

So erzeugt man aus einer .java Datei eine .class Datei

javac -classpath "foo/bar.jar:foo/tests.jar:../foo.jar" MyClass.java

Dabei muss man alle jar Dateien angeben, die direkt von der Klasse genutzt werden (also nicht die, die nur von Klassen genutzt werden, die wir aufrufen).

So erzeugt man jar Dateien

jar cf MyJar.jar MyClass.java

Siehe auch die JAR Dateien erzeugen Anleitung.

So führt man das Java Programm dann aus (jetzt muss man wirklich all jars auflisten die zur Ausführung gebraucht werden)

# java -classpath "foo/bar.jar:foo/tests.jar:../foo.jar:../misc.jar" MyClass

Java debuggen

So kann man auf einem entfernten Rechner Java so starten, dass es im lokalen Debugger untersucht werden kann

java -Xdebug -Xrunjdwp:transport=dt_socket,address=8787,server=y,suspend=n ...

Dabei sorgt

suspend=y

dafür, dass das Programm erst losläuft, wenn der Debugger verbunden ist.
Um den Debugger einzurichten, in Eclipse

open debug digalog
 remote java application
  new
   Rechnername und Port des Java Programms

Kleines Beispiel

Ein Interface, darf nur abstrakte Methoden und Konstanten enthalten

/**
 *  My Interface
 */
package mypackage;

/**
 * @author John Doe
 *
 */
public interface MyInterface
{

 /**
  * @param number The number which is added
  * @return The new sum
  */
 public double add(final int number);

 /**
   * The limit for the result after the mathematical operations
   */
 final static double maxValue=10000;
}

Eine abtrakte Klasse, enthält mindestens eine abstrakte Methode

/**
 * An abstract class which will be used for things which are
 * not allowed in an Interface
 */package mypackage;

/**
 * @author John Doe
 *
 */
public abstract class MyAbstractClass
{

  /**
   * Constructor
   */
  public MyAbstractClass()
  {
    this.value=0;
  }
  
  /**
   * This is the current value which will be modified by the 
   * mathematical operations which are offered 
   */
  protected double value;

}

Eine normale Klasse, darf höchsten von einer anderen Klasse erben, aber von beliebig vielen Interfaces implementieren.

/**
 * This class shows that you can implement multiple Interfaces
 */
package mypackage;

/**
 * @author John Doe
 *
 */
public class MyClass extends MyAbstractClass
                     implements	MyInterface, MyOtherInterface
{

	/* (non-Javadoc)
	 * @see mypackage.MyInterface#add(int)
	 */
	public double add(final int number)
        {
		System.out.println("The maxvalue is " + AdderInterface.maxValue);
		double res=this.value+=number;
		this.value=res;
		return res;
	}
}

Variablen

Type	Größe	Von bis
boolean	1
char	2
byte	1	-128...127
short	2	-32768...32767
int	4	-2147483648 ... 2147483647
long	8	-9223372036854775808...9223372036854775807
float	4	1,40239846 * 10^-45 ... 3,40282347 * 10^38
double	8	4,94065645841246544 * 10^-324 ... 1,79769131486231570 * 10^308

Autoboxing

int i     = 4711;
Integer j = i; // j = Integer.valueOf(i)
int k     = j; // k = j.intValue()

instanceof

String str = "HELLO WORLD";
b = ( str instanceof String );  // (1)
b = ( str instanceof Object );  // (2)
b = ( str instanceof Foo );     // (3)

(1) und (2) sind beide wahr, (3) nicht

Gleichheit

int x,y;
Foo a, b;

x==y // (1)

a==b // (2)

a.equals(b); (3)

(1) Bei Basistypen ein normaler Test auf Gleichheit
(2) Ansonsten Test ob beides eine Referenz auf das gleiche Objekt ist
(3) Inhaltliche Gleichheit mit equals() testen

Wenn man equals nicht selbst implementiert sieht es so aus:
und equals selbst implementieren, default ist das:

public boolean equals( Object obj ) 
{ 
  return ( this == obj ); 
}

Eine mögliche Implementierung:

public boolean equals( Object obj ) 
{ 
  if ( obj instanceof Foo ) { 
    Foo tmp = (Foo) obj; 
    return (bar == tmp.bar) 
  } 
  return super.equals( obj ); 
}

Als Parameter aber Object erwarten und nicht die Klasse für die die Methode gedacht ist. Also nicht:

//public boolean equals(Foo fooObj) {...};

Achtung, wenn man equals ändert, darauf achten, dass aus a.equals(b) auch a.hashcode()==b.hashcode() folgen muss (umgekehrt aber nicht).
Eclipse kann für equals() und hashcode() sinnvolle Vorschläge machen.

Achtung, die Reihenfolge beim equals() Vergleich ist z.B. dann relevant, wenn einer der beiden Objekte null werden kann.
Ist z.B. a potentiell null, b hingegen nicht, kann man das equals von a natürlich nicht aufrufen

// a.equals(b);
b.equals(a);

Können beide null sein, diesen Fall vorher extra abfangen (sonst gibt es eine Exception wenn versucht wird equals auf null aufzurufen).

Conditional Expressions

Kurzschreibweise für bedingte Zuweisung

//if(ungerade) max=l; else max=l-1;
int max=(ungerade) ? l : l-1;

Kurzschlußoperatoren

boolean b1 = true || foo(); // (1)
boolean b2 = true | foo(); // (2)
boolean b3 = false & foo(); // (3)

(1) foo() wird nicht aufgerufen
(2) foo() wird aufgerufen
(3) foo() wird aufgerufen

Arrays

int i[];   // == int [] i;
Foo[] x;

int i[][]; // == int [][] i == int[] i[]  
int[] i, x[], y; // == int [] i; int [][]x; int[] y;

int[] prim = { 5, 7, 7 + 4, };

Array mit vorgegebener Größe:

// int hundredElements[ 100 ];  <-- ERROR
int[] hundredElements; 
hunderdElements = new int[ 100 ];

int[] prim;
prim = new int[]{ 5, 7, 11, };

Arraygröße

System.out.println( hunderedElements.length );

Mehrdimensionale Arrays

Rechteckiges Array

int i[][]=new int[3][4];

Beliebiges mehrdimensionales Array

int i[][]=new int[3][];
i[0]=new int[7];
i[1]=new int[19];
i[2]=new int[2];
i[3]=new int[100];

Anonyme Arrays

foo( new double[]{ 1.1, 2,5, 3.2 } );

Arrays durchlaufen

double sum = 0;
double[] myarray;
List<Double> mylist=new LinkedList<Double>();

// (1)
for ( int i = 0; i < myarray.length; i++ )
{
 sum += myarray[i];
}

// (1b)
for ( double n : mylist )
{
 sum += n;
}

// (2)
for (ListIterator<Double> i = mylist.listIterator(); i.hasNext(); )
{
 sum+=i.next();
}

// (2b)
for ( double n : myarray )
{
 sum += n;
}

(1) Normaler Array Durchlauf
(1b) Kurzschreibweise für (1)
(2) Durchlauf eines Containers mit einem Iterator
(2b) Kurzschreibweise für (2). Man verliert aber den Vorteil gegebenfalls einen Iterator zur Hand zu haben (z.B. zum Löschen von Elementen).

Unnötige Methodenaufrufe in for Schleifen sparen
Häufig sehen for Schleifen so aus

for(int a=0; a<getMaxA(); a++)

Wenn sich der Rückgabewerte der Methode aber für die Dauer des Schleifendurchlaufes nicht ändert und die Methode eine nennenswerte Laufzeit hat, kann man die Schleife über eine weitere Variable deutlich beschleunigen

for(int a, int b=getMaxFoo();
    a<b;
    a++);

Teile eines Arrays in einen anderen Array oder in sich selbst kopieren

static void arraycopy( Object src, int srcPos, Object dest, int destPos, int length );

int[] y = Arrays.copyOfRange( x, 6, 9 );

Einen Array in einen Vector wandeln

So kann man einen String Array in einen String Vector wandeln

String [] myArray;
...
Vector<String> myVector = new Vector<String>(Arrays.asList(myArray));

Array Vergleichen

Arrays.equals( a1, a2 ) );   // (1)
Arrays.deepEquals( a1, a2 ); // (2)

// (1) Referenzen der Elemente im Array müssen gleich sein
// (2) Inhalt muss gleich sein // (2)

Undefinierte Parameter Anzahl

Methoden können eine undefinierte Anzahl an Parametern erwarten, ansprechbar wie ein Array

int max( int... x)
{
 System.out.println(x.lenght);
}

Clone

Foo x,y;
x=new Foo();
y=x.clone();

Flache Kopie von Objekten erzeugen:

Überdeckte Namen

void foo(int x)
  {
   x = 12;              // (1)
   this.x = 12;         // (2)
   this.x=x;
 }

(1) Zuweisung an lokale Variable x
(2) Zuweisung an Objektvariable x

enum

public enum Weekday
{ 
  MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY 
}

Der Zugriff erfolgt so:

Weekday.MONDAY

In den case Statements einer switch Anweisung dagegen so:

MONDAY

Über Enums kann man iterieren

for (Tag tag:Weekday.values()) { }

Override

Optional erklären dass man eine Methode des Vaters überschreibt (Fehler falls nicht)

@Override
public void foo( int alter )

Konstruktor

Anderen Konstruktor der eigenen Klasse aufrufen

this(5);

muss die erste Anweisung des Konstruktors sein, keine Objektvariablen übergebbar

Wenn man eine Klasse hat, von der es nur wenige Ausprägungen gibt, wie z.B. Boolean.
Dann macht es oft keinen Sinn, dass man mit new beliebig viele verschiedene Objekte dieser Klasse erzeugen kann. Eine besser Variante ist es dann, statt einem Konstruktor eine valueOf() Methode anzubieten

public static valueOf(boolean b)

Diese liefert dann immer wieder die wenigen Objekte zurück die es geben kann, hier z.B. entweder Boolean.TRUE oder Boolean.FALSE. Es darf dann natürlich keine Methode geben, ob den Wert eines solchen Objektes zu verändern, weil sonst auch alle anderen Nutzer dieses Objektes davon betroffen wären.

Exemplarinitialisierern

Initialisieren von Variablen in allen Konstruktoren

class Foo
{ 
  int j=1; // (1) 

  Foo()
  {
   this.k=0;
  }

  Foo( int i ) 
  { 
    this.k = j; 
  }
}

entspricht

class Foo
{ 
  int j;        // (1)
 
  Foo()
  {
   this.j=1;    // (1)
   this.k=0;
  }
  Foo( int i ) 
  { 
    this.j = 1; // (1)
    this.k = i; 
  } 
}

Bei statischen Variablen

public class Foo
{ 
  static int x = 2; 
}

entspricht

public class InitStaticVariable 
{ 
  static int x; 
  static 
  { 
    x = 2; 
  } 
}

Super

Konstruktor des Vaters aufrufen

super(5);

Methode des Vaters aufrufen

@Override
public void foo( int alter ) {
 super.foo(); 
 ...
}

final

Variable nicht änderbar (wohl aber Methoden aufrufbar die sie ändern)

final int x=3;
final Foo y=new Foo();
y.reset();

Erben nicht möglich

final class Bar
{ 
 // ...
}

Überschreiben nicht möglich

class Foo
{
 final void bar();
}

Innere Klassen

class Foo
{ 
  class Bar
  { 
  }
}

Zum Erzeugen eines Objekts der inneren Klasse, braucht man ein Objekt der äußeren Klasse. Versucht man z.B. in einer statischen Methode der äußeren Klasse ein Objekt der inneren Klasse zu erzeugen würde das fehlschlagen

No enclosing instance of type foo is accessible. Must qualify the allocation with an enclosing instance of type foo (e.g. x.new Bar() where x is an instance of foo).

Nur innere Klassen dürfen Private oder Protected sein. Wenn sie es sind, hat es Einfluss darauf, wer sie benutzen darf.

Statische Klasse

public class Foo
{ 
  static String s = "HELLO WORLD"; 
  int i = 1;
 
  static class Bar
  { 
    void test() 
    { 
      System.out.println(s); 
      // System.out.println( i ); // (1) 
    } 
  }
}

Mitglieds- oder Elementklassen

public class Foo
{ 
  String s = "Hello World"; 
 
  class Bar
  { 
    void test1() 
    {
      System.out.println( s ); 
    }

    //static void test2()  {  }   // (2)
  } 
}

Von aussen erzeugen

Foo a = new Foo();
Bar b = a.new Bar();

Lokale Klassen

public class Foo
{ 
  public static void main( String[] args ) 
  { 
    int i = 1; 
    final int j = 2; 
 
    class Bar
    { 
      Bar() { 
        System.out.println( j ); 
        //System.out.println( i );    // (3) Fehler, da i nicht final 
      } 
    } 
    new Bar(); 
  } 
}

Anonyme innere Klassen

Anonyme innere Klassen erben entweder von einer anderen Klasse oder implementieren eine Schnittstelle

class Foo()
{
 // ...
}

interface Bar()
{
 // ...
}

class Blub{}
{
 new Foo()
 {
  ...
 }
 new Bar()
 {
  ...
 }
}

Generische Datentypen

class Foo<T>
{ 
  private T val; 
 
  void setValue( T val ) 
  { 
    this.val = val; 
  } 
 
  T getValue() 
  { 
    return val; 
  } 
}

Foo<String>  stringFoo = new Foo<String>(); 
Foo<Integer> intFoo    = new Foo<Integer>(); 
Foo<Point>   pointFoo  = new Foo<Point>();

class Bar
{
  public static <T> T myMethod( T a, T b )
  {
   //...
  }
}

Comparable

Wenn man Comparable implementiert ist es oft sehr störend, dass man dann als Parameter jede beliebige andere Klasse akzeptieren muss. So kann man es nur für eine Bestimmte Klasse implementieren

public class Foo implements Comparable<Foo>
{
    public int compareTo(Foo pOther)
    {
    }
 }

Javadoc

/**
* @see  Bar
* @link Bar
* @version 1.01
* @author John Doe
* @param x A number
* @param y Another number
* @return This method always returns 5
* @exception NumberFormatException
* @throws    NumberFormatException
* @category Setter
* @deprecated Since yesterday
*/
public int foo(int x, float y)
{
  return 5;
}

Exceptions

try
 { 
  // ...
  return 5;
 } 
 catch ( Exception e )
 { 
  System.err.println( "Error");
 } 
 finally 
 { 
  ... // (1)
  // return 7; (2)
 }

(1) auf jeden Fall, auch nach dem return
(2) keine Exception kann nach oben durchgereicht werden

Eigene Exceptions

public class ClubException extends RuntimeException
{
  public ClubException()
  {
  }

  public ClubException( String s )
  {
    super( s );
  }
}

Stacktrace

kill -3 PID
jstack PID;
Thread.dumpStack();

Assert

Sicherstellen dass die gegebene Bedingung erfüllt ist

assert(i>0);

Überwachung der Assertions aktivieren

java -enableassertions      foo
java -enableassertions:bar foo

Multithreading

Erste Variante

Von der Klasse

Thread

erben und die Methode run überschreiben.

public class Foo extends Thread
{
 @Override
 public void run()
 {
  // ...
 }
}

Jetzt einfach ein Objekt dieser Klasse erzeugen und die Methode

start()

und nicht

run()

aufrufen.

final int nrOfThreads=4;
Foo [] f=new Foo[nrOfThreads];
for(int i=0; i<nrOfThreads; i++)
{
 f[i]=new Foo();
 f[i].start();
}

Zweite Variante

Das Interface

Runnable

implementieren

public class Bar implements Runnable
{
 public void run()
 {
 // ...
 }
}

final int nrOfThreads=4;
Thread [] f=new Thread[nrOfThreads];
for(int i=0; i<nrOfThreads; i++)
{
 f[i]=new Thread(new Bar());
 f[i].start();
}

Auf das Ende eines Threads warten

try
{
 for(int i=0; i<nrOfThreads; i++) f[i].join();
}
catch (InterruptedException e) {};

Normalerweise läuft ein Programm so lange weiter, bis auch der letzte Thread sich beendet hat. Ruft man auf einem Thread die Methode

setDaemon(true);

auf, wird auf das Ende dieses Threads nicht mehr gewartet.

Threads von außen beenden

Um einen Thread von außen beenden zu können, ist es hilfreich, wenn dieser auf

!isInterrupted()

testet und

InterruptedException

Exceptions fängt und dann selbst

interrrupt()

aufruft. Z.B.

while (!isInterrupted())
 {
   try
   {

...

   }
   catch ( InterruptedException e )
   {
    interrupt();
   }
 }

Jetzt kann man den Thread von außen mit

interrupt()

beenden.

Synchronized

Methode darf nur von einem Thread gleichzeitig betreten werden

public class Foo
{
 synchronized public static void bar()
 {
  // ...
 }
}

Pro Objekt darf Methode nur von einem Thread gleichzeitig betreten werden

public class Foo
{
 synchronized public void bar()
 {
  // ...
 }
}

Entspricht

public class Foo
{
 public void bar()
 {
  synchronized(this)
  {
   // ...
  }
 }
}

Alternative:

lock.lock();
// ...
lock.unlock();

ThreadLocal

Variablen auf die nur der entsprechenden Thread Zugriff hat (auf private Attribute hätte alle Objekte der entsprechenden Klasse Zugriff).

ThreadLocal foo = new ThreadLocal()
{
 protected int bar()
 {
  return 5;
 }
};

Datencontainer

Entweder für beliebige Objekte

Collection c = new LinkedList(); 
c.add("Hello");
c.add("World");
for ( Object x : c ) System.out.println( x );

Oder für spezielle

Collection<String> c = new LinkedList<String>();
for ( String x : c ) System.out.println( x );

Listen

ArrayList, LinkedList

Mengen

HashSet, TreeSet, LinkedHashSet

Assoziativspeicher

HashMap, TreeMap, LinkedHashMap, WeakHashMap

• man hat ein Object O
• und einen Key K
• Von dem Key K gibt es ein H(K)

Die HashMap fügt im Hash dann unter H(K) alle Objekte O ein. Es kann mehrere Objekte O geben, die den gleichen Wert für H(K) haben, aber unterschiedliche Werte für K. Ist auch K gleich, wird der vorherige Eintrag überschrieben.
Für die Klasse Integer gilt z.B. H(K)=K, das muss aber nicht so sein.

Queue

LinkedList, ArrayBlockingQueue, PriorityQueue

Sortieren von Datencontainern

So kann man eine Collection sortieren lassen:

List<Foo> myList;
Collections.sort(myList);

Comparator myComparator=new MyFooComparator();
Collections.sort(myList, myComparator);

Im ersten Fall muss Foo Comparable implementieren, im zweiten Fall kann man seine(n) eigenen Comparator(en) schreiben.
Die Sortierung arbeitet direkt auf dem Container selbst, gegenfalls vorher klonen.

Bei Sortieren kann man leicht das Problem bekommen, dass man zwei Elemente a, b hat, die nicht gleich sind (!a.equals(b)). Allerdings könnten beide Objekte bezüglich einer Sortierung weder kleiner noch größer sein. Beispielsweise bei der Sortierung von Personen nach Schuhgröße. a und b können ganz verschiedene Menschen sein und dennoch genau die selbe Schuhegröße haben. In diesem Fall muss man besonders mit einem TreeSet Container aufpassen. Dieser speichert jedes Objekt höchstens ein mal und aus a.compareTo(b)==0 schließt er (fälschlicherweise?) nur eines der beiden Objekte muss im Container gespeichert werden. Lösung: compareTo() auf mehr Attribute ansetzten oder statt TreeSet eine andere Datenstruktur benutzen (TreeBag?)

Dateien und Verzeichnisse

Dateien und Verzeichnisse

Datum

Zahlreiche Methoden der Date Objekte sind seit einiger Zeit deprecated. Mit der Hilfe der Calendar Klasse kann man weiterhin auf die entsprechenden Datumsfelder zugreifen:

Date lCurrentDate=new Date();
Calendar lCal=Calendar.getInstance();
lCal.setTime(lCurrentDate);
lCal.get(Calendar.YEAR);
lCal.get(Calendar.MONTH);
lCal.get(Calendar.DAY_OF_MONTH);

Und entsprechend lässt sich das Datum auch manipulieren

Calendar lToday = new GregorianCalendar();
lToday.set(Calendar.HOUR_OF_DAY, 23);
lToday.set(Calendar.MINUTE, 59);
lToday.set(Calendar.MINUTE, 0);
lToday.set(Calendar.SECOND, 0);
lToday.set(Calendar.MILLISECOND, 0);
Date lNewDate=lToday.getTime();

Möchte man von einem gegeben Datum einige Tage abziehen oder addieren geht das so

Calendar calendar = new GregorianCalendar();
calendar.add(Calendar.DAY_OF_MONTH, -14);
Date lNewDate=calendar.getTime();

Reflection

Class c=null;
try
{
  c = Class.forName("foo");
} catch (ClassNotFoundException ex)
{
  // ...
}

• Java ist auch eine Insel: Reflection
• IBM: Reflection

Apache Commons/

Nützliche Java Komponenten Apache Commons.

Objekte in Strings umwandeln

ToStringBuilder

ToStringBuilder.reflectionToString(this);

new ToStringBuilder(this).append("Name: ", name).append("ID: ", id).toString();

one-jar

Mit one-jar kann man mehrere jars in ein großes jar packen und über one-jar selbststartend machen.

JAD Decompiler

Mit dem JAD Java Decompiler aus class-Dateien wieder lesbaren Quellcode machen. Mit dem Eclipse Plugin JADClipse sogar vollautomatisch öffnen der entsprechenden Klassen.

String in Zahl konvertieren

Integer.parseInt("042", 10);

BigDecimal

Ein BigDecimal erzeugen

BigDecimal x=new BigDecimal("1.123456789");

Ein BigDecimal runden

BigDecimal y=x.setScale(2, BigDecimal.ROUND_HALF_UP);

(x bleibt dabei unverändert)

Mit BigDecimal teilen

BigDecimal a=new BigDecimal("1").setScale(0);
BigDecimal b=new BigDecimal("1.2345");
BigDecimal r=a.divide(b, RoundingMode.HALF_UP);

Achtung, die Genauigkeit beim Teilen zweier BigDecimal wird durch das Objekt festgelegt, dessen divide Methode aufgerufen wird. Das kann zu überraschenden Ergebnissen führen! Daher überlegen, die Genauigkeit beim Teilen anzugeben

BigDecimal r=a.divide(b, 7, RoundingMode.HALF_UP);

Gibt man beim teilen zweier BigDecimal Zahlen keine Roundsart an, und passt das Ergebnis nicht in ein BigDecimal (z.B. 1/3), gibt es eine Exception

java.lang.ArithmeticException: Non-terminating decimal expansion; noexact representable decimal result.

Deshalb beim Teilen immer eine Rundungsart angeben!

JMX

• Java Management Extensions
• Monitoring and Management Using JMX

jconsole

Kleine Java Tools

jvisualvm

OutOfMemoryError: Java heap space

Als erstes den Heap Speicher hochsetzen

-Xmx512m

Falls das nicht hilft, aktuellen heap Speicherverbrauch des Programms mit der genannten PID ausgeben

jmap -histo PID

Oder aber abwarten bis es nicht mehr gereicht hat und dann erst auswerten

# java -XX:+HeapDumpOnOutOfMemoryError -jar foo.jar
java.lang.OutOfMemoryError: Java heap space
Dumping heap to java_pid29731.hprof ...
Heap dump file created [1271286324 bytes in 143.266 secs]
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
...

Und die Datei dann auswerten

jhat -J-Xmx512m java_pid29731.hprof
...
Started HTTP server on port 7000

Swing

Links

• Java ist eine Insel: Swing
• Swing: A Quick Tutorial for AWT Programmers
• Java Swing Tutorial
• The Java Tutorials: Using Swing Components
• Wikipedia: Swing
• The Guidebook: Swing
• Java Tutorials
  • 14 - GUI Case Studies
  • 13 - Designing Swing GUIs
  • 11 - Intermediate Swing
  • 10 - GUI Swing Widgets

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

/**
 * @see <a href="http://java.sun.com/docs/books/tutorial/uiswing/learn/example2.html">Swing Tutorial</a>
 */
public class MySwingApplication implements ActionListener
{
    private static String labelPrefix = "Number of button clicks: ";
    private int numClicks = 0;
    final JLabel label = new JLabel(labelPrefix + "0    ");

    public Component createComponents()
    {
        JButton button = new JButton("Hit me!");
        button.setMnemonic(KeyEvent.VK_I);
        button.addActionListener(this);
        label.setLabelFor(button);

        JPanel pane = new JPanel(new GridLayout(0, 1));
        pane.add(button);
        pane.add(label);
        pane.setBorder(BorderFactory.createEmptyBorder(
                                        30, //top
                                        30, //left
                                        10, //bottom
                                        30) //right
                                        );

        return pane;
    }

    public void actionPerformed(ActionEvent e) {
        numClicks++;
        label.setText(labelPrefix + numClicks);
    }

    private static void initLookAndFeel()
    {
        String lookAndFeel = null;

        lookAndFeel = "com.sun.java.swing.plaf.gtk.GTKLookAndFeel";
        try
        {
        	UIManager.setLookAndFeel(lookAndFeel);
        }
        catch (Exception e)
        {
        	System.err.println("Couldn't get specified look and feel");
        }
    }

    private static void createAndShowGUI() {
        initLookAndFeel();
        JFrame.setDefaultLookAndFeelDecorated(true);
        JFrame frame = new JFrame("My Swing Application");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        MySwingApplication app = new MySwingApplication();
        Component contents = app.createComponents();
        frame.getContentPane().add(contents, BorderLayout.CENTER);

        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI();
            }
        });
    }
}

Java in Internetseiten

Java Applet

Java wird beim Client ausgeführt
Sun Java Applet Tutorial

import javax.swing.JApplet;
import java.awt.Graphics;

public class HelloWorld extends JApplet
{
 private static final long serialVersionUID = 1L;

 public void init() {};

 public void start() {};	
 public void stop() {};
 
 public void paint(Graphics g)
 {
  g.drawRect(20, 20, getSize().width - 40, getSize().height - 40);
  g.drawString("Hello world!", 40, 40);
 }

 public void destroy() {};

}

Wird so in HTML eingebettet

<applet width=300 height=300 code="HelloWorld.class"> </applet>

JavaServer Pages und Servlets

Java wird auf dem Server ausgeführt
JavaServer Pages und Servlets

Verteilte Programmierung mit RMI und WebServices

Verteilte Programmierung mit RMI und WebServices

junit

• junit
• junit Schnelleinführung

Man erzeugt eine neue Klasse, in der mit @Test markierte Methoden einzelne Tests ausführen

import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;

public class MyCTestClass
{
  @Before
  public void Myinit()
  {
   ...
  }

  @Test
  public void TestAddMethod()
  {
  	assertTrue(a.add(ZERO).equals(a));
  	assertTrue(a.add(b).equals(b.add(a)));
	  }

  @Test
  public void isDivOK()
  {
  	assertTrue(a.div(ONE).equals(a));
  	assertTrue(a.mult(b).div(b).equals(a));
		  }

  @Test(expected=NullPointerException.class)
  public void nullParameter()
  {
  	a.add(null);
  }

}

Die Tests können entweder über die Kommandozeile ausgeführt werden

java org.junit.runner.JUnitCore MyCTestClass

oder aber auch direkt über die IDE, wie hier in Eclipse

Log4j

• log4j
• wikipedia: log4j

log4j.properties

# root logger
log4j.rootLogger = ALL, RootAppender

# foo logger
#log4j.logger.foo = INFO, RootAppender
log4j.logger.foo = INFO

# foo.bar logger
#log4j.logger.foo.bar = WARN, RootAppender
log4j.logger.foo.bar = WARN


log4j.appender.RootAppender = org.apache.log4j.ConsoleAppender
log4j.appender.RootAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.RootAppender.layout.ConversionPattern=ROOT     %d{ABSOLUTE} [%-30.30C{1}] [%-17t] %-5p %x - %m%n

HelloWorld.java

import org.apache.log4j.Logger;

public class HelloWorld
{
  static Logger sFooBarLogger = Logger.getLogger("foo.bar");
  static Logger sFooLogger = Logger.getLogger("foo");
  static Logger sRootLogger = Logger.getRootLogger();

  public static void main (String[] args)
  {
    sFooBarLogger.debug("FooBar: Debug");
    sFooBarLogger.info("FooBar: Info");
    sFooBarLogger.warn("FooBar: Warn");

    sFooLogger.debug("Foo:    Debug");
    sFooLogger.info("Foo:    Info");
    sFooLogger.warn("Foo:    Warn");

    sRootLogger.debug("Root:   Debug");
    sRootLogger.info("Root:   Info");
    sRootLogger.warn("Root:   Warn");
  }
}

ANT

Das Apache ANT Werkzeug. Vergleichbar mit Makefiles, Schwerpunkt liegt aber nicht auf Abhängigkeiten (das kann Java selbst) sondern auf der Bereitstellung plattformunabhängiger Befehle (z.B. zum Kopieren von Dateien).

Links

• ANT filesets
• ANT java
• ANT javac

Kleines ANT Beispielprojekt

<project name="MyProject" default="compile" basedir=".">

  <!-- set global properties for this build -->
  <property name="src"         location="src"   />
  <property name="build"       location="build" />
  <property name="dist"        location="dist"  />
  <property name="mainclass"   value="de.tgunkel.Test.Foo" />
  <property name="distjarname" value="MyProject" />

  <!-- path for compiling the code -->
  <path id="compilepath">
    <fileset file="../../src/lib/foo_1.5.0.jar" />
    <fileset dir="../../src/lib/">
      <include name="**/*.jar"/>
    </fileset>
  </path>

  <!-- path for running the code -->
  <path id="runpath">
   <path refid="compilepath"/>
   <pathelement location="build"/>
   <pathelement location="etc"/>
   <fileset file="../../lib/otherlib/foo-2.0.0.jar" />
  </path>

  <!-- clean -->
  <target name="clean" description="clean">
    <!-- <delete dir="${build}" /> -->
    <delete includeemptydirs="true">
      <fileset dir="${build}" includes="**/*"/>
    </delete>
  </target>

  <!-- Some initial stuff -->
  <target name="init" description="init">
    <!-- Create the time stamp -->
    <tstamp/>
    <mkdir dir="${build}"/>
    <mkdir dir="${dist}"/>
  </target>

  <!-- compile it -->
  <target name="compile" description="compile the source" depends="init">
    <javac srcdir="${src}" destdir="${build}">
     <classpath refid="runpath">
     </classpath>
    </javac>
  </target>

  <!-- run the compiled code -->
  <target name="run" depends="compile" description="Run the program" >
    <java classname =3D "${mainclass}">
      <arg value="foo"   />
      <arg value="bar"    />
      <arg value="42"  />
      <classpath refid="runpath" />
    </java>
  </target>

  <!-- create a jar -->
  <target name="jar" description="makes a jar" depends="compile">
    <jar basedir="${build}" compress="true" jarfile="${dist}/${distjarname}">
      <manifest>
        <attribute name="Built-By" value="Thorsten Gunkel" />
        <attribute name="Main-Class" value="${mainclass}"  />
        <!-- You need the whole run time path here for an executable jar
         <attribute name="Class-Path" value="../../../src/lib/foo_1.0.0.jar" />
         -->
      </manifest>
    </jar>
  </target>

</project>

Variablen mit Werten aus anderen Dateien füllen

<property file="my-extra-variables.properties"/>
<property name="JAVA_HOME"  value="${YOUR_JAVA_HOME}" />

Warnungen des Compilers wie Fehler behandeln lassen

Wenn man erreichen möchte, dass sich kein Code eingebaut wird, der nur mit Warnungen übersetzt wird, kann man diese nützlich Option setzen:

<compilerarg value="-Xlint:unchecked"/>

Jede Warnung wird dann wie ein Fehler behandelt und führt zum Abbruch des Compilers. So werden Warnungen sehr früh bemerkt. FIXME

Textersetzung

So kann man mit ANT in Dateien Textersetzung durchführen

<project basedir=".">
 <target name="build" description="Replace some strings">

  <replace dir=".">
   <include name="myfiles/**" />
   <replacefilter token="__FOO__" value="BAR" />
   <replacefilter token="__43__" value="42" />
  </replace>

 </target>
</project>

Java Debug

<jvmarg value="-Xdebug"  />
<jvmarg value="-Xnoagent"  />
<jvmarg value="-Xrunjdwp:transport=dt_socket,address=8787,server=y,suspend=y" />

Maven

Maven Buch: Better Build With Maven
Erster Test, geht Maven?

mvn -version

Maven so einstellen, dass es ein Proxy benutzt wird

~/.m2/settings.xml

<settings>
  <proxies>
    <proxy>
      <active>true</active>
      <protocol>http</protocol>
      <host>my.proxy.foo.bar</host>
      <port>8080</port>
      <!--
          <username>your-username</username>
          <password>your-password</password>
      -->
    </proxy>
  </proxies>
</settings>

Ein neues Projekt erzeugen

mvn archetype:create   -DgroupId=bar.foo.main -DartifactId=MyFirstMavenApplication

Oder so

mvn archetype:generate -DgroupId=bar.foo.main -DartifactId=MyFirstMavenApplication

Compile

cd MyFirstMavenApplication
mvn compile

Man kann auch nur mal ausprobieren, ob es kompilieren würde

mvn test-compile

So führt man Surefire Tests für das Projekt durch

mvn test

So erstellt man ein Package

mvn package

Clean

mvn clean

Eclipse Konfigurationsdateien erzeugen

mvn eclipse:eclipse

Das m2eclipse Maven Eclipse Plugin
Eine Webseite über das Projekt erzeugen lassen

mvn site

Style Fehler finden (landet in checkstyle-result.xml)

mvn checkstyle:checkstyle

Eclipse

So kann man an ein jar das Javadoc anhängen: Das Projekte anklicken, Menü, Project, Properties, Libraries, [jar], aufklappen, javadoc location.

Breakpoints

Breakpoints können nur den aktuellen Thread anhalten, oder gleich die ganze VM. Den Default kann man so festlegen

Preferences -> Java -> Debug -> [ Suspend Execution | Suspend Thread ]

In der Debug View kann man mit dem J! Symbol Brakepoints setzen, die nur bei Exceptions aktiv werden

Code formatieren

Preferences -> Java -> Code -> Style -> Formater

Dort New anklicken und ein eigenes anlegen.

Mit

CTR SHIFT F

anwenden lassen

Eclipse stürzt ab

Das Eclipse Error Log liegt im Workspace Ordner und endet auf .log.

Eclipse 3.1.1 und PermGen zu klein? Wenn in der eclipse.ini sowas steht

-XX:MaxPermSize=256m

dann mal statt dessen das hier probieren

--launcher.XXMaxPermSize 256m

Quellen mit einem JAR verknüpfen

Eclipse Plugin für hprof Dateien (Speicherverbrauch)

Eclipse Memory Analyzer Plugin (MAT)

Performancemessungen / Profiler

JRat

JRat
So startet man das zu messende Programm

java -javaagent:shiftone-jrat.jar ...

So kann man sich die Ergebnisse mit dem mitgelieferten Viewer ansehen

java -Xmx256M -jar shiftone-jrat.jar

JRat hatte allerdings Probleme mit Hibernate und Annotations.

JIP

JIP
So startet man das zu messende Programm

java -javaagent:[DIR]\profile.jar ...

Am einfachsten ist es, wenn [DIR] ein absoluter Pfad ist.

Andere Variante

java -javaagent:[DIR]\profile.jar -Dprofile.properties=[DIR2]\profile.properties

Auch hier ist es einfacher, wenn [DIR] und [DIR2] absolute Pfade sind.

Im Paket ist ein Beispiel für eine profile.properties enthalten. Damit man sich die Ergebnisse visualisieren lassen kann, muss man in der properties mindestens

output=both

setzen. Wenn man in der properties den Eintrag

file

auf einen Ordner zeigen lässt, dann wird jeder neue Lauf in eine neue Datei geschrieben.
Ebenfalls nützlich ist der Eintrag

output-method-signatures=yes

So kann man sich die Ergebnisse schließlich visualisieren lassen

java -jar jipViewer.jar [DIR3]/profile.xml

Wobei hier [DIR3] der Ordner ist, in den JIP die Messwerte Schreiben sollte.