sortieren

[felix.schnee]

hey leute,
ich glaube ich stell mich grad ein wenig doof an. ich hab hier ein Array mit mehreren player Objekten diese haben wiederum Eigenschaften, wie zum Beispiel Punkte, Differenz und Tore.
Dieses Array will ich jetzt sortieren nach punkten, diff und Tore ... dafür hab ich schonmal ne comperator Klasse geschrieben

package testpackage;

import java.util.Comparator;

public abstract class Sotrieren implements Comparator<Player>{
	
	public int compare(Player o1, Player o2) {
        if(o1.getpunkte() < o2.getpunkte())
            return -1;
        else if(o1.getpunkte() > o2.getpunkte())
            return 1;
        else
            return 0;
    }
}

so da kommt zumindest kein Fehler... dann wollt ich das sortieren in ner anderen klasse aufrufen

public class Subclass extends Sotrieren{
		public Sotrieren Sotrierensubclass(){  // das ist sicher mist!!!!
			return null;}
	}
// anderer Quellltext

void sortieren(){
			
            Arrays.sort(foo1,comp);       // ja wenn das mit dem comp klappen würde...
	    for(int laufsa=0;laufsa < lauf1; laufsa++){
		foo1[laufsa].schreibstat();
			}
		}

so das ist dann der haupttext zu der Funktion die subclass hab ich aus nem Forum, sonst kommt folgender Fehler <cannot instantiate the type...> nur so geht es scheinbar auch nicht...

 

[SlaterB]

bleib doch mal bei deutscher Sprache, vollständigen Code, vollständigen Fehlermeldungen,

dass Sotrieren, mit merkwürdiger Rechtschreibung, abstract ist und dann nur eine Subklasse instanziiert werden kann,
scheint sehr unnötig, aber ist letztlich ein Weg,

wenn ein comp-Objekt erstellt wurde, was nicht näher zu sehen ist, und foo1 irgendwas sinnvolles ist, auch nicht zu sehen, sollte
> Arrays.sort(foo1,comp);
durchaus etwas leisten

so, was soll man dazu nun noch sagen? du schreibst nicht was nicht funktioniert oder sonstwie wichtig ist

die Sortiermethode sortiert im Moment nur nach einem Kriterium, aber das reicht ja auch für den Anfang

 

[felix.schnee]

ok ich dachte das wäre alles ein bisschen viel aber ok hier der code von der klasse player

package testpackage;

import java.io.Serializable;


public class Player implements Serializable {

	
	/**
	 * 
	 */
	private static final long serialVersionUID = -2592493312971716342L;
	String name;
	int spiele;
	int siege;
	int unentschieden;
	int niederlagen;
	int punkte;
	int tore;
	int gegentore;
	int differenz;
	int	quote;
	
	void refresh(){
	punkte=siege*3+unentschieden;
	differenz = tore-gegentore;
	if (spiele!=0){
	quote =siege/spiele;}
	else quote=0;
	}	
		
	void schreibstat(){
		System.out.println("\n"+name+"\t\t"+spiele+"\t"+ siege + "\t " + differenz +"\t " + punkte );
	}
	
	
		


	void schreib_quote(){
		System.out.println("\n"+name+"\t\t"+quote);
	}
	public int getpunkte() {return punkte;}
	
	}

dazu noch die arbeitsklasse

package testpackage;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Comparator;

public class Liga implements Serializable {
	
	public class Subclass extends Sotrieren{
		public Sotrieren Sotrierensubclass(){  // das ist sicher mist!!!!
			return null;}
	}
	/**
	 * 
	 */
	private static final long serialVersionUID = -2809087841179500322L;
	Player[] foo1 = new Player[10]; //platz für 5 objekte
    int lauf1 =0;
    Comparator<Player> comp = new Subclass();
    
    
    	//........................................create Array to load old save point 
    	void launch(){
			for(int i = 0; i < 10; i++){
				foo1[i]  = new Player(); //objecte erzeugen
				foo1[i].spiele =0;
					}}

    	//.......................................Reset all to Zero except name
		void reset(){
			for(int i = 0; i < 10; i++){
				foo1[i].spiele =0;
				foo1[i].siege=0;
				foo1[i].unentschieden=0;
				foo1[i].niederlagen=0;
				foo1[i].tore=0;
				foo1[i].gegentore=0;
					}}
		
		
		void schreib(){
			 foo1[2].schreibstat();
			
		}

