Methoden werden in falscher Reihenfolge bearbeitet

mac21

Aktives Mitglied
Hallo zusammen,

da ich an einem Projekt zum Einlesen von Fahrzeugscheinen arbeite (Stichwort "OCR")
habe ich folgende Klassen in einem Projekt, achtet auf die Kommentare.
Das ist KEIN fertiger Code, ich habe Unnötiges herausgelöscht, damit ihr nicht so viel lesen müsst.

Java:
public class TestApp( ) {
		
	public String[] doOCR() {
		
		waitingScreen waitingScreen;	//Deklaration
		waitingScreen = new waitingScreen(); //Initialisierung
		
	
		for (int i = 0; i < Settings.FIELDS; i++) { //in Settings.java liegen nur Konstanten
		
		inputFile = Settings.CROPPEDPATH + Settings.CROPPEDFILE + i + "."
				+ Settings.CROPPEDFORMAT; //erzeugt einen Pfad zur Eingabe-Datei
		outputFile = Settings.TEMPPATH + Settings.TEMPNAME + i + ".xml"; //Erzeugt einen Pfad zur Ausgabe-Datei

		args = new String[] { inputFile, outputFile }; //beide Pfade in einen String packen
		argList = new Vector<String>(Arrays.asList(args)); //In Vector konvertieren (gibt die OCR-API so vor

		try {
			performTextFieldRecognition(argList); //Eingabe-Datei(ein Bild) wird per OCR eingelesen und in die XML (Ausgabedatei) geschrieben
		} catch (Exception e) {
		
		}
		results[i] = XMLreader.read(outputFile, "value"); //Wert dieser Datei wird im Array results gespeichert
	} 
	return results;	//gibt das Array zurück
	}
}

und

waitingScreen.java ist nur ein JFrame mit einem nicht endenden Fortschrittsbalken.
Java:
public class waitingScreen extends JFrame{

	JProgressBar progressBar;
	final Dimension dim;
	
	public waitingScreen() {
		
		this.setTitle("Verarbeite...");
		this.setSize(400, 80);
		
		JFrame.setDefaultLookAndFeelDecorated(false);
		this.setUndecorated(true);
		this.setAlwaysOnTop(true);
		dim = Toolkit.getDefaultToolkit().getScreenSize();
		this.setLocation((int) ((dim.getWidth() - this.getWidth()) / 2),(int) ((dim.getHeight() - this.getHeight()) / 2));
		this.setResizable(false);;
		this.setLayout(null);
		this.setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
		this.setVisible(true);
		
		progressBar = new JProgressBar();
		progressBar.setSize(this.getWidth(), this.getHeight());
		progressBar.setIndeterminate(true);
		
		this.add(progressBar);
		
	}
	
}


Nun endlich zu meinem Problem:
Nach dem ich die Methode "doOCR()" der Klasse "TestApp" aufgerufen habe, wird zuerst der ganze OCR-Vorgang ausgeführt, und nach einigen Minuten (also wenn dieser Vorgang beendet ist) öffnet sich die Fortschrittsanzeige.

Wieso ist das so?
Sind diese Vorgänge nebenläufig, und der OCR-Vorgang hat eine höhere Priorität als das Anzeigen des waitingScreens?


Folgendes habe ich auch schon versucht, SuFu sei dank:

Erzeugen des waitingScreens erfolgt über eine Statische Methode, welche einen boolean liefert, wenn sie erfolgreich beendet wurde.

Der OCR-Vorgang wird erst gestartet, wenn die o.g. Methode "true" liefert.

Also in etwa

Java:
while(!waitingScreen.isReady) {
//tut nichts
}

OCR-Vorgang
 
Zuletzt bearbeitet:

anti-held

Bekanntes Mitglied
Das passiert, wenn du die OCR Aufgaben im UI Thread laufen lässt.
Erst wenn dieser nämlich fertig ist, kann er die Änderungen an der UI anzeigen (z.B. deine Progressbar)

