Eine ziemlich einfache Lösung bietet dir PapercutSMTP. Das ist ein Mailserver, den du zum Testen auf deinem lokalen Gerät verwenden kannst.

Wie du ihn benutzen kannst, wird in diesem Artikel erklärt: Test sending emails with PapercutSMTP in PHP using XAMPP.

Noch eine andere Lösung wäre der Mercury Mailserver, den XAMPP in seinem Installationspaket anbietet. Dessen Konfiguration ist allerdings etwas aufwendiger. Eine Schritt-für-Schritt-Anleitung findet man beispielsweise hier.

Und noch zwei Anmerkungen zu deinem Code:

1) Fehlende Angaben sind nicht auf einen internen Serverfehler zurückzuführen, sondern auf einen Fehler des Client. Der Statuscode 400 würde besser passen.

2) Die htmlspecialchars-Funktion ersetzt Sonderzeichen gegen HTML Entities. Das beinhaltet ebenso spitze Klammern. Das heißt, aus

$message = htmlspecialchars('<p>test</p>');

wird

&lt;p&gt;test&lt;/p&gt;

In diesem Ergebnis wird die strip_tags-Funktion nichts zum Entfernen finden.

...zur Antwort
(...) aber ich verstehe nicht, wie ich diesen Code lesen muss. (...)

Der Quellcode wird von oben nach unten gelesen. Bei Zuweisungen wird erst der rechtsseitige Ausdruck ausgewertet und Funktionen werden erst ausgeführt, sobald sie explizit aufgerufen werden.

Auf was verweist aber beispielsweise const name = replacements[0] oder oder const age = replacements[1].

Die Variable replacements wird als Parameter im Funktionskopf deklariert:

