Compiler findet Methode nicht

Was bitte soll denn daran einfacher sein wenn du einen Socket erzeugst der , dadurch das du ihm sein Zeil schon im Konstruktor mitgegeben hast , sowieso schon auto-connected ist und diese dann erst mit einer völlig aus der Luft gegriffenen Methode connecten musst ?
Das ist erstens umständlicher als es die Standard-API und zweitens wie sheel schon sagte : wenn ihr euch nach der Schule drauf verlasst das überall diese modifizierte Klasse vorhanden ist ... was nun mal nicht der Fall ist ... werdet ihr noch ernste Probleme bekommen.
 
Ja das stimmt schon, aber in der Klasse werden ein paar andere Dinge direkt mit initialisiert was es warscheinlich für manche einfacher machen soll. Kla ist das für später beschissen, aber zur Zeit muss ich es wohl so lernen, da ist sonst Probleme bei Arbeiten oder ähnliches bekomme.

Kennt einer ein gutes Tutorial für das Verbinden von Threads? Also das zwei Threads miteinander Kommunizieren können ?
 
Kannst du uns den Source dieses CustomSockets mal bitte posten ... ich möchte mal sehen ob dein Lehrer wirklich so intiligent war und dieser Klasse das selbe Package gegeben hat. Außerdem möchte ich mal wissen was darin so wichtiges mit-initialisiert wird ...

Außerdem : warum solltest du Probleme bei Arbeiten / Prüfungen bekommen ...
Ich würde einfach nur um dem Lehrer zu zeigen das er Mist gebaut hat mit voller absicht NUR die Standard-API verwenden ... und wenn ich dazu 500 Zeilen mehr schreiben müsste ...
 
Naja es geht ja um mein Abi xD Da muss ich ein wenig aufpassen ^^
Ja die Socket Klasse ist seeehr abgespeckt wie ich finde aber bittesehr.

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

/**
 * <b>Ein-/Ausgabe über Sockets</b>. <br />
 *  Ein Objekt der Klasse Socket kapselt eine Socket-Schnittstelle.
 *  Festlegung der Socket-Parameter kann nur bei der Objekt-Erzeugung
 *  vorgenommen werden.<br />
 *  <br />
 *  Das Socket-Objekt kann sich mit einem Server-Socket.
 *  Ob die Verbindungsanforderung erfolgreich war, kann durch den Rückgabewert
 *  der Methode {@link Socket#connect connect()} festgestellt werden (true, wenn
 *  die Verbindung akzeptiert wurde).<br />
 *  <br />
 *  Das Socket-Objekt gestattet im Zustand &quot;verbunden&quot; das Lesen bzw.
 *  Schreiben von einzelnen Bytes, Byte-Arrays oder Strings von der bzw. auf
 *  die Socket-Schnittstelle.<br />
 *  <br />
 *  Copyright 2006, Michael Zimmer<br />
 *  <br />
 *  @author   Michael Zimmer
 *  @version  1.1 (Mo, 13.03.2006, 17:42 MEZ)
 *  @see ServerSocket
 */
public class Socket {
  	/** Der Hosname des Servers. */
	private String hostname;
  	/** Der Port, auf dem der Server-Socket horcht. */
	private int port;
  	/** Der Socket. */
	private java.net.Socket socket;
    /** Ein BufferdReader zum Lesen von Strings */
	private BufferedReader reader;

	/** Konstruktor. <br />
	 *  <br />
	 *  Erzeugt einen neuen Socket mit der angegebenen Portnummer zu dem
	 *  angegebenen Host.
	 *  <br />
	 *  @param hostname der Hostname des Servers
	 *  @param port der Port, auf dem der Server horcht
     *  @throws IOException
	 */
	public Socket(String hostname, int port) throws IOException {
		this.hostname = hostname;
		this.port = port;
	}
	/** Konstruktor. <br />
	 *  <br />
	 *  Erzeugt einen neuen Socket mit der angegebenen Socket.
	 *  Wird vom ServerSocket benutzt.
	 *  <br />
	 *  @param socket der Socket, mit dem das Socket-Objekt arbeiten soll
     *  @throws IOException
	 */
	public Socket(java.net.Socket socket) throws IOException {
		this.socket = socket;
		this.port = socket.getPort();
		this.hostname = socket.getRemoteSocketAddress().toString();
		reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
	}
	/** Schließt den Socket.  <br />
	 *  Nach dem Schließen des Socket ist das Socket-Objekt
	 *  nicht mehr verbunden.<br />
     *  @throws IOException
	 */
	public void close() throws IOException {
		reader.close();
		socket.close();
	}
	/** Verbindet das Socket-Objekt zu der entsprechenden
	 *  Portnummer auf dem entsprechenden Host.  <br />
  	 *  <br />
	 *  Ging alles gut, ist das Socket-Objekt verbunden.
  	 *  <br />
  	 *  @return  true, wenn die Verbindung akzeptiert wurde
	 */
	public boolean connect() {
		try {
		  socket = new java.net.Socket(hostname, port);
		  reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		}
		catch (Exception e) {
			return false;
		}
		return true;
	}

//	--- Implementierung Leseoperationen ------------------------------

