Zunächst einmal: Was ist eine rekursive Funktion?

Antwort: Eine Funktion, die sich selbst wieder aufruft.

Wozu benötigt man das?

Wenn das Ergebnis der Funktion identisch zu seinem Ausgangspunkt ist. Übrigens lässt sich jede Rekursion durch eine Schleife ersetzen, aber nicht umgekehrt.

Beispiel für eine Rekursionsaufgabe: Durchsuche das ganze Dateisystem und träge sämtliche Dateien (aber nicht die Ordner) in eine Datenbank ein.

Lösungsansatz: Eine Funktion, die 1) einen Ordner und 2) eine Datenbank erhält. Sie trägt jede Datei in die Datenbank ein, ruft sich dann selbst auf jeden Unterordner auf.

Probiers mal hiermit.

https://infothek.rotkel.de/tastaturkuerzel/schriftzeichen/sonderbuchstaben/nach-sprachen.html

Benutze am besten das Model-View-Controller-System. Das heißt, du hast einen Controller, der dein Programm steuert. Der steuert die View, die Anzeige. Beide haben Zugriff auf das Model, den Speicher; aber nur der Controller darf die Daten verändern.

Dein Model hält, für ein Spielfeld, ein mehrdimensionales Arrays. Die View hält ein JButton-Array der selben Größer. Jedes Mal, wenn die View neu lädt, holt sie die Daten für die Buttons aus dem Model. Möglicherweise kennt auch jeder Button sein Darstellung im Model.

Was ist die Aufgabe (genau)?

Gebe die Zahlen 1 4 9 16 25 aus.

Die einfachste Lösungsmöglichkeit:

System.out.println("1 4 9 16 25");

So war das natürlich nicht gemeint, es ging darum, dass es fünf aufeinander folgende Quadratzahlen sind. (Bitte formuliere deine Fragen klarer und achte darauf, dass die Formatierung des Codes stimmt!)

Also:

• Tue 5 Mal:
• den Index (die Zahl, die aussagt, das wievielte Mal wir es gerade tun)
• zum Quadrat aus

Lies dir diesen Link bitte durch: https://www.gutefrage.net/frage/wie-schreibt-man-eine-methode-filter-welche-alle-werte-eines-feldes-a-ausgibt-die-groesser-als-n-sindmit-systemoutprintln?foundIn=list-answers-by-user#answer-239659961

Da habe ich schon mal erklärt, was Java für Schleifen kennt und was der Unterschied ist.

Erste Tatsache: Wir machen etwas eine feste Anzahl oft. (In verständlichem deutsch: wir wissen, wir oft wir es tun): 5 Mal. Das heißt: es ist Unsinn, eine While-schleife zu nehmen. Eine For-schleife ist viel passender.

For-Schleifen funktionieren so:

for(int index=0; index<soOftSollEsGetanWerden; index++) {
  //Hier kommt das, was getan werden soll
}

Was tut das?

1. Einen int (primitiver ganzzahliger Datentyp) namens index erstellen, diesem den Wert 0 zuweisen

2. Die Bedingung, die für erneutes ausführen der Schleife wahr sein muss: index muss kleiner als eine von dir gewählte Zahl sein.

3. Ein Befehl, der jede Runde ausgeführt wird. index++ bedeutet, dass bei jeder Ausführung +1 gerechnet wird.

Was muss jetzt jedes Mal getan werden?

Wir müssen die Quadratzahl von index ausgeben.

Also so?

for(int index=0; index<5; index++) {
  System.out.println(index*index);
}

Das Ergebnis sieht folgendermaßen aus:

0
1
4
16

Und? Hast du schon erraten, wo der Fehler liegt?

Ich habe dir 90% deiner Hausaufgabe gemacht, nach dem Rest kannst du jetzt gucken, aber ich helfe natürlich auch gerne weiter.

Faustregel: immer dann, wenn du einen eingerückten Block hast.

