Objektattribut in Methode erhöhen?

Hallo, ich verzweifle gerade an etwas vermutlich Banalem:
Ich habe in meinem Programm eine Art Schlange fester Länge drin (IrgendJemand kennt bestimmt das Fachwort dafür):
Ich habe ein String Array der Länge 16 (eigentlich würde es auch ein char array tun da nur „Z“,„R“;„S“ und „U“ vorkommen; will mich aber nicht mit ascii code vs buchstabe rumärgern, aber das nur am Rande).

Naturgemäß ist diese maximal 16 Sachen umfassende Schlange eingangs leer (ich initialisiere alle 16 Positionen mit „U“ für unbekannt.)

Dann soll pro runde eine Farbe („R“,„S“ oder „Z“) hinzugefügt werden können.
Sollte die Schlange schon voll sein, also 16 strings ungleich „U“ sein, dann soll das älteste Element durch die neue Farbe ersetzt werden.

Klar könnte ich nun hingehen im array alles „eins nach unten schieben“ und die 0te position mit dem neuen String belegen.
Ist aber performance technsich unschön, daher benutze ich eine „cycling queue“ (oder so ähnlich hieß das Teil).
ich habe also wie gesagt das 16 Strings umfassende array und einen cursor, der auf das aktuellste Element im array zeigt.
das Element unterm Cursor und die aufsteigend (modulo 16) folgenden 15 Elemente sind dann eben die aktuelle Schlange.

Langes vorgerede aber ich scheitere gerade am hinzufügen eines neuen Strings.
Habe mir eine Methode gebaut, der man den neuen String übergibt.
Im Prinzip muss ja nur der Cursor um 1 runtergesetzt werden (halt modulo 16, heißt war der cursor vorher auf index 0, dann ist er danach auf index 15)
und an der (neuen) cursorposition muss der string ausgetauscht werden.

der cursor ist halt ein int, der als objektattribut vorhanden ist (und bei objekterzeugung mit 15 initialisiert wurde. sprich, ich fülle von oben nahc unten auf eingangs) und in der methode um eins runtergesetzt werden soll.

code sieht wie folgt aus, stark eingeschränkt auf das Wichtige:
(Da sind noch zwischendrin 200 ineinander verschachtelte Methoden, die sich gegenseitig aufrufen und eine davon ruft halt die addcolor auf.
Man kann davon ausgehen dass da ganz korrekt ein string der methode übergeben wird, also am restlichen kram scheitert es sicher nicht.)



public class Test {
	String[] Colors=new String[16]; //Array der letzten 16 gezogenen Farben
	int NewIndex=15;//index of the last drawn color
	
	double[] et,ft; //nächste Einsätze et=Farbe, ft=Null
	
	double[] einsbut={0.1,0.5,1,2,5,10,25,50,100,500,1000};
	
	Robot bot = new Robot();

	
	Map EZP = new HashMap(); //einsätze->indec
	
	Map VTK = new HashMap(); //index->einsätze
	
	int currwheelpos=2;//left most position of the visible wheel right now, 5 pos visible at once
	
	public static void main(String[] args)throws AWTException, InterruptedException{
		
		//Disbale scaling??
		//System.setProperty( "sun.java2d.uiScale", "1.0" );

		
		//Start Timetracking
		Test a=new Test();
		
		
	}
//Konstruktor und andere Methoden hier

	//fertig
	public void addColor(String color){
		NewIndex=  (NewIndex-1>=0) ? (NewIndex--) : (NewIndex=NewIndex+15);
		Colors[NewIndex]=color;
	}
}

Aus Tests weiß ich dass zwr erfolgreich die Farbe ausgetauscht wird, aber der Cursor einfahc nicht um 1 verkleinert wird.
Heißt, als resultat verändert die methode immer nur das selbe element anstatt bei jedem aufruf um eins runter zu gehen und jenes element zu ändern.
weil eben newindex nichtv errignert wird wie hingeschrieben!

Weiß Jemand woran das liegen könnte oder wie ich es besser mache?
Die umsetzung als objektattribut erscheint mir aktuell die sinnhafteste Art diesen Counter von überall zugreifbar zu halten.

Nur meine Vermutung aber kann es an irgendetwas Schwachsinnigem liegen wie „innerhalb einer Methode kann ein Objektattribut nicht geändert werden“ oder sowas? O_o

Das Problem mit der Fixierung auf Arrays ist, dass sie den Blick auf eine einfach Lösung verstellen…

