Objektorientierte Programmierung. Modul 24

Überblick
(Kurzerklärung) UI-Buttons
Funktionen
Variablen
Debugging
Datentypen
Simpel
Komplex
Unity-Documentation Research
(Funktionsparameter)

OnClickEvent
Public class MyComponent()
{
public void MyFct1()
{
}
}
Button

Entgegennehmen von Interaktionen
Buttons
Button
Event
Nutzer
Component A
Funktion
Funktionsliste
Component B
Funktion
+
Button -> Funktion

OnClickEvent
Public class MyComponent()
{
public void MyFct1()
{
}
public void MyFct2( int parameter)
{
}
}
parameter
Button

Berechnen, Entscheiden, Speichern, Laden
Darstellen, Abspielen, Verändern
Start durch System oder Nutzer
Können einander aufrufen
Funktionen

public class MyFirstClass: MonoBehaviour
{
public void MyFunction()
{
}
public void MyFunction2()
{
}
}
Funktionen

MyFunction
void
public
{
Inhalt/ Befehle, jeweils mit Semikolon
}
( )
Protection
keyword
Rückgabewert
(void, wenn ohne Rückgabe)
Freiwählbarer Name
Eindeutig
Konvention: vorn Groß
Parameter
( ), wenn keine
KEIN SEMIKOLON!
Die Funktion wird beschrieben, aber nicht ausgeführt, kein Speicher vorbereitet ? Kein Befehl
;
Funktionsdefinition

Klassen können mehrere Funktionen haben
Inhalt der Funktion durch geschweifte Klammern eingefasst
public, void und () einfach akzeptieren, dazu später mehr ( Sichtbarkeit, Rückgabewert, Parameter)
public class MyFirstClass: MonoBehaviour
{
public void MyFunction()
{
}
public void MyFunction2()
{
}
}
Funktionen

Kleinste Funktionsbausteine
Verändern Variablen
Führen andere Funktionen aus
public void MyFunction()
{
MyFunction2();
}
public void MyFunction2()
{
Debug.Log( „Das ist ein Test“ );
}
Befehle

Serielle Abarbeitung
Immer in einer Funktion (außer Definitionen)
Immer mit SEMIKOLON beendet
Damit der Rechner das Ende erkennt
public void MyFunction() {DoStuff();MyFct3();Go( „Yeah“ ); }
public void MyFunction()
{
DoStuff();
MyFct3();
Go( „Yeah“ );
}
Befehle
Für den Rechner identisch

public class MyFirstClass: MonoBehaviour
{
MyFunction( );
public void MyFunction()
{
MyFunction( )
}
public void MyFunction2()
{
MyFunction( );
}
MyFunction( )
}
Funktionen
1
2
3
4
Ausserhalb einer Funktion
und keine Var.-Definition
Kein Semikolon
Läuft
Kein Semikolon
und siehe 1

public class MyFirstClass: MonoBehaviour
{
public void MyFunction()
{
Debug.Log( „Das ist ein Test“ );
}
public void MyFunction2()
{
Debug.Log( „Now something completly different“ );
}
}
Man bräuchte eine einzelne Funktion für alles
Das ist Y = 5 nicht Y = 522 / X;
-> Variablen
Funktionen

public class Charakter: MonoBehaviour
{
public void GreifeAn( Character target )
{
target.ErleideSchaden();
}
public void ErleideSchaden()
{
Debug.Log( „Autsch“ );
}
}
Funktionen
Kurzer Ausblick auf Variablen und Parameter

meineVariable
string
public
Protection
keyword
Datentyp
Freiwählbarer Name
Eindeutig
Konvention: vorn klein
;
Semikolon!
SEMIKOLON!
Das Anlegen einer Variable reserviert Speicher
Ist für den Computer also ein Befehl
Variablen

Datentypen
Simple und komplexe Datentypen
Simple sind Daten wie
Zeichen
Texte
Ganze Zahlen
Gebrochene Zahlen
Wahrheitswerte

