Vererbung Konstruktoren nicht erkannt

RoHo

Mitglied
Hallo mal wieder,

ich habe drei Klassen: Field, FreeField und PredefField, wobei gilt:
Field extends JFrame
FreeField extends Field
PredefField extends Field

jetzt habe ich für jede Klasse einen Konstruktor erstellt, wobei eigentlich nur der von der Vaterklasse Field was macht
Java:
public FreeField(Ground g, int x, int y){
		super(g, x, y);
	}
...
	public PredefField(Ground g, int x, int y){
		super(g, x,y);
	}

der existiert auch mit
Java:
	public Field(Ground g, int x, int y){
		this.coord_x = x;
		this.coord_y = y;
		...
	}

jetzt der interessante Teil: ich habe eine Methode geschrieben, die den Typen eines Feldes ändern soll
Java:
/**
	 * Ändert den Typ eines Feldes
	 * @param f welches Feld
	 * @param type zu welchem Typ
	 */
	public static void changeType(Field f, String type){
		if (type.toUpperCase().equals("FREE")){
			f = new FreeField(f.playground, f.get_Coord_X(), f.get_Coord_Y());
		}
		else if (type.toUpperCase().equals("PREDEF")){
			f = new PredefField(f.playground, f.get_Coord_X(), f.get_Coord_Y());
		}
		else if (type.toUpperCase().equals("DEFAULT")){
			f = new Field(f.playground, f.get_Coord_X(), f.get_Coord_Y());
		}
		else {
			System.out.println("No type to change found...");
		}

		System.out.println(f.getClass().getName());

	}

aber leider sagt mir Eclipse, dass diese Art von Konstruktor bei PredefField nicht existiert (das ist das mittlere else-if) und schlägt mir vor, es hinzuzufügen, mach ich -> neue Fehlermeldung, denn der Konstruktor ist ja schon vorhanden. Bei Field oder Freefield meckert er an dieser Stelle nicht.
Aaaber, dafür sagt mir meine FreeField.class, dass der super-Konstruktor von Field nicht existiert -> automatisch hinzugefügt, wieder das gleiche Problem, Methode 2x vorhanden.
In der Klasse PredefField gibts immerhin keinen Fehler, den Eclipse mir anzeigen kann :-S (sagt mir aber, dass irgendwo einer sei)
Eclipse schon neugestartet und veruscht so auszuführen -> NosuchMethodError

Der gesamt-Code ist relativ lang (ca 450 Zeilen) möchte den also wenn möglich nicht hier reinbomben, falls irgendwelche anderen Teile zur Analyse benötigt werden, immer raus damit.
Danke schonma

Gruß
Ro
 

XHelp

Top Contributor
Da Field eine existierende Klasse in der API ist vermute ich einfach, dass bei dir in den imports
Code:
java.lang.reflect.Field
importiert wird und deswegen auch verwendet wird. Da gibt es deinen Konstruktor natürlich nicht.

Deine Methode zur Typänderung wird übrigens nicht klappen, da Java kein CallByReference kann

Edit: hm, hab nicht bedacht, dass du von Reflection-Field gar nicht erben kannst. Pack am besten doch etwas mehr Quelltext. Da lassen sich bestimmt viele Teile rausschmeißen, so dass nur ein paar wesentliche und zusammenhängende Zeilen bleiben.
 
Zuletzt bearbeitet:

RoHo

Mitglied
verdammt^^, das mit dem CallbyReference hab ich nicht bedacht, deswegen hat so einiges nicht funktioniert :D
ich versuch erstmal das zu umgehen, danach kommt der (neue) Code hoch, aber danke soweit

Gruß
Ro

€: die changeType-Methode hab ausgelagert, sodass kein direkter CallByReference mehr drin ist (hoffe, dass das jetzt geht).
Da ich den Fehler nicht finden konnte bei den Konstruktoren einfach mal der ganze Code
Java:
package fields;

import composited.*;
//---
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


/**
 * Das ist ein leeres Feld, in dem weder Zahlen vorgegeben werden, 
 * noch welche eingetragen werden können.
 * Außerdem kann durch die extends-Beziehung ein Array von Feldern (Field) angelegt
 * werden, sodass die Felder in freie(FreeField) oder Vorgebende(PredefField 
 * (Predefining = vorgeben)) umgewandelt werden können
 * @author Robin
 *
 */
public class Field extends JPanel {
	//Wo liegt das Feld?
	private int coord_x , coord_y;
	private boolean marked = false;	//wurde das Feld ausgwählt / angeklickt
	
	//auf welchem Spielfeld liegt das Feld?
	private Ground playground = null;
	
	//PopUp um den Typen zu ändern
	JPopupMenu pum_changeType = null;
	JMenuItem mi_changeToFree = null;
	JMenuItem mi_changeToPredef = null;
	JMenuItem mi_changeToDefault = null;
	
	
	//Konstuktoren
		//TODO
	/**
	 * Konstrukttor mit Angaben zur Position
	 */
	public Field(Ground g, int x, int y){
		this.coord_x = x;
		this.coord_y = y;
		this.playground = g;
		this.setToolTipText(this.toString() + " _ " + this.getClass().getName());
		initPopUp();
	}
	
	



	/**
	 * Ändert den Typ eines Feldes
	 * @param f welches Feld
	 * @param type zu welchem Typ
	 */
	public  void changeType(String type){
		this.playground.changeType(this, type);
	}
	
	/**
	 * Das das Feld nicht benutzt wird, wird es einfach schwarz ausgemalt
	 */
	@Override
	public void paintComponent(Graphics g){
		super.paintComponent(g);
		g.setColor(Color.BLACK);
		g.fillRect(0, 0, this.getWidth()-1, this.getHeight()-1);
	}
	
	/**
	 * Gibt die Koordinaten zurück
	 * @return
	 */
	public int[] getCoordinates(){
		int[] temp = {coord_x, coord_y};
		return temp;
	}
	
	/**
	 * Liefert die x-Koordinate
	 * @return
	 */
	public int get_Coord_X(){
		return coord_x;
	}
	
	
	/**
	 * Liefert die y-Koordinate 
	 * @return
	 */
	public int get_Coord_Y(){
		return coord_y;
	}
	
	/**
	 * fragt ab, ob das feld markeirt ist
	 * @return
	 */
	public boolean isMarked(){
		return marked;
	}
	
	/**
	 * setzt das feld als markeirt
	 */
	public void mark(){
		marked = true;
	}
	
