Variable..aber wohin?

[Loud Silence]

Hallo Comunity,

Ich habe eine Frage.(Wie das in Foren meistens so ist)
In einer Klasse habe ich ein JFrame, einen Button und ein TextField kreiert.
Nun möchte ich in einer separaten Klasse das System auf Knopfdruck auslesen lassen, was im TextField steht. Er kennt aber natürlich die Variable nicht mehr.
Wie kann ich diese dort hin "transportieren"?

 

[F.S.WhiTeY]

Indem du dich ein wenig mit OOP in java auseinander setzt.

JAVA: 5. Objektorientierte Programmierung (OOP)

 

[Loud Silence]

Aha soweit ich das jetzt verstanden habe muss ich extends benutzen.
Hätte man auch drauf kommen können.
Aber meine Klasse erbt schon von einer anderen.
Wie kann ich 2 Klassen an eine vererben?

 

[F.S.WhiTeY]

Du musst nicht vererben, du kannst auch Objekte erstellen. Das ist ja das Priziep der OBJEKT Orientierten Programmiersprachen.

Deine Berechnungen führst du in der Klasse mit den Swing-/AWT-Elemnten durch, indem du dir ein Objekt der anderen Klasse erstellst.


Ich sag ja: Lern OOP.

 

[Final_Striker]

Wie kann ich diese dort hin "transportieren"?

In dem du sie der Methode in der separaten Klasse per Parameter übergibst.

 

[jgh]

mal ein kurzes und knappes Bsp, wie man sowas machen könnte:

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextField;

public class DeineFrameKlasse {
	public static void main(String[] args) {
		new DeineFrameKlasse();
	}

	private JButton button;
	private JTextField textField;
	private JFrame frame;
	private DeineFrameKlasse dfk;

	public DeineFrameKlasse() {
		dfk = this;
		frame = new JFrame();
		frame.setSize(300, 300);
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		button = new JButton("System auslesen");
		button.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				new SystemAuslesenKlasse(dfk);

			}
		});
		frame.setLayout(new FlowLayout());
		frame.add(button);
		textField = new JTextField(10);
		frame.add(textField);
		frame.setVisible(true);
	}

	public JButton getButton() {
		return button;
	}

	public JTextField getTextField() {
		return textField;
	}
}

class SystemAuslesenKlasse {
	DeineFrameKlasse dfk;

	public SystemAuslesenKlasse(DeineFrameKlasse dfk) {
		this.dfk = dfk;
		System.out.println(dfk.getTextField().getText());
	}
}

 

[Loud Silence]

Danke das waren die Antworten die ich gebraucht habe.
:applaus:

 

[Loud Silence]

Mir ist soeben aufgefallen das besagte Lösung leider nicht funktioniert, da die zweite Klasseein Thread ist und Socket als Paramenter erwartet. Glaube ich zumindest...

Es hilft leider nichts:
Hier der Quellcode.


Klasse Kleiner Server

import java.net.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
 
public class KleinerServer{
    
    ServerSocket server = new ServerSocket( 1234);
    static Button b1;
    static String str;
    static PrintWriter p;
    static ServerThread st;
    static TextField tf;
    
KleinerServer() throws IOException {
     while(true) {
            Socket client = server.accept();
             st = new ServerThread(client);
           
        }   
}

public static void main (String [] args) 
{
    Frame f = new Frame();
    f.setLayout( new FlowLayout() );
    b1 = new Button("GetText");
     tf = new TextField();
    tf.setPreferredSize(new Dimension(80, 30));
    f.add(b1);
    f.add(tf);
    ActionListener al = new ActionListener() {
      public void actionPerformed( ActionEvent ae ) {
    	  st.start();
       
      }
    };
    
    b1.addActionListener( al );
    
f.pack();
f.setVisible(true);
 
try {
        @SuppressWarnings("unused")
        KleinerServer server = new KleinerServer();
    } catch (IOException e) {
        System.out.print(e);
    }
}
}

Klasse Server Thread

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
 
public class ServerThread extends Thread{
private Socket s;
public ServerThread(Socket client) {
this.s = client;
}
 
public void run(){

	
	
	try{
String str = "Hallo";
	BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
out.write(str);
out.write("Was geht´n");
out.newLine();
out.flush();

//out.close();
	} catch(IOException e){
	System.out.println("Fehler");
}
}
}