Datentypen
Größe des benötigten Speichers
Hilfe für die Zusammensetzung von rohen Daten
Erleichtert das Verwenden von Funktionen, des jeweiligen Datentyps

Können feste Werte im Code ersetzen
An ihre Stelle tritt dann ihr Inhalt
Zu DIESER Zeit im Programm -> dynamisch
public class MyFirstClass: MonoBehaviour
{
public string meinText;
public void MyFunction()
{
Debug.Log( „Das ist ein Test“ );
Debug.Log( meinText );
}
}
Variablen

Können auch zur Laufzeit verändert werden
public string meinText;
public int y;
public int x;
public void Function1()
{
Debug.Log(meinText);
meinText = „You are not prepared!“;
Debug.Log(meinText);
}
public void Function2()
{
y = 6584 * ( 543 / x );
y = y + y + x;
}
// Ausgabe: Was im Inspector stand
// Ausgabe: You are not prepared!
Variablen

Concatinieren
string + string
string + „/“ + string
string + variable
Rechnen
Probleme
(Beispiel int / int ? Keine float Zahl)
Variablen

Variablen
Variablen können grob unterschieden werden
Klare Daten
Texte, Zahlen, Bool, Vektoren (also auch komplexe Datentypen)
Verknüpfungen zu Daten
GameObjects, Komponenten, Assets
Component
Variable
„Das ist ein Test“
182643
true
Component
GameObject
Asset

Einfache Daten-Zuweisung
Mittels „=„
Component
Funktion 1
Variable
public int dieAntwortAufDasLebenUndAlles;
public void Funktion1()
{
dieAntwortAufDasLebenUndAlles = 42;
}
Verknüpfung/Interne Änderung

Aufgabe 1 ? AddMultiplyScene
Button „Add“ : Addiert zwei Variablen und gebt das Ergebnis in der Konsole aus.
Button „Multiply“ : Multipliziert dieselben Variablen und gebt das Ergebnis in der Konsole aus.
Debug.Log( „Meine Ausgabe“ );
Debug.Log( meineZahl.ToString() );
Hinweis: Konsolenausgabe

Testen, Suchen und Fehlerbehebung
30 – 40% der Entwicklungszeit
Fehler sind Normalität!
Unterscheidung
„Syntax“-Fehler
Denkfehler
Implementationsfehler
Erfahrung -> Strategie zur Fehlerfindung
Debugging

Error
Vom System erkannte Fehler beim Kompilieren (vor der Laufzeit)
Nicht ausführbare Befehle (zur Laufzeit)
Warnings
Hinweise auf unsauberen Code
Können bei Updates zu Fehlern werden
Logs
Vom Programmierer gesetzte Ausgabe/Hilfe
Debugging

Console (in Unity!)
Toogle zum Anzeigen
der 3 Log-Arten
Log-Text
1) Klasse, Funktion und Zeile des Befehl-Ursprungs
2) Nächste Station der Befehlskette

Kommentare
Text im Code, der nicht ausgeführt wird
Dient der Erklärung
Realisiert durch „//“ vor der Zeile
Häufig benutzt um Code-Zeilen zu deaktivieren
Debugging
public void DoSomethingAwesome()
{
// AwesomeStuff();
// Awesome didn‘t work…
DoSomethingNormal();
}

Errors
Kompilierungsfehler verhindern das
Ausführen/Starten des Programms
Console (in Unity!)
1) Pfad, (Klasse)
2) Fehlermeldung
3) Fehleranzahl/-Indikator

Interface Text
Ansprechen der Variable (Komponent)
. - Punkt!
Auswahl der gewünschten Variable
Component A
Funktion 1
Text
public Text myInterfaceText;
public void Funktion1()
{
myInterfaceText . text = „Das ist ein Test“;
}
public class Text
{
public string text;
ZeigMalDenTextAn();
}
Verknüpfung/Externe Änderung

