Memo für Anfänger zum Erlernen von Java (5)

Fügen Sie einige Grundkenntnisse in Java hinzu.

1. Ausnahmen
Die Behandlung von Ausnahmen in Java ist die gleiche wie in Delphi. Es geht nicht darum, ihr Auftreten absichtlich zu vermeiden, sondern sie zu beheben, nachdem sie aufgetreten ist.
Die Ausnahmebehandlung von Delphi ist einfach folgende Anweisung

Try
Except//Wenn eine Ausnahme auftritt, wird sie hierher zur Ausführung übertragen
Finally//Unabhängig davon, ob die Ausnahme auftritt oder nicht, wird sie hierher zur Ausführung übertragen
Ende

Ähnlich wie hier ist die Grundform der Ausnahmebehandlung von Java wie folgt
try{
}catch(ExceptionType1 e){
file://Behandlung von Ausnahme 1
}catch(ExceptionType2 e) {
file://Behandlung von Ausnahme 2
throw(e)//Wirft eine Ausnahme aus, die dasselbe ist wie raise in Delphi
}

Zu hinzufügen Wenn Sie die meisten Ausnahmen explizit in einem normal laufenden Programm und nicht in einem Programm, das Ausnahmen abfängt, auslösen möchten, verlangt der Java-Compiler, dass Sie die Ausnahme, die Sie auslösen möchten, im Voraus deklarieren, andernfalls Es wird nicht zugelassen. Diese Aufgabe wird durch Würfe abgeschlossen.

2.1 Ausgabe
System.out.PRint file://Hier ist ein statische Methode
System.out.println
System.err.print file://err ist auch die Standardausgabe wie out Was den Unterschied betrifft, weiß ich noch nicht
System.err.println
2.2 Eingabe
System.in.read()
2.3 Dateioperationen
Nur ​​ein paar kommentierte Beispiele reichen aus.
Das erste ist ein Programm, das grundlegende Informationen zu Dateien anzeigt