	/**
	 * Deakiviert die Markierung
	 */
	public void unMark(){
		marked = false;
	}
	
	/**
	 * 
	 */
	public String toString(){
		return String.format("(%d/%d)", this.get_Coord_X(), this.get_Coord_Y());
	}
	
	/**
	 * ERstelle ein PopUp-Menu um den Typen des Feldes zu ändern
	 */
	private void initPopUp(){
		//ERstelle das Menu
		this.pum_changeType = new JPopupMenu("Typ of this field:");
		this.mi_changeToDefault = new JMenuItem("Default");
		this.mi_changeToPredef = new JMenuItem("Predefining");
		this.mi_changeToFree = new JMenuItem("Free");
		
		//Setze es zusammen
		this.pum_changeType.add(mi_changeToDefault);
		this.pum_changeType.add(mi_changeToPredef);
		this.pum_changeType.add(mi_changeToFree);
		
		
		//Füge die Actions zu den Auswahlfeldern
		mi_changeToDefault.addActionListener(new AbstractAction() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("Changed to Default");
				Field.this.changeType("DEFAULT");
			}
		});
		mi_changeToFree.addActionListener(new AbstractAction() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("Changed to Free");
				Field.this.changeType("FREE");
			}
		});
		mi_changeToPredef.addActionListener(new AbstractAction() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("Changed to Predef");
				Field.this.changeType("PREDEF");
				Field.this.repaint();
			}
		});
		
		
		
		//Aktiviere das Menu
		this.add(pum_changeType);
		
		this.addMouseListener( new MouseAdapter()
		{
		  public void mouseReleased( MouseEvent me ) {
		    if ( me.isPopupTrigger() )
		      pum_changeType.show( me.getComponent(), me.getX(), me.getY() );
		  }
		} );
	}
	

	

}

Java:
package fields;

import java.util.*;
import composited.*;



/**TODO
 * 
 * 
 * DONE
 * - Wert setzen
 * - Wert lesen
 * - Zahlen auscschließen
 */

/**
 * DAs ist das (weiße) Feld in das die Werte eingetragen werden können
 * @author Robin
 *
 */



public class FreeField extends Field {
	
	//Werte
	private int value = 0;
	private boolean possibleValues[] = {true, true, true,/*3*/ 
						true, true, true,/*6*/ true, true, true/*9*/};
	
	//Zu welchen Reihen gehört das Feld, [0] unten, [1] rechts
	private Row[] rows = {null,null};
	
	//steht das feld fest? oder kann es noch geändert werden
	private boolean locked = false;
	
	
	//Konstruktoren
		//TODO	
	public FreeField(Ground g, int x, int y){
		super(g, x, y);
	}
	
	/**
	 * setzt das Feld zum Anfangszusatand zurück, 
	 * sodass alle Möglichkeiten wieder möglich sind
	 */
	public void reset(){
		for (boolean b: possibleValues){
			b = true;
		}
		rows = null;
		value = -1;
	}
	
	/**
	 * setzt den wert des feldes
	 * @param val der gesetzte wert
	 */
	public void setValue(int val){
		if (val > 0 && val <9)
			this.value = val;
	}
	
	/**
	 * liest den wert des feldes aus
	 * @return wert
	 */
	public int getValue(){
		return this.value;
	}
	
	/**
	 * Deaktiviert die gegebene zahl, umrechnung auf array ist drin
	 * @param val die ZAhl, NICHT die Array-stelle
	 */
	public void delValue(int val){
		if (val >0 && val > 10){
			possibleValues[val-1] = false;
		}
	}
	
	/**
	 * blockiert die variable für weitere änderungen
	 */
	public void lock(){
		locked = true;
	}
	
	/**
	 * Hebt das SChloss wieder auf
	 *   - public sinnvoll?
	 */
	public void unlock(){
		locked = false;
	}
	
	public boolean isLocked(){
		return locked;
	}
	
	/**
	 * Gibt die möglichen Werte zurück
	 * @return boolean Array, feste größe(9)
	 */
	public boolean[] getPossibleValues(){
		return this.possibleValues;
	}
	
	/**
	 * das gleiche wie oben
	 * @return gibt ein Int-array zurück (variable größe)
	 */
	@Deprecated
	public int[] getPossibleValuesAsInt(){
		//Wieviele Zahlen gibt es
		int counter = 0;
		for (boolean b: possibleValues){
			if (b){
				counter++;
			}
		}
		//Lege ein Array mit soviel stellen an
		int numbers[] = new int[counter];
		counter = 0;
		//suche die zaheln und packe sie ins array
		for (int i = 0; i<9; i++){
			if (possibleValues[i]){
				numbers[counter++] = i+1; //+1 weil array(0-9) , zahlen aber (1-9)
			}
		}
		return numbers;
	}
	
	/**
	 * Sagt dem Feld, zu welcher Reihe es gehört
	 * @param r die Reihe
	 * @param where wohin zeigt die Reihe?
	 */
	public void addRow(Row r, int where){
		if (where == 0|| where == 1 ){
			this.rows[where] = r;
		}
//		return r;
	}
	
	public Row getRow(int where){
		if (where == 0|| where == 1 ){
			return rows[where];
		}
		return null;
	}
	
}

Java:
package fields;


import composited.*;
//---
import javax.swing.*;
import java.awt.*;
/**
 * DAs ist das Feld, in dem ein oder zwei Zahlen vorgegen werden
 * Da das Feld zwei Werte (nach rechts und nach unten) haben kann, wird 
 * verstärkt mit zweier-Arrays gearbeitet. UNTEN = 0, RECHTS = 1
 * @author Robin
 *
 */
public class PredefField extends Field {
	//erstmal die statischen Variablen
	private static final int DOWN = 0, RIGHT = 1; //Welches Feld für welche Richtung zuständig?
	private static int howMany = 0;	//wieviele vorgebende Felder gibts überhaupt?
	
	
	private boolean[] active = {false, false}; //Gibt eines der beiden Internen 
								//Felder überhaupt was vor, oder ist es inaktiv
	
	private int[] value = {-1,-1}; //Die Werte die vorgegeben werden sollen
	
	
	//Konstruktoren
		//TODO
	public PredefField(Ground g, int x, int y){
		super(g, x,y);
	}
	
	//Methoden
	