Es gibt immer einen Head (so nenne ich es zumindest) und einen Rumpf. Im Head wird der Aufruf o. ähnl. deklariert, im Rumpf steht das, was dann tatsächlich aufgerufen wird.

Also:

Head {
  //Rumpf
}

Beispiele: (Das Schräge ist immer der Head, alles fette ist zwingend, der Rest ist optional, die Rümpfe lasse ich leer.)

• Klassen

public class MeineKlasse extends WasAnderes implements MehrZeug {
}

• Methoden

//Beispiele:
public static void main(String[] args) {
} //eine Mainmethode

public void meineMethode() {
}

private int getIrgendEineZahl() {
  return eineZahl;
}

//Allgemein:
Sichtbarkeitsebene static/abstract/etc Rückgabewert methodenName(parameter) {
  Methodenaufrufe;
}

Sichtbarkeitsebene: public, private, protected etc

static/abstract/etc: optionales Argument

Rückgabewert: im Normalfall void

Parameter: was man der Methode übergeben muss

• Schleifen

for(int i=0; i<eineZahl; i++) {
}

for(int i:intArray) {
}

while(Bedingung) {
}

do {
} while(Bedingung);

• try-catch-Struktur

try {
  wasRiskantes();
} catch(Exception ex) {
}

• if-else-Struktur

if(Bedingung) {
}

if(Bedingung) {
} else {
}

• switch-case-Struktur

switch(meinChar) {
  case('a'): {}
  case('b'): {}
}

Text wird in Java auch ein String-Objekt genannt, kurz ein String - mit anderen Worten, ein Textobjekt.

So kann man ihn definieren:

String s = "mein Text"; //Kurzschreibweise
String t = new String("mein Text"); //langschreibweise

Strings in Java sind unveränderlich, dass heißt, dass folgender Code zwei Strings erzeugt:

String s = "";
s="hi";

Was bedeutet das konkret? Wenn du zum Beispiel ein Objekt erzeugst, dann eine zweite Referenz auf dieses Objekt zeigst und dann etwas an dem Objekt änderst, kennt die jeweils andere Referenz die Änderung auch, da beide auf das gleiche Objekt zeigen. Bei Strings ist das nicht der Fall.

Object[] o = { new Object(), new Object() };
Object[] p = o;
p.add(new Object());

if(o.equals(p)) {
 System.out.println("die Variablen zeigen auf das gleiche Objekt");
 //diese Bedingung wird erfüllt.
}
//jetzt das gleiche mit einem String:

String s = "hi";
String s2 = s;
s = "wo?"

if(!o.equals(p)) { //! => ungleich/unwahr
 System.out.println("Referenzen zeigen nicht auf das gleiche Objekt");
}
//das wird auch erfüllt

Was kann man noch so mit Strings machen?

• Man kann sie zu einem CharArray umwandeln
• ihre Länge herausfinden
• testen, ob sie Teilstrings enthalten
• diese Gegebenenfalls ersetzen
• dazu kann man reguläre Ausdrücke verwenden (eine eher komplizierte, aber ziemlich mächtige Angelegenheit für die Textverarbeitung)
• Sie auf Werte abtesten, beliebig Zeichen(ketten) an- und abhängen
• mit der Groß- und Kleinschreibung spielen
• und und und ...

Sonst noch Fragen?

Um einen String zu einem CharArray zu machen, nimmst du folgenden Befehl:

char[] zeichnekette = deinString.toCharArray();

Wenn du einfach nur überprüfen willst, ob ein String ein bestimmtes Zeichen enthält, diesen hier (liefert einen boolean zurück):

deinString.contains(irgendeinString);

Wobei irgendeinString dein Char (nur als String) ist: z.B.: "a" oder "/"

Was geht denn alles so, ohne allzu großen Aufwand?

• Pcman
• Pong
• Minesweeper
• (vermutlich auch) pinnball
• einfach Jump'n'Runs
• Billard(?)
• Point-and-Click-Adventures
• Irgendwas mit Labyrinthen
• Rätsel aller Art (z.B. Sudoku)
• evtl Schach
• eine Katze, die Mäuse fangen muss, und wenn sie 20 sec keine kriegt, stirbt sie , und die Mäuse respawnen immer langsamer
• und und und