	/** Prüfen, ob Daten verfügbar sind. <br />
  	 *  <br />
  	 *  Liefert die Anzahl der Bytes, die vom Socket gelesen werden können,
	 *  ohne beim nächsten Aufruf von read() zu blockieren.<br />
  	 *  <br />
  	 *  @return Anzahl der verfügbaren Bytes
     *  @throws IOException
  	 */
	public int dataAvailable() throws IOException {
		return socket.getInputStream().available();
	}

  	/** Lesen eines Zeichens vom Socket. <br />
  	 *  <br />
  	 *  Das Zeichen wird als int im Bereich zwischen 0 bis 255 geliefert.
  	 *  Die Methode blockiert, bis Eingabe-Daten verfügbar sind.
  	 *  Im Fehlerfall liefert sie -1 oder erzeugt eine Ausnahme. <br />
  	 *  <br />
  	 *  @return Das gelesene Byte (0..255) oder -1
     *  @throws IOException
  	 */
	public int read() throws IOException {
		return socket.getInputStream().read();
	}
	/** Lesen von Bytes vom Socket. <br />
	 *  <br />
  	 *  Die Methode blockiert, bis Eingabe-Daten verfügbar sind.
  	 *  Im Fehlerfall liefert sie -1 oder erzeugt eine Ausnahme. <br />
	 *  <br />
	 *  @return Die Anzahl der gelesenen Bytes oder -1
	 *  @param b Der Buffer
	 *  @param len Maximale Anzahl der zu lesenden Bytes
	 */
	public int read(byte[] b, int len) throws IOException {
		return socket.getInputStream().read(b, 0, len);
	}
	/** Lesen eines Strings vom Socket. <br />
	 *  <br />
	 *  Die Methode liest eine Zeile, die durch ein Zeilenendezeichen
	 *  ('\n' linefeed) abgeschlossen sein muss. Der zurückgegebene
	 *  String enthält die Zeile ohne Zeilenendezeichen.
  	 *  Die Methode blockiert, bis Eingabe-Daten verfügbar sind.
  	 *  Im Fehlerfall liefert sie -1 oder erzeugt eine Ausnahme. <br />
	 *  <br />
	 *  <br />
	 *  @return Der String oder null
     *  @throws IOException
	 */
	public String readLine() throws IOException {
		return reader.readLine();
	}

	//	--- Implementierung Schreiboperationen ---------------------------

	/** Schreiben eines Zeichens auf den Socket. <br />
	 *  <br />
	 *  Diese Methode schreibt ein Byte (die niederwertigen 8 Bit des
	 *  Parameters b) auf den Socket.
	 *  <br />
	 *  @param b Das zu schreibende Byte (0..255)
	 */
	public void	write(int b) throws IOException {
		socket.getOutputStream().write(b);
	}
  	/** Schreiben von Bytes auf den Socket. <br />
	 *  <br />
	 *  Diese Methode schreibt mehrere Bytes auf den Socket.
	 *  <br />
	 *  @param b Der Buffer
	 *  @param len Maximale Anzahl der zu schreibenden Bytes
     *  @throws IOException
  	 */
	public void write(byte[] b, int len) throws IOException {
		socket.getOutputStream().write(b, 0, len);
	}
 	/** Schreiben eines String auf den Socket. <br />
	 *  <br />
	 *  Diese Methode schreibt einen String zeichenweise auf den Socket.
	 *  <br />
	 *  @param s Der String
     *  @throws IOException
  	 */
	public void write(String s) throws IOException {
		socket.getOutputStream().write(s.getBytes());
	}
}


Moment mal, mein Lehrer heißt aber nicht so wie der Autor xD
Ok dann hat mein Lehrer die Klasse wohl auch von wo anders ^^
 
Zuletzt bearbeitet:
Was bitte ist das denn für ein Mist ?
Mal davon abgesehen das du nicht in den Stream schreiben sondern nur davon lesen kannst sollte man diese Klasse wenigstens in ein Package stecken um einen FQDN zu haben damit es da keine Missverständnisse zum java.net.Socket gibt.
Und wenn es um dein Abi geht dann solltest du gerade von solchen Custom-Zeug abstand nehmen ...
 