	/**
	 * Setzt den Wert an der gegeben Stelle
	 * @param val der Wert der gesetzt wird
	 * @param where wo? 0 = Unten, 1 = Rechts
	 */
	public void setValue(int val, int where){
		//Die Min Grenze für ein Feld, die MAx Grenze für neun Felder
		if (val > 1 && val<45){
			if (where ==0 || where ==1){
				value[where] = val;
				active[where] = true;
			}
		}
	}
	
	
	/**
	 * Gibt den Wert eines halb-Feldes zurück
	 * @param where welches Feld? Unten = 0, Rechts = 1
	 * @return dem Wert
	 */
	public int getValue(int where){
		if (where ==1 || where == 0){
			return value[where];
		}
		return -1;
	}
	
	/**
	 * Deaktiviert eine Feldhälfte vorübergehend, bis ein neuer Wert gesetzt wird
	 * @param where 
	 */
	public void deactivate(int where){
		if (where ==1 || where == 0){
			active[where] = false;
			value[where] = -1;
		}
		
	}
	
	/**
	 * prüft, ob ein halbfeld einen wert setzt, also eine summe erzwingt
	 * @param where welche hälfte, Unten = 0, Rechts = 1
	 * @return setzt diese zelle einen wert?
	 */
	public boolean isActive(int where){
		return active[where];
	}
	
	@Override
	public void paintComponent(Graphics g){
		super.paint(g);
		//TODO ???
		Polygon poly = null;
		
		//ERstmal alles weiß/platt machen
		g.setColor(Color.WHITE);
		g.fillRect(0, 0, this.getWidth()-1, this.getHeight()-1);
		
		//Schwarzer Kasten rings rum
		g.setColor(Color.BLACK);
		g.drawRect(0, 0, this.getWidth()-1, this.getHeight()-1);
		
		
		//Dreiecke ausfüllen
		g.setColor(Color.DARK_GRAY);
		
		//rechtes oberes Dreieck ausmalen
//		g.setColor(active[1]?Color.LIGHT_GRAY:Color.DARK_GRAY); //Farbauswahl 
		poly = new Polygon(new int[]{0,this.getWidth()-1, this.getWidth()-1}, new int[]{0, 0, this.getHeight()-1}, 3);
		g.fillPolygon(poly);
		
		//linkes unteres Dreieck ausmalen
//		g.setColor(active[0]?Color.LIGHT_GRAY:Color.DARK_GRAY); //Farbauswahl 
		poly = new Polygon(new int[]{0,0, this.getWidth()-1}, new int[]{0, this.getWidth()-1, this.getHeight()-1}, 3);
		g.fillPolygon(poly);
		
		//Werte in die Felder schreiben/drucken
			//TODO
			/*
			 * Schriftart erstellen (größe, farbe)
			 * Positionen bestimmen
			 */
		if (active[0]){
			g.drawString(""+value[0], 0, 0);
		}
		if (active[1]){
			g.drawString(""+value[1], 0, 0);
		}
		
		
		//WEIßE Linie von oben links nach unten rechts  
		// -> trennt die beiden halbfelder optisch von einander
		//ans Ende gesetzt falls das mit den Polygonen kollidiert
		g.setColor(Color.WHITE);
		g.drawLine(0, 0, this.getWidth()-1, this.getHeight()-1);
		
	}

}


Java:
package composited;

import fields.*;
//---
import javax.swing.*;
import java.awt.*;
import java.util.*;
/**
 * Das gesammte Spielfeld, mit der Menge der Feldern, und der Reihen 
 * zur graphischen Darstellung. Die Auswertung wird hier gestartet, beginnend 
 * mit der Erstellung der Reihen usw...
 * 
 * Eimalige ERstellung der Reihen noch nicht geklärt, vll später neue (rekursive) 
 * Reihen erstellen, ist noch nciht geklrt
 * @author Robin
 *
 */

public class Ground  extends JPanel{
	//Die Felder des Spielfeldes
	private Field[][] fields = null;
	private LinkedList<FreeField> freeFields = null;	//Liste mit freien Felden
	private LinkedList<PredefField> preFields = null;	//Liste mit vorgebenden Feldern
	private Field markedOne = null; //DAS EINE markerite Feld
	
	//Länge und Breite des Feldes
	private int height = -1, width = -1;
	//Liste der Reihen
	private LinkedList<Row> rows = null;
	
	//Konstrukoren
	/**
	 * Konstruktor 
	 * erstellt ein Feld mit gegeberner änge und Breite, erzeugt die Felder und 
	 * fügt sie hinzu
	 * macht weiter erstmal nichts
	 */
	public Ground(int width, int height){
		//Übernehme die Maße
		this.width = width;
		this.height = height;
		
		//Die Reihenfolge der Größen geprüt und er sah, dass es gut war
		this.setLayout(new GridLayout(height, width));
		
		
		//Erzeuge das Feld von Feldern (jaha, genau so!)
		fields = new Field[width][height];
		for(int h = 0; h < height; h++){
			for (int w = 0; w < width; w++){
				fields[w][h] = new Field(this, w,h);	//Feld wird erstellt
				this.add(fields[w][h]);			//Feld wird auf Ground gezogen^^ (Verstehen Sie meine Damen un Herren? Was ist denn da passiert?)
			}
		}
		
		this.repaint();
		//TODO verzweifelter versuch, dass irgendwas passiert
		
		
		//Feld wird zur Bearbeitung vorbereitet
		//is ja irgendwie Quatsch, es gibt ja nur die Defaultfelder im Moment
		createFieldLists();	//Erstelle die Listen der Feldtypen
		createRows();		//Erzeuge daraus die Reihen
		
		printFieldLists();	//Gib die oben erzeugten Listen zur Kontrolle aus
		
		
	}
	
