Interface und erforderte static's

[Moch]

Hallo,
im Rahmen der Übungen haben wir kürzlich mit Interfaces angefangen und sogleich eine "Hausaufgabe" bekommen, die mir Kopfzerbrechen bereitet.
Um uns Schreibarbeit zu ersparen, sollen wir ein Package basteln, das einige - für uns wesentliche - Grundfunktionen abdeckt.
- Zufallszahlen (von 0 bis n(Int), von m bis n(Int) und das gleiche nochmal für Double)
- Usereingabe (einlesen eines Strings aus der Konsole)
- Stringvergleiche (Rückgabe eines Bool-Werts (wo auch immer hier die Schreibarbeit sein soll...))
- Erzeugen von Arrays (Int, Double, String mit der Länge i)

Alles schön und gut. Mein Interface mit zugehöriger Klasse ist mittlerweile fertig und alle Funktionen sind - wie gewünscht - funktionstüchtig. In der nächsten Aufgabe jedoch sollen wir ein Zahlenraten-Spiel so modifizieren, dass wir die bisher ausgeschriebenen Sache durch die Funktionen des Packages ersetzen sollen. Habe damit jetzt noch nicht angefangen, aber mir ist aufgefallen, dass das zu modifizierende Programm fast komplett für die main-Methode abläuft - wie die aussieht, ist ja gemeinhin bekannt.

Aber erfordert die main-Methode nicht grundsätzlich Variablen, die als static deklariert wurden?
Das wäre dann für mich ein Widerspruch, da ich gelernt habe, dass man Interfaces (logischerweise) nicht mit static Methoden bauen kann.
Wie umgehe ich das Problem möglichst geschickt?

mfg
Moch

 

[AmunRa]

In dem du ein Object der Klasse anlegst das das Interface implementiert.

Für genaue Fragen bitte einfach mal etwas Code posten

 

[XHelp]

Naja, das man aus der main-Methode nur auf den statischen Kontext zugreifen kann ist etwas eine andere Geschichte und bezieht sich eigentlich auf die selbe Klasse. Du kannst doch problemlos wie folgt machen:

class Test{
  public static void main(String[] args) {
    VonDirGebastelteHilfsklasse eingabe = new VonDirGebastelteHilfsklasse();
    ...
    String s = eingabe.leseIrgendwasEin();
    ...
  }
}

 

[Moch]

Okay, um es kurz zu halten, werde ich hier ein vereinfachtes Beispiel posten:

1. Das Interface:
[Java]
package user_fkt;

public interface Basis_Interface {
public int zufall_Integer(int n);
public int zufall_Integer(int n, int m);
public double zufall_Double(int n);
public double zufall_Double(int n, int m);
public String input();
public Boolean strBool(String s1, String s2);
public int[] l_Array_int (int i);
public String[] s_Array_int (int i);
public Double[] d_Array_int (int i);
}
[/Java]

2. zugehörige Klasse, erzeugt via Eclipse

package user_fkt;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Basis_fkt implements Basis_Interface {

	@Override
	public int zufall_Integer(int n) {
		int a = (int) (Math.random()*n);
		return a;
	}

	@Override
	public int zufall_Integer(int n, int m) {
		int a = (int) (Math.random()*n+m);
		return a;
	}

	@Override
	public double zufall_Double(int n) {
		n=n-1;
		double a = Math.random()*n;
		return a;
	}
	
	@Override
	public double zufall_Double(int n, int m) {
		n=n-1;
		double a = Math.random()*n+m;
		return a;
	}
	
	@Override
	public String input() {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s = null;
		try{ s = br.readLine();}
		catch(IOException ioe){
			System.out.println("ERROR: IO error trying to read inputstring");
			System.exit(1);
		}
		return s;
	}

	@Override
	public Boolean strBool(String s1, String s2) {
		if(s1.equals(s2)){
			return true;
		}else{return false;}
	}

	@Override
	public int[] l_Array_int(int i) {
		int []a = new int[i];
		return a;
	}

	@Override
	public String[] s_Array_int(int i) {
		String[] a = new String[i];
		return a;
	}

	@Override
	public Double[] d_Array_int(int i) {
		Double[] a = new Double[i];
		return a;
	}

}

3. Eine simulierte Anweisung. Ich bitte Schreibfehler zu entschuldigen, da ich das Kurz selbst geschrieben habe.

public class beispiel{
public static void main(String[] args){
System.out.println("Bitte Namen eingeben");
String s = user_fkt.Basis_fkt.input();
System.out.println("Hallo, " + s);
}
}

Das jetzt nur als sehr einfaches Beispiel, da ich hier ungerne zig Seiten Quelltext abschreiben und posten wollte. Macht erstens viel Aufwand und zweitens macht's das sehr unübersichtlich denke ich.

 

[jgh]

na ja, wie X-Help schon geschrieben hat...du musst erstmal eine Instanz deiner Klasse erzeugen und dann auf die Methoden zugreifen, wie gewünscht.
Dein Bsp. mal (mehr oder weniger) korrekt:

	public static void main(String[] args) {
		System.out.println("Bitte Namen eingeben");
		Basis_fkt basis_fkt = new Basis_fkt();

		String s = basis_fkt.input();
		System.out.println("Hallo, " + s);

	}

 

[Moch]