Verwende also für GUI Aufgaben wie das Erstellen des Fensters ein solches Konstrukt:

Java:
EventQueue.invokeLater(new Runnable() { 
  @Override
  public void run() {
     // dein GUI Code
  }
});
 

mac21

Aktives Mitglied
Hallo Anti-Held,

vielen Dank für die schnelle Antwort!

Ich füge hier noch einmal die komplette Klasse "GUI" an (ganz unten an dieser Antwort).
Am Ende der Klasse habe ich einige ActionListener eingebaut, diese rufen im Endeffekt die Methode "OCRtool.doOCR()" auf. OCRtool ist ein Interface mit nur einer Methode, da ich noch am experimentieren bin, welche OCR-API ich verwende.

Nun stellt sich mir die Frage, wo ich deinen Code einfügen+anpassen muss...
Sämtlicher Code in der Klasse "GUI" baut die Oberfläche,
dann wird die Interface-Methode aufgerufen,
woraufhin wieder eine grafische Komponente angezeigt wird (der waitingScreen).

Java:
package de.systeccomputer.ocr;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FocusTraversalPolicy;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;

import javax.imageio.ImageIO;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.WindowConstants;
import javax.xml.stream.XMLStreamException;

public class GUI {
//########## Attributes ###################################
	BufferedImage scan;
	JButton[] editButtons;
	JFrame mainFrame;
	JPanel correctPanel;
	public JPanel editPanel;
	ImagePanel scanPanel;
	JTextField[] correctFields;
	JTextArea[] correctAreas;
	JComponent[] order;
	OCRinterface OCRtool;
	JFrame logFrame;
	JTextArea logArea;

//######### Constructor ###################################		
	public GUI() throws FileNotFoundException, XMLStreamException {
		
		initComponents();
		initTabOrder();
		addComponents();	
		initListeners();
		//createLogDialog();		
	}
//######### Methods #######################################
	public void initComponents() {
		mainFrame = new JFrame("TestTitel");
		mainFrame.setSize(Settings.FRAMEWIDTH, Settings.FRAMEHEIGHT);
		final Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
		mainFrame.setLayout(null);
		mainFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
		//mainFrame.setResizable(false);
		mainFrame.setLocation((int) ((d.getWidth() - mainFrame.getWidth()) / 2),(int) ((d.getHeight() - mainFrame.getHeight()) / 2));
		mainFrame.setVisible(true);

		try{
			scan = ImageIO.read(new File(Settings.FILEPATH));		
			}catch(Exception e){System.out.println("Problem beim Einlesen");}
		
		  scanPanel = new ImagePanel(mainFrame.getContentPane().getWidth()-100,(mainFrame.getContentPane().getHeight()/2), scan, this);
		  scanPanel.setSize(mainFrame.getContentPane().getWidth()-100,(mainFrame.getContentPane().getHeight()/2));
		  scanPanel.setLocation(0,0); 
		  scanPanel.setBorder(BorderFactory.createLoweredBevelBorder());
		  scanPanel.setVisible(true);
		  
		  correctPanel = new JPanel();
		  correctPanel.setSize(mainFrame.getContentPane().getWidth()-100,(mainFrame.getContentPane().getHeight()/2));
		  correctPanel.setLocation(0,(mainFrame.getContentPane().getHeight()/2+1));
		  correctPanel.setBackground(Color.BLUE);
		  correctPanel.setLayout(null);
		  correctPanel.setBorder(BorderFactory.createLoweredBevelBorder());
		  correctPanel.setVisible(true);
		  
		  editPanel = new JPanel();
		  editPanel.setSize(mainFrame.getContentPane().getWidth()-scanPanel.getWidth(),mainFrame.getContentPane().getHeight());
		  editPanel.setLocation(mainFrame.getContentPane().getWidth()-editPanel.getWidth(), 0);
		  editPanel.setBackground(Settings.EDITPANELCOLOR);
		  editPanel.setLayout(null);
		  editPanel.setBorder(BorderFactory.createLoweredBevelBorder());
		  editPanel.setVisible(true);
		
			 correctFields = new JTextField[65];
		 
		 int a = 0;
		 for(int i = 0; i < scanPanel.rectangles.length; i++) {
			 if(i != 4 && i != 27) {
			 correctFields[a] = new JTextField();
			 correctFields[a].setBounds(scanPanel.rectangles[i]);
			 correctFields[a].setVisible(true);
			 correctFields[a].setBorder(BorderFactory.createLineBorder(Color.black));
			 correctPanel.add(correctFields[a]);
			 a++;
			 }
		 }
		 
		 correctAreas = new JTextArea[2];
		 correctAreas[0] = new JTextArea();
		 correctAreas[0].setWrapStyleWord(true);
		 correctAreas[0].setBounds(scanPanel.rectangles[4]);
		 correctAreas[0].setVisible(true);
		 correctAreas[0].setLineWrap(true);
		 correctAreas[0].setBorder(BorderFactory.createLineBorder(Color.black));
		 correctPanel.add(correctAreas[0]);
		 
		 correctAreas[1] = new JTextArea();
		 correctAreas[1].setBounds(scanPanel.rectangles[27]);
		 correctAreas[1].setVisible(true);
		 correctAreas[1].setLineWrap(true);
		 correctAreas[1].setBorder(BorderFactory.createLineBorder(Color.black));
		 correctPanel.add(correctAreas[1]);
		 
		  editButtons = new JButton[3];
		  for(int i = 0; i < editButtons.length; i++) {
			  editButtons[i] = new JButton("Start");
			  editButtons[i].setSize(70, 16);
			  editButtons[i].setLocation(10, 60+i*Settings.BUTTONPADDING);
			  editButtons[i].setVisible(true);  
		  }
	}
//#########################################################
	public void addComponents() {	
		
		mainFrame.add(scanPanel); 
		mainFrame.add(correctPanel);
		mainFrame.add(editPanel);
		 for(int i = 0; i < editButtons.length; i++) {
		editPanel.add(editButtons[i]);
		 }
		try{
			mainFrame.repaint();			
		}catch(Exception es){}
	}
//#########################################################
		 public void initTabOrder() {
			 
			 order = new JComponent[Settings.FIELDS];
			 for(int i = 0; i < order.length; i++) {
				 if(i == 4) {
					 order[4] = correctAreas[0];
				 }else if(i == 27){
					 order[27] = correctAreas[1];
				 }else{
					 if(i < 4) {order[i] = correctFields[i];}
					 if(i > 4 && i <= 27) {order[i] = correctFields[i-1];}
					 if(i > 27) {order[i] = correctFields[i-2];}
				 }
			 }
			 
			  FocusTraversalPolicy policy = MyFocusTraversalPolicy.getFocusTraversal(order);
				    correctPanel.setFocusTraversalPolicy(policy);
				    correctPanel.setFocusCycleRoot(true);
		 }
//#########################################################
		 public void makeSubimages() {
			 //int fac = scanPanel.getFactor();
			 double facX = scanPanel.fakX;
			 double facY = scanPanel.fakY;
			 
			 for(int i = 0; i < order.length; i++) {
				 imgPart.parting(order[i].getX()*facX, order[i].getY()*facY, order[i].getWidth()*facX, order[i].getHeight()*facY, scan, i);
			 }
			 //imgPart.parting(scanPanel.rectangles[0].getX()*facX, scanPanel.rectangles[0].getY()*facY, scanPanel.rectangles[0].getWidth()*facX, scanPanel.rectangles[0].getHeight()*facY, scan);
		 }
//#########################################################
			public void setOCRtool(OCRinterface newOCRtool){
				this.OCRtool = newOCRtool;
			}
//#########################################################
			public OCRinterface getOCRtool(){
				return this.OCRtool;
			}
//#########################################################
			public void createLogDialog() {
				logFrame = new JFrame("Log:");
				logFrame.setVisible(true);
				//logFrame.setAlwaysOnTop(true);
				logFrame.setSize(300, 300);
				logFrame.setLayout(new BorderLayout());
				logFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
			    logArea = new JTextArea();
			    logArea.setEditable(false);
			    logArea.setLineWrap(true);
			    JScrollPane pane = new JScrollPane(logArea);
			    logFrame.add(pane);
		    }
//#########################################################
			public JTextArea getLogDialog() {
				return this.logArea;
			}
//#########################################################
		 public void initListeners() {
			 
				correctAreas[0].addKeyListener(new KeyListener() {
					
					@Override
					public void keyPressed(KeyEvent arg0) {

						if(arg0.getKeyCode() == 9) {
							arg0.consume();
							correctFields[4].requestFocus();
						}
					}
					
					@Override
					public void keyReleased(KeyEvent arg0) {}
					
					@Override
					public void keyTyped(KeyEvent arg0) {}
				});
				
				correctAreas[1].addKeyListener(new KeyListener() {
					
					@Override
					public void keyPressed(KeyEvent arg0) {

						if(arg0.getKeyCode() == 9) {
							arg0.consume();
							correctFields[26].requestFocus();
						}
					}
					
					@Override
					public void keyReleased(KeyEvent arg0) {}
					
					@Override
					public void keyTyped(KeyEvent arg0) {}
				});
		 
		editButtons[0].addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent arg0) {
							
				makeSubimages();
				String[] a = OCRtool.doOCR();
				
				for(int i = 0; i < Settings.FIELDS; i++) {
					if(i == 4) { 
						correctAreas[0].setText(a[4]);
					}else if(i == 27) {
						correctAreas[0].setText(a[27]);
					}else {
						if(i < 4) {correctFields[i].setText(a[i]);}
						 if(i > 4 && i <= 27) {correctFields[i-1].setText(a[i]);}
						 if(i > 27) {correctFields[i-2].setText(a[i]);}
					}
				}
			}
		 });
		 }			 
}