	//erzeugt aus den Felden die Reihen
	/**
	 * TODO geht noch nciht --> warum?
	 */
	private void createRows(){
		//erstelle ersmal die Liste, in die die Reihen reinkommen
		this.rows = new LinkedList<Row>(); //TODO das hier ist der Übeltäter
		
		Row tempRow = null; 	//eine leere Reihe, die erstmal beschrieben wird
						//und am Ende verlinkt, das macht die Erstellung einfacher
		
		
		//Welche Felder gehören zu der Reihe
		LinkedList<FreeField> fieldz = null;
		Field tempField = null;
		
		
		//klappere alle vorgebenden Felder ab
		for (PredefField pfield: preFields){
			System.out.println("Es werden nun Reihen erzeugt");
			
			//Das Feld zeigt nach UNTEN -> X-Coord ist konstant
			if(pfield.isActive(0)){
				//Menge der Felder wird zurückgesetzt
				fieldz = new LinkedList<FreeField>();	
				
				//Startfeld zum Durchlaufen der Spalte = Nachfolger des pfield 
				tempField = getField(tempField.get_Coord_X(), tempField.getY()+1);
				
				//erstelle eine neue Reihe
				tempRow = new Row(pfield, 1, fieldz);	
				
				//suche alle nachfolgenden freien Felder
				while(tempField != null && tempField instanceof FreeField){
					//dem Feld wird eine Reihe zugewiesen
					((FreeField)tempField).addRow(tempRow, 0);	
					
					//das nächste Feld wird untersucht
					tempField = getField(tempField.get_Coord_X(), tempField.getY()+1);						
				}
				
				//Erstellte Reihe wird hinzugefügt
				rows.add(tempRow);						
				
				
			}	//Ende der SPALTE
			
			//Das Feld zeigt nach RECHTS -> Y-Coord ist konstant
			if(pfield.isActive(1)){
				//Menge der Felder wird zurückgesetzt
				fieldz = new LinkedList<FreeField>();	
				
				//Startfeld zum Durchlaufen der Zeile = Nachfolger des pfield 
				tempField = getField(tempField.get_Coord_X(),tempField.getY()+1);		
				
				//erstelle eine neue Reihe
				tempRow = new Row(pfield, 1, fieldz);	
				
				//suche alle nachfolgenden freien Felder
				while(tempField != null && tempField instanceof FreeField){
					//dem Feld wird eine Reihe zugewiesen
					((FreeField)tempField).addRow(tempRow, 1);	
					
					//das nächste Feld wird untersucht
					tempField = getField(tempField.get_Coord_X()+1,tempField.getY());						
				}
				
				//Erstellte Reihe wird hinzugefügt
				rows.add(tempRow);						
				
			}	//Ende der ZEILE
		}		//Ende der Forschleife: alle vorgebenden Felder durch
	}
	
	

	/**
	 * Ändert den Typ eines Feldes
	 * @param f welches Feld
	 * @param type zu welchem Typ
	 */
	public void changeType(Field f, String type){
		
		if (f==null){	//da kann man nichts machen :D
			return;
		}
		int x = f.get_Coord_X();
		int y = f.get_Coord_Y();
		Field toChange = this.getField(x, y);
		
		if (type.toUpperCase().equals("FREE")){
			toChange = new FreeField(this, x, y);
		}
		else if (type.toUpperCase().equals("PREDEF")){
			toChange = new PredefField(this, x, y);
		}
		else if (type.toUpperCase().equals("DEFAULT")){
			toChange = new Field(this, x, y);
		}
		else {
			System.out.println("No type to change found...");
		}
		toChange.repaint();
		System.out.println(this.getField(x, y).getClass().getName());
		
		//TODO wieder ras
	}
	
	
	/**
	 * Markiert EIN Feld, demarkiert alle anderen
	 * @param f das zu markierende Feld
	 */
	public void markField(Field f){
		//setze die Markierung für ALLE Felder erstmal auf false
		unmarkAll();
		//danach wird die neue markierung gesetzt
		markedOne = f;
		markedOne.mark();
	}
	
	
	/**
	 * Demarkeirt alle Felder
	 */
	private void unmarkAll(){
		for (Field[] fa: fields){
			for(Field f: fa){
				f.unMark();
			}
		}
	}
	
	/**
	 * Gibt das markerite Feld zurück, eigentlich nur zu Überprüfungszwecken gedacht
	 * @return
	 */
	//TODO gaanz am Ende wieder raus
	public Field getMarked(){
		return markedOne;
	}
	
	/**
	 * Eigene Methode um ArrayIndexOutOfBounds-Exceptions zu verhindern,
	 * wenns nicht passt, gibts halt ein null zurück
	 * Ansonsten gehts wie der Arrayzugriff
	 * @param x x-Koord
	 * @param y y-Koord
	 * @return das gesuchte Feld, falls es existiert
	 */
	private Field getField(int x, int y){
		if (x < this.width && y < this.height){
			return fields[x][y];
		}
		else{
			return null;
		}
		//return (x < this.width && y < this.height)?fields[x][y]:null;
		//Die coole Einzeilervariante
	}
	
	/**
	 * Erzeugt erstmal die Listen mit den einzelnen Feldarten
	 */
	private void createFieldLists(){
		freeFields = new LinkedList<FreeField>();
		preFields = new LinkedList<PredefField>();
		//Durchläuft das zweidimensionale Array
		for(int l = 0; l < this.height; l++){
			for(int w = 0; w <this.width ;w++){
				if (fields[w][l] instanceof FreeField){
					freeFields.add((FreeField) fields[w][l]);
				}
				if (fields[w][l] instanceof PredefField){
					preFields.add((PredefField) fields[w][l]);
				}
			}
		}
	}
	
	private void printFieldLists(){
		StringBuffer sb = new StringBuffer();
		
		if (preFields != null){
			//Vorgebende Felder
			sb.append("Vorgebende:\n");
			for(PredefField pField: this.preFields){
				sb.append(pField + ", ");
			}
			sb.append("\n---\n");
		}
		
		if(freeFields != null){
			//Freie Felder
			sb.append("Freie:\n");
			for(FreeField fField: this.freeFields){
				sb.append(fField + ", ");
			}
			sb.append("\n---\n");
		}
		
		if (rows != null){
			//Reihen
			sb.append("Reihen: \n");
			for (Row r : rows){
				sb.append(r+ "\n");
			}
			sb.append("\n---------------\n");
		}
		System.out.println(sb.toString());
	}
	
	
	/**
	 * Prüft ob alle Reihen, wenn die alle passen, dann gibts true zurück
	 * 
	 * TODO wird am Anfang aufgerufen, ich hab aber keine Ahnung warum
	 * --> ist Methode von JPanel..., müsste sie also umbenennen
	 * --> TODO TODO TBD
	 */
	public boolean check(){
		//gibts die reihen überhaupt?
		if (fields == null|| freeFields == null || preFields == null || rows == null){
			return false;
		}
		//überprüfe die reihen
		for (Row r : rows){
			if (r == null || !r.isCorrect()){
				return false;
			}
		}
		return true;
	}
	
	/**
	 * Setzt das gesamte Feld zurück,
	 * die native Resetmethode wird aufgerufen
	 */
	public void reset(){
		if (freeFields != null){
			for (FreeField f : freeFields){
				f.reset();
			}
		}
	}
	
