Programmieren-Wiki

https://sdq.kastel.kit.edu/programmieren/
Admin
This wiki, created for a programming course at KIT, provides students with fundamental programming...
Tokens:109,481
Snippets:833
Trust Score:9.7
Update:9 months ago
Show doc for...
Tokens:
Raw
### Implement Quake 3 Inverse Square Root Algorithm in C

Source: https://sdq.kastel.kit.edu/programmieren/Schwieriger_Code

Illustrates the Quake 3 'quick inverse square root' algorithm in C. The negative example shows the original implementation with cryptic comments, while the positive example provides more descriptive comments to explain the bit-level manipulation and the Newton-Raphson iteration for approximation.

```c
/**
 * Q_rsqrt "Quick-inverse-square-root" calculates the inverse square-root of a given number.
 * param number The number to calculate the square-root of
 * return float The square-root of the given number
 */
float Q_rsqrt( float number ) {
	long i;
	float x2, y;
	const float threehalfs = 1.5F;

	x2 = number * 0.5F;
	y  = number;
	i  = * ( long * ) &y; // evil floating point bit level hacking
	i  = 0x5f3759df - ( i >> 1 ); // what the fuck?
	y  = * ( float * ) &i;
	y  = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration
    //y  = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed

	return y;
}

```

```c
/**
 * Q_rsqrt "Quick-inverse-square-root" calculates the inverse square-root of a given number.
 * param number The number to calculate the square-root of
 * return float The square-root of the given number
 */
float Q_rsqrt( float number ) {
	long i;
	float x2, y;
	const float threehalfs = 1.5F;

	x2 = number * 0.5F;
	y  = number;
	i  = * ( long * ) &y; // Converting the adress from a float which is tied to the IEEE-754 standard to a long which allows "proper" bit-magic
	i  = 0x5f3759df - ( i >> 1 ); // This will result in a good approximation. The magic number improves accuracy of the approximation by giving it the least average differentiation from the real value
	y  = * ( float * ) &i;
	y  = y * ( threehalfs - ( x2 * y * y ) ); // first iteration of approximating with the newton method

	return y;
}

```

--------------------------------

### Positive Example: JavaDoc Comment Structure

Source: https://sdq.kastel.kit.edu/programmieren/JavaDoc

This example illustrates the correct way to structure JavaDoc comments, with detailed descriptions for classes and methods, including parameter and exception information.

```java
/**
 * Implements a generic game.
 * @author AwesomeDeveloper
 */
public class Game {

    /**
     * Simulates a turn on the board.
     * A turn can only be simulated if the player does not exit the board. In that case an error should occurr.
     *
     * @return a boolean signalling a (un)successful turn
     * @throws IllegalArgumentException if the turn could not be simulated because of a wrong input.
     */
    public boolean doTurn() throws IllegalArgumentException {

    }
}
```

--------------------------------

### Informative JavaDoc Example (Java)

Source: https://sdq.kastel.kit.edu/programmieren/JavaDoc_Trivial

An example of a well-written, informative JavaDoc comment that clearly explains the method's purpose, behavior, and return value. This serves as a positive example for effective documentation.

```java
/**
 * Gets the full name of the person, i.e. the first name(s) separated by whitespaces, followed by a whitespace and the last name.
 * This method returns {@code null} if no name was set.
 *
 * @return the full name of the person or {@code null} if no name was set
 */
public String getName() {
    return this.name;
}

```

--------------------------------

### Negative Example: JavaDoc Comment Structure

Source: https://sdq.kastel.kit.edu/programmieren/JavaDoc

This example demonstrates an incorrect structure for JavaDoc comments, including overly simplistic descriptions and missing details in method comments.

```java
/**
 * This is a game.
 * @see otherGame
 * @author someone
 */
public class Game {

    /**
     * Do a turn and see what happens.
     * @throws IllegalArgumentException because why not
     */
    public boolean doTurn() throws IllegalArgumentException {

    }
}
```