function tagFunction(strings, ...replacements) {

Hierbei wird die rest parameter-Syntax angewandt. Die drei Punkte vor dem Parameternamen deuten an, dass bei Aufruf der Funktion beliebig viele Argumente an der Stelle übergeben werden können.

Das heißt, Aufrufe wie diese wären valid:

tagFunction("Max", 1);
tagFunction("Max", 1, 2);
tagFunction("Max", "a", "b", "c");

Diese Argumente werden anschließend in ein Array gesteckt, auf welches replacements zeigt.

Folgendermaßen hättest du, würdest du die obigen Aufrufe nutzen, folgende Ergebnisse für name und age:

tagFunction("Max", 1):
name: 1
age: undefined

tagFunction("Max", 1, 2):
name: 1
age: 2

tagFunction("Max", "a", "b", "c"):
name: "a"
age: "b"

An dieser Stelle solltest du merken, dass du die Funktion nicht so aufrufst, wie es eigentlich angedacht war. Die Werte für Name und Alter sollten eigentlich als separate Argumente übergeben werden und damit es mit dem resultierenden Text auch passt, müsste für das erste Argument ebenfalls ein Array erstellt werden.

const name = "Max Mustermann";
const age = 98;
const text = [ "Mein Name ist ", ", ich bin ", " Jahre alt" ];
const message = tagFunction(text, name, age);

Bezüglich Funktionsaufrufen würde ich übrigens dazu raten, stets auch die Klammern für die Argumentenliste mit anzugeben. So wird beim Lesen schneller deutlich, dass es sich gerade um einen Funktionsaufruf handelt.

Und mal ganz nebenbei: Wie würdet ihr die praktische Relevanz der Tag-Funktion einschätzen?

Aktuell ist diese Funktion nur für einen bestimmten Anwendungsfall beschränkt und kann daher wohl eher als Demonstration / Beispiel für die rest parameter-Syntax betrachtet werden.

In der Praxis sollte sie auf jeden Fall einen passenden Namen erhalten, der auch verrät, was sie tut. Das Gleiche gilt für den ersten Parameter.

Die rest parameter-Syntax an dieser Stelle zu verwenden, halte ich zudem für einen schlechten Stil. Wenn die Funktion zwei Werte erwartet, sollten auch explizit zwei Parameter in der Parameterliste aufgelistet werden. Das hilft nicht zuletzt auch dem Programmierer, der die Funktion irgendwann einmal nutzen möchte: Er sieht, welche Argumente die Funktion erwartet und kann anschließend selbst entscheiden, inwiefern er sie bedient.

Bei der aktuellen Implementation muss man stattdessen erst die Funktionsimplementation studieren, bevor man weiß, was in die jeweiligen Argumente darf. Das ist zeitaufwendig und unintuitiv.

Relevanz könnte die Funktion erlangen, wenn man sie für einen allgemeineren Anwendungsfall umschreibt.

function format(template, ...args) {
  return template.replace(/{(\d+)}/g, (match, number) => {
    return typeof args[number] === "undefined" ? match : args[number];
  });
}

console.log(format("Hello, my name is {0} and I'm {1} years old.", "John Doe", 56));

Das erste Argument ist ein Text mit Platzhaltermarken. Diese werden gegen die konkreten Werte ausgetauscht, die man als weitere Argumente übergibt. Dabei gilt: Das erste Zusatzargument wird gegen {0} getauscht, das zweite Zusatzargument gegen {1}, usw..

Vorteilhaft gegenüber einer String-Interpolation ist, dass so View (die Ausgabe) und Model (die konkreten Daten) voneinander getrennt werden. Der Template-String braucht bei mehrfacher Verwendung (mit unterschiedlichen Platzhalterwerten) nur einmal definiert werden.

const template = "Hello, my name is {0} and I'm {1} years old.";
console.log(format(template, "John Doe", 56));
console.log(format(template, "Max Mustermann", 23));
...zur Antwort
Oder ist eine Sprache sinnvoller?

Es wäre sinnvoll, eine Sprache zu wählen, die bereits Tools bietet, die dich bei deinem Vorhaben unterstützen können.

Für C++ würde es sich anbieten, das Qt-Framework zu nutzen. Mit dem kannst du Anwendungen für verschiedene Plattformen (Android, iOS) bauen. Solltest du allerdings noch frei in der Wahl sein und nicht auf C++ pochen wollen, würde ich eine einfachere Option wie Dart (mit Flutter) empfehlen.

Die anderen von dir genannten Sprachen würde ich eher nicht in Erwägung ziehen, auch wenn es Bibliotheken wie kivy (Python) oder EQL5 (CLisp) gibt.

Was allerdings eine gute Alternative sein dürfte, wäre die Entwicklung einer Webseite. Die wichtigsten HTML- und CSS-Kenntnisse lassen sich schnell lernen und für den Logikteil könntest du Python (in Kombination mit einem Framework wie Flask oder Pyramid) einsetzen. Die Daten könnte man möglicherweise direkt auf dem selben Server speichern (oder in einer angebundenen Datenbank).

Wie kann ich etwas selber programmiertes zu einer App umwandeln

Das notwendige Endprodukt entsteht beim Projektbuild.

Wie kann ich Daten zwischen der App und einem online Speicher hin und her schicken?

Entweder du nutzt einen Cloud-Speicher wie Back4App Firebase oder Parse, mit dem du über eine API kommunizieren kannst oder du baust dir selbst eine Anwendung, die auf einem Server liegt und eine (REST) API zur Verfügung stellt, mit der deine Anwendung kommunizieren kann.

Die von dir beschriebenen Anforderungen lassen sich allerdings bereits mit bestehender Software lösen. Auf Google Drive kannst du beispielsweise Dokumente anlegen und Dateien hochladen. Zusätzlich besteht sogar die Möglichkeit, den Zugriff auf die jeweiligen Daten zu steuern.

In einer WG sollte so eine fertige Lösung zudem besser ankommen. Dein Weg würde das absolute Vertrauen deiner Mitbewohner in dich (deine Motivation und technischen Kompetenzen) erfordern. Vor allem wenn du deine erstellte App in keinem Store publizieren möchtest.

...zur Antwort

Mit Komponenten sind hier die einzelnen Elemente gemeint, die im Vektor stehen. Übertragen auf das Beispiel eines Arrays:

int[] numbers = new int[] { 1, 2, 3 };

wären also 1, 2 und 3 jeweils einzelne Komponenten.

Wie deine Klasse die einzelnen Elemente intern konkret speichert, wird nicht vorgeschrieben. Du könntest Objekte kettenhaft verknüpfen oder bereits vorhandene Datentypen (Array, List, Stack, ...) nutzen. Die Anmerkung, dass die Länge der Datenklasse initial gesetzt wird und folglich unveränderlich sein soll, gibt meines Erachtens aber auch schon einen Tipp, was sich als interner Datenspeicher ganz gut eignen würde.

...zur Antwort

Zur Laufzeit gibt es den generischen Typ nicht mehr. Daher kannst du ihn auch nicht in Kombination mit dem instanceof-Operator verwenden.

Stattdessen kannst du aber die isAssignableFrom-Methode verwenden. Dafür brauchst du die Klasseninformation zum zu prüfenden Objekt und die Klasseninformation zum generischen Typ.

public boolean isInstanceOf(Class<T> type, Object objectToCheck) {
  return type.isAssignableFrom(objectToCheck.getClass());
}

// usage:
if (someObject.isInstanceOf(String.class, "some value")) {
  System.out.println("Is String");
}

Alternativ würde es ebenso mit der isInstance-Methode klappen.

type.isInstance(objectToCheck)

Im Hinblick auf deinen Code würde ich dir übrigens dazu raten, ein paar Redundanzen loszuwerden. Da sich das name-Feld im Namen offensichtlich nie ändert, könnte es als Konstante gekennzeichnet werden und den Key könntest du direkt im Konstruktor in einem weiteren Feld speichern.

private final String challengesKey;

// constructor
challengesKey = "Challenges.Settings." + getName();

Sollte er sich zukünftig einmal ändern, brauchst du nur noch eine Stelle im Code ändern und die Anzahl an Zeilen, in denen Tippfehler auftauchen können, reduziert sich erheblich.

Außerdem brauchst du die Konfiguration nicht mehrmals einlesen, wenn du den Wert doch bereits in obj gespeichert hast.

if (config.contains(challengesKey)) {
  Object challenges = config.get(challengesKey);

  if (/* check type ... */) {
    setValue((T)challenges);
  }
}
...zur Antwort

Mit einem Framework wie PyQt lässt sich so etwas einfach umsetzen. Eine QPixmap (dient der Repräsentation eines Bildes) lässt sich mit einem QTransform-Objekt rotieren.

image = QPixmap("image.png")
transform = QTransform().rotate(45)
image = image.transformed(transform)

Mit einem QTimer wiederum kann man den zeitlichen Ablauf steuern. Hier findest du einen Artikel, der zeigt, wie man die Klasse konkret einsetzen kann.

Während das Bild rotiert wird, solltest du dir in einer Variable den aktuellen Winkel speichern, denn diesen Wert benötigst du für die Endrotation zurück zum Ausgangspunkt.

...zur Antwort

Wenn du eine Datei mit dem Modifier w öffnest, wird sie entweder neu erstellt (sofern sie noch nicht existiert) oder überschrieben. Der Dateizeiger wird dafür an die erste Stelle gesetzt und der Inhalt auf die Länge 0 gekürzt.

Im Falle einer Exception solltest du also die Datei nicht einfach wieder schließen, sondern den alten Inhalt zuvor auch wieder hineinschreiben.

Statt mehrere if aneinanderzureihen, würde ich im Übrigen ein if-elif empfehlen. Immerhin ist doch die Erwartungshaltung, dass stets nur ein Fall zutrifft. Im Bestfall kann sich das Programm also zwei Prüfungen ersparen.

Nach aktuellem Stand würde sogar ein if-else vollkommen genügen.

if count in counting:
  # ...
else:
  # ...

Die anderen Fälle verhalten sich doch ansonsten gleich.

...zur Antwort

Du brauchst dich im Grunde mit JavaScript nur an das submit-Event des Formulars hängen. Die Attribute action und method fliegen dafür im Markup raus.

const form = // get form ...
form.addEventListener("submit", evt => {
  evt.preventDefault();
  // ...
});

In dem kannst du die Formulardaten sammeln:

const formData = new URLSearchParams(new FormData(form));

gegebenenfalls noch einmal validieren und anschließend verschicken:

fetch("check.php?login=1", { method: "post", body: formData })
  .then(response => response.text())
  .then(answer => {
    // ...
  });

Die Antwort, die du erhältst, kann im Callback verarbeitet werden. In answer würde dann der konkrete Text aus dem Response Body stehen.

Den PHP-Teil, der aktuell am Anfang deiner Datei steht, verschiebst du in eine eigene Datei. Meinem Beispielcode zu Folge, müsste sie check.php heißen.

Die Fehlermeldung ($errorMessage) müsstest du nun direkt ausgeben. Mit JavaScript kannst du sie innerhalb des oben erwähnten Callbacks in das DOM einfügen. Sollte die Anmeldung stattdessen erfolgreich gelaufen sein, benötigst du eine Weiterleitung (oder du fügst deinen Link im DOM ein):

location.href = "Ziel-URL...";

Zuletzt noch ein paar Verbesserungsvorschläge zu deinem aktuellen Stand:

1) Verwende überall eine sichere Zeichenkodierung wie UTF-8. Die schützt deine Anwendung vor Injections und reduziert Fehlerfälle.

