ScrollBar inaktiv / Rekursive Methode

Status
Nicht offen für weitere Antworten.
H

HalloWelt

Mitglied
Hi... Ich habe folgende Problem:

In der Hauptklasse habe ich eine Scrollbar mit der ich den Wert einer Variable bestimmen möchte.
Weiter habe ich eine Klasse mit einer rekursiven Methode. In der rekursiven Methode benötige ich immer den aktuellen Wert der Scrollbar. Nun kann ich aber die Scrollbar nicht verändern (sie ist wie inaktiv), währen das Programm in der rekursiven Methode ist...

Was muss ich tun um die Scrollbar verändern (schieben) zu können während das Programm in der Methode ist?

Vielen dank schon im Voraus :)
 
hdi

hdi

Top Contributor
Was heisst "wie inaktiv" ? Swing Elemente legt Java automatisch auf den Event Dispatch
Thread, d.h. normalerweise kann man da immer etwas bewegen, weil es eben ein anderer
Thread ist und du nicht darauf warten musst, dass dein eigentliches Programm aus einer
Methode zurückkehrt oder sonst was.
Wenn allerdings deine Methode die CPU zu 100% auslastet und keine Pause
während der Rekursion einlegt, kann es schon sein dass der EDT nicht mehr zum Zug kommt.

Also bau doch mal in deine rekursive Methode vor jedem rek. Aufruf ein:

Thread.sleep(10);

Damit legt sich dein Programm für 10ms schlafen, und diese Zeit könnte der EDT nutzen
um Events auf der Scrollbar entgegen zu nehmen.

Wenn das nicht funzt versuch mal die Schlaf-Zeit Stück für Stück höher zu setzen. (In 10er oder 50er Schritten)
 
H

HalloWelt

Mitglied
Danke für die Antwort hdi, aber ich bin leider noch nicht weiter gekommen.

Mit "inaktiv" meine ich dass ich die Scrollbar nicht mehr verschieben kann... das gleiche ist mit den Button die ich im applet habe, die Buttons reagieren erst wieder, wenn die rekursive Methode beendet ist.

Beim Programm handelt es sich übrigens um ein Applet.. (weiss nicht ob das eine Rolle spielt)

In der rek. Methode habe ich bereits ein "sleep", und mit der ScrollBar wollte ich die dauer des sleep einstellen können...
 
hdi

hdi

Top Contributor
Achso Applet. Naja ich kenn mich damit nicht aus, aber ich weiss das dort
sowieso Swing/AWT Elemente nicht so einfach zu benutzen sind wie in einer App.
Was hast du genau, eine JScrollbar? Vermeide Dinge mit "J" vorne, soweit ich mal
hörte sollte man in Applets nur AWT-Komponenten nutzen.

Ansonsten... weiss nich. Mit Applets kenn ich mich wie gesagt leider nicht aus
 
H

HalloWelt

Mitglied
Ich kann sonst mal den Code posten....

Habe alles bis auf mein Problem rausgelöscht.... (Entschuldige mein Programmierstil :eek:.... ist schliesslich mein erstes java-programm :)

Code:
//   Sudoku-Projekt.java
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import javax.swing.*;
import javax.swing.event.*;