Wenn Du statt einem Array eine Implementierung vom Interface List nemen würdest lösten sich Deine Probleme in Luft auf:

private final List<String> collorQueue = new LinkedList<>();
void addColor(String newColor)[
  collorQueue.add(newColor);
  if(16<collorQueue.lenght())
      collorQueue.remove(0);
}

bye
TT

ich mag eigentlich meine arrays. ich will nicht wirklich mit linkedlist und ähnlichem rumhantieren wenn es nicht zwingend sein muss.
die sind vermutlich auch performancemässig lan
gsamer, oder?

Mich ärgert es schon dass ich überhaupt hashmaps für mein Programm brauche.

Ja, sind sie. Nimm lieber ne Deque, genauer: eine ArrayDeque.

Richtig brisant wird das aber erst ab Millionen von Operationen. :wink: Aber das ist dennoch kein Grund, um nicht von Anfang an die richtige DS einzusetzen. :slight_smile:

NIcht solchen Code wie

NewIndex= (NewIndex-1>=0) ? (NewIndex--) : (NewIndex=NewIndex+15);

schreiben :astonished: Da is so viel Murx drin komprimiert, dass ich es gerade als Herausforderung sehe, aufzuzählen:

  • NewIndex-1>=0 ist NewIndex>=1
  • Der Fall von NewIndex = NewIndex--; ist das klassische Beispiel für „So schreibt man das nicht, aber in einer Anfänger-Klausur kommt garantiert mal die Frage ‚Was kommt dabei raus?‘, weil so schön viele sie falsch beantworten“
  • Der andere Fall lautet, ausgeschrieben
    NewIndex=NewIndex=NewIndex+15 :dizzy_face:

Also: Schreib’ das nochtmal richtig, und … probier’ halt mal sowas hier aus:

System.out.println("addColor wurde mit "+color+" aufgerufen");
System.out.println("NewIndex ist vorher  "+NewIndex);
if (...) { ... }
System.out.println("NewIndex ist nachher "+NewIndex);

und du wirst sehen: Wenn du den Wert richtig änderst, dann … macht der Computer auch das, was du ihm sagst…


Zum Thema Performance: Achte nicht drauf. Nicht auf dieser Ebene. Und wenn du mir nicht glaubst:

(Und wenn du nicht weißt, wer Brian Goetz ist: Achte nicht auf Performance :wink: )

1 „Gefällt mir“

Ergänzend zu den vielen richtigen Bemerkungen (Premature optimization is the root of all evil) noch ein Hinweis:

200 verschachtelte Methoden sind ein deutlicher Hinweis darauf, dass deine Klasse viel zu viele Dinge tut und du in einzelne Klassen abgeschlossene Bereiche auslagern solltest, ganz unabhängig davon, was für eine Unterstruktur du verwendest.

Ja, aber anstatt der LinkedList, die primär nicht dafür gedacht ist, könnte er schon die ArrayDeque verwenden, die genau für diesen Anwendungsfall gedacht ist. Er muss nur eben den Code entschlacken.

import java.util.ArrayDeque;
import java.util.Deque;

public class MyLimitedQueue<Elem> {
    public final int limit = 16;
    private final Deque<Elem> queue = new ArrayDeque<>();

    public void add(Elem e) {
        if (queue.size() >= limit) {
            queue.removeFirst();
        }
        queue.addLast(e);
    }

    public Elem removeAndGetFirst() {
        return queue.removeFirst();
    }
}
1 „Gefällt mir“

Solange du auf einem handelsüblichen Rechner der letzten 20 Jahre arbeitest, wird ein System.arraycopy() zeitlich nicht messbar sein, auch wenn ich einen Ringspeicher hier tatsächlich - premature optimization hin oder her - auch für das Beste halte.

Ringspeicher.

2 „Gefällt mir“

okay, jetzt wo ich das so lkese, ergibt es Sinn :slight_smile:
Ich bin es einfach extrem gewohnt NewIndex-- und so zu schreiben.

Hatte diesen komischen ternären Operator so im Hinterkopf wie wenn das so eine if Bedingung wäre und die 2 Klammern das wären, was a ausgeführt wird.
An das NewIndex= auf der linken Seite habe ich einfach gar nicht mehr gedacht, aber so ergibt das natürlich viel Sinn.
Werde es gleich mal ausbessern gehen :slight_smile:

Von Deque habe ich wirklich noch nie gehört, muss ich mich mal einlesen dazu

Das mit dem Ausdrucken hatte ich versucht, daher wusste ich ja ursprünglich auch dass die variable nicht erhöht oder eniedrigt wird.
Mir fiel bloss nicht auf, warum nicht facepalm

Ich shcätze mal, so sit es sinnvoller, oder? :slight_smile:
Habe auch noch an 2 anderen Stellen Anpassungen gemacht wo ich den ternären Operator (flasch) benutzt hatte.
Nun läuft es, zumindest dieser Teil :slight_smile:

NewIndex=  (NewIndex>=1) ? (NewIndex-1) : (NewIndex+15);

Wenn das falsch wäre, wäre es richtig.
Die neue Variante sieht sinnvoller aus.

Dass sie auf vielen anderen Ebenen unsinnig ist, ist klar. Dort sollte NIE diese 15 stehen. Zumindest sollte das Colors.length sein, was eigentlich colors.length sein sollte, was eigentlich elements.length sein sollte, und das sollte in einer eigenen Klasse sinnvoll gekapselt sein, aber … es geht dir offenbar nicht darum, „Software zu entwickeln“, und es geht dir offensichtlich nichtmal darum, zu „Programmieren“, sondern nur darum, „Code hinzuschreiben, damit der Computer irgendwas macht“, von daher ist das wohl gerade alles egal.

1 „Gefällt mir“

ehm wat?

Ich verstehe gerade nur tweilweise was du mir sagen willst.
Welche elements meisnt du da?

Klar könnt eich Colors.length schreiben, von mir aus. Aber für ein einziges String Array extra eine Color Klasse, womgölich noch mit 3 int Attributen R,G und B anlegen, etc. pp.?

Naja, man kann es aber auch übertreiben mit dem betriebenen Aufwand :smiley:

Und du hast nicht ganz Unrecht, solange es halbwegs sinnhaft ist und tut was es soll bin ich happy damit :slight_smile:

Will ja Niemanden an der uni mit meiner Objektorientiertheit beeindrucken, es soll schnell und eifnahc das tun, was es soll.

Und irgendwie hege ich so meine Zweifel, von der Ausführungsgeschwindigkeit her, ob man mit der Erzeugung von zig Objekten und Unterobjekten so viel besser dran ist…

Die übergeordnete Botschaft ist: Dein Code ist schlecht.

Das klingt aber halt so pauschal und unfundiert. „Schlecht“ hat viele Ausprägungen. (Es gibt oft viele Ausprägungen für „schlecht“ - für „gut“ sind es meistens deutlich weniger…). Und ich bin mir nicht sicher, wie weit ich in diese „Schlechtheit“ reinzoomen soll (oder inwieweit dich das überhaupt interessiert).

Das bezog sich darauf, dass du an dieser Stelle nicht 15 in den Code schreiben solltest, sondern stattdessen Colors.length, wobei Colors der Name deines Arrays ist. (Wobei ich gerade sehe, dass der Array eine Länge von 16 hat, und ich mich frage, wo die 15 überhaupt herkommt…). Der Punkt ist: Wenn du die Länge des Arrays irgendwann änderst, müßtest du auch diese 15 ändern. Das ist aber unpraktikabel.

Das ist OK. Und verständlich. Nicht jeder hat den Anspruch an sich selbst etwas zu machen, was nicht offensichtlich komplett ‚schlecht‘ ist. Ich hacke auch manchmal schnell irgendwas hin, wenn ich nur will, dass der Computer für mich eine Sache erledigt, bei der es zu aufwändig wäre, sie händisch zu machen.

Da ist (obwohl ich jetzt schon oft das Wort ‚schlecht‘ verwendet habe :wink: ) erstmal noch keine soooo starke „Wertung“ dabei.

Einen absurden Widerspruch erkenne ich aber dann, wenn du …

  • Fragen stellst, die sich gar nicht stellen würden, wenn du versuchen würdest, es „besser“ zu machen
  • von der „Ausführungsgeschwindigkeit“ redest.

In bezug auf letzteres würde ich dir empfehlen, mal ein bißchen mit C (der Programmiersprache) zu entwickeln. Erstens würdest du dann die Vorzüge von Java mehr zu schätzen wissen. Zweitens würdest du erkennen, dass „Performance“ ihren Preis hat. Drittens würdest du dann einige Dinge lernen, die auch dazu beitragen könnten, „performanteren“ Java-Code zu schreiben. Drittens wüßtest du dann, dass String ein absurd-kompliziertes Objekt ist. Java ist einen steinigen Weg gegangen, um String so verwendbar zu machen, wie es ist. Aber stell’ dir mal vor, du müßtest statt

String[] Colors=new String[16];
int NewIndex=15;//index of the last drawn color
	
public void addColor(String color){
    ...
    Colors[NewIndex]=color;
}

sowas schreiben wie

char** colors = (char*)malloc(16 * sizeof(char*));
for (int i=0; i<16; i++) {
    colors[i] = malloc(sizeof(char));
}

void addColor(const char* color) {
    ...
    memcpy(colors[i], color, sizeof(char));
}

Dann würdest du wahrscheinlich erkennen, dass ein ein-elementiger char-Array nicht so clever ist, und das schon 1000 weitere Fragen aufwirft. (D.h. du würdest deinen String[] durch einen char[] ersetzen - ob die Farbe nun "U" ist, oder 'U', spielt so gesehen keine Rolle).

Nah, könnte noch weitermachen. Aber … lohnt sich das?


EDIT: Ach, das hatte ich hingehackt, während ich die Antwort geschrieben habe

package bytewelt;

import java.util.Arrays;

public class RingBufferExample
{
    public static void main(String[] args)
    {
        StringRingBuffer b = new StringRingBuffer(4, "U");
        System.out.println("Initially     : " + b + ", current is " + b.get());
        b.add("A");
        System.out.println("After adding A: " + b + ", current is " + b.get());
        b.add("B");
        System.out.println("After adding B: " + b + ", current is " + b.get());
        b.add("C");
        System.out.println("After adding C: " + b + ", current is " + b.get());
        b.add("D");
        System.out.println("After adding D: " + b + ", current is " + b.get());
        b.add("E");
        System.out.println("After adding E: " + b + ", current is " + b.get());
        b.add("F");
        System.out.println("After adding F: " + b + ", current is " + b.get());
    }
}

class StringRingBuffer
{
    private final String array[];
    private int index;
    
    StringRingBuffer(int size, String defaultValue)
    {
        if (size < 0)
        {
            throw new IllegalArgumentException(
                "The size may not be negative, but is " + size);
        }
        this.array = new String[size];
        Arrays.fill(array, defaultValue);
        this.index = 0;
    }
    
    void add(String string)
    {
        array[index] = string;
        index = (index + 1) % array.length;
    }
    
    String get()
    {
        int i = (index - 1 + array.length) % array.length;
        return array[i];
    }
    
    @Override
    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i=0; i<array.length; i++)
        {
            if (i > 0)
            {
                sb.append(", ");
            }
            sb.append(array[i]);
        }
        sb.append("]");
        return sb.toString();
    }
}
1 „Gefällt mir“

Das ist ziemlich hart, und würde ich einem Anfänger nie an den Kopf werfen.

  1. Das ist vollkommen okay!
  2. Lieber mit kleinen Erfolgen motivieren (es funktioniert) statt von Anfang an perfekt machen zu wollen und aufzugeben
  3. Perfektion durch Iteration

Jedes Array in Java kennt seine eigene Größe „array.length“ bzw. in deinem Falle Colors.length gibt 16 zurück. Das ist kein Aufwand. Marco meint einfach, du hast die Größe des Arrays an 3 verschiedenen Stellen in deinem Code geschrieben. Versuch doch mal die Größe des Arrays in deinem Code zu verändern, was für Aufwand das verursacht, vor allem aber was für Fehlerquellen entstehen wenn das nicht richtig gemacht wird.

Jetzt ist das noch kein Problem, wenn du bisschen Übungen machst zum Programmieren UND auch - ganz offensichtlich - die Motivation hast dich damit zu beschäftigen - dann ist das alles noch kaum ein Problem.

So hab ich damals auch gedacht. Also ich kenne deine Gedanken. Und dann hab ich irgendwann zum ersten mal einen Debugger für meine Android App angeworfen. So viele Objekte wie die JVM im Hintergrund in Sekunden erzeugt und vernichtet hatte, und das auf einer (mittlerweile sehr alten) mobilen Plattform. Da haben meine paar Tausende Objekte keinen sichtbaren Anteil mehr gehabt.

Naja, ich bin, auch in Mathe, eher der Typ der erst mal guckt dass ich es für ne feste Zahl hinkrieg. und danahc kann man es immer noch erweitern und anpassen um mit avriablen Längen klarzukommen.
An sich könnte ich auch irgendwo als Attribut die längen der Arrays vorschreiben und dann das Attribut überall benutzen oder so.