Änderungen müsstest du dabei an drei Stellen vornehmen. Einmal beim Connectionstring:

$pdo = new PDO('mysql:host=localhost;dbname=phptest;charset=utf8mb4', 'root', '');

Dann sollte die Datenbank natürlich entsprechend konfiguriert werden (Zeichenkodierung utf8mb4 - das ist im Prinzip UTF-8, Kollation: utf8mb4_unicode_ci).

Und zu guter Letzt fehlt noch eine Metaangabe im head deines HTML-Dokuments.

<meta charset="utf-8"> 

2) Bau weitere Filter / Tests ein, bevor du überhaupt eine Datenbankverbindung herstellst (aktuell verbindest du dich auch dann mit der Datenbank, wenn keine Daten verschickt wurden). In PHP gibt es hierfür Filterfunktionen.

...zur Antwort

Jede Komponente - das heißt jede Swing-Klasse, die von JComponent erbt, besitzt zum einen eine paint sowie eine paintComponent-Methode.

Erstere macht etwas mehr, als nur die Komponente selbst zu zeichnen. Sie zeichnet ebenso den Rahmen um die Komponente und die Kindkomponenten. Da man im Regelfall mit Subklassen nur das Aussehen einer Komponente ändern möchte, macht es keinen Sinn, paint zu überschreiben.