EDIT: In Eclipse sieht der Code besser aus, er tut zwar das gleiche, aber die Formatierung ist ja schrecklich^^
 
Zuletzt bearbeitet:

Joose

Top Contributor
anti-held hat eigentlich schon gesagt was das Problem ist.
Seinen Code solltest do in der "doOCR" Methode einbauen, wenn du deinen "waitingScreen" aufrufen willst.

Noch zu deinem Code:
Java:
waitingScreen waitingScreen;	//Deklaration
waitingScreen = new waitingScreen(); //Initialisierung
Diese zwei Zeilen kann man ruhig zu einer Zeile zusammenfassen. Vor allem wenn man mehrere lokale Variablen braucht kann es doch unübersichtlich werden.

Java:
args = new String[] { inputFile, outputFile }; //beide Pfade in einen String packen
Dein Kommentar ist falsch. Du "packst" beide Strings in ein String Array ;)

Java:
public class waitingScreen extends JFrame{

Klassennamen werden in Java in UpperCamelCase geschrieben.
Außerdem sollte man nicht von JFrame ableiten wenn man dessen Funktionalität nicht erweitern will.
 
Zuletzt bearbeitet:

mac21

Aktives Mitglied
Hallo Joose,

vielen Dank auch an dich.
Sofern ich das richtig verstanden habe (<--Fehler gefunden ;) ) soll ich den Code so korrigieren:
(dieses Mal unbeschnitten)
Java:
public String[] doOCR() {
		
		 
		EventQueue.invokeLater(new Runnable() { 
		  @Override
		  public void run() {
			  waitingScreen waitingScreen = new waitingScreen();
			waitingScreen.setVisible(true);
		  }
		});
				
		f = new File(Settings.TEMPPATH);
		f.mkdir();
	
		for (int i = 0; i < 1/**Settings.FIELDS*/; i++) {
		
		inputFile = Settings.CROPPEDPATH + Settings.CROPPEDFILE + i + "."
				+ Settings.CROPPEDFORMAT;
		outputFile = Settings.TEMPPATH + Settings.TEMPNAME + i + ".xml";

		args = new String[] { inputFile, outputFile };
		argList = new Vector<String>(Arrays.asList(args));

		try {
			performTextFieldRecognition(argList);
		} catch (Exception e) {
		
		}
		results[i] = XMLreader.read(outputFile, "value");
	} 
	return results;		
	}