import java.io.*;//IO-bezogene Klassen laden
class fileinfo{
file://note , Die Hauptfunktion muss eine statische Methode sein

public static void main(String args[])throws IOException{
File fileToCheck;//Erstelle eine Instanz mit dem Dateiobjekt
if (args.length> ;0) {
for (int i=0;ifileToCheck=new File(args[i]);//Speicherplatz für das Dateiobjekt zuweisen
info( fileToCheck);/ /Die Informationen, auf die hier verwiesen wird, müssen ein statisches Methodenmitglied sein
}
}
else{
System.out.println("keine Datei angegeben");
}
}

public static void info(File f)throws IOException{
System.out.println("Name:"+f.getName());
System.out.println(" Pfad:"+f .getPath());
if (f.exists()){
System.out.println("Datei existiert.");
System.out.print((f .canRead ()? ?"und ist beschreibbar:" "));
System.out.print(".");
System.out.println("File is"+f.length()+"bytes." );
}
else{
System.out.println("Datei existiert nicht.");
}
}
}

Das zweite Beispiel ist eine kleine Datei, die Telefoninformationen speichert. Beim Programm gibt der Benutzer den Namen und die Telefonnummer ein. Das Programm speichert sie in der Datei phone.numbers und implementiert sie über FileOutputStream

import java.io.*;

class phone{
static FileOutputStream fos;
public static final int lineLength=81;
public static void main(String args[])throws IOException{
byte[] phone=new byte[lineLength];
byte[] name=new byte[lineLength];
int i;
fos=new FileOutputStream("phone.numbers");
while(true){
System.err.println("Geben Sie einen Namen ein (geben Sie „done“ ein, um den Vorgang zu beenden)");
readLine(name);
if ("done".equalsIgnoreCase(new String(name,0,0, 4))){
break;
}
System.err.println("Geben Sie die Telefonnummer ein");
readLine(phone);
for (i=0;phone[ i]!=0;i++){
fos.write(phone[i]);
}
fos.write(′,′);
for (i=0;name[i ]!=0;i++){
fos.write(name[i]);
}
fos.write(′ ′);
}
fos.close();
}

private static void readLine(byte line[])throws IOException{
int i=0,b=0;
while((i<(lineLength-1))&&( (b=System.in.read()) !=′ ′)){
line[i++]=(byte)b;
}
line[i]=(byte)(0);
}
}

2.4 Streams
sind nichts weiter als zwei
Ausgabestreams, die wir schreiben können
Eingabestreams, die wir lesen können
Es gibt viele Arten von Eingabe- und Ausgabestreams im java.io-Paket
1.FileInputStream- und FileOutputStream-Knotenstreams
2.BufferedInputStream- und BufferedOutputStream-gefilterte Streams
3.DataInputStream- und DataOutputStream-erweiterte gefilterte Streams
4.PipedInputStream- und PipedOutputStream-Streams für Threads

Sobald Sie das Konzept von Streams verstanden haben, können Sie mit dem Erlernen von Sockets beginnen. Ich habe gestern bereits über die Rolle von Sockets gesprochen.

Jetzt erstellen wir ein einfaches Kommunikationsprogramm Grundlegendes Verständnis von Sockets. Das Programm besteht aus zwei Teilen: dem Client (RemoteFileClient) und dem Server (RemoteFileServer). und übergeben Sie die entsprechenden Dateiinformationen an den Client.

Zuerst erstellen wir die RemoteFileClient-Klasse:
import java.io.*;//Das java.io-Paket Bietet Tools zum Lesen und Schreiben von Streams und ist auch mit TCP kompatibel. Die einzige Möglichkeit, mit Sockets zu kommunizieren.
import java.net.*;//Das java.net-Paket bietet Socket-Funktionen.

public class RemoteFileClient {
protected String hostIp;
protected int hostPort;
protected BufferedReader socketReader;//Das Objekt, das für das Lesen von Daten verantwortlich ist
protected PrintWriter socketWriter;//Das Objekt, das für das Schreiben von Daten verantwortlich ist

Der Konstruktor der Klasse „file://“ hat zwei Parameter: die IP-Adresse von Der Remote-Host (hostIp) und die Portnummer (hostPort) weisen sie der Instanzvariablen
public RemoteFileClient(String aHostIp, int aHostPort) {
hostIp = aHostIp;
hostPort = aHostPort;}
public static void main(String[] args) {
}
file://Mit dem Remote-Server verbinden
public void setUpConnection() {
}
file: // to Der Remote-Server fordert Dateiinformationen an
public String getFile(String fileNameToGet) {
}
file://Disconnect from the remote server
public void TearDownConnection() {
}
}

Zuerst main() implementieren
public static void main(String[] args) {
RemoteFileClient remoteFileClient = new RemoteFileClient("127.0.0.1", 3000);//In der Reihenfolge Um das Debuggen zu erleichtern, behandeln wir den lokalen Server als Remote-Server
remoteFileClient.setUpConnection();//Connect. Sie können setUpConnection nicht direkt verwenden, da es sich um eine nicht statische Variable handelt. Sie können mein Tagebuch am ersten Tag lesen. Es ist sehr spezifisch. getFile("RemoteFile .txt");//Lesen

remoteFileClient.tearDownConnection();//Trennen

System.out.println(fileContents);//Gelesenen Inhalt ausgeben
}

Die Schritte sind sehr klar. Schauen wir uns dann an, wie Verbindung, Lesen und Trennen separat implementiert werden
public void setUpConnection() {
try {
Socket client = new Socket(hostIp, hostPort);//Socket-Objekt erstellen

OutputStream outToServerStream=client.getOutputStream();
InputStream inFromServerStream=client.getInputStream();
socketReader = new BufferedReader(new InputStreamReader(inFromServerStream));
file://Verpacken Sie den InputStream des Sockets in einen BufferedReader, damit wir die Zeilen des Streams lesen können

socketWriter = new PrintWriter(outToServerStream);
file:// Wrapping den OutputStream des Sockets in einen PrintWriter, damit wir Dateianfragen an den Server senden können

} Catch (UnknownHostException e) {
System.out.println("Fehler beim Einrichten der Socket-Verbindung: unbekannter Host bei " + hostIp + :: + hostPort);
file://Ausnahmebehandlung für Socket-Objekt-Erstellungsfehler
} Catch (IOException e) {
System.out.println("Fehlereinstellung up socket-Verbindung: " + e);
file://Ausnahmebehandlung für IO-Fehler
}
}

2. Read
public String getFile(String fileNameToGet) {
StringBuffer fileLines = new StringBuffer();//Das StringBuffer-Objekt ist ebenfalls ein String-Objekt, aber es ist flexibler als es. Hier wird es zum Speichern des gelesenen Inhalts verwendet

versuchen Sie es mit {
socketWriter .println(fileNameToGet);
socketWriter.flush();//Geben Sie die Dateispeicheradresse an den socketWriter aus, löschen Sie dann den Puffer und senden Sie diese Adresse an den Server

String line = null;
while ((line = socketReader.readLine()) != null)
fileLines.append(line + " ");
file://Da es an den Server gesendet wurde, müssen wir alle warten Das Programm wartet hier auf den von uns benötigten Dateiinhalt
} Catch (IOException e) {
System.out.println("Error reading from file: " + fileNameToGet);
}

return fileLines.toString();//Vergessen Sie nicht, den Inhalt im Puffer in String umzuwandeln und zurückzugeben
}

3.Disconnect
public void tearDownConnection() {
try {
socketWriter.close();
socketReader.close();
} Catch (IOException e) {
System.out.println("Fehler beim Herunterreißen socket-Verbindung: " + e);
}
}

Die Methode „tearDownConnection()“ schließt nur den BufferedReader und PrintWriter, den wir für den InputStream und OutputStream des Sockets erstellt haben. Dadurch wird der zugrunde liegende Stream geschlossen, den wir vom Socket erhalten, sodass wir mögliche IOException abfangen müssen

Okay, jetzt können wir die Schritte zum Erstellen des Client-Programms zusammenfassen
1 Verwenden Sie die IP der Maschine verbunden sein. Instanziieren Sie den Socket mit der Portnummer (lösen Sie eine Ausnahme aus, wenn ein Problem auftritt).
2. Holen Sie sich den Stream zum Lesen und Schreiben in eine Instanz von BufferedReader/PrintWriter Senden Sie die Dateiadressinformationen an den Server und lesen Sie die Dateiinformationen vom Server auf dem Reader
5. Schließen Sie den geöffneten Stream.

Das Folgende ist die Codeliste von RemoteFileClient

import java.io.*;
import java.net.*;

public class RemoteFileClient {
protected BufferedReader socketReader;
protected PrintWriter socketWriter;
protected String hostIp;
protected int hostPort;

public RemoteFileClient(String aHostIp, int aHostPort) {
hostIp = aHostIp;
hostPort = aHostPort;
}
public String getFile(String fileNameToGet) {
StringBuffer fileLines = new StringBuffer();

try {
socketWriter.println(fileNameToGet);
socketWriter.flush();

String line = null;
while ((line = socketReader.readLine()) != null)
fileLines.append(line + " ");
} Catch (IOException e) {
System.out.println("Fehler beim Lesen aus Datei: " + fileNameToGet);
}

return fileLines.toString();
}
public static void main(String[] args) {
RemoteFileClient remoteFileClient = new RemoteFileClient("127.0.0.1", 3000);
remoteFileClient.setUpConnection( );
String fileContents = remoteFileClient.getFile("RemoteFile.txt");
remoteFileClient.tearDownConnection();

System.out.println(fileContents);
}
public void setUpConnection() {
try {
Socket client = new Socket(hostIp, hostPort);

OutputStream outToServerStream=client.getOutputStream();
InputStream inFromServerStream=client.getInputStream( );
socketReader = new BufferedReader(new InputStreamReader(inFromServerStream));
socketWriter = new PrintWriter(outToServerStream);

} Catch (UnknownHostException e) {
System.out.println( „Fehler beim Einrichten der Socket-Verbindung: unbekannter Host bei „ + hostIp + :“ + hostPort);
} Catch (IOException e) {
System.out.println(“Fehler beim Einrichten der Socket-Verbindung: „ ​​+ e );
}
}
public void tearDownConnection() {
try {
socketWriter.close();
socketReader.close();
} Catch (IOException e ).怎么写.
创建RemoteClientServer类：
import java.io.*;
import java.net.*;

public class RemoteFileServer {
protected int listenPort = 3000;
public static void main(String[] args) {
}
public void AcceptConnections() {
}
public void handleConnection(Socket incomingConnection) {
}
}

跟客户机中一样，首先导入 java.net 的 java.io。接着,给我们的类一个实例变量以保存端口,我们从该端口侦听进入的连接.缺省情况下，端口Mehr als 3000.
acceptConnections()将答应客户机连接到服务器
handleConnection()负责与客户机 Socket 交互以将您所请求的文件的内容发送到客户机.

首先看main()

public static void main(String[] args) {
RemoteFileServer server = new RemoteFileServer();
server.acceptConnections();
}
非常简单, Die Funktion „AcceptConnection()“, „AcceptConnection()“ und „RemoteFileServer()“ wird verwendet.的实例,而不是直接调用.

那么服务器是怎样通过acceptConnection( )来监听客户机的连接呢？并且假如兼听到了，又怎样处理呢？我们来看
public void AcceptConnections() {
try Socket-Server = new ServerSocket(listenPort);/ /同客户机的Socket对应,在服务器端,我们需要ServerSocket对象,参数是兼听的端口号
Socket incomingConnection =. null;//创建一个客户端的Socket变量,以接收从客户端监听到的Socket
while (true) {
incomingConnection = server.accept();//调用该 ServerSocket 的 Accept() 来告诉它开始侦听,
handleConnection(incomingConnection);
}
file://不断监听直到来了一个连接请求,然后交由handleConnection处理
} Catch (BindException e) {
System.out.println("Unable to bind to port " + listenPort);
} Catch (IOException e) {
System.out.println("Unable to instanziate a ServerSocket on port: " + listenPort);
}
}

无论何时假如创建了一个无法绑定到指定端口（可能是因为别的什么控制了该端口）的 ServerSocket, Java 代码都将抛出一Sobald Sie die BindException-Funktion aktiviert haben, können Sie die BindException-Funktion verwenden Wenn Sie eine IOException haben, können Sie den ServerSocket-Server nicht erneut verwenden SoTimeout() ist die Funktion „accept()“. Verwenden Sie setSoTimeout() und akzeptieren Sie (), um eine IOException zu erhalten了客户端的Socket,要从该Socket中读取客户端的请求并且响应.

public void handleConnection(Socket incomingConnection) {
try {
OutputStream outputToSocket = incomingConnection.getOutputStream();
InputStream inputFromSocket = incomingConnection.getInputStream();

file://首先获取同Socket相关中outputToSocket和InputStream
file://其中outputToSocket是要返回给客户端Socket的流
file://InputStream是客户端发来Geben Sie die Datei „RemoteFile.txt“ ein将InputStream ist der Name von BufferedReader

FileReader fileReader = new FileReader(new File(streamReader.readLine()));
file://Lesen Sie den Dateipfad von BufferedReader und erstellen Sie ein neues Objekt FileReader

BufferedReader bufferedFileReader = new BufferedReader(fileReader) ;

file://erstellt das BufferedReader-Objekt erneut, dieses Mal liest es den Inhalt der Datei

PrintWriter streamWriter =
new PrintWriter(OutputStream);

file:// verpackt den OutputToSocket-Stream von Socket in PrintWriter, damit wir Dateiinformationen an den Client senden können

String line = null;
while ((line = bufferedFileReader.readLine()) != null ) {
streamWriter.println(line);
}
file://Dateiinformationen aus bufferedFileReader lesen und dann über streamWriter an den Client ausgeben

fileReader.close(); >streamWriter.close(); // Achten Sie auf die Reihenfolge, in der die beiden Streams von Socket geschlossen werden
streamReader.close();
Alle Streams schließen, nachdem file:// abgeschlossen ist

} Catch ( Exception e) {
System.out.println("Error processing a client: " + e);
}
}

Bitte achten Sie auf die Reihenfolge des Schließens Nach Abschluss aller Vorgänge wird der Stream von streamWriter geschlossen, bevor streamReader geschlossen wird. Dies ist kein Zufall. Wenn Sie den StreamReader schließen, erhalten Sie keine Dateiinformationen wird in streamWriter geschrieben, aber es können keine Daten durch den Kanal geleitet werden (der Kanal ist geschlossen). Muss ich nicht bereits im vorherigen streamWriter.println() ausgegeben werden? Geschlossen? Nur die Informationsausgabe an den Client ist möglich. Ich habe versucht,
streamWriter.close(); das Programm abzustürzen Nur durch normales Schließen des Kanals in einer bestimmten Reihenfolge kann die Übertragung der Kommunikationsdaten abgeschlossen werden, andernfalls erhält der Client die Informationen nicht

Abschließend fassen wir noch die Schritte zum Erstellen eines serverseitigen Programms zusammen
1. Instanziieren Sie einen ServerSocket mit einem Port, den er auf eingehende Clientverbindungen überwachen soll (z. B. 3000 im Programm) (lösen Sie eine Ausnahme aus, wenn ein Problem auftritt).
2. Rufen Sie „accept()“ von ServerSocket auf, um auf Verbindungen zu warten.
3. Holen Sie sich den Socket-Stream des Clients für Lese- und Schreibvorgänge.
5 Socket
6. Schließen Sie den offenen Stream (denken Sie daran, niemals den Reader zu schließen, bevor Sie den Writer schließen) und schließen Sie die Kommunikation ab

Das Folgende ist die Codeliste des
RemoteFileServer

Import java.io.* ;
import java.net.*;

public class RemoteFileServer {
int listenPort;
public RemoteFileServer(int aListenPort) {
listenPort = aListenPort;
}
public void AcceptConnections() {
try {
ServerSocket server = new ServerSocket(listenPort);
Socket incomingConnection = null;
while (true) {
incomingConnection = server.accept() ;
handleConnection(incomingConnection);
}
} Catch (BindException e) {
System.out.println("Unable to bind to port " + listenPort);
} Catch (IOException e) {
System.out.println("ServerSocket konnte nicht auf Port instanziiert werden: " + listenPort);
}
}
public void handleConnection(Socket incomingConnection) {
try {
OutputStream inputToSocket = incomingConnection.getOutputStream();
InputStream inputFromSocket = incomingConnection.getInputStream();

BufferedReader streamReader = new BufferedReader(new InputStreamReader(inputFromSocket));

FileReader fileReader = new FileReader(new File(streamReader.readLine()));

BufferedReader bufferedFileReader = new BufferedReader(fileReader);
PrintWriter streamWriter = new PrintWriter(outputToSocket);
String line = null ;
while ((line = bufferedFileReader.readLine()) != null) {
streamWriter.println(line);
}

fileReader.close() ;
streamWriter .close();
streamReader.close();
} Catch (Exception e) {
System.out.println("Fehler bei der Behandlung eines Clients: " + e);
}
}
public static void main(String[] args) {
RemoteFileServer server = new RemoteFileServer(3000);
server.acceptConnections();
}
}

Okay, ich fange endlich mit Socket an

Das Obige ist der Inhalt des Memos (5) für Anfänger, die Java lernen. Für weitere verwandte Inhalte achten Sie bitte auf PHP-Chinesisch Website (www.php.cn)!