# Javadoc



## Xenya (29. Mrz 2011)

Hallo,
ich wollte meine Documentation bisschen ausbauen.
Im Kopf habe ich im Moment nur author und version stehen. Was ich für mein Team noch viel interessanter fände wäre Erstellungsdatum, Änderungsdatum und der jenige, der zuletzt eine Änderung gemacht hat.

Außerdem würde ich noch gerne einbauen, mölgliche Erweiterungen. So "coming soon"

Klar könnte ich nun selber was hinschreiben aber bevor ich das mache wollte ich fragen, ob es offizielle Tags dafür gibt. Habe keine gefunden.

Danke


----------



## hansmueller (29. Mrz 2011)

Hallo,

vielleicht hilft dir das hier weiter: javadoc-The Java API Documentation Generator

MfG
hansmueller


----------



## fastjack (29. Mrz 2011)

Erstellungsdatum hast Du eigentlich im FileHeader.



> Änderungsdatum und der jenige, der zuletzt eine Änderung gemacht hat



kann man im SVN/CVS etc. ablegen. Wir hatten das auch in unseren Klassen und die wurden richtig groß, besonders wenn viele Leute viele Änderungen machen. Am Ende war das viel Ballast.



> Außerdem würde ich noch gerne einbauen, mölgliche Erweiterungen. So "coming soon"



gehört vielleicht in ein Ticketsystem. Wenn ich eine Klasse ändern/erweitern soll/muß, interessiert es mich wenig, was mal von irgendjemanden geplant war oder wurde. Die Änderung/Erweiterung muß gemacht werden. Also whl. auch Ballast.

Wir hatten das alles mal im größeren Stil probiert, am Ende hast Du Klassen, in denen man vor lauter scrollen nicht mehr durchblickt und eigentlich nur noch genervt die entsprechenden Stellen sucht, in denen man etwas erledgigen muß.


----------



## Xenya (29. Mrz 2011)

Hallo,
danke für eure Tipps und Erfahrungen.

Ich werd sie mir zu Herzen nehmen und überlegen, wie ich, bzw. wir es umsetzen.

in dem Link von hansmueller hab ich auch gesehen, dass die das Datum zur version dazu schreiben. Das kann ich auf jeden Fall auch mal so übernehmen


----------



## Janes (31. Mrz 2011)

Hallo,
Ich wollte kein neues Thema anfangen, sondern hier das weiterführen, hoffe dass ist ok so für Mods 



*kann mir jemand Javadoc vereinfacht erklären* ???:L, wenn es geht mit irgend einem Beispiel-Code's  
(ich habe unten ein schon mal gepostet an dem man sich ausprobieren könnte)

Ich habe keine Ahnung von Javadoc, muss es aber für ein Code erstellen 

Javadoc ist doch eine HTML-Dokumentation 
wobei in dem Code selbst die Kommentare dazu dienen (aber wie?)
und daraus eine HTML-Datei (oder mehrere Dateien?) erstellt werden 
ist das soweit richtig ???:L

Eclipse und UltraEdit32 kann Javadoc, kann das auch joe?

Wie soll die Dokumentation üblicher weise sein, was ist zu viel was sollte unbedingt rein?




*kann das einer an diesem Beispiel mir zeigen,* ich danke schon mal im voraus :toll: 
bin heute den ganzen Tag und die Nach online ^^