Dies führt jedoch zum selben Ergebnis... erst die Abarbeitung des OCR-Vorgangs (Ein paar Zeilen erscheinen in der Konsole, nur zum Nachvollziehen) und DANN taucht mein WaitingScreen auf...

Apropos: 1. Danke für den Hinweis, bin immer dankbar für Feedback.
Normalerweise mache ich das auch richtig, ab und an unterläuft mit ein Fehler ;) z.B. auch in "imgPart.java"
Anhang anzeigen 6914

2. Normalerweise trenne ich Deklaration und Initialisierung auch von einander,
"waitingScreen waitingScreen;" steht vor dem Konstrukivator ;D
"waitingScreen = new waitingScreen();" steht im Konstruktor

3. Dann verbessere ich mich: beide Pfade in ein String[] packen ;)

4. Also
Java:
JFrame mainFrame = new JFrame()
mainFrame.set...
verwenden?
Merci, das war mir nicht bewusst.
 

anti-held

Bekanntes Mitglied
Da ich gerade kein Eclipse zur Hand habe, nur unformatierten Beispielcode, wie es aussehen sollte:

Java:
actionPerformend(...)
   final WaintingScreen waitingscreen = new WaintingScreen();
   waitingscreen.setVisible(true);
   new Thread(){
      public void run(){
          doOCR();
EventQueue.invokeLater(new Runnable() {
        public void run() {
            waitingscreen.dispose();
        }
    });
      }
   }.start();
 