Oh, tschuldige XHelp, Deinen Beitrag habe ich übersehen :-(
Vielen Dank auf jeden Fall Euch beiden.

Wenn ich aber noch nachfragen darf: Welchen Effekt bewirkt denn diese Instaziierung?
Also, dass dadurch eine neue Instanz erstellt wird, ist selbst mir klar.
Was ich nur nich verstehe ist, warum ich hier "plötzlich" mit non-statics arbeiten kann/darf oder vorher nicht.

Hab' früher (in der Schule) schon mal den Fehler gemacht, etwas einfach als gegeben hinzunehmen -> hauptsache es lief irgendwie... erst im Studium habe ich dann auch teilweise verstanden warum oder was da lief und konnte das dementsprechend auch anders nutzen. Deshalb hinterfrage ich das, da ich vermutlich irgendwo im Teil über Instanzen nicht aufgepasst/zugehört habe, oder das nicht erklärt worden ist.

mfg und nochmals vielen Dank
Moch

 

[Gastredner]

Statische Methoden und Felder sind an die Klasse gebunden, nicht-statische an ihre Instanzen.
Will heißen: statische Methoden können verwendet bzw. auf statische Felder kann zugegriffen werden, ohne dass eine Instanz der Klasse angelegt werden muss. Daher verwendet man diese oftmals für Hilfsfunktionen, die aus den hineingegebenen Daten irgendetwas berechnen/erzeugen/was auch immer damit anstellen. Problematisch ist dies jedoch, wenn diese Methoden über mehrere Aufrufe hinweg einen persistenten Status benötigen, um ihre Funktion zu erfüllen. Diesen Status müsste man in statischen Feldern ablegen, die selbstverständlich auch durch andere Methoden manipuliert werden können. Das führt dann entweder zu hässlichem Code (für jede Methode eigene Felder) oder zu unerwarteten Fehlern (falscher Status beim Aufruf der Methode, da Status zwischendurch geändert).
Instanzen einer Klasse besitzen ihren eigenen Status bzw. kapseln ihren Zustand, sodass nur ihre eigenen Methoden darauf zugreifen können. Verschiedene Instanzen können verschiedene Zustände besitzen, ohne sich dabei in die Quere zu kommen. Nicht-statische Methoden haben dann nur Zugriff auf die Felder ihrer Instanz bzw. deren Methoden.

Ein Beispiel:

public enum TemperaturScale {

	/*
	 * Dieses enum repräsentiert nicht nur die verschiedenen Temperaturskalen,
	 * sondern übernimmt für uns auch die Konvertierung in und aus einer einheitlichen
	 * Skala, hier Kelvin. Damit erfolgt die Umrechnung.
	 */

	KELVIN {
		public float toKelvin(float degree) {
			return degree;
		}
		public float fromKelvin(float kelvin) {
			return kelvin;
		}
	},
	CELSIUS {
		public float toKelvin(float degree) {
			return degree + 273.15f;
		}
		public float fromKelvin(float kelvin) {
			return kelvin - 273.15f;
		}
	};

	public abstract float toKelvin(float degree);
	public abstract float fromKelvon(float kelvin);
}

public class StaticTemperaturConverter {

	public static TemperaturScale currentScale;

	public static float convert(float degree, TemperaturScale toScale) {
		return toScale.fromKelvin(currentScale.toKelvin(degree));
	}
}

public class TemperaturConverter {

	private TemperaturScale fromScale;
	private TemperaturScale toScale;

	public TemperaturConverter(TemperaturScale fromScale, TemperaturScale toScale) {
		this.fromScale = fromScale;
		this.toScale = toScale;
	}

	public float convert(float degree) {
		return toScale.fromKelvin(fromScale.toKelvin(degree));
	}
}

public class Test {

	public static void main(String[] args) {
		float kelvin = 23.753f;
		// Statisch - hätten wir die Initialisierung vergessen, gäbe es hier eine
		// NullPointerException. Wäre sie zwischendurch unbemerkt geändert worden,
		// dann gäbe es zwar keine Exception, aber die Konvertierung würde falsche
		// Werte zurückliefern!
		StaticTemperaturConverter.currentScale = TemperaturScale.KELVIN;
		float celsius = StaticTemperaturConverter.convert(kelvin, TemparaturScale.CELSIUS);
		// Nicht-statisch - benötigt ein Objekt und daher Speicher, bietet aber für
		// die Lebenszeit des Objekts eine garantiert gleichbleibende und unveränderbare
		// Konvertierung.
		TemperaturConverter fromKelvinToCelsius = new TemperaturConverter(TemperaturScale.KELVIN, TemperaturScale.CELSIUS);
		celsius = fromKelvinToCelsius.convert(kelvin);
	}
}

 

[Moch]

Ich bedanke mich vielmals für die Erklärung =)
Muss ich wohl in der Vorlesung nicht mitbekommen haben.

liebe Grüße
und nochmal vielen Dank an Alle!
Moch

 

[Crian]

Ich würde dir noch einen Blick auf die naming conventions empfehlen.

Außerdem sollten Methoden und Variablen möglichst sprechende (und aussprechbare) Namen haben.

Bist du sicher, dass die Zufallsmethoden, die double-Werte zurückgeben, die Grenzen als int bekommen sollen? Vielleicht möchte jemand Zufallswerte zwischen 0.4 und 0.7?