		void new_player(String new_name){
			foo1[lauf1].name = new_name;
			lauf1++;
			
		}
		
		void schreiball(){
			
			System.out.println("\nname \t\t spiele\tsiege\tdiff\tpunkte" );
			for(int laufsa=0;laufsa < lauf1; laufsa++){
				foo1[laufsa].refresh();
				foo1[laufsa].schreibstat();
				
			}}
	
		void lpunkte(int data){
			 foo1[data].punkte++;
			 foo1[data].schreibstat();
			}

		void sortieren(){
			Arrays.sort(foo1,comp);       // ja wenn das mit dem comp klappen würde...
			for(int laufsa=0;laufsa < lauf1; laufsa++){
				foo1[laufsa].schreibstat();
			}
		}
		
		void schreib_quote(){
			
			System.out.println("\nname \t\tquote" );
			for(int laufsa=0;laufsa < lauf1; laufsa++){
				foo1[laufsa].refresh();
			
				foo1[laufsa].schreib_quote();
				
			}}	
}

aufgerufen wird das ganze durch eine weitere klasse aber das wäre sicher zu verwirrend. hier noch der Fehler


Exception in thread "main" java.lang.ClassCastException: testpackage.Player cannot be cast to java.lang.Comparable
at java.util.Arrays.mergeSort(Arrays.java:1144)
at java.util.Arrays.mergeSort(Arrays.java:1155)
at java.util.Arrays.sort(Arrays.java:1208)
at testpackage.Liga.sortieren(Liga.java:67)
at testpackage.Hauptmenü.main(Hauptmenü.java:84)

 

[SlaterB]

das ist in der Tat eine teuflische Fehlermeldung, wenn ich mir alles zusammenkopiere tritt sie nicht auf,
kann es sein dass sie zu alten/ anderen Quellcode gehört? bei
> Arrays.sort(foo1)
wäre das genau die zu erhaltene Fehlermeldung,
probiere diese Code-Zeile mal aus, kommt dann eine andere Fehlermeldung, andere Zeilennummer für die Arrays-Klasse statt
> at java.util.Arrays.sort(Arrays.java:1208)
?

teste auch weiter Code-Veränderungen, benenne die Klasse Player in Player2 oder so um,
damit kannst du ganz sicher gehen ob der aktuelle Code verwendet wird oder alter (immer noch 'Player' in der Fehlermeldung)

mit Comparator sollte jedenfalls gerade der Comparable-Zwang aufgehoben sein, bei mir geht es bestens, etwas kürzer:

public class Test {
	public static void main(String[] args) {
		Player2[] foo1 = new Player2[10];
		for (int i = 0; i < 10; i++) {
			foo1[i] = new Player2(); 
			foo1[i].punkte = 40 - i;
		}
		Comparator<Player2> comp = new Sortieren();
		Arrays.sort(foo1, comp);

		for (int i = 0; i < 10; i++) {
			System.out.println("i: " + foo1[i].punkte);
		}

	}
}

class Player2 implements Serializable {

	int punkte;

	public int getpunkte() {
		return punkte;
	}

}

class Sortieren implements Comparator<Player2> {

	public int compare(Player2 o1, Player2 o2) {
		if (o1.getpunkte() < o2.getpunkte())
			return -1;
		else if (o1.getpunkte() > o2.getpunkte())
			return 1;
		else
			return 0;
	}
}

lustiger Kommentar übrigens:
> Player[] foo1 = new Player[10]; //platz für 5 objekte

merke: schreibe nie in Kommentare, wieviel Platz ein Array hat, besser auch nicht ähnlich triviales,
> foo1 = new Player(); //objecte erzeugen

wer Array-Deklarationen oder Objekt-Erzeugung nicht lesen kann, hat so große Probleme dass du mit deinem Kommentar auch nicht viel weiterhilfst

 

[Landei]

Es sieht so aus, als ob [c]Arrays.sort(foo1);[/c] statt [c]Arrays.sort(foo1,comp);[/c] aufgerufen würde. Wurde wirklich neu compiliert?

 

[felix.schnee]