Zuletzt bearbeitet:

Thallius

Top Contributor
Also mich würde mal interessieren wie das mit dem InvokeLater funktionieren soll. Wenn ich das richtig verstanden habe, dann macht der doch nichts anderes als die Swing UI auf einen eigenen EDT Thread zu packen und irgendwann zu starten. Damit kann ich doch keine Thread synchronisation hinbekommen. In dem Fall oben wird der EDT Thread sicher erst gestartet und das UI Aktualisiert wenn das OCR Ding durch ist oder?

Ich mache sowas immer mit einem SwingWorker, weil ich da auch direkt den Progress an den UI Thread weiterreichen kann zum anzeigen.

Gruß

Claus
 

mac21

Aktives Mitglied
Du bist mein (Anti-)Held,
und auch vielen Dank an Joose,

so klappt es perfekt!

Ich hoffe, ich habe es nun richtig verstanden:

Java:
editButtons[0].addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent arg0) {
				
				final WaitingScreen waitingScreen = new WaitingScreen(); //Geschieht vor dem Thread, da dieser noch nicht erzeugt/gestartet wurde. 
				waitingScreen.setVisible(true); 
				   new Thread(){  //neuer anonymer Thread
					      public void run(){ //wird nach dem Starten des Threads ausgeführt
					    	  makeSubimages(); //zerlegt mein Bild in einzelne Bilder
					    	  resultStrings = OCRtool.doOCR(); //Das zurückgegebene String-Array wird in das lokale Array gespeichert
					EventQueue.invokeLater(new Runnable() { //EventQueue.invokeLater bedeutet, dass dieser Teil erst nach Abschluss der o.g. Run() ausgeführt wird?
					        public void run() {
					            waitingScreen.dispose(); //Fenster schließen
					            for(int i = 0; i < Settings.FIELDS; i++) { //der folgende Code schreibt die Werte aus dem String Array in TextFields und TextAreas
									if(i == 4) { 
										correctAreas[0].setText(resultStrings[4]);
									}else if(i == 27) {
										correctAreas[0].setText(resultStrings[27]);
									}else {
										if(i < 4) {correctFields[i].setText(resultStrings[i]);}
										 if(i > 4 && i <= 27) {correctFields[i-1].setText(resultStrings[i]);}
										 if(i > 27) {correctFields[i-2].setText(resultStrings[i]);}
									}
								}
					        }
					    });
					      }
					   }.start(); //Erst JETZT wird der Thread gestartet, durch diese Schreibweise reicht ein Anonymer Thread
						//sonst müsste ich schreiben: Thread thread = new Thread(){...}; thread.start();

			}
		 });
		 }