Ich will den Inhalt des TextFields tf rausschicken aber erst wenn auf den Button geklickt wird.
Bitte um Entschuldigung für die vergeudete Zeit der Antwortschreiber.

 

[Loud Silence]

Kann mir niemand helfen?

 

[Marcinek]

Du erstellst ein Button und einen ActionListener.

Wie das geht ist hier tausendfach im Forum beschrieben.

 

[Loud Silence]

Danke.
Aber ich glaube es ist unschwer zu erkennen, dass dies bereits geschehen ist.
Und meine Frage ist eine andere.
s. oben

 

[Michael...]

Kann mir niemand helfen?

Ist schwierig, da Dir noch einiges an Grundlagenkenntnis fehlt. Und wenn daraus ein Chat werden soll, musst Du Dich noch mit einigen Grundlagen auseinandersetzen.

Wie in dem anderen Thread bereits gesagt, müsstest Du Dich zunächst mal mit dem Thema Threads auseinandersetzen. Das Lesen und schreiben muss sowohl auf Serverseite als auch beim Clients in jeweils unabhängigen Threads laufen.
Um den Text eines Textfeldes auf Knopfdruck zu versenden, muss man eigentlich nur den Text auslesen und per z.B. println(...) auf den Ausgabestrom schreiben.
Dazu benötigt man aber das richtige Grundgerüst und das gibt Dein Code nicht her.

Durchlaufe doch mal Deinen Code gedanklich, dann wirst Du feststellen, dass das keinen Sinn macht.

Hier mal eine ganz simple Demo der Server kann nur mit einem Client gleichzeitig kommunizieren und antwortet nur mit dem was der Client gesendet hat. Über die Konsoleneingabe kann man über den Client Nachrichten an den Server schicken.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;


public class ClientServerDemo {
	private int port = 9999;
	
	public static void main(String[] s) {
		new ClientServerDemo();
	}
	
	public ClientServerDemo() {
		new Thread(new Runnable() {
			public void run() {
				new Server();
			}
		}).start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		new Client();
		System.out.println("ready for sending...");
		System.out.println("type message for server:");
	}
	