	/**
	 * Löst den Plan soweit eindeutig möglich, hauptsächlich durch Ausschluss
	 */
	public void solve_excluding(){
		
	}
	
	/**
	 * Löst den Plan vollautomatisch
	 * 1. über Ausschluss
	 * 2. wenn nötig über Raten
	 */
	public void solve_auto(){
		//1. Lösen
		solve_excluding();
		//2. Raten
	}
}

Und nocheinmal die Fehlermeldung, die kommt, wenn ich es trotzdem auszuführen versuche:
Code:
 -->Opendialog gestartet
Width: 2, Height: 2, Sum: 4
 <-- Opendialog geschlossen

Kakuro-fenster wird gestartet
Kakuroframe gestartet
Exception occurred during event dispatching:
java.lang.Error: Unresolved compilation problems: 
	The constructor Field(Ground, int, int) is undefined
	The constructor PredefField(Ground, int, int) is undefined
	The constructor PredefField(Ground, int, int) is undefined
	The constructor Field(Ground, int, int) is undefined

	at composited.Ground.<init>(Ground.java:51)
	at frames.KakuroFrame.initGround(KakuroFrame.java:49)
	at frames.KakuroFrame.<init>(KakuroFrame.java:34)
	at frames.OpenDialog$1.actionPerformed(OpenDialog.java:83)
	at javax.swing.AbstractButton.fireActionPerformed(Unknown Source)
	at javax.swing.AbstractButton$Handler.actionPerformed(Unknown Source)
	at javax.swing.DefaultButtonModel.fireActionPerformed(Unknown Source)
	at javax.swing.DefaultButtonModel.setPressed(Unknown Source)
	at javax.swing.plaf.basic.BasicButtonListener.mouseReleased(Unknown Source)
	at java.awt.Component.processMouseEvent(Unknown Source)
	at javax.swing.JComponent.processMouseEvent(Unknown Source)
	at java.awt.Component.processEvent(Unknown Source)
	at java.awt.Container.processEvent(Unknown Source)
	at java.awt.Component.dispatchEventImpl(Unknown Source)
	at java.awt.Container.dispatchEventImpl(Unknown Source)
	at java.awt.Component.dispatchEvent(Unknown Source)
	at java.awt.LightweightDispatcher.retargetMouseEvent(Unknown Source)
	at java.awt.LightweightDispatcher.processMouseEvent(Unknown Source)
	at java.awt.LightweightDispatcher.dispatchEvent(Unknown Source)
	at java.awt.Container.dispatchEventImpl(Unknown Source)
	at java.awt.Window.dispatchEventImpl(Unknown Source)
	at java.awt.Component.dispatchEvent(Unknown Source)
	at java.awt.EventQueue.dispatchEvent(Unknown Source)
	at java.awt.EventDispatchThread.pumpOneEventForFilters(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
	at java.awt.Dialog$1.run(Unknown Source)
	at java.awt.event.InvocationEvent.dispatch(Unknown Source)
	at java.awt.EventQueue.dispatchEvent(Unknown Source)
	at java.awt.EventDispatchThread.pumpOneEventForFilters(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
	at java.awt.EventDispatchThread.pumpEventsForHierarchy(Unknown Source)
	at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
	at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
	at java.awt.EventDispatchThread.run(Unknown Source)


Ich seh im Moment aber nicht, wie der andere Code damit zutun haben könnte...
Gruß Ro
 
Zuletzt bearbeitet:

Mofi

Bekanntes Mitglied
Benenn mal die Klasse "Field" einfach um.
Laut Java API gibt es dort schon eine Klasse Field, daher kann da der Fehler liegen. Was anderes kann ich mir auch nicht erklären, warum er die Konstruktoren nicht annimmt.

Den Code hab ich mir jetzt nicht durchgelesen. Aber bevor wir sich da jemand "tot sucht" wäre es vielleicht hinlfreich erstmal aus zuschließen, dass es an dem Klassennamen liegt.
 

RoHo

Mitglied
Field umbenannt in MyField
Das Problem mit den Konstruktoren wird im Moment nicht mehr angezeigt (Eclipse sagt mir weiterhin, dass irgendwas falsch sein, aber kann keine Zeile anzeigen)
Neuer Fehler(trat vorher nicht auf):
bei
Java:
				if (fields[w][l] instanceof PredefField){
					preFields.add((PredefField) fields[w][l]);
				}
kommt
Code:
Incompatible conditional operand types MyField and PredefField
Cannot cast from MyField to PredefField

PredefField extends MyField ist gesetzt.
 

Mofi

Bekanntes Mitglied
Field umbenannt in MyField
Das Problem mit den Konstruktoren wird im Moment nicht mehr angezeigt (Eclipse sagt mir weiterhin, dass irgendwas falsch sein, aber kann keine Zeile anzeigen)
Neuer Fehler(trat vorher nicht auf):
bei
Java:
				if (fields[w][l] instanceof PredefField){
					preFields.add((PredefField) fields[w][l]);
				}
kommt
Code:
Incompatible conditional operand types MyField and PredefField
Cannot cast from MyField to PredefField

PredefField extends MyField ist gesetzt.

ALso ich hab mich jetzt nicht durch den ganzen Code gequält (ist mir persönlich zu lang), aber dein fields-Array wie genau wird das deklariert/initialisiert?
So wie ich das gesehen habe ist das in etwa so
Java:
MyField[] fields = null;
//viel code
fields = new MyField[width][height];
        for(int h = 0; h < height; h++){
            for (int w = 0; w < width; w++){
                fields[w][h] = new MyField(this, w,h);    //Feld wird erstellt
                this.add(fields[w][h]);         //Feld wird auf Ground gezogen^^ (Verstehen Sie meine Damen un Herren? Was ist denn da passiert?)
            }
        }

und danach irgendwann versuchst du mit deinem instanceof herauszufinden ob die fields von PredefField oder FreeField ist (hießen die Klassen so?)

DAS kann so nicht gehen. Im Array sind für mich sichtbar nur MyField-Objekte drin. MyField-Objekte sind aber niemals eine Instanz von PredefField noch von FreeField. ABER PredefField- und FreeField-Objekte sind Instanzen von MyField.

Ich weiß nicht ob ich das verständlich erklärt hab...Aber in deinem Array waren niemand PredefField-Objekte drin, daher meckert der Compiler. Denn von einem MyField-Objekt kann man nicht zu einem PredefField casten. Andersrum vermutlich schon. (Von PredefField zu MyField)

Kam meine Erklärung halbwegs verständlich rüber? ^^

Falls etwas falsch sein sollte bitte berichtigen.

Und ich glaube du hast einen Teil der Fehlermeldungen abgeschnitten beim kopieren, die ergibt so nur wenig Sinn.
 

xehpuk

Top Contributor
Warum sollte das nicht gehen? Downcasts sind doch wesentlich "normaler" als Upcasts.
Java:
Number n = 0;
if (n instanceof Integer) {
	Integer i = (Integer) n;
}

Zum Problem des Themenerstellers kann ich nicht viel sagen. Mir scheint, als wäre das Projekt irgendwie schrott. :D
 

Mofi

Bekanntes Mitglied
Warum sollte das nicht gehen? Downcasts sind doch wesentlich "normaler" als Upcasts.
Java:
Number n = 0;
if (n instanceof Integer) {
	Integer i = (Integer) n;
}

Zum Problem des Themenerstellers kann ich nicht viel sagen. Mir scheint, als wäre das Projekt irgendwie schrott. :D

Naja ich hatte mir versucht ein kurzes Beispiel selbst zu machen aus seinem Haufen von Code um das Problem genauer zu sehen...

Und bei mir sieht es momanten so aus:
Java:
public class MyField {

}

public class FreeField extends MyField{

}

public class PrefField extends MyField{

}

import java.util.LinkedList;
import java.util.List;

public class Testen {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int height = 10;
		int width = 10;
		List<PrefField> prefield = new LinkedList<PrefField>();
		
		MyField[][] fields = new MyField[width][height];
        for(int h = 0; h < height; h++){
            for (int w = 0; w < width; w++){
                fields[w][h] = new MyField();    //Feld wird erstellt
//                this.add(fields[w][h]);         //Feld wird auf Ground gezogen^^ (Verstehen Sie meine Damen un Herren? Was ist denn da passiert?)
            }
        }
        for(int h = 0; h < height; h++){
            for (int w = 0; w < width; w++){
//            	if(fields[w][h] instanceof PrefField){
            		prefield.add((PrefField) fields[w][h]);
            		System.out.println("Von PreField");
//            	}else{
            		System.out.println("nicht von PrefField");
//            	}
            }
        }
        
	}

}

Und genau so geschrieben ergibt es ein Laufzeitfehler. (ClassCastException um genau zu sein)

Aber sollte ich mich wirklich irgendwie irren oder einfach vertan haben, bin ich gern für Berichtigungen zu haben.
(Die if/else Verzweigung war zum Testen auskommentiert)
 
G

Gast2

Gast
Und genau so geschrieben ergibt es ein Laufzeitfehler. (ClassCastException um genau zu sein)

Ja, muss ja auch. DU fügst ja nur MyField Objecte in das Array. Ein MyField Object kannst du nicht ohne weiteres zu einem PrefField Object casten.

Java:
import java.util.LinkedList;
import java.util.List;
 
public class Testen {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        int height = 10;
        int width = 10;
        List<PrefField> prefield = new LinkedList<PrefField>();
        
        MyField[][] fields = new MyField[width][height];
        for(int h = 0; h < height; h++){
            for (int w = 0; w < width; w++){
            	if(w % 2 == 0){
                fields[w][h] = new MyField();    //Feld wird erstellt
            	} else {
            		fields[w][h] = new PrefField();
            	}
//                this.add(fields[w][h]);         //Feld wird auf Ground gezogen^^ (Verstehen Sie meine Damen un Herren? Was ist denn da passiert?)
            }
        }
        for(int h = 0; h < height; h++){
            for (int w = 0; w < width; w++){
              if(fields[w][h] instanceof PrefField){
                    prefield.add((PrefField) fields[w][h]);
                    System.out.println("Von PreField");
              }else{
                    System.out.println("nicht von PrefField");
              }
            }
        }
        
    }
 
}