--------------------------------

### Lambda Expression Syntax Example

Source: https://sdq.kastel.kit.edu/programmieren/Lamda_Expressions

Demonstrates the basic syntax of a lambda expression in Java. It shows how to define parameters, use the arrow token '->', and structure the code body. This example checks if a person's age is within a specific range.

```Java
p -> p.getAge() >= 18 
&& p.getAge() <= 25
```

```Java
p -> {
return p.getAge() >= 18
&& p.getAge() <= 25
}
```

--------------------------------

### JavaDoc Comment Example with Method

Source: https://sdq.kastel.kit.edu/programmieren/JavaDoc

This snippet demonstrates a standard JavaDoc comment for a method, including a summary, detailed description, HTML formatting, and various block tags like @param, @return, @see, and @throws. It also shows an inline tag @link.

```java
/**
* Returns an Image object that can then be painted on the screen. 
* The url argument must specify an absolute <a href="#{@link}">{@link URL}</a>. The name
* argument is a specifier that is relative to the url argument. 
* <p>
* This method always returns immediately, whether or not the 
* image exists. When this applet attempts to draw the image on
* the screen, the data will be loaded. The graphics primitives 
* that draw the image will incrementally paint on the screen. 
*
* @param  url  an absolute URL giving the base location of the image
* @param  name the location of the image, relative to the url argument
* @return      the image at the specified URL
* @see         Image
*/
public Image getImage(URL url, String name) {
    try {
        return getImage(new URL(url, name));
    } catch (MalformedURLException e) {
        return null;
    }
}

```

--------------------------------

### Programming Against Interfaces in Java

Source: https://sdq.kastel.kit.edu/programmieren/SOLID

Demonstrates how to program against interfaces in Java for increased flexibility. It shows an example of using ArrayList directly versus using the List interface, highlighting the ease of switching implementations (e.g., from ArrayList to LinkedList) when programming against an interface.

```java
List list = new ArrayList(); // oder auch LinkedList

public void maxElement(List list) {...}
```

--------------------------------

### Person Class Definition

Source: https://sdq.kastel.kit.edu/programmieren/Lamda_Expressions

Defines a simple 'Person' class in Java with attributes for name, birthday, and email address. It includes methods for getting the person's age and printing their details, serving as a basis for filtering examples.

```Java
public class Person {

    String name;
    LocalDate birthday;
    String emailAddress;

    public int getAge() {
        // ...
    }

    public void printPerson() {
        // ...
    }
}
```

--------------------------------

### Trivial JavaDoc Example (Java)

Source: https://sdq.kastel.kit.edu/programmieren/JavaDoc_Trivial

An example of a trivial JavaDoc comment that does not provide meaningful information about the method's functionality. This serves as a negative example, highlighting what to avoid.

```java
/**
 * 
 * @return name
 */
public String getName() {
    return this.name;
}

```

--------------------------------

### Grundlagen der Versionskontrolle mit Git

Source: https://sdq.kastel.kit.edu/programmieren/Spezial%3ASuche/%241

Dieses Snippet gibt einen kurzen Überblick über Git, ein Versionskontrollsystem. Es verweist auf eine Vorlesung für tiefere Einblicke und konzentriert sich auf die für das Arbeiten mit Artemis notwendigen Befehle.

```Text
Einblick in Versionskontrolle mit Git gibt es in der Vorlesung Softwaretechnik 1. In diesem Artikel werden lediglich die, zum Arbeiten mit Artemis, notwendigen
```

--------------------------------

### Java Account und UI Implementierung (Negativbeispiel)

Source: https://sdq.kastel.kit.edu/programmieren/IO/UI

Diese Java-Codebeispiele zeigen eine Implementierung, bei der die Benutzeroberfläche (UI) direkt mit der Logikklasse (Account) interagiert und Ausgaben tätigt. Dies bindet die Logik an die spezifische UI-Implementierung und erschwert die Wiederverwendbarkeit, z.B. in einer GUI.