Ganz oben war noch eine Zeile die hab ich vergessen zu Kopieren.
Java:
//package socketio;

Ja da es aber um mein Abi geht und wir in der Schule diese Klasse benutzen, muss ich sie wohl nehmen. ^^
 
Hmm .. wie gesagt : ich bleibe bei der Meinung das es nur schaded wenn man sich auf so einen totalen Schwachsinn einlässt ... aber naja ... wie du oder dein Lehrer darüber denken kann mir ja auch egal sein.

Ich gebe dir nur den guten Rat dich nicht weiter mit diesem Mist zu beschäftgen wenn es nicht explizit verlangt wird sondern alles nur mit Standard-API zu lösen ...

Du könntest aus Spass deinen Lehrer ja auch mal mit ner völlig anderen Lib wie den Apache-Commons ärgern um ihm mal zu zeigen : wenn wir schon Custom-Content nutzen ... dann bitte ORDENTLICHEN !


btw : wenn das Package auskommentiert ist hat es ja wenig Sinn ... deinen Lehrer möchte ich mal persönlich kennen lernen ...
 
Beim "Lehrer ärgern" kommt meist nur das raus, dass er einen aufm Kika hat und man im Grunde alles vergessen kann, bis hin zu den Noten/Punkten und da kommt man nich so raus mit "Ja, aber ...". Es gibt auch gute Lehrer, aber gerade wenn die Lehrer schon in der Industrie mal gearbeitet haben, dann hab ich die Erfahrung gemacht, dass die sehr pissig werden können, wenn einer sein eigenes Ding macht und sich absichtlich über den Lehrer hinweg setzt. Bei einem Kumpel von mir hat einer aus seiner Klasse die Ausbildung wegen sowas abgebrochen. Also das kann echt ungemütlich werden, wenn das son A-loch-Lehrer ist, das is dann kein Spaß mehr und vor allem wenn der dann noch im entsprechenden Prüfungsgremium sitzt...

Es ist definitiv ratsam auf eigene Faust für sich selbst was zu machen, damit man es auch richtig lernt, aber in der Schule lieber auf das hören, was der Lehrer sagt, egal wie schwachsinnig das sein mag.

EDIT:
Ich hab mir mal grad die Klasse angeschaut und ich muss auch sagen, dass die für Schüler definitiv die leichtere Variante ist. Das ist eine Klasse, die einfach drei Sachen vereint. Der Socket wird in der Klasse intern verarbeitet und genauso auch das Arbeiten mit den Streams. Man kann also bequem mit einem Objekt lesen und schreiben und muss sich das alles nicht irgendwie zusammenwurschteln und vor allem braucht man keinerlei Wissen zu Streams und Sockets. Also dumm ist die Klasse auf keinen Fall und für Schüler definitiv eine sehr gute Unterstützung.
 
Zuletzt bearbeitet:
Gut ... die Klasse ist aber an sich sehr schlecht implementiert.

1) Es fehlt ein eigenes Package , bzw das vom Original-Autor verwendete wurde auskommentiert.
2) Der Name ist mit dem der "Original" Klasse identisch was insbesondere bei explizitem Import der Klasse java.net.Socket zu Problemen führen kann *eigentlich sollte hier der Compiler schon meckern da er ja nicht differenzieren kann*.
3) Für die read-Operationen beim Erstellen des Sockets einen BufferedReader ... hier hätte man lieber den InputStream nehmen sollen um auch Byte-Operationen ausführen zu können.
4) OutputStream fehlt völlig und wird bei allen write-Operationen mit getOutputStream() neu erzeugt.

Also wie gesagt ... alleine davon das diese Klasse einem das arbeiten mit Sockets und Streams erschwert ist sie durch die oben genannten Fehler auch sehr schlecht implementiert. Ich sage ja auch nicht das man das nicht verwenden sollte weil es einem etwas Arbeit abnimmt ... sondern weil sie so gravierende Mängel und Fehler enthält ... und auch nur dazu führt das man sich falsches zur angewohnheit macht wie z.B. der Irrglaube das man von einem Socket dierekt lesen könnte.
Alles in allem stecken da schon eine Menge Konzept-Fehler vom Original-Autor drin ... die sein Lehrer übernommen und durch das auskommentieren des Packages teilweise noch verschlimmert hat.
 
Ich denke, noxum hat schon verstanden, was gemeint ist.
Es bringt doch keinem was, wenn man sich lang und breit über eine andere Klasse beschwert, auf die man sowieso keinen Einfluss hat, und ins OT rutscht.

Wenn noxum weitere Fragen hat, wird er sie schon stellen.
 
Zurück