Ein Kapitel zum DOM ist typischerweise ein fester Bestandteil von nahezu jedem Buch, welches JavaScript-Grundlagen vermitteln möchte. Ein paar Beispiele:

• JavaScript: Das umfassende Handbuch von P. Ackermann (Kapitel 5)
• Einstieg in JavaScript von T. Theis (Kapitel 5)
• JavaScript von M. Haverbeke (Kapitel 14)
• JavaScript - Das Handbuch für die Praxis von D. Flanagan (Kapitel 15)
• JavaScript Kompendium von D. Herken (Kapitel 6-7)

Ein größeres Buchkapitel (oder Webtutorial) sollte zu diesem Thema auch völlig ausreichen. Wenn man weiter in die Tiefe gehen wollte, dann wäre wohl ein Blick in die Historie (Technologie vor DOM Level 2, damalige Unterschiede in Browsern und Schaffung eines Standards) oder die detailliertere Funktionsweise von Browsern (Parser, Rendering) interessant.

Auf Media Event findest du ein Kapitel zum DOM, welches eine kurze, verständliche und skizzierte Einleitung bietet. Auch auf SelfHTML findest du eine Einleitung sowie mehrere Unterseiten, die sich mit den DOM-relevanten Elementen/Funktionen auseinandersetzen.

Einen englischen Guide bietet MDN. Zum Nachschlagen bezüglich einzelner Details (Funktionsdeklarationen u.ä.) solltest du besser deren API-Dokumentation als Referenz nutzen. Sie ist besser gepflegt. Die wohl meistgenutzten Attribute und Methoden findest du unter den Schnittstellen zu Document, Element, Node und Window.

Es handelt sich um eine einfache Assoziation. Das heißt, ein Dialogsystem hat eine BinaryTree-Instanz. Das Feld, welches auf diese Instanz verweisen soll, ist privat (Sichtbarkeit) und soll baum heißen.

Statt dem Assoziationspfeil könnte man das Feld auch einfach mit in die Box von Dialogsystem schreiben.

----------------------
| Dialogsystem       |
----------------------
| - baum: BinaryTree |
----------------------
| etc. ...           |
----------------------

Das Einbetten eines Videos kann zum einen vom Autor, der es auf YouTube hochgeladen hat, verhindert werden und zum anderen kann YouTube die Wiedergabe auch selbst blockieren, wenn das Video urheberrechtlich geschütztes Material (z.B. Musik) beinhaltet. In letztgenanntem Fall könnte man (als Autor) in den Videoeinstellungen von YouTube das Einbetten von Musik deaktivieren und es dann erneut probieren.

Teste es einfach in einem JSFiddle aus. Wenn der Einbettungscode dort funktioniert, liegt es nicht an einem der oben genannten Gründe.