erstmal danke für die antworten
@ slater b: ja meine schreibform ist kacke ich lerne gerade unter anderem mit diesem programm und wenn ich das jetzt nochmal schreiben würde würd ich es wohl ganz anders machen.

wie gesagt wenn ich das einfach so aufrufe (ohne subclass) kommt der Fehler...
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Cannot instantiate the type Sotrieren

at testpackage.Liga.<init>(Liga.java:16)
at testpackage.Einspeichern.<init>(Einspeichern.java:7)
at testpackage.Hauptmenü.main(Hauptmenü.java:10)

ohne sortierfunktion geht das Programm.

@ landei: wie finde ich das raus?

 

[felix.schnee]

hab das jetzt mal ohne comp also

Arrays.sort(foo1); probiert kommt der gleiche fehlercode.


Exception in thread "main" java.lang.ClassCastException: testpackage.Player cannot be cast to java.lang.Comparable
at java.util.Arrays.mergeSort(Arrays.java:1144)
at java.util.Arrays.mergeSort(Arrays.java:1155)
at java.util.Arrays.sort(Arrays.java:1079)
at testpackage.Liga.sortieren(Liga.java:67)
at testpackage.Hauptmenü.main(Hauptmenü.java:84)

 

[SlaterB]

> ohne sortierfunktion geht das Programm.

siehe meinen Quellcode zuletzt, die Klasse darf einfach nicht abstract sein

> wie finde ich das raus?

siehe auch wieder meinen Quellcode, dadurch dass in der neuen Exception
> at java.util.Arrays.sort(Arrays.java:1079)
statt
> at java.util.Arrays.sort(Arrays.java:1208)
steht ist schon ein wesentlicher Unterschied erreicht,
der den Fehler allerdings nur umso schwerermacht,

es kann eigentlich nicht sein dass dort auf Comparable gecastet wird, wenn doch ein Comparator da ist,
vielleicht wenn der Comparator null ist? ja, das wäre eine Variante, viel mehr kommt wirklich nicht mehr in Frage

prüfe das noch, auch wenn dein geposteter Quellcode nicht darauf hindeutet

ich habe in meinem Code noch Player in Player2 umbenannt, richtig geschriebenes Sortieren unterscheidet sich eh von deiner Klasse Sotrieren,
du könntest den Quellcode komplett in eine Datei Test.java kopieren und laufen lassen, das sollte sortieren

 

[felix.schnee]

ok das letzte hab ich nicht verstanden das abstract hab ich rausgenommen. was muss ich dann gleich noch tun?

schonmal vielen dank

 

[SlaterB]

ohne abstract sollte 'Cannot instantiate the type Sotrieren' nicht mehr kommen

der Rest ist auch klar, was soll ich da neu formulieren, vielleicht reagierst du auf eine Kurzversion besser:
- comp ist null, das würde jedenfalls den Fehler erklären, prüfen!
- meinen Quellcode ausprobieren

 

[felix.schnee]

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Cannot instantiate the type Comparator<Testplayer.Player2>

at testpackage.TestNummer5.main(TestNummer5.java:17)

die Fehlermeldung beim probieren deines Programmes...

ich hab jetzt n Breakpoint vor
>Arrays.sort(foo1,comp); gesetzt bei diesem ist comp null

weiter geht das programm ja nicht danach sagt er sorce not found wenn ich einen break point nach der sortieranweisung aufrufe...

würde es helfen meinen fehler zu finden, wenn ich den kompletten Quellcode hier hinschreibe? dann könntest du das programm mal ausprobieren.

aber vielen dank das du dir so viel Geduld mit mir nimmst

 

[SlaterB]

kompletter Quellcode kann helfen, ja, wenn möglich vorher kopieren und kürzen, schau dir meine Player2-Klasse an, ähnlich kurz könnte deine auch sein,

---

setze doch mal testweise genau vor der Zeile
> Arrays.sort(foo1,comp);
eine Zuweisung
> comp = new Subclass();
das schadet ja nicht, selbst wenn es 'eigentlich' schon vorher gesetzt sein sollte, funktioniert es wenigstens dann?

-----

> Cannot instantiate the type Comparator<Testplayer.Player2>
du hast aber auch merkwürdige Fehler..,
und du hast wirklich den Code unverändert übernommen, nicht zufällig
> Comparator<Player2> comp = new Comparator<Player2>();
geschrieben?