```
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.*;
import javax.swing.*;

public class CMain {
    public static void main(final String[] args) {
        Runnable gui = new Runnable() {
            
            public void run() {
                MyActionListener cmd = new MyActionListener();
                MainMenu view = new MainMenu(cmd);
                cmd.setView(view);
                view.setVisible(true);
            }
        };
        //GUI must start on EventDispatchThread:
        SwingUtilities.invokeLater(gui);
    }
}
class MyActionListener implements ActionListener {
    private MainMenu mm;
    private Random r = new Random();
    public void actionPerformed(final ActionEvent event) {
        String cmd = event.getActionCommand();
        if (cmd.equals("Beenden")) {
            System.exit(0);
        } else if (cmd.equals("Test")) {
            Point location = new Point(r.nextInt(300), r.nextInt(200));
            mm.createCircle(location, 50, 50);
        }
    }
    public void setView(final MainMenu mm) {
        this.mm = mm;
    }
}
class MainMenu extends JFrame {
    private final ActionListener listener;
    private final JMenu menuFile;
    private final JMenuBar menubar;
    private final JPanel panel;
    public MainMenu(final ActionListener listener) {
        super("MainMenu");
        this.listener = listener;
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(400, 300);
        setLocationRelativeTo(null);
        menuFile = createFileMenu(listener);
        menubar = new JMenuBar();
        menubar.add(menuFile);
        setJMenuBar(menubar);
        panel = new JPanel(null);
        add(panel);
    }
    private JMenu createFileMenu(final ActionListener listener) {
        JMenu menu = new JMenu("File");
        menu.setMnemonic('f');
        JMenuItem mi = addNewMenuItem("Test", 't', 't', listener);
        menu.add(mi);
        menu.add(new JSeparator());
        mi = addNewMenuItem("Beenden", 'b', 'b', listener);
        menu.add(mi);
        return menu;
    }
    private JMenuItem addNewMenuItem(final String CMenuItemName, final char cShortcut,
            final char cAccelerationKey, final ActionListener Listener) {
        JMenuItem mi = new JMenuItem(CMenuItemName);
        mi.setMnemonic(cShortcut);
        mi.setAccelerator(KeyStroke.getKeyStroke(cAccelerationKey));
        mi.addActionListener(listener);
        return mi;
    }
    public void createCircle(final Point location, final int width, final int height) {
        Shape shape = new Ellipse2D.Double(0, 0, width, height);
        ShapeComponent shapeComponent = new ShapeComponent(location, shape);
        panel.add(shapeComponent);
        shapeComponent.setForeground(Color.GREEN);
        shapeComponent.requestFocusInWindow();
    }
}
class ShapeComponent extends JComponent {
    private final Shape shape;
    private final JPopupMenu popup;
    public ShapeComponent(final Point location, final Shape shape) {
        setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
        setToolTipText("");
        setOpaque(false);
        popup = new JPopupMenu();
        popup.add(new JMenuItem("Test 1"));
        popup.add(new JMenuItem("Test 2"));
        setComponentPopupMenu(popup);
        Rectangle bounds = shape.getBounds();
        setBounds(location.x, location.y,
                bounds.width + 2,
                bounds.height + 2);
        this.shape = shape;
        addFocusListener(new FocusListener() {
            public void focusGained(final FocusEvent e) {
                repaint();
            }
            public void focusLost(final FocusEvent e) {
                repaint();
            }
        });
        addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(final MouseEvent e) {
                getParent().setComponentZOrder(ShapeComponent.this, 0);
                requestFocusInWindow();
            }
        });
    }
    @Override
    public String getToolTipText(final MouseEvent event) {
        return "hasFocus:" + hasFocus();
    }
    @Override
    public boolean contains(final int x, final int y) {
        return shape.contains(x, y);
    }
    @Override
    protected void paintComponent(final Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D) g;
        g2.setColor(getForeground());
        if(hasFocus()){
            g2.setColor(getForeground().darker().darker());
        }
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2.fill(shape);
    }
}
```


----------



## BigBiber89 (31. Mrz 2011)

Das könnte dir evtl. helfen eigentlich recht simpel erklärt:

Galileo Computing :: Java ist auch eine Insel – 5.14 Dokumentationskommentare mit JavaDoc


----------



## Janes (31. Mrz 2011)

Danke, 

aber ist dass im Grunde dann nichts anderes als ein Kommentar,
außer dass es ein Stern mehr hat - oder verstehe ich da was falsch !? 


```
/**
 * 
 */
```

was ich nicht verstehe sind diese Sachen wie 
	
	
	
	





```
@deprecated
```
 oder 
	
	
	
	





```
{@code equals()} an not {@code ==}.
```
haben die 
	
	
	
	





```
@
```
 so ein Sonderstatus ... 


```
/**
 * @deprecated  As of JDK 1.1,
 * replaced by {@link #setBounds(int,int,int,int)}
 */


/**
 * Compares this current object with another object.
 * Uses {@code equals()} an not {@code ==}.
 */
```


werde  mich jetzt nebenbei in das trockene Thema einlesen, 
hoffe ihr gebt ihr noch paar Kommentare


----------



## fastjack (1. Apr 2011)

Javadoc wirkt in Public-Kommentaren von Klassen, Methoden und Feldern. Darin verwendet man Annotations, die dann vom Javadoc-Generator entsprechend ausgewertet werden. Probier es doch einfach mal aus und schau dir an einer Klasse an, was Javadoc aus deinen Kommentaren generiert.


----------



## Janes (1. Apr 2011)

Ich habe zuhause nur das Program joe, 
ich glaube nicht das man damit ein Javadoc machen kann ...


obwohl ich grad unter joe/optionen/einstellungen 
Java JDK gefunden habe mit "JDK Dokumentation"
aber da könnte ich wohl nur html-Dateien öffnen 
(glaube nicht javadoc abspeichern ... )

ich hasse das javadoc, gerade weil ich nichts davon weiß


----------



## fastjack (1. Apr 2011)

dann mußt du es lernen


----------



## Janes (4. Apr 2011)

kann sich das noch einer mal ansehen, der sich mit Javadoc auskennt? bitte


----------