Top-Level-Container (TLC) wie JFrame oder JDialog wiederum besitzen keine paintComponent-Methode und erben paint von der AWT-Klasse Window. Es handelt sich hierbei also um eine andere Methode, die zwar gleich heißt, aber eine etwas andere konkrete Implementation hat.

Aber auch hier gibt es einige Punkte zu beachten bzw. abzuwägen.

  • Wenn du die Methode überschreibst, solltest du immer auch die Basisimplementation erst aufrufen, da sie auch Eigenschaften wie die Deckkraft definiert, die wichtig für das Rendering der Kindelemente ist.
  • TLC verwenden anders als Komponenten kein Doublebuffering beim Zeichnen. Das kann also bei häufigem Neuzeichnen der Fläche zu einem unschönen Flackereffekt führen.
  • Wenn du bei deinem Beispielprogramm sehr nah unter der Kante der Fenstertitelleiste klickst, sollte dir etwas auffallen: Der Text wird auch noch unter der Titelleiste eingefügt. Wenn du in der paint-Methode zeichnest, musst du die Höhe der Titelleiste mit einbeziehen, da der Koordinatenursprung tatsächlich in der linken oberen Ecke des Fensters liegt und die Titelleiste dabei nicht berücksichtigt.

Besser wäre es also auch hier, das Überschreiben einer Komponente (z.B. einem JPanel) vorzuziehen, die man dann dem Frame anhängt. Gerade dein Beispiel stellt so einen Anwendungsfall dar.

Ein Vorteil, der sich dabei möglicherweise noch ableiten lässt, ist die Wiederverwendbarkeit einer überschriebenen Komponente, denn die kann auch noch in andere TLC (oder andere Komponenten) eingehängt werden.