Jetzt traue ich mich ja fast nicht mehr, mit meiner nächsten Frage anzukommen…
Aber was solls, schlimmer als Vorheriges wirds auch nicht sein :smiley:
Vermutlich mache ich mich mit der Frage noch Lächerlicher wie beim letzten Mal…
le Code:

	public void RundebisDreh() throws InterruptedException, AWTException, Exception{
		//einsätze für aktuelle runde auffarbfelder und null platzieren
		//einsätze leeren sicherheitshalber
		int l=GetStreakLength();
		
		String color="R";
		if(getCurrColor().equals("R")){color="S";}//only change color if it is red
		
		double etemp=et[l];
		double ftemp=et[l];
	
		//nur für Testzwecke eingefügt, wieder löschen!!!!
		etemp=2.9;
		ftemp=0.4;
		
		
		System.out.println("Einsätze für diese Runde sind: Farbe="+etemp+", Null="+ftemp);
		//bet on zero with ftemp
		// bet with etemp on the opposite of what col is
		//dont bet at all if etemp and ftemp are equal to zero, aka their product is zero
		
		
		//einsätze leeren
		Click("del");
		
		//falls es eine nullrunde ist
		if(etemp*ftemp==0.0){
			//rollbutton klicken
			Click("dreh");
			return;
		}
		//place the bets and press the roll button
		double temp=0.0;
		System.out.println("etemp="+etemp+", ftemp="+ftemp+", temp="+temp);
		
		for(int i=10;i>=0;i--){
			temp=Double.parseDouble (VTK.get(i)+"");
			System.out.println("Vor einsatzclick!");
			//click einsatzclick(i)
			if((etemp>=temp)||(ftemp>=temp)){
				einsatzclick(i);
			}
			System.out.println("Nach einsatzclick!");
			while(etemp>=temp){
				//farbe klicken
				System.out.println("etemp Schleife!");
				Click(color);
				etemp=etemp-temp;
				System.out.println("Placed "+temp+" on "+color+"!");
				System.out.println("etemp now only "+etemp);
			}
			while(ftemp>=temp){
				//null klicken
				Click("Z");
				ftemp=ftemp-temp;
				System.out.println("Placed "+temp+" on Z!");
				System.out.println("ftemp now only "+ftemp);
			}			
		}
		
		
		if(etemp*ftemp!=0){
			System.out.println("Something went horribly wrong while placing the bets!");
		}
		
		Click("dreh");
	}

Steht viel Kram drin, den zu verstehen nicht wirklich nötig ist.
Click ist halt ne Funktion, die basierend auf dem input String wo klickt.
et und ft Arrays der Länge 17 (Man schlage mich tot wegen der Namensgebung. Aber sie ergibt Sinn in meinem Kopf).
GetStreakLength() ist halt auch eine Methode die einen int auswirft.
VTK ist eine Hashmap.
Der Ausdruck temp=Double.parseDouble (VTK.get(i)+"");
sorgt dafür dass bei jedem Durchlauf der for Schleife temp ganz bestimmte Double Zahlen zugewiesen werden.

langer Rede kurzer Sinn:
mein problem kommt bei der Ungenauigkeit beim kommazhlen subtrahieren.
Nachfolgend was die Konsole dazu sagt was passiert. mal von einigem Fillertext abgesehen wird bspw. eingangs etemp auf 2.9 gesetzt.
dann wird 2.0 abgezogen, sollte also 0.9 rauskommen.
Es kommt aber 0.8Periode9 raus.
-0.5 ergibt hier 0.3 periode9.
-0.1 ergibt 0.2999999…993.
Hier kommen irgendwelche ungenauigkeiten vor, die mir gar nicht passen und die mir den Plan schmeisen wenn ich zum beispiel prüfe ob etemp>=0.1 ist.
für etemp=0.1 würde es zutreffen, aber für etemp=0.0periode9 nicht.

Ich kann mir, mal wieder, nicht erklären woher diese Ungenauigkeiten kommen, aht vermutlich mit dem verwendeten Double Format zu tun.
Kann man die irgendwie ausbügeln dass er da genau rechnet?