```java
public class UI {
	public static void main(String[] args) {
		Account a = new Account(100);
		while(true) {
			System.out.println("Input an Integer");
			String input = ""; 
			// We will imagine the input being produced here
			int amount = 0;
			try {
				amount = Integer.parseInt(input);
			} catch(NumberFormatException e) {
				continue;
			}
			a.transfer(amount);
		}
	}
}

public class Account {
	private int balance;
	
	public Account(int startingBalance) {
		balance = startingBalance;
	}
	
	public void transfer(int amount) {
		if (balance + amount > 0) {
			balance += amount;
			System.out.println("Balance: " + balance);
		} else {
			System.out.println("Unable to make transfer. Your balance is: " + balance);
		}
	}
}
```

--------------------------------

### Java Account und UI Implementierung (Positivbeispiel)

Source: https://sdq.kastel.kit.edu/programmieren/IO/UI

Dieses Java-Codebeispiel präsentiert eine verbesserte Implementierung, bei der die Logikklasse (Account) ihre Zustandsänderungen über Rückgabewerte signalisiert und die UI für die Ausgabe zuständig ist. Dies fördert die Trennung und Wiederverwendbarkeit der Logik.

```java
public class UI {
	public static void main(String[] args) {
		while(true) {
			System.out.println("Input an Integer");
			String input = "";
			// We again imagine the input is present now
			int amount = 0;
			try {
				amount = Integer.parseInt(amount);
			} catch(NumberFormatException e) {
				continue;
			}
		}
		
		if (a.transfer(amount)) {
			System.out.println("Balance: " + a.getBalance());
		} else {
			System.out.println("Unable to make transfer. Your balance is: " + a.getBalance())
		}
	}
}

public class Account {
	private int balance;
	
	public Account(int startingBalance) {
		this.balance = startingBalance;
	}
	
	public boolean transfer(int amount) {
		if (balance + amount > 0) {
			balance += amount;
			return true;
		} else {
			return false;
		}
	}
	
	public int getBalance() {
		return balance;
	}
}
```

--------------------------------

### Java: 'main'-Methode als Programm-Einstiegspunkt

Source: https://sdq.kastel.kit.edu/programmieren/Nur_Main

Dieses Beispiel zeigt die empfohlene Verwendung der 'main'-Methode als reinen Einstiegspunkt. Sie validiert Kommandozeilenargumente, lädt eine Konfigurationsdatei und startet dann die Hauptanwendung. Fehler werden abgefangen und entsprechende Meldungen ausgegeben. Dies dient als Muster für eine gut strukturierte 'main'-Methode.

```java
public static void main(String[] args) {
    // Validieren der Parameter
    if (args.length < 1) {
        System.err.println("Please enter the path to configuration file");
        return;
    }

    Config config;
    try {
        // Laden der Konfigurationsdatei
        config = ConfigLoader.load(args[0]);
    } catch (IllegalArgumentException exception) {
        // Abfangen von Exceptions
        System.err.println("The configuration file could not be loaded:" +
            exception.getMessage());
        return;
    }

    // Erzeugen und Starten der Hauptanwendung
    Application app = new Application(config);
    app.run();
}
```

--------------------------------

### Anzeigen von Programm-Dokumentation mit 'man' (Linux/macOS)

Source: https://sdq.kastel.kit.edu/programmieren/Kommandozeile

Der 'man'-Befehl (manual) auf Unix-basierten Systemen zeigt detaillierte Dokumentation zu fast jedem installierten Programm direkt in der Kommandozeile an. Das Programm, dessen Dokumentation abgerufen werden soll, wird als Argument übergeben.

```shell
man <Programmname>
```

--------------------------------

### Simple Java Enum Example

Source: https://sdq.kastel.kit.edu/programmieren/Enum

A basic example of a Java enum defining a set of named constants for directions. This demonstrates the fundamental syntax for creating an enum type with limited functionality.