Zudem ist es dann nicht notwendig, die eigene Klasse von der TLC-Klasse (in deinem Beispiel JFrame) abzuleiten. Es reicht aus, ein einfaches TLC-Objekt anzulegen und die eigene Klasse hat wieder die Freiheit, bei Bedarf von einer anderen Klasse zu erben.

...zur Antwort

Ich denke, für eine Entscheidung sollten verschiedene Faktoren erwogen (bzw. bestimmte erste Fragen gestellt) werden. Ich gehe folgend auf einige ein, die mir direkt einfallen.

1) Welche konkreten Anforderungen stellt die Zielanwendung?

Das wäre natürlich die erste Frage, um abgleichen zu können, ob sich das Framework auch nur ansatzweise lohnt.

Wenn ich beispielsweise das Szenario einer E-Commerce-Plattform heranziehe (das verstehe ich unter einer komplexen Webanwendung), hätte ich ein System vor mir, welches neben den einfachen Seitenbesuchern noch weitere Nutzertypen (Stakeholder) mit diversen Schnittstellen bedienen muss. Solche (wie z.B. eine grafische Oberfläche zur Verwaltung der Inhalte oder Anknüpfungspunkte an Analytics-Software/CRMs/...) bietet mir CppCMS nicht. Bereits ausgereifte E-Commerce-CMS hingegen schon.

Der ausgewiesene Fokus des Frameworks liegt hingegen darin, eine gute Performance zu leisten. Das das mit C++ möglich ist, möchte ich nicht bezweifeln, doch müsste man wohl erst einmal einen Anwendungsfall finden, bei dem man mit anderen Technologien (C#, Java, Go, ...) nicht ebenso zu einem befriedigenden Ergebnis kommen würde.

Die Benchmark-Tests, die das CppCMS auf seiner Seite präsentiert, finde ich übrigens nicht so vertrauenswürdig. Ich verstehe bspw. nicht, wieso für einen Vergleich WordPress herangezogen wird, immerhin ist dieses System doch eher auf einen breiteren Anwendungsbereich ausgelegt (unter anderem den, für den CppCMS nicht entwickelt wurde). Die Tests sind zudem nicht aktuell (Vergleich mit Java 6, PHP 5, ...) und es fehlen Informationen über den genauen Ablauf.

2) Welchen Support kann ich erwarten?

Laut dem GitHub Repository fand der letzte Commit vor zwei Jahren statt und die Dokumentation (sowie Examples) sind vermutlich nicht auf dem neuesten Stand. Diverse Links auf der offiziellen Webseite führen zudem ins Leere.

Das heißt, man sollte nicht unbedingt mit der weiteren/regelmäßigen Wartung und Erweiterung des Frameworks seitens des Entwicklers rechnen und es ist gut möglich, dass man bezüglich bestimmter Funktionen öfter gezwungen ist, selbst im Quellcode des Projekts nachzuschauen.

Ein Blick in die Roadmap verrät zudem, dass es an bestimmten grundlegenden Features (HTTPS-Support, Virtual Hosts-Support, WebSocket-Support) mangelt. Laut URL könnte man zwar meinen, dies bezieht sich nur auf 1.x-Versionen, doch auf keiner der What's New-Seiten für 1.0.0-2.0 habe ich noch einmal Erwähnung dazu gefunden. An der Stelle muss man also wahrscheinlich Abstriche machen bzw. selbst Lösungen finden.

3) Welche Ressourcen stehen überhaupt zur Verfügung?

Eine entscheidene Ressource sind zum einem die vorhandenen Kenntnisse der Entwickler, die das Framework nutzen möchten. Wenn man ein Entwicklerteam hat, welches sich vorrangig auf C++ spezialisiert hat, ist es legitim, darüber nachzudenken, eine C++-Lösung zu nutzen. Bei einem breiter gefächerten Kenntnisstand würde ich allerdings davon abraten. Nicht zuletzt, da man zu anderen, weiter verbreiteten Technologien wie z.B. ASP.NET oder Spring eher Support findet (mehr/bessere Dokumentation, größere Community, viel mehr unterstützende Bibliotheken).

Das Hosting wiederum ist heutzutage weniger ein Problem. Selbst preislich kann man sich aufgrund Lösungen wie AWS oder Azure recht gut an die eigenen Bedürfnisse anpassen.

