✔ Java 1.5.x - Enum und Annotation

[schnuffie]

Reine Neugier:

Was ist / wofür benutzt man Enum und Annotation?

 

[Thomas Darimont]

Hallo!

Enums dienen Dazu Typsichere "Aufzählungen" beispielsweise für Konstanten zu Erzeugen:
Im prinzip handelt es sich bei dem Java 5 Typ "Enum" um eine Abstraktion des Enum Patterns
Was man durch dekompilieren schnell nachvollziehen kann.

public enum MyJava5Enum {
	READ,WRITE,READ_WRITE;
}

Ergibt:

// Decompiled by DJ v3.6.6.79 Copyright 2004 Atanas Neshkov  Date: 05.04.2005 15:26:52
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 
// Source File Name:   MyJava5Enum.java

package de.tutorials;


public class MyJava5Enum extends Enum
{

    private MyJava5Enum(String s, int i)
    {
        super(s, i);
    }

    public static final MyJava5Enum[] values()
    {
        MyJava5Enum amyjava5enum[];
        int i;
        MyJava5Enum amyjava5enum1[];
        System.arraycopy(amyjava5enum = ENUM$VALUES, 0, amyjava5enum1 = new MyJava5Enum[i = amyjava5enum.length], 0, i);
        return amyjava5enum1;
    }

    public static final MyJava5Enum valueOf(String s)
    {
        MyJava5Enum amyjava5enum[];
        MyJava5Enum myjava5enum;
        for(int i = (amyjava5enum = ENUM$VALUES).length; --i >= 0;)
            if(s.equals((myjava5enum = amyjava5enum[i]).name()))
                return myjava5enum;

        throw new IllegalArgumentException(s);
    }

    public static final MyJava5Enum READ;
    public static final MyJava5Enum WRITE;
    public static final MyJava5Enum READ_WRITE;
    private static final MyJava5Enum ENUM$VALUES[];

    static 
    {
        READ = new MyJava5Enum("READ", 0);
        WRITE = new MyJava5Enum("WRITE", 1);
        READ_WRITE = new MyJava5Enum("READ_WRITE", 2);
        ENUM$VALUES = (new MyJava5Enum[] {
            READ, WRITE, READ_WRITE
        });
    }
}

Annotations stellen u.a. einen Ersatz für die Marker-Interfaces wie etwa Serializable
oder Remote dar. Zusätzlich lassen sie sich mit Werten / Wertlisten belegen die sich zur
Laufzeit per Reflection Auswerten lassen. Dadurch erhält man mehr Flexibilität. Weiterhin
werden die heutigen geschwätzigen Deployment Deskriptoren damit bald der Vergangenheit angehören,
da Java diese Informationen zur Laufzeit aus dem Kompilierten Code herausziehen kann.

Kurz gesagt, lassen sich mit Annotations Meta-Informationen im Code unterbringen die per Reflection zur Laufzeit
verfügbar sind.

Gruß Tom

 

[schnuffie]

...interessant, meine Neugier wächst. ;-)

Enum:
Also verwende ich Enum immer dann, wenn ich eigene Klassen schreibe, die irgendwelche Inhalte für andere Klassen oder Methoden beinhalten, die als Konstanten eingesetzt werden sollen. Wie sähe das dann für diese Klasse z.B. aus?:

public class Person {
private String name;
private int alter;
private final gewicht;
private Person(String name, int alter, final gewicht) {
this.name = name;
this.alter = alter;
this.gewicht = gewicht;
}
public String getName() {
return name;
}
//...usw.
}

Annotation:
Es wäre also theoretisch denkbar, z.B. die "web.xml" zur Annotation zu machen. Wie muß denn eine Annotation "innen" aussehen? Methoden, Konstanten?

 

[Thomas Darimont]

Hallo!

Wie sähe das dann für diese Klasse z.B. aus?:

Für diese Klasse sollte man besser keinen Enum erstellen. Enums verwendet man um eine endliche Menge von Wohldefinierten Möglichkeiten zu Kapseln

Bsp.:

/**
 * 
 */
package de.tutorials;

/**
 * @author Tom
 * 
 */
public class BadClass {

	public final static int A = 0x0010;

	public final static int B = 0x0001;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		doSomething(A);
		doSomething(B);

		/*
		 * Benutzer können BELIEBIGE Werte eintragen die zu unvorhersehbarem
		 * Programmverhalten und zu sehr schlecht wartbaren Code führen können
		 */
		doSomething(20101905);
	}

	/**
	 * 
	 * @param i
	 */
	private static void doSomething(int i) {
		if ((i & A) == A) {
			System.out.print("A ");
		}

		if ((i & B) == B) {
			System.out.print(" B");
		}
		System.out.println();
	}

}

/**
 * 
 */
package de.tutorials;

/**
 * @author Tom
 * 
 */
public class GoodClass {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		doSomething(Constant.A);
		doSomething(Constant.B);
		doSomething(Constant.C);
		
		doSomething("FOO"); //Compile time error ;-)
	}

	private static void doSomething(Constant c) {
		switch (c) {
		case A:
			System.out.println("A");
		case B:
			System.out.println("B");
		case C:
			System.out.println("C");
		}
	}

	public static enum Constant {
		A("A"), B("B"), C("C");

		private final String value;

		private Constant(String value) {
			this.value = value;
		}

		public String getValue() {
			return value;
		}

		@Override
		public String toString() {
			return this.value;
		}
	}
}

Annotation:
Es wäre also theoretisch denkbar, z.B. die "web.xml" zur Annotation zu machen. Wie muß denn eine Annotation "innen" aussehen? Methoden, Konstanten?

Siehe selbst:
http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html


Vorstellbar wäre beispielsweise sowas:

/**
 * 
 */
package de.tutorials;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import java.lang.annotation.*;

/**
 * @author Tom
 *
 */
@Servlet(name="annotatedServlet" path="/annotatedServlet" description="My Annotated Servlet")
public class AnnotatedServlet extends HttpServlet{

	@Override
	protected void doGet(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException {
		// TODO Auto-generated method stub
		super.doGet(arg0, arg1);
	}

	@Override
	protected void doPost(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException {
		// TODO Auto-generated method stub
		super.doPost(arg0, arg1);
	}

}

Ein weiteres kleines Schmankerl ist die Möglichkeit mittels dieser Annotationen Codegeneratoren zu steuern. Siehe dazu APT (Annotation Processing Tool) ->
http://java.sun.com/j2se/1.5.0/docs/tooldocs/share/apt.html

Gruß Tom

 

[schnuffie]

...danke Tom für den Überblick. Da muß ich mich längerfristig intensiver damit beschäftigen. Das ist doch ein recht interessantes Thema ab der 1.5.x...