Ist meine Klasse richtig kommentiert?

[bob651]

Also man sollte ja immer Kommentare hinzufügen, habe ich gemacht. Was würdet ihr anders kommentieren, was weglassen, was fehlt?

public class LinkedList123<T> implements listss12312<T> {
    // reference zum head node
        private Node head;
        private static int listCount;
      
      
public LinkedList()
        {
            // leere liste
            // new node ohne daten
            head = new Node(null);
            listCount = 0;
        }
    public void add(T asd) {
        // bestimme element am ende der liste adden
        {
            Node temp = new Node(asd);
            Node current = head;
            // start von head bis ende
            while(current.getNext() != null)
            {
                current = current.getNext();
            }
            //
            //letzter nodes "next" referenz wird neuer node
            current.setNext(temp);
            listCount++;// variable erhöhen
      
    }}

  
    public void add(int index, T asd) {
        // bestimmter element in bestimmte position adden
        {
            Node temp = new Node(asd);
            Node current = head;
            // gehe zum bestimmten index oder zum letzen, je nachdem was zuerst kommt      
            for(int i = 1; i < index && current.getNext() != null; i++)
            {
                current = current.getNext();
            }
          
            //setze referenz vom neuen node zu dem vom this.nodes "next"
            temp.setNext(current.getNext());
          
            //setze this.nodes "next"  referenz zu einem neuen node
            current.setNext(temp);
            listCount++;// variable erhöhen
      
    }}

  
    public T contains(T asd) {
         return asd;
    }

  
    public int indexOf(T asd) {
        // TODO Auto-generated method stub
        return 0;
    }

  
    public T remove(T asd) {
        // TODO Auto-generated method stub
        return null;
    }

  
    public boolean  remove(int index) {
        // wenn index außerhalb des gültigen bereiches --> exit
                if(index < 1 || index > size())
                    return false;
              
                Node current = head;
                for(int i = 1; i < index; i++)
                {
                    if(current.getNext() == null)
                        return false;
                  
                    current = current.getNext();
                }
                current.setNext(current.getNext().getNext());
                listCount--; //  verringern der variable
                return true;
    }

  
    public T get(int index) {
        // element in einer bestimmten position in liste returnen
      
            // index muss 1 oder höher
            if(index <= 0)
                return null;
          
            Node current = head.getNext();
            for(int i = 1; i < index; i++)
            {
                if(current.getNext() == null)
                    return null;
              
                current = current.getNext();
            }
            return (T) current.getData();
    }

  
    public int size() {
        // anzahl der elemente in der liste returnen
      
            return listCount;
    }
      


    public String toString()
    {
        Node current = head.getNext();
        String output = "";
        while(current != null)
        {
            output += "[" + current.getData().toString() + "]";
            current = current.getNext();
        }
        return output;
    }
  
    public static void main(String[] args) {
        LinkedList neueListe = new LinkedList();
        neueListe.add("LOL");
        neueListe.add("XD");
        neueListe.add(4);
        neueListe.add(3);
        neueListe.add(2);
        neueListe.add(1);
        neueListe.add(0);
     
     
      
        neueListe.remove(1); //LOL wird gelöscht, Index beginnt mit 0
        neueListe.remove(6);
      
//     System.out.println("Endergebnis--> "+ neueListe);
//      System.out.println("");
    
//      System.out.println(listCount);
      neueListe.size();
    }
  
  
  
  
  
  
  
  
  
    class Node
    {
        // reference zu nächte node in reihe
        // oder  null wenn nichts ist
        Node next;
        // data ist in diesem node
        // kann alle typen sein
        Object data;
      

        // konstruktor
        public Node(Object _data)
        {
            next = null;
            data = _data;
        }
      
        // anderer konstruktor
        // node pointer
        public Node(Object _data, Node _next)
        {
            next = _next;
            data = _data;
        }
      
      
        public Object getData()
        {
            return data;
        }
      
        public void setData(Object _data)
        {
            data = _data;
        }
      
        public Node getNext()
        {
            return next;
        }
      
        public void setNext(Node _next)
        {
            next = _next;
        }
    }}

Das soll eine doppelt verkettete Liste sein.

 

[Flown]

Also Grundsätzlich fehlen dir die Implementierungen einiger Methoden. listCount ist static, warum?
Code dokumentiert man mit JavaDoc und nicht so! HIER oder HIER ein Tutorial.

EDIT:
- Paar Fehler sind in der Implementierung enthalten.
- Node könnte Typsicher mit T arbeiten
- Naminconvention beachten (also keine _<variable>), sondern mit this.<variable> = <variable>; arbeiten.

 

[Saheeda]

Diese beiden Kommentare:
// reference zum head node
und
// leere liste
// new node ohne daten

Finde ich ziemlich sinnbefreit. Dass "Node head" eine Referenz ist, sehe ich anhand des Typs, dass es der Anfang der Liste ist, nehme ich anhand des Namens an.
Dass die Liste leer ist, nehme ich anhand von listcount = 0 an.

Wir haben bei uns folgende Regel: Kommentiere nicht, was der Code tut, sondern warum.
Was der Quellcode macht, sehe ich. Warum er das so tut sehe ich nicht, das kommt meistens aus den Anforderungswünschen des Kunden.


Bei der Methodendoku ist wiederum die Sicht von außen wichtig. Frage dich folgendes: Wenn du nur die Methodensignatur + Doku liest, weißt du dann alles, was du darüber wissen musst?
Null-Handling? Geworfene Exceptions? Default-Werte? Die genaue Implementierung ist für die Doku irrelevant, aber ein Benutzer muss schnell verstehen können, was sie tut (oder nicht tut).