public class Sudoku extends JApplet	//Hauptklasse => public von der Klasse JApplet (J => swing) abgeleitet
	implements  ActionListener{

		// Member Variablen black
		int Zahl = 11; //=> auf keinen Button (0-9) geklickt
		int ZeilenIndex, SpaltenIndex, InputWert = 10;

		//Public Variablen
		public int TastenCode, AktivZeile = 9, AktivSpalte = 9;
		public int EnteredFeldZeile = 9, EnteredFeldSpalte = 9; // Wert von 9 zuweisen => keine Spalte ausgewählt
		public int ZahlCursor = 10, ZahlFeld;
		public int[][] SpielFeldWerte = new int[9][9];//Array anlegen in dem die Werten des Spieles abgelegt werden
		public int[][] SolvedWerte = new int[9][9];//Array in dem die Werte des Solvers abgelegt werden


		//Konstanten
		final int x0 = 300, y0 = 300; //Null-Koordinaten => Konstanten (final)
		//Ursprung umsetzen: g.translate(150,150); => in paint Graphics() methode

		//Schrift Arten
		Font Ueberschrift = new Font("Serif", Font.BOLD, 20);
		Font NormalSchrift = new Font("Monospaced", Font.PLAIN, 20);
		Font fontTitle = new Font ("SansSerif", Font.BOLD, 20);
		Font FeldAusgabe = new Font("Monospaced",Font.PLAIN + Font.ITALIC,17);


		//Hintergrundfarben definieren:
		Color BackCol 	= new Color(93,30,60);
		Color GenCol 	= new Color(210,75,9);
		Color SolCol 	= new Color(43,143,238);
		Color HelCol 	= new Color(194,221,39);

		//Panels
		JPanel SudokuContent = new JPanel();
		JPanel SpielFeld = new JPanel();


		JPanel OLFeld = new JPanel();
		JPanel OMFeld = new JPanel();
		JPanel ORFeld = new JPanel();

		JPanel MLFeld = new JPanel();
		JPanel MMFeld = new JPanel();
		JPanel MRFeld = new JPanel();

		JPanel ULFeld = new JPanel();
		JPanel UMFeld = new JPanel();
		JPanel URFeld = new JPanel();

		JPanel SudokuLöser = new JPanel();

		CWait Delay = new CWait();

		//CSudokuFeld c = new CSudokuFeld();	//Neue Instanz (c) der Klasse PaintCanvas
		CSudokuSolve  Solve = new CSudokuSolve();


		//Buttons
		private JButton Generator, Solver, Help, Lösen; //Funktionen Auswhal
		JScrollBar SetDelay = new JScrollBar(SwingConstants.HORIZONTAL);
		private JButton Z0, Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8, Z9;//ZahlenEingabe
		public CPaintPanel[][] PanelFeld = new CPaintPanel[9][9];


/***************************************************************/
		public void init(){

			//SpielFeldWerte reseten:
			for(int Zeilen = 0; Zeilen<9; Zeilen++){
				for(int Spalten = 0; Spalten < 9; Spalten++){
					SpielFeldWerte[Zeilen][Spalten] = 0; //Werte (initialisieren) löschen  (0 => keine mögliche Zahl)
				}
			}

			setSize(600,600);

			//Haupt Panel => Beinhalted alle andern Panel
			SudokuContent.setLayout(new FlowLayout());//Neuer Layout Manager einrichten
			SudokuContent.setBackground(BackCol);//Hintergrundfarbe


			//Die andern Panel einfügen
			SudokuContent.add(SpielFeld);
			SudokuContent.add(SudokuLöser);
			add(SudokuContent);//HauptPanel einfügen

			Lösen = new JButton("Lösen");
			Lösen.addActionListener(this);
			SudokuLöser.setLayout(new GridLayout(2,1,2,2));
			SudokuLöser.setPreferredSize(new Dimension(150,60));
			SudokuLöser.add(Lösen);
			SudokuLöser.add(SetDelay);


			//Das Pane Spielfeld enthält die neun Button Quadrate)
			SpielFeld.setLayout(new GridLayout(3,3,2,2));
			SpielFeld.setPreferredSize(new Dimension(362,362));
			SpielFeld.setBackground(BackCol);
			SpielFeld.setBorder(BorderFactory.createMatteBorder(15, 20, 10, 20, BackCol)); //Rahmen um das SpielFeld zeichnen
			SpielFeld.setFont(NormalSchrift);
			SpielFeld.add(OLFeld);
			SpielFeld.add(OMFeld);
			SpielFeld.add(ORFeld);
			SpielFeld.add(MLFeld);
			SpielFeld.add(MMFeld);
			SpielFeld.add(MRFeld);
			SpielFeld.add(ULFeld);
			SpielFeld.add(UMFeld);
			SpielFeld.add(URFeld);

			//***************Button Quadrate:  Alle Button Quadrate enthalten neun Buttons*********************
			//Quadrat Oben Links
			OLFeld.setLayout(new GridLayout(3,3,1,1));
			OLFeld.setBackground(Color.black);
			OLFeld.setFont(NormalSchrift);

			for(ZeilenIndex = 0;ZeilenIndex<3;ZeilenIndex++){

				for(SpaltenIndex = 0;SpaltenIndex<3;SpaltenIndex++){
					PanelFeld[ZeilenIndex][SpaltenIndex] = new CPaintPanel();
					PanelFeld[ZeilenIndex][SpaltenIndex].setFont(FeldAusgabe);
					PanelFeld[ZeilenIndex][SpaltenIndex].ZahlOut(0);//initialisieren
					OLFeld.add(PanelFeld[ZeilenIndex][SpaltenIndex]);
				}
			}

			//Quadrat Oben Mitte
			OMFeld.setLayout(new GridLayout(3,3,1,1));
			OMFeld.setBackground(Color.black);
			OMFeld.setFont(NormalSchrift);

			for(ZeilenIndex = 0;ZeilenIndex<3;ZeilenIndex++){

				for(SpaltenIndex = 3;SpaltenIndex<6;SpaltenIndex++){
					PanelFeld[ZeilenIndex][SpaltenIndex] = new CPaintPanel();
					PanelFeld[ZeilenIndex][SpaltenIndex].setFont(FeldAusgabe);
					PanelFeld[ZeilenIndex][SpaltenIndex].ZahlOut(0);//initialisieren
					OMFeld.add(PanelFeld[ZeilenIndex][SpaltenIndex]);
				}
			}

			//Quadrat Oben Rechts
			ORFeld.setLayout(new GridLayout(3,3,1,1));
			ORFeld.setBackground(Color.black);
			ORFeld.setFont(NormalSchrift);

			for(ZeilenIndex = 0;ZeilenIndex<3;ZeilenIndex++){

				for(SpaltenIndex = 6;SpaltenIndex<9;SpaltenIndex++){
					PanelFeld[ZeilenIndex][SpaltenIndex] = new CPaintPanel();
					PanelFeld[ZeilenIndex][SpaltenIndex].setFont(FeldAusgabe);
					PanelFeld[ZeilenIndex][SpaltenIndex].ZahlOut(0);//initialisieren
					ORFeld.add(PanelFeld[ZeilenIndex][SpaltenIndex]);
				}
			}

			//Quadrat Mitte Links
			MLFeld.setLayout(new GridLayout(3,3,1,1));
			MLFeld.setBackground(Color.black);
			MLFeld.setFont(NormalSchrift);

			for(ZeilenIndex = 3;ZeilenIndex<6;ZeilenIndex++){

				for(SpaltenIndex = 0;SpaltenIndex<3;SpaltenIndex++){
					PanelFeld[ZeilenIndex][SpaltenIndex] = new CPaintPanel();
					PanelFeld[ZeilenIndex][SpaltenIndex].setFont(FeldAusgabe);
					PanelFeld[ZeilenIndex][SpaltenIndex].ZahlOut(0);//initialisieren
					MLFeld.add(PanelFeld[ZeilenIndex][SpaltenIndex]);
				}
			}

			//Quadrat Mitte Mitte
			MMFeld.setLayout(new GridLayout(3,3,1,1));
			MMFeld.setBackground(Color.black);
			MMFeld.setFont(NormalSchrift);

			for(ZeilenIndex = 3;ZeilenIndex<6;ZeilenIndex++){

				for(SpaltenIndex = 3;SpaltenIndex<6;SpaltenIndex++){
					PanelFeld[ZeilenIndex][SpaltenIndex] = new CPaintPanel();
					PanelFeld[ZeilenIndex][SpaltenIndex].setFont(FeldAusgabe);
					PanelFeld[ZeilenIndex][SpaltenIndex].ZahlOut(0);//initialisieren
					MMFeld.add(PanelFeld[ZeilenIndex][SpaltenIndex]);
				}
			}

			//Quadrat Mitte Rechts
			MRFeld.setLayout(new GridLayout(3,3,1,1));
			MRFeld.setBackground(Color.black);
			MRFeld.setFont(NormalSchrift);

			for(ZeilenIndex = 3;ZeilenIndex<6;ZeilenIndex++){

				for(SpaltenIndex = 6;SpaltenIndex<9;SpaltenIndex++){
					PanelFeld[ZeilenIndex][SpaltenIndex] = new CPaintPanel();
					PanelFeld[ZeilenIndex][SpaltenIndex].setFont(FeldAusgabe);
					PanelFeld[ZeilenIndex][SpaltenIndex].ZahlOut(0);//initialisieren
					MRFeld.add(PanelFeld[ZeilenIndex][SpaltenIndex]);
				}
			}

			//Quadrat Unten Links
			ULFeld.setLayout(new GridLayout(3,3,1,1));
			ULFeld.setBackground(Color.black);
			ULFeld.setFont(NormalSchrift);

			for(ZeilenIndex = 6;ZeilenIndex<9;ZeilenIndex++){

				for(SpaltenIndex = 0;SpaltenIndex<3;SpaltenIndex++){
					PanelFeld[ZeilenIndex][SpaltenIndex] = new CPaintPanel();
					PanelFeld[ZeilenIndex][SpaltenIndex].setFont(FeldAusgabe);
					PanelFeld[ZeilenIndex][SpaltenIndex].ZahlOut(0);//initialisieren
					ULFeld.add(PanelFeld[ZeilenIndex][SpaltenIndex]);
				}
			}

			//Quadrat Unten Mitte
			UMFeld.setLayout(new GridLayout(3,3,1,1));
			UMFeld.setBackground(Color.black);
			UMFeld.setFont(NormalSchrift);

			for(ZeilenIndex = 6;ZeilenIndex<9;ZeilenIndex++){

				for(SpaltenIndex = 3;SpaltenIndex<6;SpaltenIndex++){
					PanelFeld[ZeilenIndex][SpaltenIndex] = new CPaintPanel();
					PanelFeld[ZeilenIndex][SpaltenIndex].setFont(FeldAusgabe);
					PanelFeld[ZeilenIndex][SpaltenIndex].ZahlOut(0);//initialisieren
					UMFeld.add(PanelFeld[ZeilenIndex][SpaltenIndex]);
				}
			}

			//Quadrat Unten Rechts
			URFeld.setLayout(new GridLayout(3,3,1,1));
			URFeld.setBackground(Color.black);
			URFeld.setFont(NormalSchrift);

			for(ZeilenIndex = 6;ZeilenIndex<9;ZeilenIndex++){

				for(SpaltenIndex = 6;SpaltenIndex<9;SpaltenIndex++){
					PanelFeld[ZeilenIndex][SpaltenIndex] = new CPaintPanel();
					PanelFeld[ZeilenIndex][SpaltenIndex].setFont(FeldAusgabe);
					PanelFeld[ZeilenIndex][SpaltenIndex].ZahlOut(0);//initialisieren
					URFeld.add(PanelFeld[ZeilenIndex][SpaltenIndex]);
				}
			}
		}

		public void paint(Graphics g){
		}


		public void actionPerformed(ActionEvent e){

			if(e.getSource() == Lösen){

				//SolvedWerte mit Original-Werten überschreiben:
				for(int Zeilen = 0; Zeilen<9; Zeilen++){
					for(int Spalten = 0; Spalten < 9; Spalten++){
						SolvedWerte[Zeilen][Spalten] = SpielFeldWerte[Zeilen][Spalten];
					}
				}

				Solve.SolveBacktrack(0,0);

				//Original-Werte mit Solved Werte initialisieren:
				for(int Zeilen = 0; Zeilen<9; Zeilen++){
					for(int Spalten = 0; Spalten < 9; Spalten++){
						SpielFeldWerte[Zeilen][Spalten] = SolvedWerte[Zeilen][Spalten];
					}
				}
			}

 		}

		/*******************************************/
		class CPaintPanel extends JPanel
		{
			private int OutputZahl;
			private Color SchriftFarbe;

			public void paintComponent(Graphics g){
				super.paintComponent(g);
				g.setColor(SchriftFarbe);

				if((OutputZahl < 10) && (OutputZahl > 0)){//Wenn OutputZahl gültig
					g.drawString(""+OutputZahl,10,25);//Zahl ausgeben
				}

				if(OutputZahl == 0){ // Wenn Delete-Button betätigt oder keine Zahl eingegeben
					g.drawString(""+OutputZahl,12,25);//Die Zahl mit der Hintergrundfarbe überschreiben
				}
			}

			public void ZahlOut(int Zahl){ //Feld nicht Aktiv

				OutputZahl = Zahl;
				setBackground(Color.blue);
				SchriftFarbe = Color.white; //Standart-Farbe

				if(OutputZahl == 0){
					SchriftFarbe = Color.blue;//Farbe des Hintergrund => unsichtbar
				}
				repaint();
			}

			public void ButActiv(int AZahl){ //Feld Aktiv

				OutputZahl = AZahl;
				setBackground(Color.white);
				SchriftFarbe = Color.blue; //Output-Farbe

				if(OutputZahl == 0){
					SchriftFarbe = Color.white; //Farbe des Hintergrund => unsichtbar
				}
				repaint();
			}
		}/*****************************************/

		/********************************/
		class CSudokuSolve{

			CSudokuSolve(){//Konstruktor
			}

			//Löst ein Sudoku mit der Backtracking-Methode
			public void SolveBacktrack(int Zeile, int Spalte){

				int ZeilenNr = Zeile;
				int SpaltenNr = Spalte;
				boolean passt, Finished;
				int Werte = 1;

				if(SpaltenNr > 8){//Zeilenende erreicht?

					if(ZeilenNr > 7){//Spaltenende erreicht?
						return; //Fertig => letztes Feld wurde erreicht
					}
					else{
						ZeilenNr++;//Neue Zeile
						SpaltenNr = 0;//Zeilen Anfang (Spalte 0)
					}
				}

				if(SpielFeldWerte[ZeilenNr][SpaltenNr] == 0){ //Feld nicht beschrieben

					while(Werte < 10){//Werte 1 bis 9 testen
						passt = Kontrolle(ZeilenNr, SpaltenNr, Werte);//Überprüfen, passt der Wert ins Feld
						if(passt){//Wert passt
							SolvedWerte[ZeilenNr][SpaltenNr] = Werte; //Wert ins Feld schreiben

							Graphics MyGraphic = PanelFeld[ZeilenNr][SpaltenNr].getGraphics();
							MyGraphic.setColor(Color.blue);
							MyGraphic.fillRect(0,0,40,40);//Vordere zahl löschen (sonst werden meherere Zahlne übereinander geschrieben)
							MyGraphic.setColor(Color.white);
							MyGraphic.drawString(""+SolvedWerte[ZeilenNr][SpaltenNr],10,25);//Zahl ausgeben
							Delay.many_mSec();//Pause (ms)

							SolveBacktrack(ZeilenNr,(SpaltenNr + 1));//Rekursion => nächstes Feld
							//Passte im vorderen Feld kein Wert, gehts hier weiter => Backtrack

							//Wurden all oberen Felder glöst?
							Finished = true; //Variabel zur Kontroll ob die oben Felder gelöst wurden
							for(int mZeile = 8; mZeile >= ZeilenNr; mZeile--){
								for(int mSpalte = 8; mSpalte >= SpaltenNr; mSpalte--){
									if(SolvedWerte[mZeile][mSpalte]==0){ //Obere Felder gelöst?
										Finished = false;//ein Feld wurde nicht gelöst!
									}
								}
							}
							if(Finished){
								return;
							}
						}
						Werte++;//Nächst höherer Wert
					}

					if(SpielFeldWerte[ZeilenNr][SpaltenNr]> 0){
						return;//Ist ein OriginalWert im Feld darf dieser nicht gelöscht werden
					}
					else{
						SolvedWerte[ZeilenNr][SpaltenNr] = 0; //Wenn kein Wert passt, Feld wieder löschen
						//return;//Zum Vorderen Feld zurückkehren
					}
				}

				else{//Feld bereits beschrieben (mit Original-Wert):

					//Dieses Feld überspringen
					SolveBacktrack(ZeilenNr,SpaltenNr+1); //Rekursiv => nächstes Feld

					//return;
				}
				return;
			}

			//Kontrolliert, ob eine bestimmte Zahl in ein bestimmtes Feld geschrieben werden darf
			public boolean Kontrolle(int ZeilenNr, int SpaltenNr, int Zahl){

				//gleiche Zahl in der gleichen Zeile?
				for(int Spalte = 0; Spalte <9;Spalte++){
					if(SolvedWerte[ZeilenNr][Spalte] == Zahl){
						return false;
					}
				}

				//gleiche Zahl in der gleichen Spalte?
				for(int Zeile = 0; Zeile<9; Zeile++){
					if(SolvedWerte[Zeile][SpaltenNr] == Zahl){
						return false;
					}
				}

				//Zahl im gleichen Quadrat?
				//Berechnung welches Quadrat(Links, Mitte, Rechts)? => FeldPosX = (int)(FeldPosX/3)*3
				//Berechnung welches Quadrat(Oben, Mitte, Unten)? => FeldPosY = (int)(FeldPosY/3)*3
				int QuadratYPos = ((int)(ZeilenNr/3)*3); //Erstes Feld des Quadrates
				int QuadratXPos = ((int)(SpaltenNr/3)*3);//Erstes Feld des Quadrates

				int QuadratXMax = (QuadratXPos + 3); //Letztes Feld des Quadrates
				int QuadratYMax = (QuadratYPos + 3);//Letztes Feld des Quadrates

				for(int Zeile  = QuadratYPos;Zeile < QuadratYMax; Zeile++){//Durchlaufen vom 1. bis zum letzten Feld
					for(int Spalte = QuadratXPos;Spalte < QuadratXMax; Spalte++){
						if(SolvedWerte[Zeile][Spalte] == Zahl){
							return false;
						}
					}
				}
				//Die Zahl passt:
				return true;

			}
		}/**********************************/

		class CWait {
			//public void setDelay(){
			long Faktor = 1000;
		 	//long Faktor = SetDelay.getValue();

		  //scale[0] = (((float) scaleP.getValue()) / 50) * (((float) scaleP.getValue()) / 50);
		 	public void many_mSec(/*long s*/) {
		     	try {
		      	 	Thread.currentThread().sleep(Faktor * 1);
		       		}
		     		catch (InterruptedException e) {
		       		}
		    	}
			}
	}//Hauptklasse schliessen

