Modularität?

V

vjung

Aktives Mitglied
Hallo lieber java-forum,

Ich habe das Thema Modularität in etwa so verstanden:
Durch Zerlegung eines komplexen Problemes in Teilprobleme entstehen sogenannte Module?

Wenn ich nun sagen wir einfach mal einen Taschenrechner programmieren möchte, könnte ich die einzelnen Operationen (+, -, *, / ...) als jeweils eigene Methoden schreiben und jede dieser Methode wäre dann ein Modul, habe ich dies denn richtig verstanden?
Außerdem muss die Schnittstelle so passen das ich weitere Module problemlos hinzufügen könnte ohne den restlichen Code wirklich verändern zu müssen?
Wäre an sich soweit alles kein Problem.
Habe nun jedoch eine Aufgabe hier:

Gegeben ist ein Programm (siehe nächste Seite), welches mathematische Ausdrücke auswerten und
ausgeben kann. Diskutieren Sie kritisch die Modularität dieser Implementierung.
Welche der folgenden Änderungen können modular ausgeführt werden und welche nicht?
a) Negative Zahlen sollen zusätzlich in Klammern dargestellt werden
b) Neben Drucken und Evaluieren soll auch Vereinfachen von Ausdrücken, z.B. x+0=x und –x=x
unterstützt werden.
c) Neben Addition soll auch Subtraktion unterstützt werden
Verändern Sie das Programm mit dem Ziel, die Modularität zu erhöhen. Erläutern Sie, inwiefern
ihre Implementierung besser ist. Welche Änderungen können jetzt modular durchgeführt werden,
welche nicht?
3
Zum Vergrößern anklicken....

Java: 
public class Main {
  public static void main(String[] args) {
    Expr e = new Add(new Add(new Number(1), new Neg(new Number(2))), new Number(4));
    System.out.print("Der Ausdruck ");
    new Printer().print(e);
    System.out.println(" evaluiert zu " + new Evaluator().eval(e));
  }
}

public interface Expr {}

public class Number implements Expr {
  public int value;
  public Number(int v) { this.value=v; }
}

public class Add implements Expr {
  public Expr left, right;
  public Add(Expr left, Expr right) { this.left=left; this.right=right; }
}

public class Neg implements Expr {
  public Expr expr;
  public Neg(Expr expr) { this.expr=expr; }
}

public class Printer {
  public void print(Expr e) {
      if (e instanceof Number)
          System.out.print(((Number) e).value);
      if (e instanceof Add) {
          System.out.print("(");
          print(((Add) e).left);
          System.out.print("+");
          print(((Add) e).right);
          System.out.print(")");
      }
      if (e instanceof Neg) {
          System.out.print("-");
          print(((Neg) e).expr);
      }
  }
}
public class Evaluator {
    public int eval(Expr e) {
        if (e instanceof Number)
            return ((Number) e).value;
        if (e instanceof Add)
            return eval(((Add) e).left) + eval(((Add) e).right);
        if (e instanceof Neg)
            return -eval(((Neg) e).expr);
        throw new RuntimeException("not a valid expression");
  }
}

Wollen die das ich für Teilaufgabe a eine extra methode schreibe oder einfach nur eine veränder?
Wenn ich den if Fall (e is instance of Neg) einfach veränder dann habe ich dies doch nicht modular erweitert so wie ich das verstehe?

Bei Teilaufgabe b) würde ich einfach mal sagen ja, kann man :D

und bei Teilaufgabe c) habe ich garkeine Ahnung was ich da als Ansatz nehmen würde, da ich wie gesagt auch nicht ganz verstanden habe wie man modular programmiert D:

Bitte helft mir
 
T

TM69

Bekanntes Mitglied
Unter einem Modul in der Softwareentwicklung versteht man eine Zusammenfassung von Methoden und Attributen, die ein abgeschlossene Aufgabe darstellt. In der objektorientierten Entwicklung sind dieses Klassen.
 
T

TM69

Bekanntes Mitglied
Kann M.L. nur zustimmen.

Bei der Analyse in objektorientierten Programmierung kannst du dir einfach folgendes Merken:

Substanvie => Objekt. ........ z.B. Ein Auto kann... (Auto = Klasse)
Adverbien => Methoden und Attribute..... z.B. Ein Auto kann bremsen (Klasse = Auto -> Methode = bremsen)
"Ist ein" => Generalisierung ..... z.B. Ein Auto ist ein Fahrzeug (abgleitete Klasse (Subclass) Auto -> Basis Klasse (Superklasse) = Fahrzeug)
"Hat ein" => Assoziation .... z.B. Ein Auto hat Räder (Die Klassen Auto und Räder haben eine Beziehung untereinander)
 
Zuletzt bearbeitet:
X

Xyz1

Gast
Das lässt sich im ersten Schritt einfacher schreiben:
Java: 
	public static void main(String[] args) {
		Expr e = new Add(new Add(new Number(1), new Neg(new Number(2))), new Number(4));
		System.out.print("Der Ausdruck ");
		e.print();
		System.out.println(" evaluiert zu " + e.eval());
	}
}

class Expr {
	public int eval() {
		return eval(this);
	}

	private int eval(Expr e) {
		if (e instanceof Number)
			return ((Number) e).value;
		if (e instanceof Add)
			return eval(((Add) e).left) + eval(((Add) e).right);
		if (e instanceof Neg)
			return -eval(((Neg) e).expr);
		throw new RuntimeException("not a valid expression");
	}

	public void print() {
		print(this);
	}

	private void print(Expr e) {
		if (e instanceof Number)
			System.out.print(((Number) e).value);
		if (e instanceof Add) {
			System.out.print("(");
			print(((Add) e).left);
			System.out.print("+");
			print(((Add) e).right);
			System.out.print(")");
		}
		if (e instanceof Neg) {
			System.out.print("-");
			print(((Neg) e).expr);
		}
	}
}

class Number extends Expr {
	public int value;

	public Number(int v) {
		this.value = v;
	}
}

class Add extends Expr {
	public Expr left, right;

	public Add(Expr left, Expr right) {
		this.left = left;
		this.right = right;
	}
}

class Neg extends Expr {
	public Expr expr;

	public Neg(Expr expr) {
		this.expr = expr;
	}
}

im zweiten Schritt noch einfacher:
Java: 
	public static void main(String[] args) {
		Expr e = new Add(new Add(new Number(1), new Neg(new Number(2))), new Number(4));
		System.out.print("Der Ausdruck ");
		e.print();
		System.out.println(" evaluiert zu " + e.eval());
	}
}

class Expr {
	public int eval() {
		return this.eval();
	}

	public void print() {
		System.out.print(this.toString());
	}
}

class Number extends Expr {
	public int value;

	public Number(int v) {
		this.value = v;
	}

	@Override
	public String toString() {
		return String.valueOf(value);
	}

	public int eval() {
		return value;
	}
}

class Add extends Expr {
	public Expr left, right;

	public Add(Expr left, Expr right) {
		this.left = left;
		this.right = right;
	}

	@Override
	public String toString() {
		return "(" + left.toString() + ")+(" + right.toString() + ")";
	}

	public int eval() {
		return left.eval() + right.eval();
	}
}

class Neg extends Expr {
	public Expr expr;

	public Neg(Expr expr) {
		this.expr = expr;
	}

	@Override
	public String toString() {
		return "-(" + expr.toString() + ")";
	}

	public int eval() {
		return -expr.eval();
	}
}


Stelle diese 3 Versionen gegenüber, 2 Klassen und unzählige instanceof fliegen raus. Welche Vorteiler ergeben sich noch? :)
 
X

Xyz1

Gast
Upps, muss nochmal eine Schönheitskorrektur machen
Java: 
abstract class Expr {
	public abstract int eval();

	public void print() {
		System.out.print(this.toString());
	}
}


(Expr sollte abstract sein, dass keiner auf die Idee käme den Spaß unmittelbar zu instanziieren)
 
temi

temi

Top Contributor
TM69 hat gesagt.:
Adverbien => Methoden und Attribute..... z.B. Ein Auto kann bremsen (Klasse = Auto -> Methode = bremsen)
Zum Vergrößern anklicken....

Klugscheißmodus an: Du meinst vermutlich Verben. Adverbien sind etwas anderes. Adverb, von lat. adverbium „was beim Verb steht“. Beispiele für Adverbien sind: "oft" oder "gerne" => Wir gehen gerne in die Natur. Wir gehen oft in die Natur.
 

Aktuelle Jobs

Neue Themen


Oben