Eine Skalierung, dass anbei, ist übrigens nicht nur eine Frage der Performance, sondern auch der Sicherheit. Wenn ein Server aus welchen Gründen auch immer ausfällt - es muss überhaupt nichts mit der Webanwendung selbst zutun haben - kann ein anderer einspringen.

Noch ein wichtiger Punkt, der einzuplanen ist, ist die Zeit, die man für das Projekt und dessen Wartung hat. Jede weitere Feature-Implementation bedeutet Aufwand und birgt ein Fehlerrisiko. Die Tatsche, dass C++ erfahrungsgemäß etwas schwieriger als andere Programmiersprachen ist, spielt noch mit hinein.

Oder denkt ihr, aus Aufwand / Nutzen Perspektive wäre php/Java besser?

Gerade wenn du eine große Entscheidungsfreiheit hast (z.B. aufgrund von Kompetenzen in C#/Java/Go/...) und kein experimentelles Hobbyprojekt starten möchtest, würde ich dir eine andere Lösung als C++ empfehlen. Für leistungsstarke, komplexe Webanwendungen eignen sich beispielsweise C#/ASP.NET, Go oder Java. Ansonsten kann man mit JavaScript, PHP oder Ruby (On Rails) ebenso schon eine Menge erreichen.

Bei all diesen genannten Technologien empfängst du besseren Support (mehr Dokumentation, größere Communities, fortschrittlichere Tools), was den Aufwand am eigenen Projekt erheblich senkt.

Wenn du auf C++ beharren möchtest, würde ich dir eher dazu raten, nach anderen, ausgereifteren Frameworks (wie TreeFrog oder wt) Ausschau zu halten, die sichtbar kontinuierlich weiterentwickelt werden.

...zur Antwort

Es hängt von der Konsole ab, die du verwendest. Einige Konsolen unterstützen weitere Farben, andere wiederum nicht.

Eine erste kleine Übersicht findest du auf Wikipedia: ANSI Escape-Codes - Colors. Eine Auflistung an Konsolenanwendungen, die wohl Truecolors (also 24-bit) unterstützen, findest du hier.

Für deine Python-Anwendung würde das bedeuten, dass du mit

print("\033[38;2;138;69;19m" + "Hello" + "\033[0m")

einen Text in brauner (saddlebrown) Schriftfarbe erhalten würdest.

Die erste Zeichenfolge setzt die Vordergrundfarbe nach dem Muster:

\033[38;2;RED;GREEN;BLUEm

Die zweite Zeichenfolge ist der auszugebende Text. Ich habe ihn von der ersten Zeichenfolge separiert, um den Code lesbarer zu gestalten.

Die dritte Zeichenfolge setzt den Zustand wieder zurück, sodass folgende Ausgaben wieder in den Standardfarben ausgegeben werden.

...zur Antwort
Ja, ist möglich

Ja, das ist möglich und praktische Beispiele dafür gibt es auch schon.

Zum Beispiel:

  • BeanShell
  • Groovy (wird vor der Ausführung in Java-Bytecode übersetzt)
  • JRuby (ein Ruby-Interpreter)
  • Jython (eine Python 2-Implementation in Java)
  • Rhino (JavaScript-Interpreter)

Zu all diesen Projekten kannst du dir auf GitHub den Quellcode anschauen.

Bezüglich der Theorie würde ich dir dazu raten, dich mit einigen Themengebieten der theoretischen Informatik auseinanderzusetzen (z.B. formale Grammatiken, DFA, NFA, abstrakte Syntaxbäume).

Grundsätzlich (grob) müsstest du dir eine Syntax überlegen, die deine Sprache erlaubt und zu dieser einen Lexer/Parser entwickeln (Ersterer teilt den Code in Tokens auf, Letzterer interpretiert die Tokens und ordnet sie in einen Syntaxbaum). Die Knoten können anschließend ausgeführt / übersetzt werden.

...zur Antwort

Das, was du im ersten Snippet als JSON-String bezeichnest, ist kein JSON-String, sondern ein Objekt. Wenn es Ersteres sein sollte, müsste der Code so aussehen:

let variablen = '{"dingsbumbs":"Das ist eine Variable"}';

Strings stehen in Anführungszeichen und die Keys in JSON ebenso (dort müssen es allerdings doppelte Anführungszeichen sein).

Für dein Programm ist ein JSON-String allerdings eher hinderlich, da du ihn zum Lesen und Verändern immer wieder parsen müsstest. Ich würde JSON nur in Betracht ziehen, wenn das Objekt in variablen persistent gespeichert werden müsste.

Nun noch ein Beispiel, wie man einen Eintrag in einem Objekt suchen kann:

const variables = { "someVariable": "Some value" };
const variableName = "someVariable";

if (variables.hasOwnProperty(variableName)) {
  console.log(variables[variableName]);
}
else {
  console.log("undefined");
}
...zur Antwort

Zwei Lösungsvorschläge:

a) Du legst die Liste in der main-Methode an und übergibst sie an die zweite Methode.

class Example {
  public static void main(String[] args) {
    List<String> words = new ArrayList<>();
    String randomWord = getRandomWord(words);
    int size = words.size();
  }

  private String getRandomWord(List<String> words) {
    /* ... */
  }
}

Sofern die künftige Länge der Liste schon vor Aufruf klar ist, könntest du statt einer Liste auch die Länge in main definieren und übergeben.

b) Du legst die ArrayList als Feld an.