Component B
Aufruf der Funktion (Komponent)
. - Punkt!
Auswahl der Funktion wie sonst
Component A
Funktion 1
public MyCoolComponent comp;
public void Funktion1()
{
comp. DoStuff();
}
public class MyCoolComponent
{
public void DoStuff()
{
}
}
Funktion anderer Objekte
Funktion 2

Documentation Research
Suchen nach Funktion oder Variable einer Klasse
? Unity-Documentation
? Internet-Research, Foren
Beispiel: UnityEngine.UI.Text.text

using UnityEngine;
using UnityEngine.UI;
Achtung: Interface namespace Oben hinzufügen

Aufgabe 2.1 ? ProgressBarScene
Erhöhen einer int-Variable um Wert einer anderen int-Variable.
Ausgabe im UI-Text ProgressText.
int myNumber = 826;
string hallo = myNumber.ToString( );
Hinweis: Zahl zu Text machen (int zu string überführen)

Aufgabe 2.2 ? ProgressBarScene
Recherche zu „Image“ an Objekt ProgressBar
Variablen-Wert als Füllung der Grafik des Objekts ProgressBar darstellen
(Zusatzaufgaben für gesamte Stunde:
Auf 100 begrenzen (ohne Bedingungen: if, switch,..)
Image progressBarGraphic;
progressBarGraphic.fillAmount = ??? ;

public int element = 2;
public void MagicFct()
{
element = element + 10;
}
Button
MagicFct
Klassen/Funktionsvariablen

Klasse
Funktion
public int speed; //Klassenvariable
int distance; //Funktionsvariable
Funktion
int distance; //Neue Funktionsvariable
public int intelligence; //Klassenvariable
public string name; //Klassenvariable
Klassen/Funktionsvariablen

void MyFunction()
class MyComponent
public int myGlobalNumber;
public int myNumber;
myGlobalNumber = 10;
myNumber = 55; void MyFunction2()
public int myNumber;
myGlobalNumber = 1000;
myNumber = myNumber + 30;
Werden auf derselben Ebene wie Funktionen definiert
Erscheinen im Inspector
Werden bis zum Szenenwechsel gespeichert
Werden innerhalb von Funktionen definiert
Erscheinen NICHT im Inspector
Werden nach der Funktion gelöscht
Funktionsvariablen
Klassenvariablen
Funktionsvariablen

FunktionsVariablen
werden außerhalb von Funktionen definiert
Sie sind von allen Funktionen ansprechbar (intern und extern)
Sie werden mit der Instanz gespeichert
werden innerhalb einer Funktion definiert
Sie existieren nur innerhalb dieser Funktion
Inhalt/Speicher wird nach dem letzten Befehl wieder gelöscht
KlassenVariablen
Klassen/Funktionsvariablen

void MyFunction()
class MyComponent
public int myGlobalNumber = 55;
public int myNumber = 100000;
public string meinText = „BAM“ ;
Variablen können übrigens schon bei der Definition
mit Daten gefüllt werden
Funktionsvariablen

void SuperFunction()
class MyComponent
public int myGlobalNumber;
public int myNumber = 5;
myNumber = 1000;
myGlobalNumber = myGlobalNumber + myNumber;
void AwesomeFunction()
public int myNumber;
myGlobalNumber = myGlobalNumber + myNumber;
myGlobalNumber = 20;
SuperFunction();
AwesomeFunction();
SuperFunction();
Funktionsvariablen
Wie groß ist „myGlobalNumber“ am Ende?

Aktivieren/Deaktivieren von GameObjekten
Nutzen der
Buttons
„Reset“- und „Full“

Aufgabe 2.3 ? ProgressBarScene
Nutze die Buttons „Reset“- und „Full“-Button
Button „Reset“:
Variablen-Wert zurücksetzen (0) und Darstellung anpassen.
Button „Voll“:
Variablen-Wert auf 100 setzen und Darstellung anpassen.

Klassen / Funktion – Variablen
public int element = 2;
public void Function1() { int index = 10;
element = element + index;
Function2();
}
public void Function2() {
int index = 34;
element = element + index;
}
public void Function3() {
element = element + index;
}
Variablen

public int ergebnis = 55;
Erlauben es, Daten als Funktionsvariablen in die Funktion mitzugeben
void AddiereZuErgebnis( int myParameter )
ergebnis = ergebnis + myParameter ;
void MyFunction ( )
AddiereZuErgebnis( 526 );
Funktion: Parameter

Funktionsvariablen, die von außen gesetzt werden
public class Debug
{
public void Log( string text )
{
DisplayInConsole( text ) ;
}
}
Debug.Log( „Das ist ein Test“ );
Parameter

Funktionsvariablen, die von außen gesetzt werden
Ermöglichen einer Funktion unendliche Probleme gleicher Art zu lösen
Verallgemeinern mehrerer Funktionen zu einer kann Fehler und Arbeitsaufwand verringern
public void ZumQuadrat( int parameter1 )
{
int quadrat = parameter1 * parameter1 ;
Debug.Log( quadrat );
}
public int zahl;
public void MyButtonFunction( )
{
ZumQuadrat ( zahl );
}
Parameter

Funktionsvariablen, die von außen gesetzt werden
Ermöglichen einer Funktion unendliche Probleme gleicher Art zu lösen
Verallgemeinern mehrerer Funktionen zu einer kann Fehler und Arbeitsaufwand verringern
public void ZumQuadrat( int parameter1 )
{
int quadrat = parameter1 * parameter1 ;
Debug.Log( quadrat );
}
public int zahl;
public void MyButtonFunction( )
{
ZumQuadrat ( zahl );
}
Parameter

Charakter
Leben
Greife an
Erleide Schaden
Char1
Leben
Greife an
Erleide Schaden
Char2
Leben
Greife an
Erleide Schaden
Char2
?
Charakter
?
Angriff
Angriff
Angriff

public int leben;
public int angriff;
public void GreifeAn( Character targetChar)
{
targetChar.ErleideSchaden( angriff );
}
public void ErleideSchaden( int schaden )
{
leben = leben – schaden;
}
Charakter
Leben
Greife an
Erleide Schaden
Charakter
?
Angriff
Objekt-Wechsel

public int leben;
public int angriff;
public int level;
public void GreifeAn( Character targetChar )
{ int schaden = (angriff * 4) * (level / 2);
targetChar.ErleideSchaden( schaden );
}
Charakter
Leben
Greife an
Erleide Schaden
Charakter
?
?
Angriff

Aufgabe 2.4 ? ProgressBarScene
Nutzen von Parametern zur besseren Funktionsnutzung
Alle drei Buttons sollen am Ende dieselbe Funktion aufrufen, die dann den entsprechenden Parameter „in die Anzeige einträgt“
Button „Reset“
Button „Step“
Button „Full“
???
???
???
Display
Grafik/Text

Datentypen sind generell definierte Klassen mit speziellen Funktionen.
Die häufigen/einfachen Datentypen wurden dabei in den meisten höheren Prog.-Sprachen so vereinfacht, dass viel Schreibarbeit erspart bleibt.
Normalerweise müsste jede Variable folgenderweise definiert werden
Komplexe / Referenz-Datentypen
public void MyFct()
{
int myNumber = new int();
}
Erst das Schlüsselwort „new“ veranlasst den Computer Speicher für diese Variable zu reservieren

Erfolgt dieser Aufruf nicht, gibt es zwar die Variable, aber sie hat keinen Wert.
Dieser nicht vorhandene Wert wird als NULL beschrieben
NULL
public UnityEngine.UI.Text myText;
public void MyFct()
{
myText.text = „Hallo“;
// Ist im Inspector für „myText“ kein entsprechendes Objekt
// zugewiesen, wird der Fehler „NullReference“ ausgegeben.
// Eine Referenz zu etwas nicht vorhandenem
}