class MyField {
	 
}
 
class FreeField extends MyField{
 
}
 
class PrefField extends MyField{
 
}

Mir scheint, als wäre das Projekt irgendwie schrott. :D

Erstmal Project -> Clean probieren. Ich denke mal das Project Clean sollte schon helfen falls da noch alte class files oder so rumlungern.
 

Mofi

Bekanntes Mitglied
Ja, muss ja auch. DU fügst ja nur MyField Objecte in das Array. Ein MyField Object kannst du nicht ohne weiteres zu einem PrefField Object casten.

Java:
import java.util.LinkedList;
import java.util.List;
 
public class Testen {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        int height = 10;
        int width = 10;
        List<PrefField> prefield = new LinkedList<PrefField>();
        
        MyField[][] fields = new MyField[width][height];
        for(int h = 0; h < height; h++){
            for (int w = 0; w < width; w++){
            	if(w % 2 == 0){
                fields[w][h] = new MyField();    //Feld wird erstellt
            	} else {
            		fields[w][h] = new PrefField();
            	}
//                this.add(fields[w][h]);         //Feld wird auf Ground gezogen^^ (Verstehen Sie meine Damen un Herren? Was ist denn da passiert?)
            }
        }
        for(int h = 0; h < height; h++){
            for (int w = 0; w < width; w++){
              if(fields[w][h] instanceof PrefField){
                    prefield.add((PrefField) fields[w][h]);
                    System.out.println("Von PreField");
              }else{
                    System.out.println("nicht von PrefField");
              }
            }
        }
        
    }
 
}

class MyField {
	 
}
 
class FreeField extends MyField{
 
}
 
class PrefField extends MyField{
 
}



Erstmal Project -> Clean probieren. Ich denke mal das Project Clean sollte schon helfen falls da noch alte class files oder so rumlungern.

Ja mir ist das klar ^^ Aber es klang bei xehpuk so, als sollte das eben doch möglich sein. Daher hatte ich das Beispiel gepostet um ihm zu zeigen, dass es eben da doch Fehler gibt.
Aber da ich mir darüber selbst nicht 100% sicher bin (ist etwas länger her, dass ich mich mit Vererbung gründlich auseinander gesetzt habe), war ich etwas Unsicher und hatte gehofft, dass mir wer zustimmt oder es besser erklärt ^^

Aber ob das dem RoHo hilft mit seinem Projekt weiß ich nicht.
 
G

Gast2

Gast
Java:
if(something instanceof SomeClass){...}
geht immer!* Da wird auch keine ClassCastException oder sonst was geworfen. Maximal halt eine ClassNotFoundException when SomeClass nicht gefunden wird.

Wenn also die IDE hier meckert ist wohl das Project messed up.