```java
public enum Direction {
	NORTH,
	EAST,
	SOUTH,
	WEST;
}
```

--------------------------------

### Primzahlberechnung: Schlechte vs. Gute Implementierung (Java)

Source: https://sdq.kastel.kit.edu/programmieren/Komplexit%C3%A4t

Vergleicht zwei Implementierungen zur Berechnung von Primzahlen: eine mit hoher Verschachtelungstiefe (schlechtes Beispiel) und eine, die Hilfsmethoden verwendet (gutes Beispiel). Die gute Implementierung zerlegt die Logik in kleinere, verständlichere Funktionen, was die Lesbarkeit und Wartbarkeit verbessert.

```Java
public static List<Integer> primesBad(final int max) {
    final List<Integer> primes = new ArrayList<>();
 
    for(int n = 1; n <= max; n++) {
        int divisors = 0;
 
        for(int i = 1; i <= n; i++) {
            if(n % i == 0) {
                divisors++;
            }
        }
 
        if(divisors == 2) {
            primes.add(n);
        }
    }
 
    return primes;
}
```

```Java
public static List<Integer> primesGood(final int max) {
    final List<Integer> primes = new ArrayList<>();
 
    for(int n = 1; n <= max; n++) {
        if(isPrime(n)) {
            primes.add(n);
        }
    }
 
    return primes;
}

private static boolean isPrime(final int n) {
    int divisors = 0;
 
    for(int i = 1; i <= n; i++) {
        if(divides(i, n)) {
            divisors++;
        }
    }
 
    return divisors == 2;
}

private static boolean divides(final int divisor, final int dividend) {
    return dividend % divisor == 0;
}
```

--------------------------------

### Java Enum with Attributes and Methods Example

Source: https://sdq.kastel.kit.edu/programmieren/Enum

An example of a Java enum representing planets, including attributes (mass, radius) and methods (surfaceGravity, surfaceWeight). This showcases how enums can encapsulate data and behavior.

```java
public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    private double mass() { return mass; }
    private double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    private static final double G = 6.67300E-11;

    double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}
```

--------------------------------

### Debugging-Tools und Prozess

Source: https://sdq.kastel.kit.edu/programmieren/Spezial%3ASuche/%241

Dieses Snippet beschreibt die Verwendung von Debugging-Buttons in einer Entwicklungsumgebung. Es erläutert die Funktionen zum Ausführen, Stoppen und schrittweisen Durchlaufen eines Programms im Debugging-Modus.

```Text
Buttons um uns in dem Debugging-Prozess zu unterstützen: Zunächst die Buttons (1- 8): Führt das Program erneut im Debugging-Modus aus Stoppt das Programm Springt
```

--------------------------------

### Manual Scanner Closing Example in Java

Source: https://sdq.kastel.kit.edu/programmieren/Scanner

This example shows how to manually close a Scanner after use. While functional, it requires the developer to remember to call `scanner.close()` explicitly, which can be error-prone if not handled carefully. It reads lines from System.in until a 'quit' command.

```java
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    while (scanner.hasNext()) {
        String line = scanner.nextLine();
        // do something with line
        if (line.equals("quit")) {
            break;
        }
    }
    scanner.close();
}
```

--------------------------------

### Java Enum Example for Customer Type (Incorrect Usage)

Source: https://sdq.kastel.kit.edu/programmieren/Enum

A negative example demonstrating an incorrect way to use enums for conditional logic in Java. This approach is discouraged as it leads to bloated code and violates open/closed principles.

```java
public enum CustomerType {
    CHILD,
    ADULT,
    SENIOR;
}

public class Customer {
    private double balance;
    private CustomerType type;
 
    public Customer(double balance, 
	CustomerType type) {
        this.balance = balance;
        this.type = type;
    }
 
    double payEntryFee() {
        double fee;
        switch(type) {
            case CHILD : fee = 5.00; break;
            case ADULT : fee = 10; break;
            case SENIOR : fee = 8; break;
        }
        balance -= fee;
        return fee;
    }
}
```

