---
# System prepended metadata

title: SQ06A

---

# SQ06A

> [name=Martin. S]
> [name=Lucas. C]
> [name=Lukas. B]
> [name=Linus. S]

## Aufgabe 1
#### Alter Code:

```java
public class DRYExample { 
	public static void main(String[] args) { 
		System.out.println("1 + 2 = " + add(1, 2)); 
		System.out.println("3 + 4 = " + add(3, 4)); 
		System.out.println("5 + 6 = " + add(5, 6)); 
	} 
	
	public static int add(int a, int b) { 
		return a + b; 
	}
 } 
```
#### Verbesserter Code:
```java
public class DRYExample { 
	public static void main(String[] args) { 
		printAddition(1, 2); 
		printAddition(3, 4); 
		printAddition(5, 6); 
	} 
	
	public static void printAddition(int a, int b) {
		System.out.println(a + " + " + b + " = " + add(a, b));
	}
	
	public static int add(int a, int b) { 
		return a + b; 
	}
}
```
Wir haben eine neue Methode "printAddition" erstellt um die Ausgabe der Additionsergebnisse zu handhaben. Sie kümmert sich um die Formatierung der Ausgabe und ruft die Methode add auf, um die Addition durchzuführen. Dadurch werden die Verantwortlichkeiten für die Addition und das Drucken voneinander getrennt, was dem SRP-Prinzip entspricht. Der Code entspricht auch dem DRY-Prinzip, da die Ausgabe nicht mehr wiederholt wird.

## Aufgabe 2
#### Alter Code:
```java 
public class TaskManager{
	private Task t1;
	private Task t2;
	private Task t3;
	
	/*… ausgeschnitten */
	
	public void displayTasks(){
		System.out.println("Task: " + t1.getName());
		System.out.println("Status: " + t1.getStatus());
		System.out.println("Task: " + t2.getName());
		System.out.println("Status: " + t2.getStatus());
		System.out.println("Task: " + t3.getName());
		System.out.println("Status: " + t3.getStatus());
	}
	
	/* … ausgeschnitten */
}
```
#### Verbesserter Code:
```java
public class TaskManager {
    private List<Task> tasks;

    public TaskManager() {
        tasks = new ArrayList<>();
        tasks.add(new Task());
        tasks.add(new Task());
        tasks.add(new Task());
    }

    public void displayTasks() {
        for (Task task : tasks) {
            System.out.println("Task: " + task.getName());
            System.out.println("Status: " + task.getStatus());
        }
    }
}
```
Um das DRY-Prinzip einzuhalten und Duplikationen zu vermeiden benutzt man nun eine ArrayList anstelle der individuellen Variabeln "t1", "t2", "t3", usw. Um das SRP-Prinzip einzuhalten wurde die "displayTask" Methode erstellt, welche einen for-schleife enthält um eine den Tasknamen und Status auszugeben. Somit wurde die Verantwortlichkeit vom Erstellen neuer Taks und der Ausgabe von Task getrennt.

## Aufgabe 3
#### Alter Code:
```java
public class UserAccount { 
	private String name; 
	private String email; 
	public void setName(String name) { 
		this.name = name; 
	} 
	
	public void setEmail(String email) { 
		this.email = email; 
	} 

	public void validate() { 
		if (name == null || email == null) { 
			throw new IllegalArgumentException("Name and email must be set!"); 
		} 
		// validate mail via Regex 
		if (!email.matches("^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$")) { 
			throw new IllegalArgumentException("Email is not valid!"); 
		}
	} 
}
```

#### Verbesserter Code:

```java=
public class UserAccount { 
	private String name; 
	private String email; 
	
	public void setName(String name) { 
		this.name = name; 
	} 
	
	public void setEmail(String email) { 
		this.email = email; 
	} 

	public boolean isNameSet() { 
		return name != null; 
	} 
	
	public boolean isEmailSet() { 
		return email != null; 
	}
	
	public boolean isEmailValid() { 
		if (email == null) { 
			return false; 
		}
		// validate email via Regex 
		return email.matches("^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$"); 
	} 
}
```
Um das SRP-Prinzip einzuhalten wurde die "Validate" Methode wird ausseinander genommen und in weitere kleinere Methoden aufgeteilt


