Liste mit 2 Werten pro Eintrag

[TJava]

Hallo, ich frage mich wie man am besten eine Liste mit 2 Werten pro Eintrage programmiert.

Ich habe das ganze nun folgendermaßen gelöst

public void addError(String errMessage, String errLevel) {
		/**
		 * errMessage errLevel
		 */
		HashMap<String, String> errorMap = new HashMap<String, String>();
		errorMap.put("errMessage", errMessage);
		errorMap.put("errLevel", errLevel);
		errorList.add(errorMap);

	}

Allerdings entsteht dadurch viel boilercode(nennt man das so 😀)

public boolean hasError() {
		return !errorList.isEmpty();
	}

if (cr.hasError()) {
			List<HashMap<String, String>> errorList = cr.getErrorList();
			for (Iterator iterator = errorList.iterator(); iterator.hasNext();) {
				HashMap<String, String> errorMap = (HashMap<String, String>) iterator
						.next();
				_logger.info(errorMap.get("errLevel"));
				_logger.info(errorMap.get("errMessage"));

			}
		}

Gruß,

Tim

 

[fhoffmann]

Hallo,

warum schreibst du dir nicht eine kleine Klasse Fehler mit jeweils einem Member für errMessage und errLevel (und einer toString()-Methode).

Gruß
Fritz

 

[TJava]

Wäre das nicht eine Datenklasse und sollte vermieden werden?

 

[JavaMeister]

Aha. Dann hast du Objekt orientierte Programmierung nicht verstanden.

 

[Phash]

Dein Fehler ist doch eine Klasse.
Jeder Fehler, den du produzierst ist eine Instanz dieser Klasse

 

[TJava]

haha ich suche gleich mal die Folie aus der Uni raus 😀
Vielleicht verstehe ich das aber auch falsch.

Objektorientierte Programmierung WS 2013/2014 - Folie 506
Objektorientierte Programmierung WS 2013/2014 - Folie 507

Die Frage ist wo fängt das an und wo hört das auf.

Ich habe das jetzt so implementiert. Also eine extra ErrorKlasse, ist das denn so üblich.

 

[Phash]

Stimmt, unnötige Klassen verschlechtern die Wartung.

Allerdings ist dein Fehler ja nicht unnötig.

Vielleicht willst du den Fehler ja aufheben (in einer Liste speichern) um ihn irgendwann abzuarbeiten - vielleicht willst du ihn auch für immer in einer Datenbank aufheben...

Selbst wenn du ihn nur an eine andere Klasse als Aufrufparameter übergibst, dort wird er genommen und gleich weggeworfen, ist es besser EINEN Parameter zu haben als dann 7 Strings. (So ein Fehler wächst schnell mal: da kommt der Timestamp hinzu, wann er aufgetreten wurde, dann kriegt er einen Timestamp, wann er bearbeitet wurde, dann bekommt er einen internen Bearbeitungsstatus und schon ist es mehr als nur 2 Strings zu Beginn)

Die Fehlerklasse würde genau einen Zweck erfüllen- Principle of Single Responsibility: Single-Responsibility-Prinzip ? Wikipedia

Die Fehler-Strings in einer anderen Klasse zu halten, würde dies genau verletzen.

Du kannst die Fehler, wenn du sie in einer anderen Klasse als Member-Strings hälst, woanders nicht weiterbenutzen.

Das heisst, um es wartungsfreundlich zu machen, machst du sehr kleine Klassen, die du testen kannst, und die du nie wieder anfassen musst.
Meiner Meinung nach, gibt es sowas wie "zu viele Klassen" eigentlich nicht. Wenn du es benennen kannst, ist es eine Klasse (pi mal Daumen)
Eine Videothek hat Abteilungen und Videos und Kunden und Geschäftszeiten - alles Klassen.
Ein Video hat auch noch einen Preis - wieder eine Klasse, und nicht nur eine Int-Variable von Video. (Evtl verleihen die ja auch noch CDs und schon brauchst du den Preis wieder...) etc...


Wenn du die Klasse fertig hast, getestet hast und sie ihren Zweck erfüllt, kannst du sie einfach benutzen, ohne dich darum kümmern zu müssen.
Machst du das alles in einer dicken Klasse, die alles kann und macht, musst du jedesmal wieder testen, ob sich das Verhalten nicht doch plötzlich geändert haben könnte -> hier sind wir beim Blob (um bei deiner Folie zu bleiben)

 

[turtle]

Was du brauchst, nennt der Mathematiker ein Tupel.
Daher habe ich eine solche Tupel-Klasse mal geschrieben😉
Der Test dazu

   @Test
    public void test() {
	Tupel<String, String> tupel = new Tupel<>("errMessage", "errLevel");
	assertEquals("errMessage", tupel.getT1());
	assertEquals("errLevel", tupel.getT2());
    }

Spoiler: Tupel

public class Tupel<T1, T2> {
    private T1 t1;
    private T2 t2;

    public Tupel(T1 t1, T2 t2) {
	this.t1 = t1;
	this.t2 = t2;
    }

    public T1 getT1() {
	return t1;
    }

    public void setT1(T1 t1) {
	this.t1 = t1;
    }

    public T2 getT2() {
	return t2;
    }

    public void setT2(T2 t2) {
	this.t2 = t2;
    }

}

 

[TJava]

Super Antworten, danke so wünscht man sich das auf dem Weg zu gutem Code 😉

Gruß,

Tim

 

[Phash]

Dann:
Thema als erledigt markieren, und den Danke Button klicken, wenn wir dir geholfen haben 🙂