	class Server {
		private PrintWriter writer;
		public Server() {
			try {
				ServerSocket socket = new ServerSocket(port);
				while(true) {
					Socket client = socket.accept();
					new ClientReadingThread(client);
					writer = new PrintWriter(client.getOutputStream());
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		public void sendMessage(String msg) {
			if (writer!=null) {
				writer.println(msg);
				writer.flush();
			}
		}
		
		
		private class ClientReadingThread implements Runnable {
			private BufferedReader reader;
			
			public ClientReadingThread(Socket client) {
				try {
					reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
					new Thread(this).start();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			public void run() {
				try {
					String msg;
					while((msg=reader.readLine())!=null) {
						System.out.println("$$$ server received message from client $$$");
						System.out.println(msg);
						System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
						sendMessage("You wrote me: " + msg);
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	class Client {
		private PrintWriter writer;
		
		public Client() {
			try {
				Socket socket = new Socket("localhost", port);
				new ReceivingThread(socket);
				writer = new PrintWriter(socket.getOutputStream());
				
			} catch (UnknownHostException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		public void sendMessage(String msg) {
			if (writer!=null) {
				writer.println(msg);
				writer.flush();
			}
		}
		
		class ReceivingThread implements Runnable {
			private BufferedReader reader;
			
			public ReceivingThread(Socket client) {
				try {
					reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
					new Thread(this).start();
					new Thread(new Runnable() {
						public void run() {
							Scanner scanner = new Scanner(System.in);
							String msg;
							while(!(msg = scanner.nextLine()).equalsIgnoreCase("end")) {
								sendMessage(msg);
							}
							System.out.println("client cannot send anymore.");
						}
					}).start();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			public void run() {
				try {
					String msg;
					while((msg=reader.readLine())!=null) {
						System.out.println("*** client received message from server ***");
						System.out.println(msg);
						System.out.println("*******************************************");
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

 

[Loud Silence]

Schön.
Ich glaube dir zwar das an dem Code einiges falsch sein kann aber:
1. Ja aber man lernt immer dazu
2. Es wird kein Chat
3. Danke für die Lösung
4. Darum geht es überhaupt nicht
5. Wie bekomme ich die Variablen tf & b1 in die Klasse ServerThread?

 

[Michael...]

5. Wie bekomme ich die Variablen tf & b1 in die Klasse ServerThread?

Was spricht denn dagegen den Frame, das Textfeld und den Button in dieser Klasse zu erzeugen?

 

[Loud Silence]

Der Thread wird im Moment erst bei Knopfdruck gestartet. Knopfdruck = Schreiben
Der sollte also schon da sein.

 

[SleepProgger]

Ich habe das ganze mal ein wenig erweitert.
Das ganze muss natürlich jetzt noch in schön gebaut werden, aber vom Prinziep her sollte es das sein, oder ?

package kleinerserver;

import java.net.*;
import java.util.ArrayList;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
 
public class KleinerServer{
    
	/**
	 * Am besten noch ein wenig mit OOP beschaeftigen.
	 * Die ganzen Variablen muessten nicht static sein
	 */
    static ServerSocket server;
    static Button b1;
    static String str;
    static PrintWriter p;
    // Ich habe dies zu einer Liste geandert damit sich mehrere Client verbinden koennen
    static java.util.List<ServerThread> st;
    static TextField tf;
    
KleinerServer(){

}
 
	public static void main (String [] args) 
	{
	    Frame f = new Frame();
	    f.setLayout( new FlowLayout() );
	    b1 = new Button("GetText");
	     tf = new TextField();
	    tf.setPreferredSize(new Dimension(80, 30));
	    f.add(b1);
	    f.add(tf);
	    
	    st = new ArrayList<ServerThread>();
	    
	    // Hier werden die ClientAnfragen angenommen, muss natürlich in eine eigene Klasse ;)
		try {
			server = new ServerSocket( 1234);
			// Thread zum lauschen auf Verbindungen
			Thread thread = new Thread(new Runnable() {
				@Override
				public void run() {
					Socket newClient;
					ServerThread newServerThread;
					// ACHTUNG momentan noch Endlosschleife, sollte man aendern ;)
					while(true){
						try {
							newClient = server.accept();
							newServerThread = new ServerThread(newClient);
							newServerThread.start();
							st.add(newServerThread);
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					// Wenn keine Endlosschleife mehr kann und sollte dies hier aufgerufen werden ;)
					//server.close();
				}
			});
			thread.start();
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		
	    ActionListener al = new ActionListener() {
	      public void actionPerformed( ActionEvent ae ) {
	    	  // Sende Nachricht an alle angemeldeteten Clients
	    	  for (ServerThread connection : st) {				
	    		  if(connection.sendMessage(tf.getText())){
	    			  System.out.println("Message send ok");
	    		  }else{
	    			  System.out.println("Message send failure");
	    		  }
	    	  }
	          
	      }
	    };
	    
	    b1.addActionListener( al );
	    
		f.pack();
		f.setVisible(true);
	}
}

Server:

package kleinerserver;

import java.io.*;
import java.net.*;
import java.util.Queue;
 
public class ServerThread extends Thread{
	private Socket s;
	boolean run;
	
	public ServerThread(Socket client) {
		this.s = client;
		run = false;
	}
 
	public synchronized boolean sendMessage(String message){
		try{
			BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
			out.write(message);
			out.newLine();
			out.flush();
			return true;
		} catch(IOException e){
			// TODO um Exception kuemmern, werfen ?
			System.out.println("Fehler");
			return false;
		}
	}
	public synchronized void shutdown(){
		run = false;
	}


	public void run(){
		try {
			BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));
			run = true;
		
			while (!interrupted() && run) {
				/**
				 * Hier wuerde gelesen werden
				 * in etwa:
				 * 
				 * char[] buffer = new char[1024];
				 * int bytesRead = in.read(buffer);
				 * System.out.println(new String(buffer, 0, bytesRead));
				 * 
				 */
			}
		} catch (IOException e1) {
			run = false;
			/**
			 * TODO Um Exception kuemmern
			 */
			e1.printStackTrace();
		}
		finally{
			try {
				s.close();
			} catch (IOException e) {
				//TODO um Exception kuemmern
				e.printStackTrace();
			}
		}
	}
}

 

[Loud Silence]

Das ist wirklich mehr als ich erwartet hätte.
Tolle Arbeit! :toll:
Aber des Rätsels Lösung vom Anfang war diese Code Zeile:

out.write(KleinerServer.tf.getText());

Danke für eure große Mühe.
Auch einem Banausen wie mir kann man was lehren. :rtfm: