Int an andere Klasse übergeben

[Call_He_Tempi]

Hallo zusammen,

ich hab jetzt wieder ewig rumgerätselt, komm aber einfach nicht weiter.

In der Klasse "Generator" weise ich der der Variable "input" einen Wert zu, welcher festlegt, wie viele Zufallszahlen generiert werden sollen.

System.out.println("How many random numbers should be generated?");
        input = eingabe.nextInt();
        setter.setInput(input);
        value = new int[getInput()];

Im nächsten Schritt will ich in der "Analyzer" Klasse und der Methode "analyzer" auswerten, wie viele von welcher Zahl generiert wurden.

Mein Problem ist, das die Übergabe der Variable "input" mit der Anzahl an generierten Zufallszahlen nicht richtig an

int[] count = new int[myGen.getInput()];

übergeben wird, denn ich bekomme dann folgende Fehlermeldung:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 0
at Analyzer.analyzer(Analyzer.java:26)
at Main.main(Main.java:11)


Wenn ich der Variable "input" manuell einen Wert zuweise funktioniert das Programm.

 private int input = 12;

Hier ist mein ganzes Programm:

[CODE lang="java" title="Main"]public class Main {
public static void main(String[] args) {

Generator genObject = new Generator();
genObject.gen();

Analyzer analyzerObject = new Analyzer();
analyzerObject.counter(genObject.getValue());

Analyzer countObject = new Analyzer();
countObject.analyzer(genObject.getValue());
}
}[/CODE]


[CODE lang="java" title="Generator"]import java.util.concurrent.ThreadLocalRandom;
import java.util.Scanner;

public class Generator {

private int[] value;
private int input = 12;

public int[] getValue() {
return value;
}

public void setInput(int input) {
this.input = input;
}

public int getInput() {
return input;
}

public void gen() {
Generator setter = new Generator();
Scanner eingabe = new Scanner(System.in);
int min = 1;
int max = 10;

System.out.println("How many random numbers should be generated?");
input = eingabe.nextInt();
setter.setInput(input);
value = new int[getInput()];



System.out.println("Following random numbers are generated:");
for (int i = 0; i < input; i++) {
int getRandomValue = ThreadLocalRandom.current().nextInt(min, max) + min;
value = getRandomValue;
System.out.print(value);
}
System.out.println("\n");
}
}
[/CODE]


[CODE lang="java" title="Analyzer"]public class Analyzer {
private Generator myGen = new Generator();

public void counter(int[] value) {
int below = 0;
int above = 0;
int adder = 1;


for (int j = 0; j < value.length; j++)
if (j < 10) {
below = below + adder;
} else if (j > 10) {
above = above + adder;
}
System.out.println("\n" + below + " of the generated values are below 10\n\n" + above + " of the generated values are above 10\n");
}

public void analyzer(int[] value) {

int counter = 0;
int[] count = new int[myGen.getInput()];

for (int i = 0; i < value.length; i++) {
int index = value;
count[index] = count[index] + 1;

}
for (int j = 0; j < value.length; j++) {
System.out.println("The Value " + counter + " excist´s " + count[j] + " times");
counter = counter + 1;
}
}
}[/CODE]

 

[DrPils]

Du erzeugst in der Analyzer class ein neues Generator object. Die Attribute werden auf ihre Standardwerte gesetzt wenn du sie nicht im Konstruktor setzt. Bei Ganzzahlen ist das eine 0.
Deswegen gibt dir myGen.getInput() auch 0 zurück, womit int[] count = new int[myGen.getInput()]; dir ein Array mit der Größe 0 liefert.

 

[Call_He_Tempi]

Du erzeugst in der Analyzer class ein neues Generator object. Die Attribute werden auf ihre Standardwerte gesetzt wenn du sie nicht im Konstruktor setzt. Bei Ganzzahlen ist das eine 0.
Deswegen gibt dir myGen.getInput() auch 0 zurück, womit int[] count = new int[myGen.getInput()]; dir ein Array mit der Größe 0 liefert.

Wie setzte ich sie denn im Konstruktor?

 

[DrPils]

public class Main {
    public static void main(String[] args) {

        int number = 42;
        ConstructorDemo constructorDemo = new ConstructorDemo(number);
        System.out.println(constructorDemo.getNumber()); //42
    }
}

class ConstructorDemo {
    private final int number;

    public ConstructorDemo(int number) {
        this.number = number;
    }

    public int getNumber() {
        return number;
    }
}

Alternativ kannst du es auch mit dem Setter setzen. Aber ich würde dir den Konstruktor empfehlen, da du sicher sein kannst das alle Felder ihre Werte bekommen

 

[fhoffmann]

In deinem Code ist dreimal (!) new Generator(); enthalten.
Du erzeugst also drei Instanzen der Klasse Generator. Änderungen an einer Instanz haben keine Auswirkung auf eine andere Instanz.

 

[Neumi5694]

Eine Frage der Denkweise: Int an eine andere "Klasse" übergeben? Man übergibt nichts an andere Klassen.
Man übergibt etwas an andere "Objekte" ... ab dem Moment sind dann solche Methodenaufrufe naheliegend:

anderesObjekt.setInt(meinInt)

 

[Blender3D]

ich hab jetzt wieder ewig rumgerätselt, komm aber einfach nicht weiter.

Möchtest Du in etwa so etwas?

[CODE lang="java" title="StartRndTest" highlight="12-15"]import java.util.Arrays;

public class StartRndTest {
public static void main(String[] args) {
RndIntGenerator rnd = new RndIntGenerator(12);
rnd.setRange(1, 10);
System.out.println(rnd);
int[] sortedValues = rnd.getValues();
Arrays.sort(sortedValues);
System.out.println(Arrays.toString(sortedValues));
System.out.println("Mittelwert\t" + StatisticTool.meanValue(sortedValues));
int bound = 5;
int lessBound = StatisticTool.countValuesLess(sortedValues, bound);
int equalBound = StatisticTool.countValuesEqual(sortedValues, bound);
int greaterBound = sortedValues.length - lessBound - equalBound;
System.out.println("Grenze " + bound);
System.out.println(
String.format("kleiner %dx\t| gleich %dx\t| groesser %sx", lessBound, equalBound, greaterBound));
}
}[/CODE]
[CODE lang="java" title="RndIntGenerator" highlight="18-19,13-14,23"]public class RndIntGenerator {
private int[] values;
private int min = 0;
private int max = 100;

public RndIntGenerator(int size) throws IllegalArgumentException {
if (size < 1)
throw new IllegalArgumentException("Minimum size is <1> not <" + size + "> !");
generate(size);
}

public void generate(int size) {
values = new int[size];
generate();
}

public void generate() {
for (int i = 0; i < values.length; i++)
values = ThreadLocalRandom.current().nextInt(min, max + 1);
}

public int[] getValues() {
return Arrays.copyOf(values, values.length);
}

public void setRange(int min, int max) {
if (min > max) {
int tmp = min;
min = max;
max = tmp;
}
this.max = max;
this.min = min;
generate();
}

@Override
public String toString() {
return Arrays.toString(values);
}
}[/CODE]
[CODE lang="java" title="StatisticTool"]public class StatisticTool {
public static int countValuesEqual(int[] values, int val) {
int cnt = 0;
for (int i = 0; i < values.length; i++) {
if (values == val)
cnt++;
}
return cnt;
}

public static int countValuesGreater(int[] values, int val) {
int cnt = 0;
for (int i = 0; i < values.length; i++) {
if (values > val)
cnt++;
}
return cnt;
}

public static int countValuesLess(int[] values, int val) {
int cnt = 0;
for (int i = 0; i < values.length; i++) {
if (values < val)
cnt++;
}
return cnt;
}

public static double meanValue(int[] values) {
return sumOf(values) / (double) values.length;
}

public static long sumOf(int[] values) {
long sum = 0;
for (int i = 0; i < values.length; i++)
sum += values;
return sum;
}

}[/CODE]

 

[Call_He_Tempi]

Möchtest Du in etwa so etwas?
Anhang anzeigen 17761
[CODE lang="java" title="StartRndTest" highlight="12-15"]import java.util.Arrays;

public class StartRndTest {
public static void main(String[] args) {
RndIntGenerator rnd = new RndIntGenerator(12);
rnd.setRange(1, 10);
System.out.println(rnd);
int[] sortedValues = rnd.getValues();
Arrays.sort(sortedValues);
System.out.println(Arrays.toString(sortedValues));
System.out.println("Mittelwert\t" + StatisticTool.meanValue(sortedValues));
int bound = 5;
int lessBound = StatisticTool.countValuesLess(sortedValues, bound);
int equalBound = StatisticTool.countValuesEqual(sortedValues, bound);
int greaterBound = sortedValues.length - lessBound - equalBound;
System.out.println("Grenze " + bound);
System.out.println(
String.format("kleiner %dx\t| gleich %dx\t| groesser %sx", lessBound, equalBound, greaterBound));
}
}[/CODE]
[CODE lang="java" title="RndIntGenerator" highlight="18-19,13-14,23"]public class RndIntGenerator {
private int[] values;
private int min = 0;
private int max = 100;

public RndIntGenerator(int size) throws IllegalArgumentException {
if (size < 1)
throw new IllegalArgumentException("Minimum size is <1> not <" + size + "> !");
generate(size);
}

public void generate(int size) {
values = new int[size];
generate();
}

public void generate() {
for (int i = 0; i < values.length; i++)
values = ThreadLocalRandom.current().nextInt(min, max + 1);
}

public int[] getValues() {
return Arrays.copyOf(values, values.length);
}

public void setRange(int min, int max) {
if (min > max) {
int tmp = min;
min = max;
max = tmp;
}
this.max = max;
this.min = min;
generate();
}

@Override
public String toString() {
return Arrays.toString(values);
}
}[/CODE]
[CODE lang="java" title="StatisticTool"]public class StatisticTool {
public static int countValuesEqual(int[] values, int val) {
int cnt = 0;
for (int i = 0; i < values.length; i++) {
if (values == val)
cnt++;
}
return cnt;
}

public static int countValuesGreater(int[] values, int val) {
int cnt = 0;
for (int i = 0; i < values.length; i++) {
if (values > val)
cnt++;
}
return cnt;
}

public static int countValuesLess(int[] values, int val) {
int cnt = 0;
for (int i = 0; i < values.length; i++) {
if (values < val)
cnt++;
}
return cnt;
}

public static double meanValue(int[] values) {
return sumOf(values) / (double) values.length;
}

public static long sumOf(int[] values) {
long sum = 0;
for (int i = 0; i < values.length; i++)
sum += values;
return sum;
}

}[/CODE]

Ja genau! Deine Ausgabe sieht viel schöner aus.
Ich schau mir Mal deine Schlüsselwort an.
Vllt kann ich meinen Code noch etwas übersichtlicher gestalten.
Wofür ist den "StatisticTool"?

 

[KonradN]

Wofür ist den "StatisticTool"?

Ich erlaube mir mal, hier einfach mal mit paar Erläuterungen einzuspringen.

In der Regel sollte man immer versuchen, ein objektorientierten Ansatz zu nutzen, d.h. es werden Klassen geschrieben die dann genutzt werden, um Instanzen zu erzeugen und dise Instanzen interagieren dann miteinander. Aber manchmal ist dies so leider nicht ganz zweckmäßig, da etwas einfach nicht wirklich ohne unnötigen Aufwand umgesetzt werden kann.

In diesem Zusammenhang kommen dann die Helper oder Utility Klassen ins Spiel. Diese Klassen enthalten dann einfach nur statische Methoden, die etwas machen. Diese Klassen haben keinen internen Zustand und es werden keine Instanzen erzeugt. Beispiele für solche Klassen wären im Java Framework z.B. die Klassen Objects und Arrays oder man findet in diversen Libraries Klassen wie StringUtils (z.B. Apache Commons Lang).
Da erkennt man die Namensgebung: Immer den Namen der Klasse, um die es geht und dann der Plural (Objects -> Hilfsmethoden rund um Object) oder es wird ein "Utils" angehängt (StringUtils -> Hilfsmethoden rund um String).

StaticTool ist einfach eine solche Hilfsklasse. Den Namen kann man ggf. noch besser wählen, aber da es sich nicht um eine spezielle Klasse dreht passt das Naming Pattern nicht ganz. Und im Rahmen des Forums tritt die Namensfindung auch mehr in den Hintergrund. Da packt man Dinge eher zusammen, da mehrere einzelne Klassen sich nicht lohnen. (Bei großen Projekten fällt oft deutlich mehr an, so dass sich sowas eher lohnt.)

Generell sind so statische Methoden immer ein Punkt, bei dem man prüfen sollte: ist hier evtl. ein Umschreiben angebracht. Wenn es um die "Erweiterung" bestehender (Fremd-)Klassen geht, dann ist die Frage schnell beantwortet: Apache Commons kann z.B. die String Klasse nicht erweitern. Da gibt es also nicht wirklich einen sinnvollen Weg.

 

[Call_He_Tempi]

Ich erlaube mir mal, hier einfach mal mit paar Erläuterungen einzuspringen.

In der Regel sollte man immer versuchen, ein objektorientierten Ansatz zu nutzen, d.h. es werden Klassen geschrieben die dann genutzt werden, um Instanzen zu erzeugen und dise Instanzen interagieren dann miteinander. Aber manchmal ist dies so leider nicht ganz zweckmäßig, da etwas einfach nicht wirklich ohne unnötigen Aufwand umgesetzt werden kann.

In diesem Zusammenhang kommen dann die Helper oder Utility Klassen ins Spiel. Diese Klassen enthalten dann einfach nur statische Methoden, die etwas machen. Diese Klassen haben keinen internen Zustand und es werden keine Instanzen erzeugt. Beispiele für solche Klassen wären im Java Framework z.B. die Klassen Objects und Arrays oder man findet in diversen Libraries Klassen wie StringUtils (z.B. Apache Commons Lang).
Da erkennt man die Namensgebung: Immer den Namen der Klasse, um die es geht und dann der Plural (Objects -> Hilfsmethoden rund um Object) oder es wird ein "Utils" angehängt (StringUtils -> Hilfsmethoden rund um String).

StaticTool ist einfach eine solche Hilfsklasse. Den Namen kann man ggf. noch besser wählen, aber da es sich nicht um eine spezielle Klasse dreht passt das Naming Pattern nicht ganz. Und im Rahmen des Forums tritt die Namensfindung auch mehr in den Hintergrund. Da packt man Dinge eher zusammen, da mehrere einzelne Klassen sich nicht lohnen. (Bei großen Projekten fällt oft deutlich mehr an, so dass sich sowas eher lohnt.)

Generell sind so statische Methoden immer ein Punkt, bei dem man prüfen sollte: ist hier evtl. ein Umschreiben angebracht. Wenn es um die "Erweiterung" bestehender (Fremd-)Klassen geht, dann ist die Frage schnell beantwortet: Apache Commons kann z.B. die String Klasse nicht erweitern. Da gibt es also nicht wirklich einen sinnvollen Weg.

Vielen Dank, für deine ausführliche Erklärung!!

 

[Call_He_Tempi]

Ich komm aber einfach nicht weiter *Haarerauf* ich weiß nicht, wo der Fehler ist bzw. an welcher stelle der Wert "input" nicht übergeben wird..

 

[Neumi5694]

Ich komm aber einfach nicht weiter *Haarerauf* ich weiß nicht, wo der Fehler ist bzw. an welcher stelle der Wert "input" nicht übergeben wird..

Dann ist wohl debuggen angesagt. Setz einen Breakpoint in der Set-Methode und schau, was dort reinkommt und was nach der Zuweisung gesetzt ist.

 

[Call_He_Tempi]

Dann ist wohl debuggen angesagt. Setz einen Breakpoint in der Set-Methode und schau, was dort reinkommt und was nach der Zuweisung gesetzt ist.

Danke für den Tipp! Ich wusste gar nicht, das es so eine Funktion gibt.

 

[Jw456]

Code von Post #1

zumindest sollten so die Instanzen passen.

Logik und Funktion nicht getestet nur im Editor angepasst.

public class Main {
    public static void main(String[] args) {

        Generator genObject = new Generator();
        genObject.gen();

        Analyzer analyzerObject = new Analyzer();
        analyzerObject.counter(genObject.getValue());

        Analyzer countObject = new Analyzer();
        countObject.analyzer(genObject);
    }
}

import java.util.concurrent.ThreadLocalRandom;
import java.util.Scanner;

public class Generator {

    private int[] value;
    private int input = 12;

    public int[] getValue() {
        return value;
    }

    public void setInput(int input) {
        this.input = input;
    }

    public int getInput() {
        return input;
    }