--------------------------------

### Java: 'main'-Methode mit ausgelagerter Logik

Source: https://sdq.kastel.kit.edu/programmieren/Nur_Main

Dieses Beispiel demonstriert eine verbesserte Struktur, bei der die Logik aus der 'main'-Methode in separate Klassen (Calculator, Parser) ausgelagert wurde. Die 'main'-Methode ist nun übersichtlicher und fokussiert sich auf die Orchestrierung des Programmflusses, während die detaillierte Implementierung in spezialisierten Klassen liegt. Dies fördert die Wiederverwendbarkeit und Wartbarkeit des Codes.

```java
public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        Parser parser = new Parser();

        int x;
        int y;
        try {
            x = parser.parseX(args);
            y = parser.parseY(args);
        } catch (IllegalArgumentException exception) {
            System.err.println("Parsing failed:" + exception.getMessage());
            return;
        }
        
        calculator.add(first, second);
    }
}

public class Calculator {
    public void add(int x, int y) {
        if (x < 0 || y < 0) {
            System.err.println("Negative numbers are not allowed.");
            return;
        }
        int result = x + y;
        System.out.println("Result: " + result);
    }
}

public class Parser {
    public int parseX(String[] args) {
        if (args.length < 1) {
            // Throws exception
        }
        return Integer.parseInt(args[0]);
    }

    public int parseY(String[] args) {
        // Parses the passed in y and checks if correct
    }
}
```

--------------------------------

### Neglected Scanner Closing Example in Java

Source: https://sdq.kastel.kit.edu/programmieren/Scanner

This is a negative example demonstrating a common pitfall where a Scanner is created but never closed. This can lead to resource leaks, as the InputStream remains blocked and unavailable to other processes. It reads lines from System.in indefinitely until 'quit' is entered.

```java
public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    while (scanner.hasNext()) {
        String line = scanner.nextLine();
        // do something with the line
        if (line.equals("quit")) {
            break;
        }
    }
}
```

--------------------------------

### Implement Student Class for Testing (Java)

Source: https://sdq.kastel.kit.edu/programmieren/JUnit

This Java code defines a basic Student class with constructor and placeholder equals() and hashCode() methods. It serves as the initial class to be tested.

```java
package kit;

public class Student {
    private String name;
    private String surName;
    private int matriculationNumber;

    public Student(String name, String surName, int matriculationNumber) {
        this.name = name;
        this.surName = surName;
        this.matriculationNumber = matriculationNumber;
    }

    @Override
    public boolean equals(Object obj) {
        return this == obj;
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }
}

```

--------------------------------

### Use Polymorphism instead of instanceof in Java - Positive Example

Source: https://sdq.kastel.kit.edu/programmieren/Verwendung_von_instanceOf

Illustrates the proper use of polymorphism in Java to achieve the same result as the negative example. An abstract method is defined in the superclass 'Person', and subclasses 'InfoStudent' and 'Employee' provide their specific implementations, leading to more extensible code.

```java
abstract class Person {
	public abstract String getActivity();
}

class InfoStudent extens Person {
	@Override
	public String getActivity() {
		return "Ich studiere Informatik";
	}
}

class Employee extends Person {
	@Override
	public String getActivity() {
		return "Ich arbeite in der Industrie";
	}
}

//...
public void talk(Person[] persons) {
	for (Person person : persons) {
		System.out.printf("%s …%n", person.getActivity());
	}
}


```

--------------------------------

### Positive Example: Using Constants for Magic Numbers in Java

Source: https://sdq.kastel.kit.edu/programmieren/Schlechter_Bezeichner

This Java code snippet demonstrates the proper use of named constants (e.g., CAPACITY, DEFAULT_VALUE) to replace magic numbers. By defining constants with meaningful names, the code becomes self-explanatory, improving readability and simplifying future modifications.