'Cannot instantiate the type' klingt übrigens streng nach Compilerfehler, keine Exception zur Laufzeit,
kannst du also nicht kompilieren, wird dir eine Zeile Quellcode angemeckert?

 

[felix.schnee]

asche über mein Haupt in deiner testversion hatte ich tatsächlich das mit player 2 geschrieben. ich musste ein paar sachen importieren und dabei hab ich das wohl ausversehen geändert. neuer fehler im testprogramm

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Type mismatch: cannot convert from Testsortieren to Comparator<Testplayer.Player2>

at testpackage.TestNummer5.main(TestNummer5.java:17)

quellcode folgt

 

[felix.schnee]

das hauptmenü

package testpackage;

public class Hauptmenü {

	public static void main(String[] args) throws Exception {
		
		
		Einspeichern reload = new  Einspeichern();
		reload.launch();
		reload.laden();  //program loads old save point
		
		String n2 = javax.swing.JOptionPane.showInputDialog("Hauptmenü\n" +
															"Einstellung.......................1\n" +
															"Ergebnis eingeben............2\n" +
															"Tabelle (Quote).................3\n" +
															"Tabelle (Punkte)................4\n\n" +
															"Welche Funktion soll ausgeführt werdern.");
	    int e= Integer.parseInt( n2 );
	  
	    switch (e){
	    	case 1:								//options
	    		String n3 = javax.swing.JOptionPane.showInputDialog("Einstellungen\n" +
	    															"Spieler hinzufügen.........11\n" +
	    															"Spieler löschen...............12\n" +
	    															"Tabelle zurücksetzen.....13\n" +
	    															"Tabelle löschen..............14\n\n" +
																	"Welche Funktion soll ausgeführt werdern." );
	    	    int e2= Integer.parseInt( n3 );
	    		
	    	    switch (e2){
	    			case 11://New Player
	    				String str2 = javax.swing.JOptionPane.showInputDialog( "Welche Mannschaft." );
	    				reload.new_player(str2);
	    				reload.speichern();
	    				break;
	    			
	    			case 12://delete Player
	    				reload.kfa.lauf1--;
	    				break;
	    			case 13://reset
	    				reload.reset();
	    		    	reload.speichern();
	    		    	break;
	    		
	    			case 14://delete all
	    				reload.kfa.lauf1 =0;
	    				reload.speichern();
	    				default:}
	    			break;
	    	  
	      case 2:								//get results
	    	  String str3 = javax.swing.JOptionPane.showInputDialog( "Bitte Mannschaft 1 eingeben." );
	    	  String str4 = javax.swing.JOptionPane.showInputDialog( "Bitte Mannschaft 2 eingeben." );
	    	  String str5 = javax.swing.JOptionPane.showInputDialog( "Tore Mannschaft 1." );
	    	  String str6 = javax.swing.JOptionPane.showInputDialog( "Tore Mannschaft 2." );
	    	  int he31= Integer.parseInt( str5 );
	    	  int he32= Integer.parseInt( str6 );
	    	  reload.einlesen(str3,str4,he31,he32);
	    	  reload.speichern();
	    	
	    	  break;
	    	  
	      case 3:								//quote
	    	  reload.kfa.schreib_quote();
	    	  break;
	      case 4:
	    	  reload.schreiball();
		      break;
	      
	      case 6:
	    	 reload.kfa.sortieren();
	    	 break;
	    	 
	      default:}
	    
	    }
	}

speicherklasse (da wusst ich noch nicht das man vom hauptmenü aus auf alle unteren zugreifen kann, sieht ein bisschen blöd aus...)

package testpackage;

import java.io.*;

public class Einspeichern {
	
	Liga kfa = new Liga();
	Liga sort =new Liga();
	String datei1 = "Name1"; 
	
	//........................................create Array to load old save point 
	void launch(){
		kfa.launch();
		sort.launch();
	}
	