Für den Anfang sind gute Bücher ziemlich hilfreich. Ich empfehle "Python von Kopf bis Fuß" von O'Reilly.

Normalerweise würde ich sagen "0 Ahnung, aber glaubt, er schafft das? Unwahrscheinlich.", aber ehrlich gesagt, glaube ich, dass du das schaffen kannst, weil du das wichtigste schon kannst: logisch denken. (Zumindest gehe ich davon aus, dass die, die ganz gut in Mathe sind, das beherrschen.)

Für den Anfang sind Scriptsprachen leichter (so wie Python, Javascript etc), später kommen dann eher die anspruchsvolleren Sprachen wie Java, C#, C++ etc.

Welche Sprachen genau du lernen willst, hängt davon ab, was du programmieren willst (also eher Backend oder eher Webseiten oder oder oder).

Aber am Anfang spielt das eigentlich keine Rolle, denn sobald man eine Programmiersprache beherrscht, sind die anderen nicht mehr allzu schwer.

Viel Glück!

Also rückgängig machen ginge mit

button.setEnabled(true);

aber das scheint mir ja nicht gerade deine Intention zu sein. Aber warum willst du einen Button haben, den man nicht klicken kann, der aber so aussieht, als könnte man es? Ich meine, das graue Feld ist ja genau dazu da, dass der user sehen kann, dass dieser Button gerade nicht gedrückt werden kann.

Hälst du es wirklich für eine gute Idee, dem user diese Möglichkeit zu nehmen?

Ich glaube, das eigentliche Problem in deinem Programm ist ein strukturelles, es liegt weniger an der Methode.

Folgendes: wenn du dein Programm so schreibst, wie du es vorgeschlagen hast, wird es in der Millisekunde, in der es bei dieser Codezeile angelangt bist, das abprüfen.