## Aufgabe 4
#### Alter Code:
```java=
public class User{
	private String name;
	private String email;
	private String password;
	private Date geb_datum;
	
	public User(String name, String email, String password, Date geb_datum){
		this.name = name;
		this.email = email;
		this.password = password;
		this.geb_datum = geb_datum;
	}
}
```
#### Verbesserter Code:

```java=
public class User{
	private String email;
	private String password;
	
	public User(String email, String password){
		this.name = name;
		this.email = email;
		this.password = password;
	}
}
```
Um das YAGNI-Prinzip einzuhalten braucht es nach kein kein Geburtsdatum, und kein Name.

## Aufgabe 5
#### Welche Prinzipien werden in diesem Code verletzt und warum?
```java=
public class Account{ 
	private int balance; 
	public void deposit(int amount){ 
		balance += amount; 
	} 
	
	public void transferTo(int amount, Account a){ 
		a.setBalance(a.getBalance() += amount); 
	}
}
```
Das **SRP Prinzip** wurde verletzt. Die Klasse "Account" hat mehrere Responsibilitys:
1. Die Responsibility, über die "deposit" Methode einen Betrag zum Kontostand hinzuzufügen. 
2. Die Responsibility, über die "transferTo" Methode,  einen Betrag auf ein anderes Konto zu übertragen.

Die  transferTo Methode sollte in eineseparate Klasse ausgelagert werden, um das SRP einzuhalten.

Das **DRY Prinzip** wurde verletzt. Der Betrag *'amount'* wird sowohl zum aktuellen Kontostand *'(getBalance())'* als auch zur Balance des externen Kontos (*'a'*) hinzugefügt. Diese Duplikation des Additionscodes führt zu einer unnötigen Wiederholung.

Das **YAGNI Prinzip** wird nicht verletzt.


## Aufgabe 6
#### Welche Prinzipien werden in diesem Code verletzt und warum?
```java=
public class UtilityClass { 
	public static void printMessage(String message) { 
		System.out.println(message); 
	} 
	
	public static int addTwoNumbers(int a, int b) { 
		return a + b; 
	} 
	
	public static double calculateCirclePerimeter(double radius) { 
		return 2 * Math.PI * radius; 
	}
	
	public static int generateRandomNumber() { 
		Random random = new Random(); 
		return random.nextInt(); 
	}
}
```

Das **SRP Prinzip** wird verletzt. Die Klasse "UtilityClass" hat mehrere Responsibilitys:
1. Die Responsibility, über die "printMessage" Methode, eine Nachricht auf der Konsole auszugeben. 
2. Die Responsibility, über die "addTwoNumbers" Methode, zwei Zahlen zu addieren und das Ergebnis zurückzugeben.
3. Die Responsibility, über die "calculateCirclePerimeter" Methode, den Umfang eines Kreises basierend auf dem Radius zu berechnen.
4. Die Responsibility, über die "generateRandomNumber" Methode, eine Zufallszahl zu generieren.

Die Responsibilitys sollten in separate Klassen aufgeteilt werden. Jede Klasse sollte sich auf eine spezifische Verantwortlichkeit konzentrieren und nur die damit verbundenen Methode erhalten. So könnte man:

2. für die "addTwoNumbers" Methode eine Rechenoperationen-Klasse erstellen.
3. für die "calculateCirclePerimeter" Methode eine Geometrie- oder Kreisberechnungs-Klasse erstellen.
4.  für die "generateRandomNumber" Methode eine Randomisierungs- oder Zufallszahl-Klasse  erstellen.

Das **DRY Prinzip** wird nicht verletzt.

Das **YAGNI Prinzip** wird nicht verletzt.