Achte darauf, dein HTML-Dokument über einen Webserver ausliefern zu lassen (nicht über das file:///-Protokoll) und schau ebenso, dass dein Server keinen Response Header schickt, der Informationen an YouTube über den Host unterbindet (Referrer-Policy; du kannst dafür in den Netzwerktab der Entwicklerkonsole deines Browsers schauen).

Suche dir zuerst 1-3 Projekte aus, die du explizit in deinem Bewerbungsschreiben erwähnen möchtest. Sie sollten:

• möglichst ein bestimmtes Komplexitätslevel erreicht haben (d.h. Hello World oder ein sehr einfacher Rechner sind nicht die beste Wahl), damit man sieht, dass du dich mehr als nur ein paar Stunden mit dem Thema befasst hast.
• nur dazu dienen, Thesen (oder eine Motivation), die du im Schreiben anbringen möchtest, zu untermauern (wenn du bspw. schreiben möchtest, dass du dich intensiv mit GUI-Entwicklung befasst hast, wäre es gut, ein Projekt mit einer ordentlich aufgebauten GUI zu erwähnen)
• nicht ausufernd beschrieben werden (~max. zwei Sätze), denn ein Bewerbungsschreiben sollte generell nicht länger als eine DIN A4-Seite einnehmen
• gut aufbereitet sein (gepflegte ReadMe oder eine GitHub Page zur Vorstellung des Projekts; evt. ein Release), sodass es ein Betrachter einfach hat, sich einen Überblick darüber zu verschaffen, ohne dafür das Projekt selbst herunterladen und bauen zu müssen

Von einem detaillierten Verweis auf noch mehr Projekte (oder gar der Angabe eines ganzen Pools an Projekten) würde ich definitiv abraten. Weder sollte das Schreiben zu lang werden, noch sollte die Verantwortung auf den Leser übertragen werden, sich intensiv in deine Projekte hineinarbeiten und selbst Verknüpfungen (z.B.: Mit welchen Technologien hast du bereits gearbeitet?) ziehen zu müssen.

Die Funktion parseFloat liefert stets den Wert NaN (Not A Number) zurück, wenn aus dem ihr empfangenen Argument keine valide Zahl herausgelesen werden kann. Das kann in deinem Fall also passieren, wenn das Array userinput_1 leer ist oder dessen Werte zusammengefügt eben keinen lesbaren Wert bieten (der Parser liest von links nach rechts und stoppt bei dem Token, welches für ihn nicht für einen numerischen Wert verwertbar ist; Beispiel: 12a => 12 oder a12 => NaN).

Von einem undefinierten Array kann man nicht ausgehen, andernfalls würdest du eine deutliche Fehlermeldung erhalten. Die Variable mit dem Array legst du demzufolge bereits vor Ausführung des geteilten Codesnippets an.

Die Fehlerursache für Fall 1 (dein obiges Codesnippet) solllte also klar sein. Die Variable number_A wird sofort bei Programmstart definiert, array_convert_to_int also auch schon aufgerufen, obwohl userinput_1 noch ohne Inhalt ist. Nutzereingaben werden erst später vom Programm aufgenommen. Bevor der Nutzer auch nur einen Klick oder Tastendruck durchgeführt hat, ist das Skript bereits fertig.

Bei einem Aufruf der Funktion via Buttonklick kommt es darauf an, was dem Array tatsächlich übergeben wird. Lasse es dir doch zur Prüfung direkt in der Browserkonsole ausgeben:

function array_convert_to_int() {
  console.log(userinput_1);
  /* ... */

(...) gibt aber bei der Prozentangabe hinter dem width eine Fehlermeldung (...)

Richtig. In die HTML-Attribute width und height kommen grundsätzlich keine Werte mit Einheitsangaben. Dafür sind ausschließlich die CSS-Properties gedacht. Nutze die HTML-Attribute stattdessen, um das Bildgrößenverhältnis zu definieren, an dem sich der Browser beim Skalieren später orientieren kann.

Wenn dein Bild zum Beispiel 500x345px groß ist, könntest du das so also folgendermaßen angeben:

<img alt="..." height="345" src="..." width="500">

Das hat nähmlich leider nicht geklappt...

Das klappt ganz genau so. Das einzige, was das Bild noch davon abhält, die komplette Breite seiner Box einzunehmen, ist der von dir spezifizierte Innenabstand.

Demo: https://jsfiddle.net/ufjbr1av/

Schau in die Dialogfenster Problems und Console (wenn du sie auf deiner Programmoberfläche nicht findest, kannst du sie jeweils unter dem Menüpunkt Window > Show View einblenden). Sicherlich erhältst du dort mehr Informationen, wieso die Programmausführung nicht klappt.

Ein Problem, welches es ganz sicher geben wird, ist ein fehlendes Programmargument. Ohne eine entsprechende Run Configuration wird das args-Array leer sein und der Versuch, dennoch auf einen Eintrag daraus zuzugreifen (args[0]), zu einem Programmabsturz führen.

Geh im Menü auf Run > Run Configurations, wähle unter dem Java Application-Knoten die derzeit vorhandene Run Configuration aus oder lege eine neue Konfiguration an. Solltest du Letzeres vorziehen, musst du im Main-Tab dein Projekt sowie die Hauptklasse (basis.HelloInput) definieren. In jedem Fall solltest du im Arguments-Tab noch etwas in das Program arguments-Feld eintragen (z.B. deinen Namen). Sollte der Wert ein Leerzeichen beinhalten, gruppiere ihn komplett in Anführungszeichen (Bsp.: "John Doe").

Bestätige im Anschluss deine Änderungen. In der Toolbar unter dem Menü findest du neben dem Button mit dem grünen Pfeil eine aufklappbare Leiste. In der wählst du deine geänderte Run Configuration aus, um deine Java-Anwendung zu starten.

Du kannst dich beim Entfernen der Einträge an der ID sowie der Mitarbeiter_Id orientieren. Die letztgenannte Spalte gibt dir wohl an, ob ein Eintrag im Wert einem anderen entspricht. Die ID kann dir zeigen, ob du gerade das erste Vorkommen vor dir hast oder nicht.

Folgend gehe ich einmal davon aus, dass deine Tabelle mitarbeiter heißt.

DELETE FROM mitarbeiter
USING mitarbeiter, mitarbeiter m
WHERE mitarbeiter.id > m.id AND mitarbeiter.Mitarbeiter_Id = m.Mitarbeiter_Id

Du kannst für jede Komponente, die du deiner GUI zufügst, einen eigenen Layout Manager zuordnen (selektiere dafür deine Komponente im Component Tree und schau dann unter dessen Properties). Zur Auswahl stehen da:

• BorderLayout (einfache Aufteilung in oben/unten/rechts/links/mittig)
• CardLayout (Aufteilung in Karten/Slides, von denen nur immer nur eine sichtbar ist)
• FlowLayout (einfache horizontale oder vertikale Aneinanderreihung)
• FormLayout (eine Art flexibles Grid)
• GridBagLayout (ein gewichtetes Grid)
• GridLayoutManager (ein einfaches Grid; der von IntelliJ gesetzte Standardmanager)

Plane am besten im Voraus, wie du deine Oberfläche strukturieren möchtest und schachtele anschließend Layouts, indem du Container-Komponenten (wie z.B. JPanel) ineinander verschachtelst.

Die Flexbox muss einem Container zugeordnet werden, welcher die volle Seitenhöhe einnimmt. Für die Flexboxitems kannst du dann festlegen, inwiefern sie sich innerhalb der Flexbox ausbreiten dürfen.

HTML:

<!DOCTYPE html>
<html lang="de">
  <head>
    <!-- meta data ... -->
  </head>
  <body>
    <main class="container">
      <header class="header">
        <!-- ... -->
      </header>
      <footer class="footer">
        <!-- ... -->
      </footer>
    </main>
  </body>
</html>

Die Seite wird hier klar in Header und Footer aufgeteilt. Wenn du keinen Header benötigst, kannst du stattdessen section-Elemente verwenden.

Beachte, dass du bei dir den html- und head-Knoten vertauscht hast. Außerdem sollte der Wert des lang-Attributs de sein, da deine Seite deutschen Inhalt bereitstellt.

CSS:

body {
  margin: 0;
}

.container {
  display: flex;
  flex-direction: column;
  height: 100vh;
}

.header {
  flex: 1 0 auto;
}

.footer p {
  margin-bottom: 0
}

(...) ganz of die Fehlermeldung bekomme, dass es zu oft eine module-info gäbe (duplicate module-info).

Die weiteren module-info-Definitionen werden von JavaFX kommen. Beim Build hat Eclipse daraufhin das Problem, entscheiden zu müssen, welche Definition es nun verwendet. Wenn der Build dennoch abgeschlossen wird, wählt Eclipse sicherlich die erste module-info-Datei.

Wenn ich die exportierte Datei mit Java SDX öffnen will, dann passiert nichts.

Da ich nicht weiß, wie sich das bei dir konkret gestaltet: Eine JAR lässt sich über die Konsole (deines OS) starten:

java -jar fileNameOfYourJarApplication.jar

Voraussetzung ist eine (via Manifest) definierte Hauptklasse, die einen Einstiegspunkt beinhaltet. Wenn die Manifestdatei fehlt, sollte es auch so klappen:

java -cp fileNameOfYourJarApplication.jar fullPackageNameOfYourMainClass.NameOfYourMainClass

Wenn der Befehl java nicht gefunden werden kann, kannst du ihn ebenso gegen einen absoluten Pfad zur java.exe (im Ordner deines Java SDK) ersetzen:

"c:\...\java.exe" -jar fileNameOfYourJarApplication.jar

(...) Obwohl ich meine Hauptklasse beim exportieren aber definiert habe (...)

Die Mindestangaben in der Manifestdatei sollten diese sein:

Manifest-Version: 1.0
Main-Class: fullPackageNameOfYourMainClass.NameOfYourMainClass

Wenn die Hauptklasse dann dennoch nicht gefunden wird, wird wohl der Specifier (Package/Klassenname) nicht korrekt sein oder die angegebene Klasse ist keine valide Hauptklasse (entweder ist sie nicht öffentlich oder der Einstiegspunkt fehlt).

Nein, ich verwende kein Buildtool

Dazu würde ich dir raten, denn es vereinfacht die Angelegenheit. Nutze den Guide aus der Dokumentation: https://openjfx.io/openjfx-docs/#maven.

(...) und dann später mein Wissen anzuwenden um ein eigenes kleines Programm oder Spiel zu programmieren.

Da du hier schreibst, dass du dich bereits mit Lua-Grundlagen auseinandergesetzt hast, wäre mein Rat, auch erst einmal dabei zu bleiben. Übe dich mit Lua, werde sicherer im Umgang mit dieser Sprache und baue dann erste Spieleanwendungen, um auch in diesem Bereich mehr Erfahrungen zu sammeln.

Für den Sprung zu einer anderen Sprache sehe ich bezüglich deiner bisherigen Zielbeschreibungen keinen Grund.

Nichtsdestotrotz zu deinen Fragen:

Wie kann ich Python in meiner Freizeit gut lernen, (...)

• Richte dir schon zu Beginn ein passendes Entwicklungsumfeld ein, in dem du mindestens Konsolenprogramme mit Python erstellen kannst. Da könntest du beispielsweise PyCharm, Thonny, Visual Studio oder VS Code in Erwägung ziehen. Im einfachsten Fall genügt auch die IDLE.
• Probiere dich an dem, was du dir anliest/anschaust auch praktisch aus. Anfangs wird es natürlich noch mehr experimentieren sein, doch mit der Zeit kannst du Themenfelder verbinden und dementsprechend komplexere Übungsaufgaben finden.
• Suche dir seriöse Lernquellen. Das ist natürlich für einen Anfänger gar nicht so einfach zu beurteilen, aber dennoch kannst du zu den Quellen, die du so findest, zumindest recherchieren (Autor und dessen ausgewiesene Expertise, Jahr, evt. Reviews von externen Quellen), um dir ein besseres Bild zu machen. Über zehn Jahre alte Quellen sind beispielsweise nicht gerade die beste Wahl. Von Crashkursen (Python in X Minuten/Stunden/Tagen, o.ä.) kann ich im Übrigen grundsätzlich nur abraten.
• Nimm dir zum Lernen bewusst Zeit. Eile nicht durch die Kapitel eines Buches oder Kurses, dadurch wirst du nicht schneller Programmieren lernen.
• Plane, wann/wo/wie lange du lernst. Was für dich da optimal ist, musst du selbst wissen oder noch herausfinden. Zwischen deinen Lernzeiten sollten nur nicht etliche Tage vergehen, sodass du zuvor Gelerntes wieder vergisst. Generell macht es übrigens Sinn, alte Themen ab und an zu wiederholen, damit sie nicht wieder aus dem Gedächtnis fallen.

(...) sollte ich in Erwägung ziehen mir einen Kurs auf Udemy o.ä. zu kaufen (...)

Ja, Kurse von Udemy (oder ähnlichen Plattformen wie Codecademy, Coursera, PluralSight, Udacity) kannst du definitiv in Erwägung ziehen. Ich kann speziell die Hyperskill-Plattform empfehlen sowie RealPython als allgemeine Anlaufstelle für viele verschiedene Anwendungsfelder rund um Python. Gute deutschsprachige Literatur bietet der Rheinwerk Verlag.

Ansonsten solltest du natürlich die offizielle Webseite von Python kennen, auf der du unter anderem die offizielle Dokumentation findest.

(...) und gibt es irgendwelche Übungsprogramme (...)

Schau hier für Übungsaufgaben.

Hinsichtlich der Entwicklung von Spielen hast du schon eine gute Wahl getroffen. Lua ist eine der meistgenutzten Sprachen in diesem Entwicklungsbereich. Es macht meines Erachtens keinen Sinn, nun doch wieder zu einer anderen Sprache zu wechseln.

Zur Nutzung eines/r Game-Framework/Bibliothek oder einer Game-Engine würde ich dir für die Entwicklung eines Spiels definitiv raten, denn es/sie gibt dir wichtige Basisfunktionalitäten (bspw. für Audio-, Eingabe- und Grafikverarbeitung) an die Hand, die du einfach brauchen wirst. Du kannst dir Defold, LÖVE oder Solar2D dazu einmal anschauen.

Du brauchst zunächst einmal einen Server, der online erreichbar ist und über den du eine Anwendung laufen lassen kannst, die Anfragen deiner mobilen App entgegennehmen und sie dann irgendwo (bestenfalls in einer Datenbank oder zumindest dem Dateisystem) speichern kann.

Es gibt Plattformen wie Google Firebase oder Supabase, die dir so eine Lösung schon als Paket zur Verfügung stellen. Die Datenkommunikation erfolgt über eine API und lässt sich je Nutzer in den Zugriffsrechten entsprechend einschränken. Oft gibt es vom Anbieter bereits eine Client-Bibliothek, die du direkt in dein Projekt einbinden kannst, um dir die Arbeit zu vereinfachen.

Du kannst dir aber ebenso eine kleine Webanwendung (z.B. mit der ASP.NET Minimal API) zusammenbasteln und die auf dem Server/der Cloud eines Webhosters (z.b. Azure, DigitalOcean, Hetzner, IONOS, SmarterASP.NET, Vultr, ...) laufen lassen. Die API definiert Endpunkte, die deine mobile App mit Hilfe einer HttpClient-Instanz aufrufen kann. Der Endpunkt wiederum verbindet sich mit einer Datenbank und speichert oder holt die gesuchten Daten. Die API schafft also eine Abstraktionsebene, die mobile App kennt die tatsächliche Datenquelle nicht und kann sie somit nicht direkt beeinflussen. Um indirekte Manipulationen (über die API-Endpunkte) zu verhindern, solltest du eintrudelnde Daten von der mobilen App validieren, Prepared statements für die Datenbankkommunikation nutzen und Zugriffseinschränkungen implementieren (wobei dir ASP.NET da schon sehr unter die Arme greift).

Alternativ zu ASP.NET eignen sich natürlich ebenso andere Programmiersprachen zur API-Entwicklung (wie PHP oder JavaScript auf Node.js-Basis). Du musst je gewählter Technologie lediglich einen Service Provider finden, der eine Einrichtung / das Hosting dieser Technologie unterstützt.

(...) ich weiß auch das ich später nicht als Programmierer arbeiten möchte, sondern mehr so in die Richtung Systemintegration.

Letzten Endes hängt es später zwar von deinem Arbeitgeber / dessen Projekten, in denen er dich einsetzt, ab, aber eine Sicherheit, als Systemintegrator nicht mehr mit Programmierung/Softwareentwicklung konfrontiert zu werden, gibt es nicht. Das Tätigkeitsfeld kann sowohl die Entwicklung kleiner Skriptanwendungen (z.B. mit Perl/PHP/PowerShell/T-SQL/o.ä.) als auch Anwendungserweiterungen (z.B. mit Java) umfassen. Zumindest in den Grundlagentechniken solltest du schon sicher sein, selbst wenn du sie später vielleicht nie (oder kaum) direkt einsetzen musst.

Ich habe irgendwie keine Motivation mich hinzusetzen und Java zu üben.

Vielleicht kann dir Processing den Einstieg vereinfachen oder neue Motivation geben. Es handelt sich hierbei um eine eigene Programmiersprache (mit eigener IDE), die auf Java fußt, aber mehr für Programmieranfänger ausgerichtet ist.

• Zur Standardbibliothek von Processing gehören größtenteils Zeichenfunktionen, denn sie ist für die Entwicklung kleiner grafischer Simulationen oder Minispiele konzipiert. Du kannst also einfach und schnell direkt von Beginn an visuelle Erfolge erzielen. Bereits mit wenigen Grundlagenkenntnissen (z.B. Variablen, Operatoren, Verzweigungen) kannst du dich an einem Minispiel wie Pong versuchen. Nimm noch ein paar Themen hinzu (Schleifen, Arrays) und schon kannst du weitere Minispiele in Betracht ziehen (z.B. Snake oder Space Invaders).
• Du kannst objektorientiert arbeiten, musst es aber nicht. Das ist m.E. ein großer Vorteil gegenüber Java, denn du brauchst für die Entwicklung nur die Werkzeuge, die dir je Lernstatus wirklich bekannt oder verständlich erklärbar sind.
• Die Syntax ist nahezu identisch zu Java. Die Unterschiede liegen größtenteils in der Reduktion / dem Aufbrechen der in Java erforderlichen objektorientierten Struktur. So kennt oder unterstützt Processing z.B. einige Java-Schlüsselwörter/Features (z.B. var oder statische Felder) nicht, die du als Programmieranfänger aber eh nicht brauchst.
• Die Processing IDE ist in ihrem Funktionsumfang reduzierter und daher einfacher bedienbar als klassische Java IDEs (Eclipse/IntelliJ/...). Es sind eben nur die Funktionen enthalten, die für dich als Anfänger erst einmal relevant sind.

Neben dem Infomaterial auf der offiziellen Webseite kannst du zum Lernen den Track von Daniel Shiffman nutzen oder den Einführungskurs von Prof. Dr. Kipp.

An praktischen Übungen kommst du natürlich dennoch nicht herum. Im letztgenannten Kurs findest du je Kapitel öfter kleine, gut gewählte Aufgaben. Je nach Lernstand kannst du dich wie bereits erwähnt ebenso an Minispielen oder Simulationen ausprobieren.

Ein paar Vorschläge (etwas gruppiert nach Lernstand):

• Pong (Variablen, Operatoren, Verzweigungen)
• Breakout
• Tic-Tac-Toe
• Conway's Game Of Life (+ Arrays, Schleifen)
• Memory
• Minesweeper
• Space Invaders
• Snake
• Vier gewinnt
• Flappy Bird
• Tetris (OOP)
• Pac-Man
• Super-Mario
• Uno

Webprogrammierung fand ich cool und und hat auch spaß gemacht.

Du beziehst dich hierbei vermutlich vorrangig auf die Entwicklung mit HTML und CSS. Solltest du dich mit JavaScript anfreunden können, könntest du auch schauen, ob Frontendentwicklung im Web etwas wäre, was du dir für die Zukunft vorstellen könntest. In der Hinsicht würde immerhin dein gewähltes Studienfach wieder mehr Nadelstiche setzen können (z.B. bezüglich der Handhabung von Schriftarten, Medienformaten, Seitenstrukturierung, u.ä.).

Dieses Themenfeld ist nach wie vor ein Teil der Softwareentwicklung. Im beruflichen Umfeld wirst du definitiv mit JavaScript (oder TypeScript) programmieren und dich mit diversen Entwicklungswerkzeugen (oft auch konsolenbasiert) auseinandersetzen müssen. Auf die Entwicklung von Backendanwendungen musst du dich nicht direkt spezialisieren. Ein Verständnis, wie Webanwendungen funktionieren (z.B. wie die Kommunikation zwischen Browser und Webserver abläuft), solltest du jedoch erwerben und generell ist es von Vorteil, sich auch einmal an mindestens einer einfachen Backendanwendung probiert zu haben (z.B. eine Webanwendung, die Nutzereingaben empfängt, in einer Datenbank speichert und wieder ausgibt; für die Entwicklung könntest du bspw. PHP, Express.js, NextJS oder Jakarta Servlets nutzen).

Oder ob ich einfach eine Ausbildung als Fachinformatiker (Systemintegration) anfangen soll.

In der Ausbildung wirst du dich, wie auch im Studium mit Programmierung (oft Java oder C/C++) auseinandersetzen müssen. Der wesentliche Unterschied zwischen beiden Lernpfaden liegt eher darin, dass die Ausbildung spezifischer auf dein Zielfeld (Systemintegration) abgestimmt wäre. Der komplette Bereich Medien scheint für dich ja nicht von großer Relevanz zu sein.

Ich würde dir empfehlen, erst einmal über deinen Werkstudentenjob etwas Erfahrung zu sammeln (bestenfalls mindestens zwei Monate), bevor du dich bezüglich eines Wechsels entscheidest.

Sprich bei deinem Arbeitgeber deine Mitarbeiter auch aktiv an und frage sie nach ihren Erfahrungen und Tätigkeitsfeldern der letzten Jahre die sie bei diesem (oder anderen) Arbeitgeber(n) gemacht haben.

Im Übrigen kannst du ebenso Ratschläge von den Dozenten deiner Hochschule einholen und oftmals gibt es auch eigene Beratungsstellen (bzgl. Abbruch/Studienwechsel/u.ä.) seitens der Hochschule.

Du musst den Wert übergeben. Dazu muss eines der Objekte das andere kennen.

Beispiel:

class Person {
  public String getName() { // example 1: pass by return value
    String name = "Ted";
    return name;
  }

  public void callName(Speaker speaker) { // example 2: pass by parameter
    String name = "Ted";
    speaker.say(name);
  }
}

class Speaker {
  public void sayName(Person person) {
    System.out.println("Hello " + person.getName());
  }

  public void say(String word) {
    System.out.println(word);
  }
}

// main:
Person person = new Person();
Speaker speaker = new Speaker();

person.callName(speaker); // Ted
speaker.sayName(person); // Hello Ted

In diesen Fällen übergebe ich die jeweilige Objektreferenz via Parameter an die jeweilige Methode.

Wenn die Übergabe immer an das selbe Objekt erfolgen soll, macht es allerdings Sinn, sich dessen Referenz in einem Feld zu speichern, auf welches alle Methoden Zugriff haben. Die Referenzübergabe erfolgt diesmal über den Konstruktor, um sofort nach Objekterzeugung mit dem fremden Objekt arbeiten zu können.

Beispiel:

class Person {
  private final Speaker speaker;

  public Person(final Speaker speaker) {
    this.speaker = speaker;
  }

  public void callName() {
    speaker.say("Some name");
  }

  public void callOtherName() {
    speaker.say("Other name");
  }

  /* ... */
}

// main:
Person person = new Person(new Speaker());
person.callName(); // Some name
person.callOtherName(); // Other name

(...) aus der Methode "monster1" (...)

Eine Methode bildet immer eine Tätigkeit ab. Das heißt, sie sollte dementsprechend auch immer ein Verb im Namen haben (Beispiele: start, doSomething, getSomething, ...), damit einem Leser an jeder Stelle, wo sie vorkommt, sofort ersichtlich wird, welchen Zweck sie erfüllt.

Also wenn ich z.B. 20 Methoden habe und in allen die Variable "name" vorhanden ist (...)

Hierzu würde ich dir den Rat geben, zu schauen, ob sich diese verschiedenen Methoden nicht in irgendeiner Form abstrahieren lassen.

Beispiel:

class MonsterManager {
  /* ... */

  public void callMonster1() {
    speaker.say("Sullivan");
  }

  public void callMonster2() {
    speaker.say("Randall");
  }

  /* etc. ... */
}  

Dieser Fall könnte folgendermaßen verkürzt werden:

class MonsterManager {
  private String[] monsterNames;

  private final Speaker speaker;

  public MonsterManager(final Speaker speaker) {
    this.speaker = speaker;
    monsterNames = new String[] { "Sullivan", "Randall", /* ... */ };
  }

  public void callMonster(int index) {
    if (index > -1 && index < monsterNames.length) {
      speaker.say(monsterNames[index]);
    }
  }
}

Klicke auf den grünen Button, den du im Code-Tab des Projekts siehst. In der sich öffnenden Box findest du eine Option, um den Projektcode als ZIP-Datei herunterzuladen. Auf deinem Rechner brauchst du dieses Archiv lediglich entpacken (entweder über den ZIP-Extraktor deines OS oder eine Anwendung wie 7-zip).

Da es sich um ein Expo-Projekt handelt, wäre es günstig, sich auch eine dafür passende Entwicklungsumgebung einzurichten. Kenntnisse in React und TypeScript werden im Übrigen vorausgesetzt.

• Du benötigst Node.js und npm, um das Projekt bauen und ausführen zu können.
• Bezüglich Expo solltest du dich in deren Manual einlesen.
• Als Code Editor kannst du Visual Studio Code verwenden.

Nach der Einrichtung dieser Basiswerkzeuge, kannst du dir via npm alle erforderlichen Projektabhängigkeiten installieren. Wechsel dazu in der Konsole / dem Terminal deines OS (oder VS Code) in das Verzeichnis, in dem auch die package.json liegt und führe den install-Befehl aus.

npm install

Sofern das erfolgreich war, kannst du im Anschluss die Kurzbefehle (s. scripts-Property) aus der package.json nutzen, um das Projekt zu starten.

Beispiel:

npm run start

Bei Problemen wirst du nochmals recherchieren müssen. Lies die Fehlermeldungen der Konsole, nutze die Expo-Dokumentation. Möglicherweise kannst du auch mit den Entwicklern des GitHub-Projekts in Kontakt treten.

Eclipse kannst du für dein Vorhaben gut nutzen. Zusätzlich würde ich dir empfehlen, auf Basis von libGDX zu arbeiten. Dieses Framework beinhaltet bereits verschiedene Features (für Audio-, Grafik-, Eingabeverarbeitung usw.), die du sicherlich brauchen wirst.

(...) jedoch funktioniert die Implementierung der drei senkrechten Kreise nicht so wie gewünscht.

Wenn die Kreise vertikal untereinander positioniert werden sollen, dann musst du beim Zeichnen auch die Position auf der y-Achse verändern. Aktuell zeichnest du den Kreis innerhalb der TAmpel.ZeichneKreis-Prozedur jedesmal an der selben Position.

Du könntest der Prozedur einen weiteren Parameter spendieren (z.B. für den Index, der angibt, der wievielte Kreis gezeichnet werden soll), anhand dessen du die y1- und y2-Argumente von Canvas.Ellipse berechnest. Die Berechnung für y1 hast du ja bereits in ZeichneAmpelClick und für y2 genügt es, den Kreisdurchmesser aufzurechnen.

Für Vorschläge/Tipps der Verbesserung stehe ich Ihnen gerne offen.

Wirf den Code, den du nicht verwendest (z.B. ZeichneAmpelClick) raus und binde möglichst alle Prozeduren (wie Wait) ruhig an die Forminstanz TAmpel.

Ich kann dir nicht empfehlen, für C++ die Grundlagen zu überspringen. Selbst wenn du mit einer C-angelehnten Sprache (wie D oder Objective-C) bereits sehr gut vertraut bist, gibt es doch Unterschiede in der Syntax oder Herangehensweise.

Ganz sicher gibt es ein paar Konzepte oder Strukturen (z.B. Schleifen, Verzweigungen), in die du dich sicherlich schnell einarbeiten kannst, wenn du sie bereits von einer anderen Programmiersprache kennst. Allerdings gibt es ebenso viele verschiedene Grundlagenthemen, die dir noch gänzlich unbekannt sein dürften (z.B. andere Operatoren, Typecastoperationen, Zeiger und Referenzen, const-Expressions, der Umgang mit Strings und Arrays, der funktionale Vorgang beim Kompilieren).

Eine empfehlenswerte Onlinequelle zum Lernen wäre LearnCpp. Auch Hyperskill ist eine gute Anlaufstelle. Auf YouTube würde ich auf die Playlist von Mike Shah (The C++ Programming Language) verweisen.

Ein empfehlenswerter YouTube-Kanal für später ist @CppCon. Auf ihm findest du Vorträge zu spezifischen Themen (z.B. Templates, Lambdas, Move-Operationen, ...), die z.T. (gerade im Vergleich zu üblichen Tutorials) noch etwas weiter vertieft werden.