Code ist halt immernoch etwas lang....
 
Zuletzt bearbeitet:
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
Franzi1001 ScrollBar lässt sich nicht bewegen Java Basics - Anfänger-Themen 4
B Wie kann man an ein JPanel eine Scrollbar anheften? Java Basics - Anfänger-Themen 8
DaCrazyJavaExpert JScollPane scrollbar unsichtbar machen Java Basics - Anfänger-Themen 2
M TextArea scrollbar bei editable false Java Basics - Anfänger-Themen 5
G Darstellungsproblem beim Betätigen der Scrollbar in JTabe Java Basics - Anfänger-Themen 2
T JScrollPane nicht scrollbar (mit KSKB!) Java Basics - Anfänger-Themen 4
A TextArea und ScrollBar Java Basics - Anfänger-Themen 17
J Methoden Knopffarbe einer Scrollbar Java Basics - Anfänger-Themen 5
M Scrollbar zu Textarea Java Basics - Anfänger-Themen 5
B JList mit Scrollbar? Java Basics - Anfänger-Themen 7
W Scrollbar HORIZONTAL Java Basics - Anfänger-Themen 2
C Scrollbar !? Java Basics - Anfänger-Themen 3
K Scrollbar - Bild - paint-Methode - zoom Java Basics - Anfänger-Themen 10
H JTable in JScrollPane: Scrollbar wird nicht angezeigt. Java Basics - Anfänger-Themen 2
H >>ScrollBar<< Java Basics - Anfänger-Themen 2
A Scrollbar und Änderung Java Basics - Anfänger-Themen 3
L scrollbar auf double? Java Basics - Anfänger-Themen 6
Horst79 Scrollbar in einem jEditorPane Java Basics - Anfänger-Themen 2
A ChatGUI: Scrollbar und Funktionen Java Basics - Anfänger-Themen 5
A jtable scrollbar Java Basics - Anfänger-Themen 8
G horizontale scrollbar Java Basics - Anfänger-Themen 14
K J_table scrollbar Java Basics - Anfänger-Themen 13
O Scrollbar in GUI einfügen Java Basics - Anfänger-Themen 4
E ScrollBar automatisch scrollen Java Basics - Anfänger-Themen 8
N Scrollbar addAdjustmentListener Java Basics - Anfänger-Themen 3
P In JTextArea soll automisch an einen bestimmte Scrollbar pos Java Basics - Anfänger-Themen 14
E Scrollbar mit NULL- Layout? Java Basics - Anfänger-Themen 4
H Anfänger verzweifelt: Buttons und Scrollbar in einem Applet Java Basics - Anfänger-Themen 5
H JScrollPane -> Problem bei ScrollBar Java Basics - Anfänger-Themen 3
C ein Canvas ist zu groß. mit Scrollbar ? Java Basics - Anfänger-Themen 8
E Scrollbar- Farben Java Basics - Anfänger-Themen 5
G Scrollbar einer Itemlist hinzufügen Java Basics - Anfänger-Themen 3
G scrollbar, brauche hilfe wird nicht dargestellt Java Basics - Anfänger-Themen 2
K Farbenspiel : Quadrat verschwindet,wenn Fenster inaktiv ist Java Basics - Anfänger-Themen 13
veryck Methoden Rekursive Methoden mit Rückgabeparameter Java Basics - Anfänger-Themen 9
macle Rekursive String Methode, Gerade Zahlen rausfiltern Java Basics - Anfänger-Themen 10
M Rekursive Prüfung ob ein Array sortiert ist... Java Basics - Anfänger-Themen 4
J Rekursive swapArray Methode Java Basics - Anfänger-Themen 69
D Rekursive Methode Java Basics - Anfänger-Themen 8
R Methoden rekursive Methoden Java Basics - Anfänger-Themen 6
O Quersumme rekursive Methode Java Basics - Anfänger-Themen 3
B Treetable (rekursive Funktion) aufbauen von Datenbank Java Basics - Anfänger-Themen 4
M Rekursive Methode Programmieren Java Basics - Anfänger-Themen 3
J rekursive Methode Java Basics - Anfänger-Themen 26
M rekursive division/0 mit exception Java Basics - Anfänger-Themen 18
J Rekursive Methode - Ziffern einer Zahl ausgeben Java Basics - Anfänger-Themen 2
M Rekursive Dateiliste erstellen mit Dateiendung(en) ?? Java Basics - Anfänger-Themen 4
S Rekursive Methode Java Basics - Anfänger-Themen 8
O Rekursive Methode Java Basics - Anfänger-Themen 4
V Methoden Rekursive Methode mit String als Rückgabe Java Basics - Anfänger-Themen 7
K Rekursive Methode Java Basics - Anfänger-Themen 1
K Rekursive Methode für Fakultät mit BigInteger Java Basics - Anfänger-Themen 10
L Rekursive Methode a * b berechnen Java Basics - Anfänger-Themen 2
L Rekursive Methode zur Berechnung der Potenz q hoch p Java Basics - Anfänger-Themen 17
J Methoden Rekursive Return Methode Java Basics - Anfänger-Themen 2
G Harmonische Rekursive Folge Java Basics - Anfänger-Themen 3
T Stack Overflow - Rekursive Fibonacci Java Basics - Anfänger-Themen 10
B Datentypen Suchbaum - Rekursive Ausgabe Java Basics - Anfänger-Themen 1
P Methoden Rekursive Methode für Potenzen Java Basics - Anfänger-Themen 2
M Methoden Binäre Suche als rekursive Variante Java Basics - Anfänger-Themen 5
B Rekursive Algorithmus schreiben Java Basics - Anfänger-Themen 8
S Eine rekursive Lösung Java Basics - Anfänger-Themen 4
S Int zu Hexadezimal - Rekursive Methode Java Basics - Anfänger-Themen 2
M Rekursive Suche in einem Feld Java Basics - Anfänger-Themen 11
N Rekursive Addition mit Scanner Java Basics - Anfänger-Themen 12
shiroX OOP Rekursive und Iterative Definition Java Basics - Anfänger-Themen 2
B Methoden Rekursive Methoden Java Basics - Anfänger-Themen 2
T Iterative Pi Berechnung in Rekursive Java Basics - Anfänger-Themen 2
C rekursive methode Java Basics - Anfänger-Themen 2
D Methoden Rekursive Methoden Java Basics - Anfänger-Themen 13
R rekursive Methode funktioniert nicht Java Basics - Anfänger-Themen 4
M Stürzen alle Rekursive Methoden irgendwann ab? Java Basics - Anfänger-Themen 11
D Primzahlen und Rekursive Liste Java Basics - Anfänger-Themen 29
R Rekursive Methode, Files finden Java Basics - Anfänger-Themen 2
S rekursive folge verbessern Java Basics - Anfänger-Themen 2
C rekursive Methode verstehe nicht! Java Basics - Anfänger-Themen 3
S Methoden rekursive Methode funktioniert nicht Java Basics - Anfänger-Themen 4
E Rekursive Methode Java Basics - Anfänger-Themen 3
N Methoden Rekursive Fibonaccizahlen mit Array Java Basics - Anfänger-Themen 2
R Rekursive Ausgabe eines Binärbaums Java Basics - Anfänger-Themen 4
J Methoden Rekursive Potenz ohne Math.Pow() Java Basics - Anfänger-Themen 9
A Rekursive Methode in Iterative umwandeln Java Basics - Anfänger-Themen 6
S Labyrith Rekursive Wegsuche Java Basics - Anfänger-Themen 4
C Rekursive Methode - Ziffern in Zahl Java Basics - Anfänger-Themen 33
U Dezimal zu Hexadezimal rekursive Funktion Java Basics - Anfänger-Themen 8
M rekursive Funktion zur Berechnung der Spiegelzahl Java Basics - Anfänger-Themen 7
L iterative und rekursive Folge Java Basics - Anfänger-Themen 20
G Rekursive Methode Java Basics - Anfänger-Themen 3
A rekursive Listen in Java? Java Basics - Anfänger-Themen 5
B OOP Einfach verkettete Liste - rekursive Methoden Java Basics - Anfänger-Themen 1
E Rekursive Methode mit Zufallsarray Java Basics - Anfänger-Themen 6
E Rekursive Methode Java Basics - Anfänger-Themen 18
U Rekursive lösung von pascal dreieck Java Basics - Anfänger-Themen 11
M Rekursive Methode - wo ist der Fehler? Java Basics - Anfänger-Themen 4
J rekursive methode Java Basics - Anfänger-Themen 6
J Rekursive Methode Java Basics - Anfänger-Themen 11
G Rekursive Methode Java Basics - Anfänger-Themen 5
N Rekursive Berechnung der Höhe eines binären Baumes Java Basics - Anfänger-Themen 4
K Rekursive Methoden Java Basics - Anfänger-Themen 15
K Rekursive Funktion (Verständnissfrage) Java Basics - Anfänger-Themen 5

Ähnliche Java Themen

Anzeige

Neue Themen


Oben