```java
public final class Main {
    
    private final static int CAPACITY = 3;
    private final static int DEFAULT_VALUE = 9;
    
    private Main() {

    }

    public static void main(String[] args) {
        int[] relevantNumbers = new int[CAPACITY];
        fillArray(relevantNumbers, DEFAULT_VALUE);
    }
    
    public static void fillArray(int[] array, int defaultValue) {
        for (int i = 0; i < array.length; i++) {
            array[i] = defaultValue + i;
        }
    }
}
```

--------------------------------

### Java Example: Documented empty catch block

Source: https://sdq.kastel.kit.edu/programmieren/Leerer_Block/Leerer_Konstruktor

Presents a positive example of an intentionally empty catch block in Java. This snippet shows how to correctly document the reason for an empty catch block, explaining that the exception is non-critical and does not require further handling, thus improving code clarity.

```java
try {
    file.close();
} catch (IOException e) {
    // File cannot be closed, but this is non-critical,
    // as the program can still continue running normally here.
    // No further handling required.
}
```

--------------------------------

### Java Example: Empty if-statement block

Source: https://sdq.kastel.kit.edu/programmieren/Leerer_Block/Leerer_Konstruktor

Demonstrates a negative example of an empty if-statement block in Java. This illustrates how an empty block can raise questions about missing functionality and emphasizes the need for either implementing logic or providing a clear comment explaining why the block is intentionally empty.

```java
public class Matrix {
	public void printMatrixSize(int size) {
		if (size == 0) {
		
		} else {
			System.out.println("Matrix is of size " + (size * size));
		}
	}
}
```

--------------------------------

### Create Information Template (Wiki Markup)

Source: https://sdq.kastel.kit.edu/programmieren/Spezial%3ABeitr%C3%A4ge/Jv1963

This snippet demonstrates the wiki markup for creating an 'Information' template. It uses HTML `div` elements with specific styling and Flexbox for layout to display informational messages. It accepts 'hinweis' (notice) and 'kommentar' (comment) parameters.

```text
<includeonly><div style="display:flex;align-items:center;gap:1rem;padding:1em 2em;margin-bottom:1em;border-radius:0 1em;background-color:rgb(234, 240, 250);"><div style="color:rgb(70, 100, 170);">{{FA|fa-solid fa-circle-info fa-2xl}}</div><div>'''{{{hinweis|}}}''' ''{{{kommentar| }}}''</div></div></includeonly><noinclude>Template zum Hinweis auf Informationen. {{Information|hinweis=Hier der Hinweistext|kommentar=Erläuterung zum Hinweis}} Benutzung m…
```

--------------------------------

### Create MediaWiki Login Prompt (Wiki Markup)

Source: https://sdq.kastel.kit.edu/programmieren/Spezial%3ABeitr%C3%A4ge/Jv1963

This snippet defines the wiki markup for the MediaWiki login prompt. It provides instructions for users to log in using their KIT account or a local account, integrating with other wiki templates like 'Information' and 'MediaWiki:Login-message-kit'.

```text
{{Information|hinweis=Anmeldung mit KIT-Konto:|kommentar=Falls du ein KIT-Konto besitzt, klicke bitte direkt auf die Schaltfläche '''{{MediaWiki:Login-message-kit}}''', ''ohne'' hier Benutzernamen und Passwort anzugeben. Falls du ein lokales Konto besitzt, gib bitte die Daten unten ein und klicke auf '''{{MediaWiki:login}}'''.}}
```

--------------------------------

### Refactor Complex Java Method with Helper Function

Source: https://sdq.kastel.kit.edu/programmieren/Schwieriger_Code

Demonstrates refactoring a complex Java method by extracting a sorting algorithm into a private helper method. This improves readability by separating concerns and making the main method easier to understand. The negative example shows the original complex method without the helper.