class WordManager {
  private List<String> words = new ArrayList<>();

  public static void main(String[] args) {
    WordManager manager = new WordManager();
    String randomWord = manager.getRandomWord();
    int size = manager.words.size();
  }

  public String getRandomWord() {
    /* get random word from words ... */
  }
}
...zur Antwort

1) Wenn die Oberfläche geändert wird, muss sie auch neu gezeichnet werden. Verschiebe den Aufruf von setVisible an den Schluss, nachdem du Komponenten angehängt hast. Die Methode triggert einen Zeichenvorgang für den Frame.

2) Swing wurde für recht statische Oberflächen konzipiert, nicht für Jump 'n' Run-Spiele o.ä.. Verwende besser ein Framework wie libGDX, welches sich konkret auf die Spieleentwicklung ausgerichtet hat. Du machst es dir so auch einfacher.

...zur Antwort

Du kannst das Element mit replaceWith ersetzen.

Aber ob das überhaupt notwendig ist, würde ich zunächst infrage stellen. Es kann womöglich ausreichen, das Verhalten / Aussehen des Elements mit CSS zu ändern. Das heißt, du könntest dem Element vermutlich ebenso gut einen CSS-Klassenselektor zuweisen.

element.classList.add("some-css-class");

CSS:

.some-css-class {
  /* ... */
}
...zur Antwort

Du erstellst in deinem Code kein Textfeld. Der Funktionskörper ist doch leer.

Der Aufbau sollte so aussehen:

@Composable
fun UserInput() {
  TextField(
    /* ... */
  )
}

Dabei ist es die TextField-Komponente, die erst das Textfeld zeichnet.

Auf diesen beiden Seiten findest du komplexere Beispiele:

  • JetPack Compose Playground
  • GeeksforGeeks: EditText in Android using JetPack Compose
  • Learn JetPack Compose By Example
...zur Antwort

Definiere einen eigenen WebViewClient für dein WebView. Dieser kann über die shouldOverrideUrlLoading-Methode das Laden von URLs im WebView beeinflussen.

yourWebView.setWebViewClient(new WebViewClient() {
  @Override
  public boolean shouldOverrideUrlLoading(WebView view, WebResourceRequest request) {
    String url = request.getUrl().toString();
    view.loadUrl(url);
    return false;
  }
});

Voraussetzung ist dann natürlich nur noch, dass der angegebene Pfad richtig ist.

...zur Antwort

Du erhältst diese Fehlermeldung, weil das Bild nicht gefunden werden kann. Die getResource-Methode geht von dem Ort aus, in dem die class-Datei deiner Main-Klasse liegt. In welchem Ordner die class-Datei wiederum abgelegt wird, kann abhängig von der IDE sein, die du nutzt.

Der Artikel von Mkyong zeigt anhand von Bildern und Code, wie du eine Ressource richtig einlesen kannst.

...zur Antwort