	//......................................... get new results
	void einlesen (String estr1,String estr2,int ez1,int ez2){
		if (ez1>ez2){
			for(int i=0;i<kfa.lauf1;i++){
				//team 1 gets points
				if( kfa.foo1[i].name.equals(estr1)){
					kfa.foo1[i].spiele++;
					kfa.foo1[i].siege++;
					kfa.foo1[i].tore=kfa.foo1[i].tore+ez1;
					kfa.foo1[i].gegentore=kfa.foo1[i].gegentore+ez2;	}
				//team 2 gets no points			
						if(	kfa.foo1[i].name.equals(estr2)){
							kfa.foo1[i].spiele++;
							kfa.foo1[i].niederlagen++;
							kfa.foo1[i].tore=kfa.foo1[i].tore+ez2;
							kfa.foo1[i].gegentore=kfa.foo1[i].gegentore+ez1;}	
				}}
			else{
			
				if (ez1 == ez2){
				for(int i=0;i<kfa.lauf1;i++){
					//team 1 gets points
					if(kfa.foo1[i].name.equals(estr1)){
						kfa.foo1[i].spiele++;
						kfa.foo1[i].unentschieden++;
						kfa.foo1[i].tore=kfa.foo1[i].tore+ez1;
						kfa.foo1[i].gegentore=kfa.foo1[i].gegentore+ez2;	}
					//team 2 gets  points			
							if( kfa.foo1[i].name.equals(estr2)){
								kfa.foo1[i].spiele++;
								kfa.foo1[i].unentschieden++;
								kfa.foo1[i].tore=kfa.foo1[i].tore+ez1;
								kfa.foo1[i].gegentore=kfa.foo1[i].gegentore+ez2;}
					}}
				else{if (ez1 < ez2){			// yeah at least thats the point i had to do only 
												//	s/u/n have to be in if block
				
					for(int i=0;i<kfa.lauf1;i++){
						//team 1 gets no points
						if( kfa.foo1[i].name.equals(estr1)){
							kfa.foo1[i].spiele++;
							kfa.foo1[i].niederlagen++;
							kfa.foo1[i].tore=kfa.foo1[i].tore+ez1;
							kfa.foo1[i].gegentore=kfa.foo1[i].gegentore+ez2;	}
							//team 2 gets  points			
								if( kfa.foo1[i].name.equals(estr2)){
									kfa.foo1[i].spiele++;
									kfa.foo1[i].siege++;
									kfa.foo1[i].tore=kfa.foo1[i].tore+ez2;
									kfa.foo1[i].gegentore=kfa.foo1[i].gegentore+ez1;}
					
					}}}}}
	//.........................................Takes a new player into the list
	void new_player (String new_name){
		kfa.new_player(new_name);
	}
	
	//.........................................Reset all to Zero except name
	void reset(){
		kfa.reset();
	}
	
	void schreiball(){
		//System.out.println("\n"+kfa.foo1[0].name+"\t\t"+kfa.foo1[0].spiele);
		kfa.schreiball();
	}
	//......................................... get new results, the heart of program
	void speichern(){
	 
		try{	 
			FileOutputStream fileStream = new FileOutputStream(datei1);
			ObjectOutputStream os = new ObjectOutputStream(fileStream);
			  os.writeObject(kfa);
			  os.close();
			  fileStream.close();}
        	catch (IOException ex){
        		ex.printStackTrace();
        } kfa = null;
	}
	
	void laden(){ 
		
		try{
			FileInputStream fileStreamback = new FileInputStream(datei1);
			ObjectInputStream ds = new ObjectInputStream(fileStreamback);
					try {
					 kfa =(Liga) ds.readObject();
					} catch (ClassNotFoundException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
			  ds.close();
			  fileStreamback.close();}
			catch (IOException exx){
				exx.printStackTrace();} 
			System.out.println("läd....");
			kfa.schreiball();
}}

Ligaklasse hier wird das array erzeugt und die sortierfunktion aufgerufen

package testpackage;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Comparator;

public class Liga implements Serializable {
	
	public class Subclass extends Sotrieren{
		public Sotrieren Sotrierensubclass(){  // das ist sicher mist!!!!
			return null;}
	}
	/**
	 * 
	 */
	private static final long serialVersionUID = -2809087841179500322L;
	Player[] foo1 = new Player[10]; //platz für 5 objekte
    int lauf1 =0;
    Comparator<Player> comp = new Subclass();
    