EDIT: Sry, die Formatierung ist echt für den A****
 
Zuletzt bearbeitet:

arilou

Bekanntes Mitglied
Ich persönlich würde die Synchronisierung "Fensteraufbau soll vor OCR geschehen" auch eher sicherstellen, indem ich die .repaint() überschreibe mit
Java:
public void repaint()
{
  super.repaint() ;
  //
  if( isOcrJobWaiting() )
  {
    startOcrThread(); // nebenläufig, erledigt auch:
    // set_OcrThreadWaiting( false );
  } // end if
}

(Oder eben das OCR-Geschäft ganz in einen eigenen Thread auslagern, dann ist das Fenster gänzlich entkoppelt, und man kann explizit (z.B. mit booleans) synchronisieren, wann was startet/fertig ist/...)
 
Zuletzt bearbeitet:

mac21

Aktives Mitglied
Hallo arilou,

Das Fenster wird ja aufgebaut bevor der OCR-Vorgang gestartet wird?
Dies geschieht erst auf Knopfdruck (JButton).
Und mit dem Code von Anti-Held wird ja auch erst das WarteFenster erzeugt und DANN der Vorgang ausgeführt.
Könntest du das bitte zu meinem Verständnis genauer beschreiben?

Dann würde das funktionieren wie ich das gedacht habe:
Das WarteFenster liefert einen boolean(true), wenn es fertig ist,
erst dann kann der Vorgang starten, da er bis dahin überprüft
"ist das Fenster 'Fertig'? Dann kann ich loslegen,
wenn nicht: neuer schleifendurchlauf"