```java
public void endGame(int[] numbers, Player player) {
    int size = numbers.length;
    for (int i = 0; i < size - 1; i++) {
        int minimumIndex = i;
        for (int j = i + 1; j < size; j++) {
            if (numbers[j] < numbers[minimumIndex]) {
                minimumIndex = j;
            }
        }
        int temp = numbers[minimumIndex];
        numbers[minimumIndex] = numbers[j];
        numbers[j] = temp;
    }
    int sum = 0;
    String result = "";
    for (Integer number : numbers) {
        number += sum;
        result += number + " ";
    }
    System.out.println(result);
    System.out.println("Player " + player.getName() + " scored: " + sum);
}

```

```java
public void endGame(int[] numbers, Player player) {

    int[] sortedNumbers = selectionSort(numbers);

    int sum = 0;
    String result = "";

    for (Integer number : sortedNumbers) {
        number += sum;
        result += number + " ";
    }

    System.out.println(result);
    System.out.println("Player " + player.getName() + " scored: " + sum);
}

// The standard selectionsort algorithm.
private int[] selectionSort(int[] unsortedNumbers) {
    int[] numbers = unsortedNumbers;
    int size = numbers.length;
    for (int i = 0; i < size - 1; i++) {
        int minimumIndex = i;
        for (int j = i + 1; j < size; j++) {
            if (numbers[j] < numbers[minimumIndex]) {
                minimumIndex = j;
            }
        }
        int temp = numbers[minimumIndex];
        numbers[minimumIndex] = numbers[j];
        numbers[j] = temp;
    }
    return numbers;
}

```

--------------------------------

### Hauptmethode mit Parameterprüfung

Source: https://sdq.kastel.kit.edu/programmieren/Spezial%3ASuche/%241

Dieses Java-Snippet zeigt eine 'main'-Methode, die die Kommandozeilenparameter validiert. Wenn keine Parameter übergeben werden, wird eine Fehlermeldung ausgegeben und das Programm beendet.

```Java
static void main(String[] args) {
    // Validate parameters
    if (args.length < 1) {
        System.err.println("Please enter the path to configuration file");
        return;
    }
    // Process configuration file path...
}
```

--------------------------------

### Positive Example: Instance Attribute and Method in Java

Source: https://sdq.kastel.kit.edu/programmieren/Statische_Methoden_und_Attribute

This Java code snippet presents a positive example for the Receipt class, avoiding static attributes and methods where inappropriate. The id is passed to the constructor, and getTotalPrice is an instance method that correctly accesses the object's state, illustrating better object-oriented design.

```java
public class Receipt {  
    private final int id;  
    private final List<Product> products;  

    public Receipt(int id, List<Product> products) {  
        this.id = id;    // Der idCounter wird an anderer Stelle gespeichert, z.B. in der Klasse die Receipts erzeugt und speichert  
        this.products = products;  
    }

    private double getTotalPrice() {  
        double total = 0;  

        for (Product product : this.products) {  
            total += product .getPrice();  
        }

        return total;  
    }
}
```

--------------------------------

### Negative Example: Using instanceof for Polymorphic Behavior (Java)

Source: https://sdq.kastel.kit.edu/programmieren/Polymorphie

Illustrates a less maintainable approach to polymorphism using `instanceof` checks within a method. This 'negative example' shows how conditional logic based on object type can lead to complex and error-prone code, especially as the number of types increases. It's contrasted with a more robust, idiomatic OOP solution.

```Java
class Cat{
	public void purr() {}
}

class Dog{
	public void fetch() {}
}

class Main {
	public static void main(String[] args) {
		Dog dog = new Dog();
        speak(dog);
        Cat cat = new Cat();
        speak(cat);
	}

	public static void speak(Object animal) {
		if (animal instanceof Cat) {
			System.out.println("Cat has spoken");	
		} else if (animal instanceof Dog) {
			System.out.println("Dog has spoken");
		} else {
			System.out.println("I don't know how that animal speaks");
		}
	}
}
```
Tokens:
Raw