Im Normalfall braucht man jedoch etwas ganz anderes: Sobald (nicht wenn) eine bestimmte Taste gedrückt ist, soll etwas geschehen. Und dafür brauchst du keinen Test à la isDown() sondern einen KeyListener. (Es gibt anscheinend noch einen weiteren Spezialfall, für den findest du hier mehr: https://docs.oracle.com/javase/tutorial/uiswing/misc/keybinding.html)

Den fügst du wie einen normalen Listener einer Component hinzu (im Normalfall nimmt man das Fenster und alles, was darin ist (einzeln!)), und wenn die Taste gedrückt ist, während diese Komponente angewählt ist, wird die actionPerformed()-Methode des Listeners aufgerufen.

Beispielcode zum Hinzufügen des Listeners:

JFrame meinFenster = new JFrame("toller Titel");
meinFenster.add(new KeyListener() {
@Override
public void keyPressed(KeyEvent e) {}

@Override
public void keyReleased(KeyEvent e) {}

@Override
public void keyTyped(KeyEvent e) {
 // das, was bei Tastendruck passieren soll
}

});

So in etwa.

Theoretisch wäre es möglich, dafür müsstest du die Methode überschreiben. Aber es wäre aus 2 Gründen keine gute Idee:

1. Du kämst im guten nicht mehr an die Originalmethode ran. (Wer weiß, vielleicht brauchst du die weiter unten im Code.)
2. Es wäre schlechter Stil. Du willst etwas anderes als die Originalmethode, deshalb benutzt man auch eine andere Methode.

Dazu würde ich vorschlagen, dass du den Text in einem JLabel oder einer JTextArea ausgibst. (Ich bevorzuge zweiteres, vor allem weil du durch das Hinzufügen zu einer JScrollPane ohne größere Probleme ermöglichen kannst, dass man hoch und runterscrollen kann.

Noch Fragen dazu?

Du wirst wohl Multithreading benutzen müssen. Vom Prinzip her ist ein Thread der, der auf die Antwort wartet & prüft, und der zweite der, der wartet.

Der Erste ist der main-Thread. Wenn er die richtige Lösung findet, weckt er den anderen auf und macht ihn platt. Wenn die Zeit vorbei ist (ohne das der zweite Thread plattgemacht wurde, denn dann könnte er ja nicht mehr zählen), schickt er ein Event an den Ersten von wegen: "zeit vorbei!" und dann weiß der Erste Bescheid.

Die Methode zum warten ist thread.sleep()

Ich weißt nicht, was du dir unter "OS" vorstellst, aber das ist letztendlich egal.

Kann man mit Java ein Betriebssystem programmieren? Nein. Warum? Erklär ich gleich. Erst einmal kläre ich die grundlegenden Begrifflichkeiten.

Java ist eine High-level-programmiersprache, das heißt so viel wie, dass sie auf "einer oberen Ebene" ausgeführt wird. Stell dir die Vorgänge im Computer wie ein Haus vor. Das erste ist der Boden, die direkte Prozessorarchitektur. Darauf folgt das Betriebssystem, das Fundament. Die Low-level-prozesse, das sind die Wände und Zimmer im Erdgeschoss. Und darauf bauen die Highlevelprozesse auf.

Um es noch einmal anders deutlich zu machen: C wurde in sich selbst entwickelt, da man den Speicher direkt manuell verwalten kann, also "lege auf Adresse 0x0 eine 1". Java wurde in C entwickelt, denn man kann nur sagen "speichere mir mal eine 1 und gebe mir eine Referenz darauf".

Ein Betriebssystem ist die unterste Ebene eines Systems, es muss direkt mit den Bits und Bytes interagieren.

Da das in Java nicht geht, kannst du kein Betriebssystem in Java schreiben.

(Übrigens ist denn Verweis auf die SwingBibliothek völlig fehl am Platze. Auch die Sache mit dem Desktop. Man braucht keine grafische Oberfläche um ein Betriebssystem zu haben. Frag mal ein paar Verwandte (Alter rund 50) nach ihren ersten Computern.)

Möglicherweise ist dein Homespeicher voll. Wenn du einen Windowsrechner hast, schau mal, wie voll die Platte ist und lösch gegebenenfalls etwas (zuerst den Papierkorb, da sammelt sich viel an, ansonsten vor allem Videos, Filme und Hochauflösende Bilder).

Wenn du einen Linuxrechner hast, erfährst du das, in dem du folgenden Befehl eingibst (in die interaktive Konsole, genannt Terminal):

df -h

Mach es so:

import javax.swing.JFrame

public class ReOpeningFrame extends JFrame {
  public static void main(String[] args) {
    new ReOpeningFrame();
  } //hier haben wir in der main-methode ein erstes Fenster geöffnet

  public ReOpeningFrame() {
    JButton openNew = new JButton("ein neues Fenster");
    openNew.addActionListener(new ActionLister() {
      @Override
      public void actionPerformed(ActionEvent event) {
        this.setVisible(false);
        new ReOpeningFrame(); //wenn der Button gedrückt wird, ein neues öfne
      } 
    } //mal eben einen neuen Listener geschrieben und seine 
      //ActionPerformed Methode überschrieben
    this.add(openNew);
    this.setVisible(true);
  }
} 

Das sollte an sich funktionieren, auch wenn ich es nicht getestet habe. Das wirklich interessante Problem an dieser Stelle ist die Speicherverwaltung. Und zwar: du machst die alten Fenster nur unsichtbar. Wenn du sie wirklich löschen wollen würdest, musst du dich mit Futures und ThreadHandling herumschlagen, weil du dann alles von außerhalb der Fenster managen musst. Aber für den normalen Gebrauch sollte das reichen.

Übrigens: das funktioniert immer wieder: du kannst im neuen noch mal klicken und kriegst noch ein neues etc.

Ich glaube, dein eigentliches Problem ist folgendes: du kriegst das Alte nicht aus dem neuen heraus gelöscht. Geht auch nicht, jedenfalls nicht, ohne das dein Programm "broken by design" wird.

Das bessere wäre: Eine Klasse erstellen, die alles kontrolliert, den sogenannten Controller. Der muss eine innere Klasse haben, die den ActionListener implementiert, oder es selbst tun. Dieser startet zuerst das erste Fenster, und gibt diese implementierende Klasse (z.B. sich selbst) mit.

Das erste Fenster macht fröhlich seinen Krams, aber in dem Moment, wo der "Schließen"-Button gedrückt wird, muss ja der Controller Bescheid kriegen.

Das machst du, in dem du dem Schließenbutton einen Actionlistener hinzufügst:

closeButton.addActionListener(listener);

Wenn der Schließenbutton noch andere ActionListener hat, musst du diesen als letztes hinzufügen, der Reihenfolge wegen, in der die Befehle abgearbeitet werden.

Wenn eine Klasse von ActionListener implementiert, muss die Methode actionPerformed(ActionEvent event) überschrieben werden. In diese Methode kommt folgendes:

Du machst das alter Fenster unsichtbar. Du startest das Neue. Das Neue kann sich in seinem Konstruktor selbst einrichten. So weit, so klar?

Das war eigentlich schon der Ganze Zauber.

Es kommt darauf an, wie groß das Feld ist, in dem die Zufallszahlen liegen sollen. Also, wenn du zwischen  1 und 20 willst, dann könntest du dein Programm auch ganz real Kugeln ziehen lassen. (Natürlich würde es für größere Zahlen auch gehen, aber ab ein paar 1000 wird es langsam werden - je nachdem, wie gut dein Rechner ist.)

Dazu machst du folgendes: Zunächst erzeugst du eine LinkedList<Integer> (!), in die du jede Zahl zwischen 0 und k  einmal hinzufügst. Am besten mit einer for-Schleife.

Anschließend lässt du dir n-mal eine Zufallszahl zwischen der Länge der Liste und 0 geben. Anschließend machst du folgendes: neue_liste.append(altelist.get(zufallszahl)) [oder: neue_liste.append(zufallszahl+1) - das geht nur, wenn du die zahlen geordnet hinzugefügt hast] und alteliste.remove(zufallszahl).

Die neue Liste wird alle deine gezogenen Zahlen enthalten.

Ich würde dir vorschlagen, eine rekursive Methode zu benutzen:

found = False

def isInList(search, my_list):
  for element in my_list:
    if isinstance(element, list):
     return isInList(search, element)
    else:
      return element == search

In etwa so, habe ich aber nicht getestet.

Müsste klappen, die Frage ist eigentlich recht trivial, wenn man weiß, wie, aber vorher fast unlösbar ;-)

Das kommt darauf an, was du unter einem "award" verstehst. Das Wort bedeutet ja so viel wie "Auszeichung" oder "Preis". Suchst du evtl einen Wettbewerb, wo du teilnehmen kannst?

Da gibt entweder die offiziellen Wettbewerbe von Wattpad selber (such mal nach theWattys und justWriteIt. Ersteres ist der jährliche Wettbewerb, zweiteres der monatliche. Wie du teilnehmen kannst?: Klicke auf "community" oben in der Leiste und dann auf #justwriteit.)

Außerdem gibt es "private Wettbewerbe" da gibt es wieder 2 Gruppen. Das erste sind die, die von Verlagen gesponsert werden, allerdings gibt es bei denen meist sehr genaue Teilnahmebedingungen und selten sind sie auch. Hierbei gibt es aber auch häufig wirklich was zu gewinnen. Also Geld oder ähnliches. (Mit genauen Bedingungen ist sowas gemeint wie: mindestens 18 Jahre alt und amerikanischer Staatsbürger. Die Bedingungen passen selten auf 13jährige Deutsche.)

Bei der 2. Gruppe sind es ganz normale User, die Wettbewerbe veranstalten. Such doch auf wattpad mal nach "Kurzgeschichtenwettbewerb" oder ähnlichem.

Hoffe, ich konnte dir helfen.