Verstehe ich das richtig?
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
B Leere vererbte Interface-Methoden Allgemeine Java-Themen 8
R Programm führt Methoden gleichzeitig aus Allgemeine Java-Themen 2
Encera Unterschied zweier "toString"-Methoden Allgemeine Java-Themen 1
torresbig Klasse mit extends Calendar über Methoden ändern (Hirnblockade) Allgemeine Java-Themen 7
Sachinbhatt Sind alle Methoden in Java implizit virtuell Allgemeine Java-Themen 2
B Arrays von Methoden möglich? Allgemeine Java-Themen 44
S Mit Methoden kann man definieren für was <T> steht. Geht das auch irgendwie für Variablen? Allgemeine Java-Themen 12
N abstracte klassen methoden Allgemeine Java-Themen 32
G Methoden für die Zukunft sinnvoll? Allgemeine Java-Themen 4
nonickatall Methoden Kann man Klassen/Methoden aus Variablen heraus aufrufen? Allgemeine Java-Themen 6
LimDul Hä? Lambda-Ausdruck geht, Methoden-Referenz nicht Allgemeine Java-Themen 8
B Methoden Java Getter und Setter Methoden Allgemeine Java-Themen 9
Y Java Methoden unterschiedliche Zahlenreihen Allgemeine Java-Themen 2
S Interface Design von HookUp oder Callback Methoden für eigenes Framework Allgemeine Java-Themen 9
F Sich automatisch aufrufende Java-Methoden Allgemeine Java-Themen 2
J Namen von Methoden über Reguläre Ausdrücke bearbeiten Allgemeine Java-Themen 6
D Methoden Methoden anpassen und fehlende Funktionen hinzufügen Allgemeine Java-Themen 475
V Threads Probleme beim Aufrufen von Methoden einer anderen Klasse (Threads) Allgemeine Java-Themen 14
R Statistische Methoden (Mathematik) Aufgabe Allgemeine Java-Themen 9
X Brüche kürzen mittels Methoden und ggT Allgemeine Java-Themen 15
L Operatoren Java Reflections: Alle Methoden einer Klasse aufrufen ohne Exceptions Allgemeine Java-Themen 5
L mehrere Methoden Allgemeine Java-Themen 19
KeexZDeveoper Zugriff auf Methoden vom Server Allgemeine Java-Themen 7
B StAX Parser - mehrere Methoden, ein XML Allgemeine Java-Themen 4
F Operationen/Methoden einen WebService im Browser mit Apache Axis aufrufen Allgemeine Java-Themen 4
A Automatisches Methoden Laufzeiten logging? Allgemeine Java-Themen 7
M Quellcode von Java-Methoden Allgemeine Java-Themen 9
rentasad Design-Frage - Interfaces, Klassen, statische Methoden Allgemeine Java-Themen 3
N HashMap und Methoden richtig einbinden Allgemeine Java-Themen 2
R Variable durch mehrere Methoden ändern und nutzen Allgemeine Java-Themen 17
Q-bert Methoden Methoden in Java Allgemeine Java-Themen 13
D Methoden Java-Aufgabe Allgemeine Java-Themen 2
M Compiler-Fehler Methoden-Referenz Allgemeine Java-Themen 5
X Threads Externe Variablen in Run Methoden verändern Allgemeine Java-Themen 4
S 2 methoden mit gleichen namen und ein Interface Allgemeine Java-Themen 9
F Enum-werte als Methoden-Parameter übergeben Allgemeine Java-Themen 6
N Vererbung Design-Problem mit vorhandenen, von der Klasse unabhängigen Methoden Allgemeine Java-Themen 12
E OOP Objekte und Methoden Allgemeine Java-Themen 1
K Java ruft Methoden nicht der Reihe nach auf Allgemeine Java-Themen 14
N Methoden Methoden einer Klasse auf Grundlage eines Strings aufrufen Allgemeine Java-Themen 6
T Java Array in Methoden Allgemeine Java-Themen 1
D Code für bereitgestellte Methoden Allgemeine Java-Themen 1
P Entity Objekt Methoden vs Service methoden Allgemeine Java-Themen 2
R Signatur von Methoden in eine Datei schreiben? Allgemeine Java-Themen 4
A Methoden verändern Allgemeine Java-Themen 12
F Methoden Arraylist weiterverwenden nach methoden Aufruf Allgemeine Java-Themen 2
J Best Practice Testen von protected Methoden Allgemeine Java-Themen 7
L Methoden "Schiffe versenken" Quellcode in Methoden umwandeln Allgemeine Java-Themen 6
G Matrix reduzieren zwei Methoden Allgemeine Java-Themen 2
Sogomn Best Practice "Doppelte" Methoden Allgemeine Java-Themen 3
Paul15 String Methoden Allgemeine Java-Themen 7
G Methoden BMI -Wert Aufgabe(Methoden) Allgemeine Java-Themen 4
F Testen von Methoden Allgemeine Java-Themen 3
S "Vererben" statischer Felder/Methoden Allgemeine Java-Themen 4
F Methoden in der Enumeration Klasse Allgemeine Java-Themen 1
S Methoden ohne Methodenkopf ?! Allgemeine Java-Themen 5
T Überschreiben von Methoden Allgemeine Java-Themen 6
S Methoden Methoden überschreiben Allgemeine Java-Themen 3
N Threads statische Methoden in Threads Allgemeine Java-Themen 5
O Java-Obfuscator, welcher einzelne Methoden, Klassen und Ordnerstrukturen ausnehmen kann. Allgemeine Java-Themen 1
A also definition von klassen und string methoden und algorithmik Allgemeine Java-Themen 13
X Eigene Annotation - mit Bedingung für ganze Klassen oder Methoden Allgemeine Java-Themen 2
A Threads Lock über mehrere Abschnitte in verschiedenen Methoden Allgemeine Java-Themen 5
S Methoden Frage Allgemeine Java-Themen 2
R Wie kann man diese Methoden in arrays etablieren? Allgemeine Java-Themen 8
M Methoden in Rescources speichern Allgemeine Java-Themen 4
G Synchronisation nicht statischer Methoden Allgemeine Java-Themen 4
A Vererbung finale Methoden überschreiben Allgemeine Java-Themen 24
A Methoden parallelisieren? Allgemeine Java-Themen 2
L Methoden methoden an generischen klassentyp anpassen Allgemeine Java-Themen 5
C Methoden Übernahme von standart nativen Methoden? Allgemeine Java-Themen 9
B Zusammenfassen verschiedener ähnlicher Methoden Allgemeine Java-Themen 8
K JNI: Methoden aus unterschiedlichen Threads aufrufen Allgemeine Java-Themen 3
P Unterschiedliche Clone- Methoden Allgemeine Java-Themen 5
MQue Spezialfrage Überschreiben von Methoden Allgemeine Java-Themen 14
B Methoden Alle Methoden und Variablen aus Java-Dateien auslesen. Allgemeine Java-Themen 7
MiMa Rekursive Methoden Allgemeine Java-Themen 3
S Programm das alle aufgerufenen Methoden ausgibt..? Allgemeine Java-Themen 6
F ListIterator (next & previous methoden) Allgemeine Java-Themen 5
W Frage zu Refactoring statischer Methoden Allgemeine Java-Themen 4
M Methoden/Klassen für andere Projekte Allgemeine Java-Themen 4
T Methoden per String-Namen aufrufen Allgemeine Java-Themen 2
C Kapselung Warum graift man auf Variablen nur über Methoden und nich direkt zu? Allgemeine Java-Themen 10
M Methoden Static Methoden und Thread??? Allgemeine Java-Themen 4
A Methoden ohne Referenzen finden Allgemeine Java-Themen 9
turmaline OOP zwei gleiche Methoden mit kleinen Unterschieden Allgemeine Java-Themen 15
G JUnit Test Methoden in anderen Thread verlagern Allgemeine Java-Themen 4
K Auf Methoden der Runnable Klasse zugreifen Allgemeine Java-Themen 2
S Methoden Class.forName() >> Methoden - Reihenfolge Allgemeine Java-Themen 5
D Passende Name für Methoden finden Allgemeine Java-Themen 3
D Wann sollte ich statische Methoden und Variablen benutzen? Allgemeine Java-Themen 44
A Methoden laufen im Konstruktor, außerhalb allerdings nicht Allgemeine Java-Themen 2
M Generische Methoden mit Java und globale Variablen Allgemeine Java-Themen 9
GianaSisters ArrayList in Methoden übergeben Allgemeine Java-Themen 3
S static methoden Allgemeine Java-Themen 9
J coole Methoden Allgemeine Java-Themen 6
R Methoden in einem Thread unterschiedlich oft ausführen Allgemeine Java-Themen 4
A OOP: Überschreiben/Implementierung von Methoden Allgemeine Java-Themen 5
P Methoden und Werte Allgemeine Java-Themen 17
E Performace/Ausführungszeit von Methoden ermitteln Allgemeine Java-Themen 4

Ähnliche Java Themen

Neue Themen


Oben