Warum muss ich static?

[osion]

Hallo also ich habe einen Aufruf einer anderen Klasse mit einem return (List <string>). Eclipse will das ich die static mache, aber warum? Die andere Variabel ist jaa auch nicht static.

Ist es weil die Methode von der Main aufgerufen wird?

Als Begründung: Cannot make a static reference to the non-static field wortUndBedeutung

Code:

Um diese List geht es:

static List<String> wortUndBedeutung= new ArrayList<String>();

Von hier wird die Klasse mit dem Return aufgerufen:

package analyse;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

import antworten.Smaltalk;

import dateien.DateiImport;
import empfindenBenutzer.Interesse;

public class EingabeAnalysieren {
	String eingabeScannerBenutzerGespeichert;
	static List<String> wortUndBedeutung= new ArrayList<String>();
	
	// eingabeAnalysieren Constructor

	// }

	public static void ListeEinlesen(String eingabeScannerBenutzerGespeichert) {
		
		DateiImport alleTexteEinlesen1 = new DateiImport();
		alleTexteEinlesen1.dateienEinlesen();
		

			
			SatzSplittern satzEinzelteileAnalysieren=new SatzSplittern();
			wortUndBedeutung=satzEinzelteileAnalysieren.wortZählen(eingabeScannerBenutzerGespeichert);
			SinnBilden satzZusammenfügen=new SinnBilden();
		//	satzZusammenfügen.satzteileZusammenfügen(wortUndBedeutung);
	}
	
}

Hier wird der Return erzeugt

package analyse;

import java.util.ArrayList;
import java.util.List;
import dateien.DateiImport;

public class SatzSplittern {

	private static String[] AlleListenZusammenGesplittert2 = new String[4];
	private static Integer[] AlleListenZusammenGesplittert2_0 = new Integer[1];
	int b;
	boolean pruefen = false;
	int i;
	List<String> wortUndBedeutung= new ArrayList<String>();

	public List<String> wortZählen(String eingabeScannerBenutzerGespeichert) {
		DateiImport alleTexteEinlesen1 = new DateiImport();
		alleTexteEinlesen1.dateienEinlesen();
		String[] eingabeScannerBenutzerGespeichertGesplittert = eingabeScannerBenutzerGespeichert
				.split(" ");

		while (eingabeScannerBenutzerGespeichertGesplittert.length > i)

		{
			for (int a = 0; (alleTexteEinlesen1.getAlleListenZusammen().size() - 1) > a; a++) {

				String[] AlleListenZusammenGesplittert = alleTexteEinlesen1
						.getAlleListenZusammen().get(a).split(";");

				if (eingabeScannerBenutzerGespeichertGesplittert[i].startsWith(AlleListenZusammenGesplittert[0])) {
					a = alleTexteEinlesen1.getAlleListenZusammen().size() + 2;
					wortUndBedeutung.add(AlleListenZusammenGesplittert[0]);
					wortUndBedeutung.add(AlleListenZusammenGesplittert[3]);
				}

			}
			i++;
		}
return wortUndBedeutung;
	}
}

gruss
Zelda :lol:

 

[Timothy Truckle]

Die Methode, in der Du die Referenz verwendest

public static void ListeEinlesen(String eingabeScannerBenutzerGespeichert) {

ist static, deshalb.

bye
TT

 

[osion]

Die Methode, in der Du die Referenz verwendestist static, deshalb.

bye
TT

Und dass mus Static sein, weil es was bekommt von Main was auch static ist?
Kann ich eine Methode auch wieder schliessen?

 

[Murray]

Was meinst du mit "eine Methode schliessen"? Das return-Statement beendet eine Methode ziemlich zuverlässig; wenn die Methode als void deklariert ist, dann reicht es auch, beim letzten Statement in der Methode angekommen zu sein.

Aus der main-Methode (die ja zwingend "static" sein muss), kann man entweder andere statische Methoden aufrufen, oder (und das ist der normalerweise präferierte Weg) man erzeugt eine Instanz und ruft an der die Methoden auf.

Beispiel 1 (alles statisch):

public class S1 {
	public static void main( final String ... args) {
		
		System.out.println( f2( "xyz"));
	}
	
	public static String f1() {
		return "test";
	}
	
	public static String f2( final String s) {
		return s + f1();
	}

}

Beispiel 2 (i.d.R. besser):

public class S1 {
	public static void main( final String ... args) {
		
		S1 s1 = new S1(); //--- hier wird eine Instanz der Klasse S1 erzeugt, an der 
		                  //--- man dann auch Methoden aufrufen kann, die nicht explizit 
		                  //--- als static deklariert worden sind
		System.out.println( s1.f2( "xyz"));
	}
	
	public String f1() {
		return "test";
	}
	
	public String f2( final String s) {
		return s + f1();
	}

}

 

[osion]

Was meinst du mit "eine Methode schliessen"? Das return-Statement beendet eine Methode ziemlich zuverlässig; wenn die Methode als void deklariert ist, dann reicht es auch, beim letzten Statement in der Methode angekommen zu sein.

Weiss nicht...so ne static methode bleibt ja bis zum Programmende am laufen ^^ wurde mir gesagt ...

Die Methode die Static sein muss, ist die einzige Methode die von der Main aufgerufen wird.

package freundin;


import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

import dateien.DateiImport;


import analyse.EingabeAnalysieren;


public class Grund{

	/**
	 * @param args
	 */
	public static void main(String[] args) {

			
			String eingabeBenutzerGespeichert = null;

			Scanner eingabeBenutzer =new Scanner(System.in);
			EingabeAnalysieren eingabeAnalysieren1=new EingabeAnalysieren();
		
		while(eingabeBenutzerGespeichert!="Exit")
		{
			
			System.out.println("Eingabe Bitte");

			eingabeBenutzerGespeichert=eingabeBenutzer.nextLine().toLowerCase();
			System.out.println(eingabeBenutzerGespeichert);
			EingabeAnalysieren.ListeEinlesen(eingabeBenutzerGespeichert);

			
		}
			
		System.out.println("Programm wird beendet!");
	}
}

 

[Murray]

Weiss nicht...so ne static methode bleibt ja bis zum Programmende am laufen ^^ wurde mir gesagt ...

Das ist - mit Verlaub gesagt - Quatsch. Auch statische Methoden enden, wenn entweder ein return-Staement erreicht wurde, eine nicht abgefangene Exception aufgetreten ist oder (bei void-Methoden) schlichtweg die letzte Anweisung ausgeführt worden ist.

 

[Noctarius]

Bei "normalen" Anfängerprogrammen (ohne Threading) ist diese Aussage für die main-Methode schon richtig um es einfach zu halten, nicht aber für alle statischen Methoden. Generell hat Murray recht, dass auch die main-Methode nicht bis zum Programmende überlebt.