# Basiswissen Java

## Grundlagen
### Objektorientierte Programmierung

* //Kommentare für Herr Anske immer mit Doppel
* // die Kommentare sind auch für euch sinnvoll ;)
* **Klassen** sind abstrakt
* **Objekte** sind spezifisch
* **Variabeln** definieren in Java:
*int loanLength;
String message;
boolean game0ver;*

# **Was ist ein Konstuktor:**
* **Wichtig dafür dass ein Objekt überhaupt erzeugt werden kann**

* [Hamster Wissen und Erklärungen zu Java](http://www.java-hamster-modell.de/eBooks/hamster1.pdf)

Ein **Objekt** ist ein abgeschlossenes Element eines Computerprogramms, das eine Gruppe mit verwandten Features darstellt und dafür ausgelegt ist, bestimmte Aufgaben zu erfüllen.

Eine **Klasse** ist eine Vorlage, die zur Erzeugung eines Objektes dient. Jedes Objekt, das auf Grundlage der selben Klasse erzeugt wurde, hat ähnliche oder sogar identische Eigenschaften. Vererbung ist ein Mechanismus, der es einer Klasse ermöglicht, alle Verhaltensweisen und Attribute einer anderen Klasse zu erben. Diese wird als Subklassse/Unterklasse bezeichnet.

Eine Java Klasse besteht aus zwei verschiedenen Informationstypen: **Attribut** und **Verhaltensweise**

**Attribute** sind Daten, die die einzelnen Objekte voneinander unterscheiden. Sie können benutzt werden, um die Erscheinung, den Zustand und andere Eigenschaften von Objekten festzulegen, die zu den Klassen gehören.

Eine **Klassenvariable** definiert ein Attribut einer ganzen Klasse. Die Variable bezieht sich auf die Klasse selbst und all ihre Instanzen, sodass nur ein Wert gespeichert wird und abhängig davon, wie viele Objekte dieser Klasse erzeugt wurden.
* Eine **Klasse** ist die Oberklasse für die Objekte der Unterklassen
* Die Klasse Robita ist eine Unterklasse von Roboter
* Sie erbt damit **alle** Attribute und Methoden der Klasse Roboter.

**Methoden** sind Gruppen miteinander in Beziehung stehender Anweisungen in einer Klasse. Sie dienen zur Erfüllung spezifischer Aufgaben an ihrem eigenen und auch an anderen Objekten. Sie werden so verwendet, wie es in anderen Programmiersprachen mit Funktion und Subroutinen der Fall ist.

**Objekte** kommunizieren über Methoden. Eine Klasse oder ein Objekt kann Methoden in anderen Klassen oder Objekten aus unterschiedlichen Gründen aufrufen.
* um anderen Objekten von einer Änderung zu berichten.
* um ein anderes Objekt anzuweisen, etwas zu ändern
* um ein anderes Objekt aufzufordern, etwas zu machen

Eine **Instanz** ist dasselbe, wie ein Objekt. Jedes Objekt ist eine Instanz einer Klasse. Eine Variable, die ein Attribut von der Instanz einer Klasse (der ganzen Klasse) beschreibt, ist eine Instanzvariable.

Ein **Font-Objekt** repräsentiert Name, Stil und Punktgröße der Schrift.

* private boolean kannBewegen(): Der Sensor überprüft, ob sich der Roboter bewegen kann?

* public void schraubeAblegen (): Der Roboter legt eine Schraube auf seinem Feld ab.

{%youtube XdPopEO3Vas %}

[Tutorial](https://panjutorials.de/tutorials/der-ultimative-java-kurs/)

## Sichtbarkeit
Wenn der modifier vor einer Methode oder Klasse steht: Wer kann darauf zugreifen?

Beispiel:
public - Klasse, Attribut oder Methode ist für alle sichtbar
private - Klasse, Attribut oder Methode ist quasi unsichtbar

|Modifier | die Klasse selbst |Paket|Abgeleitete Klasse |Außerhalb der Klasse
| -------- | -------- | -------- |-------- |-------- |
| public | Ja | Ja |Ja |Ja |
| protected | Ja | Ja |Ja |Nein |
| keine Angabe | Ja | Ja |Nein |Nein |
| private | Ja | Nein |Nein |Nein |

void: ausführen ohne
Rückgabewert
intint Zahl
beaoolean wahr falsch Ich
! vor Methode nein kein
kein keinakku auf feld
Ist die Klassepublic, ist sie auch außerhalb ihres Paketes sichtbar, ansonsten ist sie nur in dem Paket sichtbar, in dem sie deklariert wurde.

Von einer Klasse, die als *final* gekennzeichnet ist, kann man keine Unterklasse ableiten:
*final class* Unterklasse *extends* Oberklasse

**Switch-Bedingungen(verschachtelte if-Anweisungen):**
if (Überprüfen ob Variable bestimmten Wert angenommen hat)
else (bei Nichtannahme des Werts, Ausführung von anderer Anweisung)

Macht einen Rechtsklick auf euer Java Projekt geht auf New-Class und gebt der Klasse einen Namen. Zum Beispiel Panjutorials. Dabei ist es wichtig, dass eure Klassennamen **IMMER** mit einem Großbuchstaben anfangen. Nicht aus syntaxischen Gründen, sondern wegen der Übersichtlichkeit. Das mag euch für den Anfang unwichtig erscheinen, sobald ihr jedoch ein Java Projekt mit vielen verschiedenen Klassen und Unterklassen habt, werdet ihr es verstehen.

* Vergleiche: größer >, kleiner <, größer oder gleich >=, kleiner oder gleich<=, gleich ==
* Verknüfungen: und &&, oder ||, nicht ! bzw !=

## Method Summary

* boolean akkuAufFeld()
Der Sensor ueberprueft, ob auf dem Feld des Roboters ein Akku liegt.

* void akkuAufnehmen()
Der Roboter nimmt einen Akku auf.
* boolean anGrenze()
Der Sensor ueberprueft, ob sich der Roboter an der Weltgrenze befindet und
zur Grenze "blickt".
* void bewegen()
Der Roboter geht einen Schritt in die Pfeilrichtung.
* void dreheLinks()
Der Roboter dreht sich um 90 Grad nach links (aus der Sicht des Roboters).
* void dreheRechts()
Der Roboter dreht sich um 90 Grad nach rechts (aus der Sicht des Roboters).
* void schraubeAblegen()
Der Roboter legt eine Schraube auf seinem Feld ab.
* boolean wandLinks()
Der Sensor ueberprueft, ob sich links der Laufrichtung eine Wand befindet.
* boolean wandRechts()
Der Sensor ueberprueft, ob sich rechts der Laufrichtung eine Wand befindet.
* boolean wandVorne()
Der Sensor ueberprueft, ob sich in Laufrichtung des Roboters eine Wand
befindet.

# **das ist Duke, Duke ist das Java Maskottchen**
#

Operatorprioritäten in Java
Operatoren in Java, gelistet nach deren Priorität (höchste Priorität oben):

1. Klammern ()
2. Postfix expr++ expr--
3. Unär ++expr --expr +expr -expr ~ !
4. Multiplikativ * / %
5. Additive + -
6. Shift << >> >>>
7. Vergleich < > <= >= instanceof
8. Gleichheit == !=
9. Bitweise UND &
10. Bitweise exclusive ODER ^
11. Bitweise inclusive ODER |
12. Logisch UND &&
13. Logisch ODER ||
14. if/else ? :
15. Zuweisung = += -= *= /= %= &= ^= |= <<= >>= >>>=

## Was ist eine Vererbung?

Der Begriff **Vererbung** hört sich erstmal sehr familiär an. Man kann im weitesten Sinne unter Vererbung verstehen, dass etwas weitergereicht wird.

Im objektorientiertem Programmieren wird eine Kindsklasse als Child- oder Subklasse bezeichnet, wohingegen die Elternklasse Parent- oder Superklasse genannt wird. Man spricht in der objektorientierten Programmierung von Vererbung, wenn eine Subklasse Attribute und Methoden von der Superklasse vererbt bekommt. Eine Subklasse besitzt sowohl alle Attribute und Methoden der Superklasse, als auch eigene spezielle Attribute und Methoden, die die Subklasse näher beschreibt.

Die **Superklasse** ist also sehr allgemein gehalten, wohingegen die Subklasse eine spezielle Ausprägung der Superklasse ist. Eine Superklasse kann beliebig viele Subklassen enthalten. Als Beispiel lässt sich auch hier der Kugelschreiber anführen. Eine Superklasse könnte hier "Stift" lauten, der bereits die Attribute "Stiftfarbe" und "Schreibfarbe" hat. Die Kugelschreiber-Klasse ist eine Kindsklasse der Klasse "Stift" und erbt diese Attribute. Zusätzlich kommen noch Funktionen für das Ein- und Ausfahren der Kugeschreibermine hinzu. Die Hierarchie kann beliebig tief sein.

In der Programmiersprache Java kann allerdings eine Subklasse nur genau eine Superklasse besitzen. In der Programmiersprache C++ ist dies anders, da dort eine Subklasse von mehreren Superklassen erben kann. Brauche

Was ist ein Interface?
> --siehe zeile 165
>
Was ist eine Methode?

Was ist ein Roboter?

Was ist ein Interface?
> //1.spezielle Schaltung zur elektronischen Anpassung zweier sonst inkompatibler Geräte oder Geräteteile
2.Schnittstelle

Ein **Interface** ist eine Schnittstelle, in der festgelegt wird, über welche Methoden die Klassen, die das Interface implementieren, verfügen müssen. Die Interfaces selber enthalten daher nur Funktionsköpfe und Konstanten. Alle Klassen, die das Interface implementieren, müssen sämtliche Methoden, die das Interface vorgibt, enthalten.

Interfaces werden verwendet, um Gemeinsamkeiten (z.B. gleiche Funktionalitäten), die mehreren Klassen zugrunde liegen, in einer separaten Klasse zu definieren. Die Objekte der implementierenden Klasse sind wie bei der Vererbung dann gleichzeitig auch Objekte des Interfaces. In Java werden Interfaces daher oft genutzt, um die fehlende Mehrfachvererbung gewissermaßen zu simulieren, da eine Klasse zwar nur von einer Superklasse abgeleitet werden kann, jedoch beliebig viele Interfaces implementieren kann.

In der Praxis werden Interfaces häufig für Kommunikationszwecke verwendet. Zwei miteinander kommunizierende Seiten besitzen beispielsweise ein festgelegtes Interface, damit eine reibungslose Kommunikation durchgeführt werden kann. So wird gewährleistet, dass beide Seiten die vom Interface vorgegebenen Methoden implementieren.

Das Interface dient auch dazu, den eigenen Quellcode vor fremden Entwicklern zu schützen, da diese nur auf die Methoden des Interfaces zugreifen können.

## Was ist ein Paket?

Ein **Paket** ist eine Bündelung von zusammengehörigen Klassen. Man könnte auch sagen, dass alle Klassen in einem Paket dasselbe Thema behandeln. Ein Beispiel für eine Bündelung von Klassen ist z.B. das Paket javax.swing aus der Java Standard Edition (JSE). Das Swing-Paket enthält Klassen, mit denen man grafische Benutzeroberflächen programmieren kann.

Ein Paket ist physikalisch gesehen auf der Festplatte nichts anderes als ein Verzeichnis. Die Pakete können eine beliebig tiefe Schachtelung haben. Der Punkt wie bei javax.swing ist vergleichbar mit einem Slash bei Pfadangaben, um Über- und Unterordner zu trennen. In Java werden Pakete in Archiven mit der Endung .jar komprimiert.

Pakete dienen der einfachen Wiederverwendung von immer wiederkehrendem Quellcode. So kann ein schon vorhandenes Paket einfach in ein Projekt eingebunden werden und dort direkt verwendet werden ohne den Quellcode neu schreiben zu müssen. So kann man sich im Laufe der Zeit auch eigene nützliche Bibliotheken anlegen, die man für seine Projekte wiederverwendet.

## h90 Juan Pablo Esteban Maximiliano Del Guer

# Szenarien:

##### *Ampelwelt:*
= Unterklasse von "World", *public class Ampelwelt extends World*
--> Ampelwelt erbt von World

* mit new kann neues Objekt erzeugt werden
---> *new AutoAmpel();*
* int x ---> entspricht einer Zahl
* **Ampeln**
---> *addObject (ost, 45,26);
add Object (sued, 34, 42);
sued.setRotation (90);
addObject (west, 16, 23);
west.setRotation(180);*
---> Ampeln werden durch "addObject"auf das Feld hinzugefügt. Die Zahlen in Klammern beschreiben die Position. "setRotation" beschreibt die Richtung in die die Ampel "schauen" soll
* **Ampelschaltung**
*public void act ()
{if (x==10)
nord.rot();
sued.rot();
west.gruen();
ost.gruen();}*
---> Wenn ein Auto sich auf das Feld befindet, wo der x-Wert 10 ist, dann wird die nördliche/südliche Ampel rot und die westliche/östliche grün
* **Auto**
*public void rechtsAbbiegen();
{if (Get X()==24)
}*
---> Wenn der x-Wert 24 ist, soll das Auto nach rechts abbiegen
##### *asteroids:*
Es gibt zwei Jets. Der blaue Jet wird vom Spieler gesteuert. Man kann ihn mit der oberen Pfeiltaste beschleunigen und mit der linken und rechten drehen. Mit der Leertaste kann man schießen, trifft man einen der drei anderen Jets, verkleinert dieser sich und teilt sich.
Dieser Vorgang wiederholt sich zweimal, danach sind die Gegner "besiegt".

##### *Juego Cangrejo GRUPO II:*
##### *Crab(p)world*
Erstellt eine neue Krabbe, einen neuen Hummer und zwölf neue Würmer. Alle Objekte haben festgelegte Positionen/ Punkte an denen sie erscheinen, beim neu-erstellen einer Welt.

Das Szenario besitzt aus drei Actor-Objekte. Dem Hummer, der Krabbe und dem Wurm.

Die Krabbe kann vom Nutzer manuell gesteuert werden. Die Steuerung erfolgt über die Pfeiltasten, pro Klick dreht sich die Krabbe um fünf in die jeweilige Richtung. Es wird überprüft ob die Krabbe tot ist, wenn ja, wird diese durch ein anderes Bild ersetzt. Außerdem frisst die Krabbe die Würmer. Jedoch nur bis sie eine Anzahl von acht Würmern voll hat. Dann wird die Welt gestoppt, jedoch wird keinerlei Meldung zur Beendigung des Spiels angezeigt.

##### *Wombatszenario:*

*private static final int MAXALTER = 150*
--> maximales Alter ist eine Konstante und nicht veränderbar

*if (!tot)*
--> Ausrufezeichen steht für "nicht"

*publicWombat()*
--> gilt als Konstruktor, wenn das in Klasse "Wombat" angezeigt wird

*if(!tot)
{
if(blattGefunden())
{
issBlatt();
hunger=0;
}
else
{
hunger++;
dreheDichZufaellig();
if(kannGehen())
{
bewegen();
}
}
vermehren();
alter++;*
--> wenn er nicht tot ist und ein Blatt gefunden hat, ist hunger=0. Wenn er kein Blatt findet, ist hunger +1. Dann dreht er sich zufällig in eine Richtung und geht sofern er sich bewegen kann. Nun kann er sich vermehren und alter +1.

*public void issBlatt()
{
Actor blatt = getOneObjectAtOffset(0, 0, Blatt.class);
if(blatt != null) {
// eat the leaf...
getWorld().removeObject(blatt);
anzahlGegessenerBlaetter = anzahlGegessenerBlaetter + 1;
Blatt.gesamtzahl=Blatt.gesamtzahl-1;
}
}*
--> Als erstes wird überprüft auf welcher Stelle sich ein Blatt befindet. Wenn das Feld nicht leer ist (also blatt !=null), dann wird bei der Anzahl der gegessenen Blätter 1 hinzugefügt und von der Gesamtanzahl der Blatter 1 abgezogen

void bewegen () --> führt methonde bewegen () aus --> gut für if/else
(boolean)BlattVorhanden --> Rückgabewert