    public void gen() {
        // Generator setter = new Generator();
        Scanner eingabe = new Scanner(System.in);
        int min = 1;
        int max = 10;

        System.out.println("How many random numbers should be generated?");
        input = eingabe.nextInt();
        //setter.setInput(input);
        setInput(input);
       
        value = new int[getInput()];



        System.out.println("Following random numbers are generated:");
        for (int i = 0; i < input; i++) {
            int getRandomValue = ThreadLocalRandom.current().nextInt(min, max) + min;
            value[i] = getRandomValue;
            System.out.print(value[i]);
        }
        System.out.println("\n");
    }
}

public class Analyzer {
    // private Generator myGen = new Generator();

    public void counter(int[] value) {
        int below = 0;
        int above = 0;
        int adder = 1;


        for (int j = 0; j < value.length; j++)
            if (j < 10) {
                below = below + adder;
            } else if (j > 10) {
                above = above + adder;
            }
        System.out.println("\n" + below + " of the generated values are below 10\n\n" + above + " of the generated values are above 10\n");
    }

    public void analyzer(Generator myGen ) {

        int counter = 0;
        int[] value = myGen.getValue();
        int[] count = new int[myGen.getInput()];

        for (int i = 0; i < value.length; i++) {
            int index = value[i];
            count[index] = count[index] + 1;

        }
        for (int j = 0; j < value.length; j++) {
            System.out.println("The Value " + counter + " excist´s " + count[j] + " times");
            counter = counter + 1;
        }
    }
}

 

[Neumi5694]

Danke für den Tipp! Ich wusste gar nicht, das es so eine Funktion gibt.

Das macht die IDE. Netbeans, Eclipse usw.
Du kannst die Werte natürlich auch einfach ausgeben lassen, ordentlich beschriftet.

 

[Call_He_Tempi]