@RoHO: Irgendwie erschließt sich mir der Sinn der Vererbung in dem Project auch noch nicht ganz, was soll erreicht werden? Evtl lässt sich das ganze anders besser modelieren.


*mit der Ausnahme wenn [c]something[/c] ein primitiver Datentyp ist.
 

xehpuk

Top Contributor
Man kann natürlich nur auf einen Typ casten, den das Objekt wirklich hat. Eine Instanz der Klasse String mit dem Referenztyp Object kann ohne Probleme auf String gecastet werden. Dass eine Instanz von Object nicht auf String gecastet werden kann, ist klar. Es war also so gemeint, wie es im Code von fassy ist.

Java:
if(something instanceof SomeClass){...}
geht immer!* Da wird auch keine ClassCastException oder sonst was geworfen. Maximal halt eine ClassNotFoundException when SomeClass nicht gefunden wird.

Wenn also die IDE hier meckert ist wohl das Project messed up.

[…]

*mit der Ausnahme wenn [c]something[/c] ein primitiver Datentyp ist.
Na, da wär ich mir nicht so sicher! Der Compiler überprüft dort schon, ob ein Cast überhaupt möglich wär. Wenn dieser immer in einer ClassCastException enden würde, wird dies auch schon zur Kompilierzeit verhindert:
Java:
String s = new String();
if (s instanceof Integer) {}
Code:
Incompatible conditional operand types String and Integer

Da kann man dann aber auch ein wenig tricksen:
Java:
String s = new String();
if ((Object) s instanceof Integer) {}
Das kompiliert. Sowas ist aber natürlich nicht besonders sinnvoll. ;)

Nachtrag:
Selbiges dann auch bei Casts:
Java:
Integer i = (Integer) new String();
Nicht kompilierbar.

Java:
Integer i = (Integer) (Object) new String();
Kompilierbar.
 
Zuletzt bearbeitet:

RoHo

Mitglied
Sooo, hallo,
erstmal danke für die Mühe, die Ihr euch gemacht habt.

So wie ich das sehe ist die Zusammenfassung:
-müsste irgendwie gehen
-Projekt ist Schrott
-Vererbung unsinnig :D

Nach einem Neustart des Rechner (mit ca. 10h Pause) hat sich allerdings ergeben, dass Eclipse mir nun keine Fehler mehr anzeigt, warum, weiß ich auch nicht, aber hat sich irgendwie geklärt :bahnhof:
Also das instanceof und schein zu gehen beim Casten meckert er auch nicht mehr

Zu dem ursprünglichen Problem:
-> umbennen hat es gelöst, aber warum weiß ich nicht.
-java.lang.reflect´.field hätte ich importieren müssen um es überhaupt zu verwenden
-Field als Typen hätte er garnicht erkannt (nachdem ich Field in MyField umbenannt hatte)
-die Fields die ich verwendet hatte, waren genau meine erstellten, hatte die Attribute/Funktionen, die sie haben sollten
 
G

Gast2

Gast
Wahrscheinlich hat dein Eclipse ein Project clean gemacht nach dem Neustart. Benenn die Klasse wieder um nach Field und probier es aus. Umbennen mit der Refactoring Methode nicht per Hand!
 

RoHo

Mitglied
MyField -> Field => keine Fehlermeldungen
also hat einmal hin und zurück-umbennen das Problem gelöst -.-
ich hatte während des Problems den Rechner und Eclipse auch schonmal neugestartet, da hatte sich nichts getan...
 

tfa