    	//........................................create Array to load old save point 
    	void launch(){
			for(int i = 0; i < 10; i++){
				foo1[i]  = new Player(); //objecte erzeugen
				foo1[i].spiele =0;
					}}

    	//.......................................Reset all to Zero except name
		void reset(){
			for(int i = 0; i < 10; i++){
				foo1[i].spiele =0;
				foo1[i].siege=0;
				foo1[i].unentschieden=0;
				foo1[i].niederlagen=0;
				foo1[i].tore=0;
				foo1[i].gegentore=0;
					}}
		
		void schreib(){
			 foo1[2].schreibstat();
			
		}

		void new_player(String new_name){
			foo1[lauf1].name = new_name;
			lauf1++;
			
		}
		
		void schreiball(){
			
			System.out.println("\nname \t\t spiele\tsiege\tdiff\tpunkte" );
			for(int laufsa=0;laufsa < lauf1; laufsa++){
				foo1[laufsa].refresh();
				foo1[laufsa].schreibstat();
				
			}}
	
		void lpunkte(int data){
			 foo1[data].punkte++;
			 foo1[data].schreibstat();
			}

		void sortieren(){
			Arrays.sort(foo1,comp);       // ja wenn das mit dem comp klappen würde...
			for(int laufsa=0;laufsa < lauf1; laufsa++){
				foo1[laufsa].schreibstat();
			}
		}
		
		void schreib_quote(){
			
			System.out.println("\nname \t\tquote" );
			for(int laufsa=0;laufsa < lauf1; laufsa++){
				foo1[laufsa].refresh();
			
				foo1[laufsa].schreib_quote();
				
			}}	
}

package testpackage;

import java.io.Serializable;


public class Player implements Serializable {

	
	/**
	 * 
	 */
	private static final long serialVersionUID = -2592493312971716342L;
	String name;
	int spiele;
	int siege;
	int unentschieden;
	int niederlagen;
	int punkte;
	int tore;
	int gegentore;
	int differenz;
	int	quote;
	
	void refresh(){
	punkte=siege*3+unentschieden;
	differenz = tore-gegentore;
	if (spiele!=0){
	quote =siege/spiele;}
	else quote=0;
	}	
		
	void schreibstat(){
		System.out.println("\n"+name+"\t\t"+spiele+"\t"+ siege + "\t " + differenz +"\t " + punkte );
	}
	
	
		


	void schreib_quote(){
		System.out.println("\n"+name+"\t\t"+quote);
	}
	
	public int getpunkte() {return punkte;}
	
	}

package testpackage;

import java.util.Comparator;

public  class Sotrieren implements Comparator<Player>{
	