Nun. Das habe ich ja auch nicht von Anfang an gesagt. Stattdessen hatte ich ja versucht, (nur) Verbesserungen zu benennen. Aber wenn Vorschläge da mit " :man_shrugging: na, is doch egal, wenn’s läuft" abgetan werden, kann man auch deutlicher sagen, was Sache ist. Dass „irgendein hingehackter Murx“ auch mal OK sein kann, hatte ich auch erwähnt … aber … ich habe mich im meinem Leben (im Beruf bisher fast ausschließlich) mit „Wenn’s-Läuft-Is-Gut“-code rumärgern müssen. Wenn man aus der vermeintlichen Einfachheit und Gnädigkeit von Sprachen (und Leuten, die einem Feedback geben) zu viel Bestätigung zieht, hat man ja nie eine Motiviation, es „besser“ zu machen.

Aber nochmal relativierend @bernd1 : Ja, ich bin recht deutlich. Aber es ist an sich recht einfach: Versuch’ dir vorzustellen, was du denken würdest, wenn DU irgendwelchen Code liest, wo eine Zeile wie NewIndex= (NewIndex-1>=0) ? (NewIndex--) : (NewIndex=NewIndex+15); drin vorkommt: Du müßtest lange lesen, um nachzuvollziehen, was das eigentlich heißen soll, nur um am Ende festzustellen, dass es schlicht keinen Sinn ergibt. Und sowas wie

et und ft Arrays der Länge 17 (Man schlage mich tot wegen der Namensgebung. Aber sie ergibt Sinn in meinem Kopf).

deutet eben auf ein Mindset hin, das GANZ anders ist, als das, was ich für richtig halte: Man schreibt Code nicht, damit der Computer etwas macht. Man schreibt Code auch nicht für sich selbst. Man schreibt ihn für andere Personen. (Und diese „andere Person“ ist oft genug „Man selbst, drei Monate später“ :wink: )

Die Ungenauigkeiten gibt es „immer“, in praktisch jeder Programmiersprache (mit wenigen Ausnhmen, und dort eben mit den entsprechenden Kosten). Man muss sich darüber im Klaren sein, dass bestimmte Zahlen im Computer nicht ohne weiteres „genau“ darstellt werden können.

In der Welt, in der wir Menschen normalerweise rechnen, gibt es das Problem auch: Was ist 1.0/3.0? Ja, 0.3333333333333333333333333333333333. Das ist ungenau. Egal, wie viele Dreien man hinschreibt.

Es gibt Leute, die bei diesem Thema schnell mal auf What Every Computer Scientist Should Know About Floating-Point Arithmetic verlinken, weil’s cool ist. Andere sagen ganz platt: „Nimm BigDecimal!“, und das ergibt praktisch nie Sinn (es wirft viel mehr Fragen auf, als es beantwortet).

Realistischere oder übliche Herangehensweisen sind dort oft:

  • Nicht double verwenden. Wenn man einen Geldbetrag als double kostenInEuro = 1.10; speichern würde, kann man stattdessen oft int kostenInCent = 110; verwenden.
  • Irgendwelche „epsilons“ zu verwenden. Das hat auch seine Tücken. Aber in einfachen Fällen kann man halt sowas machen wie das hier:
private static final double EPSILON = 1e-5;

public void rechne() {
    ...
    if (etemp+EPSILON>=0.1) { ... }
}

um zu prüfen, ob etemp „beinahe“ (oder größer als) 0.1 ist.

2 „Gefällt mir“

tja - Computer können keine Kommazahlen, das sind immer nur Nährungen an das Orginal (Gleitkommazahl – Wikipedia) - Du musst also auf die Nährung an Deinen Wert prüfen

ansonsten: neue Frage → neues Thema

nicht „Klar könnt ich…“ sondern machen - aus folgenden Gründen.

  • besteht Dein Programm aus mehreren Klassen/tausenden Zeilen Code, wirst Du viel Freude haben die nötigen Zahlen zu tauschen, einfach nach 15 Suchen und durch was anderes zu ersten ist nicht sinnvoll, die Wahrscheinlichkeit ist recht hoch, das Du eine 15 mit einem anderen Sinn im Quelltext hast
  • Java wird dir das übersehen einer 15 (mehr oder weniger) verzeihen, indem es ggf. eine Exception wirft, in C/C++ bekommst Du im Idealfall einen kompletten Absturz, meistens hast Du ein undefiniertes Programmverhalten, und dann such mal den Fehler für dieses Verhalten
  • Automatismus: auch bei einfachen/nicht komplexen Dingen vernünftig schreiben, dann machst Du es automatisch bei wichtigen Dingen
2 „Gefällt mir“