Top Contributor
In solchen Fällen hilft es manchmal, ein "clean" mit anschließendem Rebuild zu machen (unter Eclipse "Project"->"Clean...").
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
D Zähler nicht sichtbar (Thema: Konstruktoren) Java Basics - Anfänger-Themen 2
N Verschiedene Konstruktoren mit gleichen Datentypen Java Basics - Anfänger-Themen 8
C Konstruktoren und Variablen Java Basics - Anfänger-Themen 42
lougoldi Verkettung von Methoden und Konstruktoren Java Basics - Anfänger-Themen 4
J Konstruktoren und Grafik Java Basics - Anfänger-Themen 3
A Cannot find symbol mit Konstruktoren Java Basics - Anfänger-Themen 27
L Brauche Hilfe beim arbeiten mit Konstruktoren Java Basics - Anfänger-Themen 20
C Objekte und Konstruktoren Java Basics - Anfänger-Themen 2
M Methodenaufrufe im Konstruktoren Java Basics - Anfänger-Themen 31
A Konstruktoren Vererbung Java Basics - Anfänger-Themen 3
W Vererbung, abstract und Konstruktoren Java Basics - Anfänger-Themen 30
M Vererbung Konstruktoren mit festen Werte Java Basics - Anfänger-Themen 2
F Mehrere Konstruktoren? Wofür? Java Basics - Anfänger-Themen 21
J Konstruktoren in Initialisierungsblöcke Java Basics - Anfänger-Themen 6
T Konstruktoren Java Basics - Anfänger-Themen 25
D was bedeutet this. bei Konstruktoren? Java Basics - Anfänger-Themen 4
C Konstruktoren und Vererbung Java Basics - Anfänger-Themen 2
C Die Klasse Menge mit Konstruktoren und einfachen Methoden Java Basics - Anfänger-Themen 5
F Mehrere Konstruktoren Java Basics - Anfänger-Themen 10
G Was ist der Nutzen von generischen Konstruktoren? Java Basics - Anfänger-Themen 4
Q Methoden Konstruktoren anlegen Java Basics - Anfänger-Themen 5
B Objekte in Konstruktoren übergeben Java Basics - Anfänger-Themen 5
A Überladen von Konstruktoren Java Basics - Anfänger-Themen 2
V Konstruktoren Java Basics - Anfänger-Themen 15
C Klassen StackOverflow bei erster Nutzung von Klassen/Konstruktoren Java Basics - Anfänger-Themen 9
F Konstruktoren Java Basics - Anfänger-Themen 4
M Erste Schritte Verständnis Problem Konstruktoren Java Basics - Anfänger-Themen 13
Y Klassen, Vererbung, Konstruktoren Java Basics - Anfänger-Themen 13
B Klassen Unterschied Konstruktoren. Java Basics - Anfänger-Themen 3
C Erste Schritte Konstruktoren verstehen Java Basics - Anfänger-Themen 7
W OOP Konstruktoren Erklärung Java Basics - Anfänger-Themen 14
N Abarbeitungsreihenfolge von Konstruktoren Java Basics - Anfänger-Themen 12
O Klassen und Konstruktoren Java Basics - Anfänger-Themen 7
V Konstruktoren -> Funktionsaufrufe Java Basics - Anfänger-Themen 7
Q Konstruktoren und Methoden Java Basics - Anfänger-Themen 2
C Konstruktoren Java Basics - Anfänger-Themen 7
J Konstruktoren Java Basics - Anfänger-Themen 10
M Konstruktoren & Veerbung Java Basics - Anfänger-Themen 6
T Konstruktoren Java Basics - Anfänger-Themen 6
P Enum Attribut in Konstruktoren Java Basics - Anfänger-Themen 10
H Klassen, Konstruktoren, Instanzen etc Java Basics - Anfänger-Themen 6
J OOP Konstruktoren, setMethode, getMethode usw. Java Basics - Anfänger-Themen 7
A überladene Konstruktoren Java Basics - Anfänger-Themen 7
L Frage zu Konstruktoren und dem this Operator Java Basics - Anfänger-Themen 16
W 2 Konstruktoren Java Basics - Anfänger-Themen 8
B Vererbung und Konstruktoren Java Basics - Anfänger-Themen 33
N Vererbung von Konstruktoren mit Parametern Java Basics - Anfänger-Themen 7
S Konstruktoren verketten Java Basics - Anfänger-Themen 6
A Konstruktoren sollen sich gegenseitig aufrufen Java Basics - Anfänger-Themen 10
B Konstruktoren Sichtbarkeit Java Basics - Anfänger-Themen 14
K Kann man Private-Konstruktoren doch aurufen? Java Basics - Anfänger-Themen 8
E Konstruktoren und Methoden Java Basics - Anfänger-Themen 10
E OOP individual + standard-Konstruktoren Java Basics - Anfänger-Themen 9
S Konstruktoren? Java Basics - Anfänger-Themen 5
K Konstruktoren Java Basics - Anfänger-Themen 13
H Konstruktoren – super! Java Basics - Anfänger-Themen 3
L Geschachtelte Konstruktoren Java Basics - Anfänger-Themen 4
hdi Kleine Design/Convention Frage zu Konstruktoren Java Basics - Anfänger-Themen 4
J Vererbung und Konstruktoren Java Basics - Anfänger-Themen 14
J Problem mit Konstruktoren Java Basics - Anfänger-Themen 2
G Überladen von Konstruktoren mit unterschiedlichen Datentypen Java Basics - Anfänger-Themen 4
H Befehl mit Konstruktoren Java Basics - Anfänger-Themen 2
L Konstruktoren bei Vererbung Java Basics - Anfänger-Themen 13
Z wie kann ich überladene Konstruktoren "umleiten"? Java Basics - Anfänger-Themen 11
D Blöde(?) Frage zu Konstruktoren und set-Methoden Java Basics - Anfänger-Themen 3
G Interface und Konstruktoren Java Basics - Anfänger-Themen 3
G Frage zu Konstruktoren Java Basics - Anfänger-Themen 12
G Verständnisfrage zu Konstruktoren Java Basics - Anfänger-Themen 5
G Konstruktoren Java Basics - Anfänger-Themen 9
A Konstruktoren überladen Java Basics - Anfänger-Themen 9
H Konstruktoren + Hilfe Java Basics - Anfänger-Themen 12
H Konstruktoren werden nie geerbt Java Basics - Anfänger-Themen 3
O Vor-/Nachteile/Unterschiede von Konstruktoren und Methoden Java Basics - Anfänger-Themen 3
Bierhumpen 2 Konstruktoren Java Basics - Anfänger-Themen 15
T mehrere Konstruktoren für eine Klasse Java Basics - Anfänger-Themen 7
J Instantvariablen und Konstruktoren Java Basics - Anfänger-Themen 2
Y Vererben - Konstruktoren Java Basics - Anfänger-Themen 2
Z übergabe von string[] an konstruktoren oder methoden Java Basics - Anfänger-Themen 3
L Klassen, Vererbung und Konstruktoren Java Basics - Anfänger-Themen 10
S Frage zu Konstruktoren Java Basics - Anfänger-Themen 7
G Problem mit Gültigkeit von Variabeln und Konstruktoren Java Basics - Anfänger-Themen 4
C Konstruktoren Java Basics - Anfänger-Themen 4
G Konstruktoren (was, wozu, wieso, warum) Java Basics - Anfänger-Themen 4
I Webservice funktioniert nicht Java Basics - Anfänger-Themen 5
C Abbruch einer Schleife mit break, meine Übung funktioniert nicht richtig Java Basics - Anfänger-Themen 4
SarahXyy Ergebnisse stimmen nicht überein? Java Basics - Anfänger-Themen 11
thomas55 Erste Schritte Modul läuft in IntelliJ, nicht in NetBeans Java Basics - Anfänger-Themen 11
richis-fragen Nicht ausführbares JAR, externe jars mit einbinden Java Basics - Anfänger-Themen 7
S Erstes Programm: Hallo Welt funktioniert nicht. Java Basics - Anfänger-Themen 3
O Obfuscateter Code lässt sich nicht ausführen? Java Basics - Anfänger-Themen 7
A "Hello World"-Programm läuft nicht Java Basics - Anfänger-Themen 16
D Regex greift nicht richtig Java Basics - Anfänger-Themen 4
richis-fragen JTable den angezeigten WERT nicht den Wert aus dem Model ausgeben. Java Basics - Anfänger-Themen 3
richis-fragen JTable Header ausgeblendete (width = 0) nicht per mouseDragged aufziehen. Java Basics - Anfänger-Themen 9
M Ausgabe einer ArrayList ensteht nur als Hashcode, nicht als Objekt Java Basics - Anfänger-Themen 16
K Warum wird mir auf der Konsole des Servers nicht "xxxx" angezeigt (Server/Client) Java Basics - Anfänger-Themen 4
K Warum wird hier nur etwas in eine txt Datei geschrieben und nicht in alle drei (InputStream/OutputStream/Reader/Writer) Java Basics - Anfänger-Themen 1
richis-fragen JTable effektiv angezeigter Text ausgeben nicht Inhalt vom Model Java Basics - Anfänger-Themen 9
S nach Import von jars (PLC4x) in Eclipse kann nicht mehr compiliert werden Java Basics - Anfänger-Themen 9
J Datenüberwachung funktioniert nicht Java Basics - Anfänger-Themen 9

Ähnliche Java Themen

Neue Themen


Oben