425 lines
15 KiB
Markdown
425 lines
15 KiB
Markdown
# 02: Basics
|
|
|
|
## Table of Contents
|
|
1. [Nutzung der Konsole](#nutzung-der-konsole)
|
|
2. [Primitive Datentypen](#primitive-datentypen)
|
|
3. [Nicht Primitive Datentypen](#nicht-primitive-datentypen)
|
|
4. [Operatoren](#operatoren)
|
|
5. [Bedingungen](#bedingungen)
|
|
6. [Schleifen](#schleifen)
|
|
7. [Exceptions](#exceptions)
|
|
|
|
## Nutzung der Konsole
|
|
|
|
### Ausgabe
|
|
```java
|
|
|
|
System.out.println("print me and create a new line");
|
|
System.out.println(); // prints nothing but creates new line afterwards
|
|
|
|
System.out.print("print me without a new line | ");
|
|
System.out.print("print me but add a new line \n");
|
|
System.out.print("yeah, this is on the new line! \n");
|
|
System.out.println(); // prints nothing but creates new line afterwards
|
|
|
|
// https://www.digitalocean.com/community/tutorials/java-printf-method
|
|
System.out.printf("%s %s \n", "parameter 1", "parameter 2");
|
|
System.out.printf("%s %e %f", "10.50", 10.50, 10.50);
|
|
```
|
|
|
|
### Eingabe
|
|
```java
|
|
import java.util.Scanner;
|
|
|
|
// class and method : start
|
|
Scanner myScanner = new Scanner(System.in);
|
|
System.out.print("Enter Username: ");
|
|
String username = myScanner.nextLine();
|
|
System.out.print("Enter Password: ");
|
|
String password = myScanner.nextLine();
|
|
System.out.println("your Username: " + username + "\nyour password: " + password );
|
|
// class and method : end
|
|
```
|
|
|
|
## Primitive Datentypen
|
|
|
|
Quelle: [w3schools.com](https://www.w3schools.com/java/java_data_types.asp)
|
|
|
|
| Data Type | Size | Description |
|
|
|-----------|---------|-------------------------------------------------------------------------------------|
|
|
| byte | 1 byte | Stores whole numbers from -128 to 127 |
|
|
| short | 2 bytes | Stores whole numbers from -32,768 to 32,767 |
|
|
| int | 4 bytes | Stores whole numbers from -2,147,483,648 to 2,147,483,647 |
|
|
| long | 8 bytes | Stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 |
|
|
| float | 4 bytes | Stores fractional numbers. Sufficient for storing 6 to 7 decimal digits |
|
|
| double | 8 bytes | Stores fractional numbers. Sufficient for storing 15 decimal digits |
|
|
| boolean | 1 bit | Stores true or false values |
|
|
| char | 2 bytes | Stores a single character/letter or ASCII values |
|
|
|
|
### Type Casting
|
|
|
|
Bei Type Casting handelt es sich um das überführen eines primitiven Datentypen
|
|
in einen anderen.
|
|
|
|
Quelle: [w3schools.com](https://www.w3schools.com/java/java_type_casting.asp)
|
|
|
|
#### Widening Casting (automatically)
|
|
|
|
Hier wird ein kleinerer Typ in einen größeren Typ konvertiert
|
|
|
|
`byte` -> `short` -> `char` -> `int` -> `long` -> `float` -> `double`
|
|
|
|
```java
|
|
int myInt = 9;
|
|
double myDouble = myInt; // Automatic casting: int to double
|
|
|
|
System.out.println(myInt); // Outputs 9
|
|
System.out.println(myDouble); // Outputs 9.0
|
|
```
|
|
|
|
#### Narrowing Casting (manually)
|
|
|
|
Hier wird ein größerer Typ in einen kleineren Typ konvertiert
|
|
|
|
`double` -> `float` -> `long` -> `int` -> `char` -> `short` -> `byte`
|
|
|
|
```java
|
|
double myDouble = 9.78d;
|
|
int myInt = (int) myDouble; // Manual casting: double to int
|
|
|
|
System.out.println(myDouble); // Outputs 9.78
|
|
System.out.println(myInt); // Outputs 9
|
|
```
|
|
|
|
## Nicht Primitive Datentypen
|
|
|
|
### String
|
|
|
|
String ist eine Wrapperklasse, welche eine Zeichenkette aus einzelnen chars
|
|
zusammenbaut. In manchen Programmiersprachen (z.B. C++) ist ein String
|
|
vergleichbar mit einem char-Array.
|
|
|
|
```java
|
|
String myString = "this is a text";
|
|
System.out.println("myString: " + myString);
|
|
|
|
String concatString = "hello" + "World";
|
|
System.out.println("concatString: " + concatString);
|
|
```
|
|
|
|
Methoden der Standardbibliothek:
|
|
|
|
| Methode | Beschreibung |
|
|
|------------------------|-------------------------------------------------------------------------------------------------------------------------|
|
|
| myString.charAt() | Returns the char value at the specified index. |
|
|
| myString.indexOf() | Returns the index within this string of the first occurrence of the specified substring. |
|
|
| myString.substring() | Returns a string that is a substring of this string. |
|
|
| myString.equals() | Compares this string to the specified object. |
|
|
| myString.toLowerCase() | Converts all of the characters in this String to lower case. |
|
|
| myString.toUpperCase() | Converts all of the characters in this String to upper case. |
|
|
| myString.contains() | Returns true if and only if this string contains the specified sequence of char values. |
|
|
| myString.replaceAll() | Replaces each substring of this string that matches the given regular expression with the given replacement. |
|
|
| myString.compareTo() | Compares two strings lexicographically. The comparison is based on the Unicode value of each character in the strings. |
|
|
|
|
### Numeric Datatypes
|
|
|
|
Im Gegensatz zu den primitiven Datentypen werden hier "Wrapper" verwendet, um
|
|
dynamisch mit den Werten arbeiten zu können. Das erlaubt auch die Erweiterung
|
|
um verschiedene Methoden in der Standardbibliothek.
|
|
|
|
Integer:
|
|
```java
|
|
Integer myNumber = 10;
|
|
Integer.parseInt(); // Parses the string argument as a signed decimal integer.
|
|
Integer.parseUnsignedInt(); // Parses the string argument as an unsigned decimal integer.
|
|
Integer.valueOf(); // Returns an Integer object holding the value of the specified String.
|
|
```
|
|
|
|
Float and Double:
|
|
```java
|
|
Double myDouble = 10.0;
|
|
myDouble.isNaN(); // Returns true if this Double value is a Not-a-Number (NaN), false otherwise.
|
|
|
|
Float myFloat = (float)10.0;
|
|
myFloat.isNaN(); // Returns true if this Float value is a Not-a-Number (NaN), false otherwise
|
|
```
|
|
|
|
Funktionen für alle Numerischen Datentypen (Nicht Primitiv):
|
|
|
|
| Methode | Beschreibung |
|
|
|------------------------|---------------------------------------------------------------------------------------|
|
|
| myNumber.compareTo() | Compares two Integer objects numerically. |
|
|
| myNumber.toString() | Returns a String object representing this Integer's value. |
|
|
| myNumber.intValue() | Returns the value of this Integer as an int. |
|
|
| myNumber.floatValue() | Returns the value of this Integer as a float after a widening primitive conversion. |
|
|
| myNumber.doubleValue() | Returns the value of this Integer as a double after a widening primitive conversion. |
|
|
| myNumber.shortValue() | Returns the value of this Integer as a short after a narrowing primitive conversion. |
|
|
|
|
|
|
### Arrays
|
|
Bei Arrays handelt es sich um Schleifen eines bestimmten Datentypen. Sie werden
|
|
verwendet, um mehrere Werte in einer Variable zu speichern.
|
|
|
|
```java
|
|
String[] myStringArray = new String[3];
|
|
myStringArray[0] = "ROT";
|
|
myStringArray[1] = "GRÜN";
|
|
myStringArray[2] = "BLAU";
|
|
|
|
int[] myIntArray = {0,1,2};
|
|
|
|
System.out.println(myIntArray.length); // 3
|
|
System.out.println(Arrays.toString(myIntArray)); // [0,1,2]
|
|
```
|
|
|
|
multidimensionale Arrays:
|
|
```java
|
|
int[][] my2DArray = {
|
|
{1, 2},
|
|
{3, 4, 5},
|
|
{6, 7, 8, 9},
|
|
};
|
|
|
|
System.out.println(my2DArray.length);
|
|
System.out.println(my2DArray[0].length);
|
|
|
|
for(int row = 0; row < my2DArray.length; row++) {
|
|
System.out.print("[");
|
|
for(int column = 0; column < my2DArray[row].length; column++) {
|
|
if (column == (my2DArray[row].length - 1) ) {
|
|
System.out.print(my2DArray[row][column]);
|
|
continue;
|
|
}
|
|
System.out.print(my2DArray[row][column] + ", ");
|
|
}
|
|
System.out.println("]");
|
|
}
|
|
```
|
|
|
|
Methoden:
|
|
|
|
| Methode | Beschreibung |
|
|
|-----------------------------------|-------------------------------------------------------------------------------------------------------------------|
|
|
| Arrays.toString(Array a) | a string representation of the object. |
|
|
| Arrays.copyOf(Array a, int index) | Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. |
|
|
| Arrays.compare(Array a, Array b) | Compares two int arrays lexicographically. |
|
|
| Arrays.equals(Array a, Array b) | Returns true if the two specified arrays of ints are equal to one another. |
|
|
| Arrays.sort(Array a) | Sorts the specified array into ascending numerical order |
|
|
| Arrays.fill(Array a, int number) | Assigns the specified int value to each element of the specified array of ints. |
|
|
|
|
## Operatoren
|
|
|
|
### Arithmetic Operators
|
|
```java
|
|
int calcAddition = 20 + 10; // = 30
|
|
int calcSubstraction = 20 - 10; // = 10
|
|
int calcMultiplication = 20 * 10; // = 200
|
|
int calcDivision = 20 / 10; // = 2
|
|
int calcModulus = 20 % 3; // = 2
|
|
|
|
int myNumber = 10;
|
|
myNumber++; // myNumber = 11
|
|
myNumber--; // myNumber = 10
|
|
myNumber--; // myNumber = 9
|
|
```
|
|
|
|
### Comparison Operators
|
|
```java
|
|
int biggerNumber = 20;
|
|
int biggerNumberAgain = 20;
|
|
int smallerNumber = 10;
|
|
|
|
// (20 == 20) => true
|
|
// (20 != 20) => false
|
|
// (20 > 10) => true
|
|
// (20 < 10) => false
|
|
// (20 >= 10) => true
|
|
// (20 >= 10) => true
|
|
```
|
|
|
|
## Bedingungen
|
|
|
|
wir verwenden folgende Variablen:
|
|
```java
|
|
int biggerNumber = 20;
|
|
int biggerNumberAgain = 20;
|
|
int smallerNumber = 10;
|
|
```
|
|
|
|
### if-condition (better version)
|
|
```java
|
|
if (biggerNumber > smallerNumber) {
|
|
System.out.println("the left number is bigger!");
|
|
}
|
|
```
|
|
|
|
### if-condition (worse version)
|
|
```java
|
|
// prefer to not write it down like this!
|
|
if (biggerNumber == biggerNumberAgain)
|
|
System.out.println("We don't do this here...");
|
|
```
|
|
|
|
### if-else-condition
|
|
```java
|
|
if (biggerNumber < smallerNumber) {
|
|
System.out.println("the left number is smaller!");
|
|
} else if (biggerNumber < biggerNumberAgain) {
|
|
System.out.println("but this time, the left number is smaller!");
|
|
} else {
|
|
System.out.println("the left number is just too big!");
|
|
}
|
|
```
|
|
|
|
### switch-case
|
|
```java
|
|
int luckyNumber = 69;
|
|
switch (luckyNumber) {
|
|
case 13:
|
|
System.out.println("some people consider 13 to be a lucky number");
|
|
break; // we need this to avoid default!
|
|
case 7:
|
|
System.out.println("slot machines value this number high");
|
|
break; // we need this to avoid default!
|
|
default:
|
|
System.out.println("seems, your number was not lucky enough...");
|
|
}
|
|
```
|
|
|
|
## Schleifen
|
|
|
|
### while-loop
|
|
```java
|
|
int whileNumber = 3;
|
|
while (whileNumber > 0) {
|
|
System.out.println(whileNumber);
|
|
whileNumber --;
|
|
}
|
|
```
|
|
|
|
### do-while-loop
|
|
```java
|
|
System.out.println("--- doWhileNumber:");
|
|
int doWhileNumber = 3;
|
|
do {
|
|
System.out.println(doWhileNumber);
|
|
doWhileNumber--;
|
|
} while(doWhileNumber > 0);
|
|
```
|
|
|
|
### for-loop
|
|
```java
|
|
System.out.println("--- forNumber:");
|
|
for(int iterator = 0; iterator <= 5; iterator++) {
|
|
System.out.println(iterator);
|
|
}
|
|
```
|
|
|
|
### Beispiel Ausführung
|
|
```java
|
|
int myNumber = 1;
|
|
// count, how many times we can add 2 until we reach 16,
|
|
// but we pretend, 13 doesn't exist for reasons
|
|
for(int counter = 0; counter <= 10; counter++) {
|
|
myNumber += 2;
|
|
if (myNumber == 13) {
|
|
continue;
|
|
}
|
|
System.out.println(counter);
|
|
if (myNumber >= 16) {
|
|
break;
|
|
}
|
|
}
|
|
```
|
|
|
|
### Hinweis
|
|
Vermeidet einfache Variablennamen wie i, u, usw.m um die Lesbarkeit einfach zu halten
|
|
```java
|
|
//
|
|
for(int i = 0; i < 10; i++) {
|
|
for(int u = 30; i > 15; u++) {
|
|
myArray[u][i] = i + u;
|
|
}
|
|
}
|
|
```
|
|
|
|
### for-each-loop
|
|
|
|
#### arrays
|
|
```java
|
|
int[] myArray = {1, 2, 3};
|
|
|
|
for(int selectedValue: myArray) {
|
|
System.out.println("myArray: " + selectedValue);
|
|
selectedValue = 0;
|
|
}
|
|
|
|
System.out.println(Arrays.toString(myArray));
|
|
|
|
for(int selection: myArray) {
|
|
System.out.println(selection);
|
|
}
|
|
```
|
|
|
|
#### lists
|
|
```java
|
|
LinkedList<String> myLinkedList = new LinkedList<>();
|
|
myLinkedList.add("List_1");
|
|
myLinkedList.add("List_2");
|
|
myLinkedList.add("List_3");
|
|
|
|
for(int selectedValue: myArray) {
|
|
System.out.println(selectedValue);
|
|
}
|
|
```
|
|
|
|
### maps
|
|
|
|
```java
|
|
HashMap<Integer, String> myHashMap = new HashMap<>();
|
|
myHashMap.put(1, "Larry");
|
|
myHashMap.put(2, "Steve");
|
|
myHashMap.put(3, "James");
|
|
|
|
myHashMap.forEach((key, value) -> {
|
|
System.out.println(key + " " + value);
|
|
});
|
|
```
|
|
|
|
## Exceptions
|
|
|
|
```java
|
|
public class Main {
|
|
public static void main(String[] args) {
|
|
|
|
// simple exception handling
|
|
try {
|
|
int[] myNumbers = {1, 2, 3};
|
|
System.out.println(myNumbers[10]);
|
|
} catch (Exception exception) {
|
|
System.out.println(exception);
|
|
System.out.println("---");
|
|
}
|
|
|
|
// extended exception handling
|
|
try {
|
|
int[] myNumbers = {1, 2, 3};
|
|
printTenthIndex(myNumbers);
|
|
} catch (RuntimeException exception) {
|
|
System.out.println("class: " + exception.getClass()); // class: class java.lang.RuntimeException
|
|
System.out.println("cause: " + exception.getCause()); // cause: java.lang.RuntimeException: array is not big enough
|
|
System.out.println("message: " + exception.getMessage()); // message: index was not found
|
|
} finally {
|
|
System.out.println("finally! The 'try catch' is finished.");
|
|
}
|
|
}
|
|
|
|
public static void printTenthIndex(int[] array) throws RuntimeException {
|
|
Exception r = new RuntimeException("array is not big enough"); // not every exception supports causes
|
|
if (array.length < 11) {
|
|
throw new RuntimeException("index was not found", r);
|
|
}
|
|
System.out.println(array[10]);
|
|
}
|
|
}
|
|
``` |