So ich hab das Problem mittlerweile gelöst und möchte es hier teilen, falls jemand anderes mal das selbe Problem haben sollte.
Das Problem lag darin, das ich zahlen von 1 - 10 generiert habe.
Im nächsten Schritt habe ich ein Array "count" erstellt, welches genauso groß war, wie der größte Wert in dem "value" Array.
Angenommen ich habe 10 Werte von 1 - 10 und die count schleife fängt an zu zählen.

 for (int i = 0; i < value.length; i++) {
            int index = value[i];
            count[index] = count[index] + 1;

Sobald die Schleife an dem Wert "10" ankommt kommt der Fehler, das Array wäre zu klein.
Natürlich!
Denn ein Array mit 10 Plätzen fängt bei 0 an. {0,1,2,3,4,5,6,7,8,9}

Das Problem habe ich gelöst indem ich in einer vorgehenden Schleife auslese, welcher Wert der größte ist, diesen in einem Int "maxValue" ablege und anschließend "maxValue" um 1 erhöhe

for (int i = 0; i < value.length; i++) { // for-ribbon to search for the highest value in "value"
            cacheOne = value[i]; // assign the value of "value[i]" to "cacheOne"
            if (cacheOne > maxValue) { // check if the current value of "value[i]" is higher than "maxValue"
                maxValue = cacheOne;   // if it is change the value of "maxValue" to the higher value of "cacheOne"
            }
        }

        maxValue = maxValue + 1; // increase the value by one. If it had the same value as the highest value inside "value" the "count" Array would be one pos. to short
        // for example: Generate 10 Values from 1 to 10; the highest value is 5; if you didn't increase the value by one you would get an Array with the pos. 0 - 4 so it would be impossible to count the value "5"
        int[] count = new int[maxValue]; // create an Array "count" with the length of "maxValue"

Jetzt funktioniert alles einwandfrei.

 

[Call_He_Tempi]

Hier nochmal der gesamte Code:

public class Main {
    public static void main(String[] args) {

        Generator genObject = new Generator();
        genObject.gen();

        Analyzer analyzerObject = new Analyzer();
        analyzerObject.counter(genObject.getValue());

        Analyzer countObject = new Analyzer();
        countObject.analyzer(genObject);
    }
}

public class Analyzer {


    public void counter(int[] value) {
        int below = 0; // Int for the quantity of values below 10
        int above = 0; // Int for the quantity above 10
        int adder = 1; // just an adder +1


        for (int j = 0; j < value.length; j++) // for-ribbon to read out and sort the values inside "value"
            if (value[j] < 10) {
                below = below + adder;
            } else if (value[j] > 10) {
                above = above + adder;
            }
        System.out.println("\n" + below + " of the generated values are below 10\n\n" + above + " of the generated values are above 10\n");
    }

    public void analyzer(Generator myGen) { // (Generator myGen) creates an object called "myGen" so that the int "value" can call the Array "value" in the Generator Class and Copy it inside the Analyzer Class
        int counter = 0;
        int cacheOne;
        int maxValue = 0;
        int[] value = myGen.getValue(); // Creates an Copy of the Array "value" from the Generator Class, so it can be used in this Class


        for (int i = 0; i < value.length; i++) { // for-ribbon to search for the highest value in "value"
            cacheOne = value[i]; // assign the value of "value[i]" to "cacheOne"
            if (cacheOne > maxValue) { // check if the current value of "value[i]" is higher than "maxValue"
                maxValue = cacheOne;   // if it is change the value of "maxValue" to the higher value of "cacheOne"
            }
        }

        maxValue = maxValue + 1; // increase the value by one. If it had the same value as the highest value inside "value" the "count" Array would be one pos. to short
        // for example: Generate 10 Values from 1 to 10; the highest value is 5; if you didn't increase the value by one you would get an Array with the pos. 0 - 4 so it would be impossible to count the value "5"
        int[] count = new int[maxValue]; // create an Array "count" with the length of "maxValue"


        for (int i = 0; i < value.length; i++) { // for-ribbon to count the quantity of each value stored inside "value"
            int index = value[i]; // create an int "index" and assign the value from "value[i]" inside it.
            count[index] = count[index] + 1; // increase the value of "count[index] by one
        }


        for (int j = 0; j < count.length; j++) {
            System.out.println("The Value " + counter + " excist´s " + count[j] + " times");
            counter = counter + 1;
        }
    }

public class Generator {

    private int[] value;
    private int input;
    int min;            // Minimum value of the generated values
    int max;            // Maximum value of the Generated Values

    public int[] getValue() {
        return value;
    }   // Get Method

    public void setInput(int input) {
        this.input = input;
    } // Set Method

    public int getInput() {
        return input;
    }

    public void gen() {

        Scanner eingabe = new Scanner(System.in);

        System.out.println("How many random numbers should be generated?");
        input = eingabe.nextInt(); // Declare "input" Via Scanner method

        setInput(input); // Set "input" via Set Method

        value = new int[getInput()]; // Create an Array with the length of "input", called by the Get Method

        System.out.println(" In wich area should the numbers be generated?\n Min value:");
        min = eingabe.nextInt();
        System.out.println("Max value:");
        max = eingabe.nextInt();



        System.out.println("Following random numbers are generated:");
        for (int i = 0; i < input; i++) { // for-ribbon to generate random values
            int getRandomValue = ThreadLocalRandom.current().nextInt(min, max) + min; // Create an int "getRandomValue" set the value equal to the value generated by "ThreadLocalRandom.current().nextInt("MINVALUE, MAXVALUE)
            value[i] = getRandomValue; // Assign the value from "getRandomValue" to the [i] position from the Array "value"
            System.out.print(value[i]+"|");
        }
        System.out.println("\n");
    }
}

 

[yfons123]

deine kommentare sind ein kompletter overkill

wenn du was "tun willst" ist das im regelfall der methoden name und es muss ausreichen den namen zu lesen um zu wissen was er tut

gen

was soll der methoden name sagen?

methoden namen werden so geschrieben

verb + nomen

bzw nur verb weil methoden tun was

generateNumber

sagt mir dass da ne nummer generiert wird egal was es intern tut

jedes mal wenn du ein kommentar schreiben musst heißt es dass du entweder schlecht benannt hast bei den variablen ODER eine methode macht zu viel

 

[Call_He_Tempi]

deine kommentare sind ein kompletter overkill

wenn du was "tun willst" ist das im regelfall der methoden name und es muss ausreichen den namen zu lesen um zu wissen was er tut

was soll der methoden name sagen?

methoden namen werden so geschrieben

bzw nur verb weil methoden tun was


sagt mir dass da ne nummer generiert wird egal was es intern tut

jedes mal wenn du ein kommentar schreiben musst heißt es dass du entweder schlecht benannt hast bei den variablen ODER eine methode macht zu viel

Die Kommentare sind eigentlich nur für mich. Ich mach n Screenshot und speichere das ab um später nicht lange suchen zu müssen.
Daher schreibe ich auch die internen Vorgänge auf um auch noch in zwei Monaten nachvollziehen zu können, was ich da gemacht habe.

 

[Call_He_Tempi]

methoden namen werden so geschrieben

bzw nur verb weil methoden tun was

Ah okay das ist interessant. Wenn nach einem Namen für Methoden suche nehme ich ein verb, wie "generate" oder "count" ?

 

[yfons123]

aber das ist doch der sinn von "gutem" code, dass isch der code selber erklärt ...


jeder weis was beim scanner die methode "readLine" tut... sie liest die zeile steckt ja im namen, keine sau braucht dazu ein kommentar

es gibt sachverhalte wo man ein kommentar braucht aber das sollte die ausnahme sein

um exakt zu beshcreiben wie die methode funktioniert kannst du in ein javadoc kommentar packen

 

[yfons123]

Ah okay das ist interessant. Wenn nach einem Namen für Methoden suche nehme ich ein verb, wie "generate" oder "count" ?

ja es gibt da "konventionen"

standard ist

getWidth

"gib mir breite" => verb + nomen

events werden so geschriebben ( wirst du auch irgendwann mal sehen bei GUI erstellen )

onActionEvent

also on + Eventtyp + Event

usw ... da gibts einiges, bei dem mit den events bin ich mir gerade aber selber nicht sicher

der fall mit verb funktioniert immer und ich versuch es dir mal so an deinem code zu erklären

du hast ein analyzerobject gemacht, das ist ja oke
da rufst du die methode coutner auf...
"analyzer counter"
neeee das kann man nicht übersetzen

analyzerObject.countNumbers();

wenn man das übersetzt
"analyzer zähl nummern" und schon hast nen satz und somit ist dein code wie ein buch zu lesen

da es alles sätze sind und sätze sind sehr einfach verständlich für den menschen deswegen ist das mit dem verb auch "konvention" da man dann automatisch sätze schreibt

 

[Jw456]

"on..." waren doch die Listener die Callback Methoden

 

[Neumi5694]

Die Kommentare sind eigentlich nur für mich. Ich mach n Screenshot und speichere das ab um später nicht lange suchen zu müssen.
Daher schreibe ich auch die internen Vorgänge auf um auch noch in zwei Monaten nachvollziehen zu können, was ich da gemacht habe.

Zu viel Dokumentation gibt's nicht, das machst du schon richtig.
Aber bei ordentlich benannten Variablen und Methoden erübrigt sich das meistens. In schlechter lesbaren Sprachen dokumentiert man oft tatsächlich jede einzelne Zeile.
Auf lange Sicht ist es sinnvoll, vor dem Code zu schreiben, warum ein Zähler z.B. bei 3 beginnt und nicht bei 0 (oder aber man verwendet eine Konstante dafür, deren Name das beschreibt).

Aber der Methodenname sollte lesbar sein, der soll mit wenigen "Worten" beschreiben, was die Methode macht. Im Idealfall steht da genau das, was man sonst in Worten ausdrücken würde.

Die genaue Beschreibung kommt dann in die Methodendokumentation.

/**
 * Das ist die Methodenbeschreibeung. Die Methode macht was Sinnvolles.
 * <br> Dabei ist wichtig, dass
 * <br> Folgende Fälle gibts:
 * <li>wert1: ...
 * @param aParameter. Der ist dazu da, um ...
 * @parem anotherParameter
 * @return
 * @throws NullpointerException im Fall von böser User
 */
ReturnClass doSomethingUseful( ...) {
  
}

 

[temi]

Wenn nach einem Namen für Methoden suche nehme ich ein verb, wie "generate" oder "count"

Es gibt auch noch die Variante für Methoden die ein boolean zurück geben: is... oder has... z. B. isValid()

 

[KonradN]

Es gibt auch noch die Variante für Methoden die ein boolean zurück geben: is... oder has... z. B. isValid()

Wobei "is" und "has" auch Verben sind

 

[temi]

Du hast ja so Recht!