	public int compare(Player o1, Player o2) {
        if(o1.getpunkte() < o2.getpunkte())
            return -1;
        else if(o1.getpunkte() > o2.getpunkte())
            return 1;
        else
            return 0;
    }
}

 

[SlaterB]

> Type mismatch: cannot convert from Testsortieren to Comparator<Testplayer.Player2>

was ist Testsortieren? keine Ahnung was du da an Fehler eingebaut hast, vielleicht sortiert das Player stattt Player2,
ohne Quellcode nicht zu sagen

-------

in deinem gesamten normalen Quellcode sehe ich
> Comparator<Player> comp = new Subclass();
und
> Arrays.sort(foo1,comp);

es gibt keine andere Variable namens comp, niemand setzt comp auf null usw.,
warum comp null sein sollte kann ich nicht nachvollziehen

da kann ich nur beim vorherigen Vorschlag bleiben: erzeuge den Comparator direkt eine Zeile davor,
oder noch simpler, schreibe
Arrays.sort(foo1,new Subclass());

als Check gegen evtl. Fehlermeldung zu alten Code wie immer genau aufpassen und Code verändern,
z.B. Player in Player3 umbenennen usw., zumindest testweise, mit einer IDE geht das in einem Schritt, sonst leider etwas Arbeit,
erstmal auch ohne versuchen,

gibts bei
> Arrays.sort(foo1,new Subclass());
immer noch denselben Sortierfehler?..

bzw.
> Arrays.sort(foo1,new Sotrieren());
sollte auch gehen, wenn Sotrieren nicht mehr abstract ist



warum
> Arrays.sort(foo1,comp);
nicht geht, kann ich wie gesagt nicht nachvollziehen,
vielleicht liegts an alten Code usw., obwohl das viel seltener passiert als ich es erwähne, eigentlich nie,
vielleicht hast du doch noch weitere Klassen usw., es ist schwer aus der Ferne, hier kapituliere ich wohl

 

[felix.schnee]

> Comparator<Player> comp = new Subclass();
und
> Arrays.sort(foo1,comp);

hat geholfen er macht jetzt was und zeigt keinen fehler mehr an. allerdings werden alle werte auf 0 gesetzt statt zu sortieren...

 

[SlaterB]

> Comparator<Player> comp = new Subclass();
und
> Arrays.sort(foo1,comp);

hat geholfen

ich hab nur deinen schon vorhandenen Quellcode zitiert
aber vielleicht diese Zeilen nun an anderen Stellen..

er macht jetzt was und zeigt keinen fehler mehr an. allerdings werden alle werte auf 0 gesetzt statt zu sortieren...

dem Code nach eher nicht, aber was zählt das in diesem Thread schon..

bist du dir sicher dass der Comparator das macht? vielleicht waren sie schon vor dem Sortieren auf 0,
immer alles genau loggen, vor und nach dem Sortieren,
System.out.println() kann alles,

logge in den Methoden die ändern können, setPunkte() gibts grad nicht, aber refresh(),
ob und wie da Punkte verändert werden für welchen Player,

direkter Zugriff auf die Variable ist freilich nicht ganz so leicht zu kontrollieren,
prüfe deinen Code, gewöhne dir den Standard an, Variablen als 'private' zu deklarieren,
aber ganze Sicherheit gibts nicht, man muss schon nachvollziehen, was der eigene Code macht

 

[felix.schnee]

unmittelbar vor dem code sind die werte noch vorhanden und die anderen methoden funktionieren hab ich mehrfach überprüft...also ohne sort gehen auch alle Programmteile. es muss also an dem comperator liegen...doofes Programm :-( ich bin kurz vorm aufgeben

 

[Landei]

Dann ist jetzt der perfekte Zeitpunkt, um zu lernen, wie man einen Debugger benutzt (falls du eine ordentliche IDE benutzt und nicht diesen BlueJ-Mist oder so). Einfach einen Breakpoint vor die problematische Stelle setzen, den Code im Debug-Mode laufen lassen und sich anschauen, was in welcher Variable drinsteht. Da das von IDE zu IDE leicht unterschiedlich ist, musst du selbst schauen, wie das geht. Dann weitersteppen (normalerweise mit F7 für "tiefer, wenn möglich" und F8 für "in Methode bleiben") und schauen, was passiert. In deinem Fall den Breakpoint am besten in der ersten Zeile vom compare deines Comparators setzen, da siehst du erst mal, ob der überhaupt aufgerufen wird, bevor es kracht...

 

[SlaterB]

@felix.schnee
vielleicht tröstet dich dass ich dir, wenn du hier keine versteckte Kamera spielst, äußerst ungewöhnliche Fehler bestätige,
die ich schwer bis gar nicht in anderen Threads im Forum erinnere

mit deinem bisherigen Programm dazu zu testen lohnt nicht wirklich,
falls es noch weitergehen sollte poste eher neuen Code

verzichte dabei zunächst auf viele Teile deines Programmes, etwa das Menü, JOptionPane, Einlesen von Datei usw.,
schau dir mein Programm in Posting #4 an, verwende eine main-Methode die paar Player erstellt und dann sortiert,
außerdem deine Ausgaben

wenn in so einfachen Programm kein Fehler auftritt, dann hat das seine guten und schlechten Seiten,
Fehler noch nicht gefunden, aber immer schön, eine funktionierende Basis zu haben,
dann Schritt für Schritt einzelne Funktionen des ursprünglichen Programms wieder hineinnehmen, Lesen aus Datei etwa
und immer testen ob das Problem wiederkommt

 

[felix.schnee]

den debugger benutze ich gerade schon. so hab ich rausgefunden, dass es vor der comp klasse läuft ich werde mich mal in ner ruhigen minute hinsetzen und mir dazu gedanken machen vll finde ich den Fehler noch ansonsten bau ich mir das programm ganz einfach und nehme den erst stück für stück wieder rein. danke euch