Angewandte Netzwerktechnik kompakt

Material zum Buch

Lösungsvorschläge zu Übungsaufgaben

Das ZIP-Archiv beinhaltet Lösungsvorschläge zu den Übungsaufgaben im Buch in Form von Java-Quellcodes und Wireshark-Aufzeichnungen.

Im Folgenden finden Sie zudem eine Vorschau, der enthalteten Quellcodes:

Kapitel 2 Kapitel 3 Kapitel 5 Kapitel 7 Kapitel 8

















Vorschau der Java-Klassen in den Lösungsvorschlägen

Loes_Aufg_2_1.java

 // Ermittlung des Mittelwertes ueber alle Noten aller Studenten
	double mittelwert (Student[] studenten) {
			
		double summe=0;
		int count=0;
		
		for(int i=0; i < studenten.length; i++) { // Schleife ueber die Anzahl der eingetragenen Studenten
			if(studenten[i].leistungen != null) { // falls mindestens eine Pruefungsleistung eingetragen, dann...
				for (int j=0; j < studenten[i].leistungen.length; j++) {
                // ...Schleife ueber die Anzahl der eingetragenen Pruefungsleistungen des jeweiligen Studenten
						summe=summe+studenten[i].leistungen[j].note; // Noten aufsummieren
						count++; // count = Anzahl der aufsummierten Noten
						}
				}
			}
			
		if (count > 0)				// Wenn mindestens eine Note, dann...
			return (summe/count);	// ...Rueckgabe des arithm. Mittelwertes
		else return 0;				// ansonsten wird 0 zurueckgegeben
	}

Loes_Aufg_2_2.java

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class Loes_Aufg_2_2 {

	public static void main(String[] args) throws IOException {

		String dateiname = "UTF-8-demo.txt";
		File f = new File( dateiname );
		InputStream in;
		in = new FileInputStream( f );
		int by;

		while( (by=in.read()) != -1 )   // naechstes einzelne Byte lesen
		{
			System.out.println(by + " = " + (char)by);  // als Code und ASCII-Zeichen (der Wert von by ist hier ein 8-Bit-Wert)
		}

		in.close();
	}
}

Loes_Aufg_2_3a.java

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Loes_Aufg_2_3a {

	public static void main(String[] args) throws IOException {

		FileInputStream fis = null;
		InputStreamReader isr = null;
		try {
			fis = new FileInputStream("UTF8-demo.txt");
			isr = new InputStreamReader(fis, "UTF8");
			int ch;
            while ((ch = isr.read()) != -1) {   // einzelnes Zeichen lesen
				System.out.print((char)ch);
			}
		} finally {
			if (fis != null) {
				fis.close();
			}
			if (isr != null) {
				isr.close();
			}
		}
	}
}

Loes_Aufg_2_3b.java

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

public class Loes_Aufg_2_3b {

	public static void main(String[] args) throws IOException {
		
		FileInputStream fis = null;
		InputStreamReader isr = null;
		BufferedReader bufRed = null;
		try {
			fis = new FileInputStream("UTF8-demo.txt");
			isr = new InputStreamReader(fis, "UTF8");
			bufRed = new BufferedReader(isr);
			String line;
			while ((line = bufRed.readLine()) != null) {   //naechste Zeile lesen
				System.out.println(line);
			}
		} finally {
			if (fis != null) {
				fis.close();
			}
			if (isr != null) {
				isr.close();
			}
			if (bufRed != null) {
				bufRed.close();
			}
		}	
	}
}

Loes_Aufg_2_4.java

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Loes_Aufg_2_4 {

	String dateiName;
	
	Loes_Aufg_2_4(String dateiName)
	{
		this.dateiName = dateiName;
	}
	
	public Student[] leseDatei() throws IOException {
		Student[] geleseneStudenten;

		FileInputStream fis = new FileInputStream(dateiName);
		DataInputStream dis = new DataInputStream(fis);

		int studCnt = dis.readInt();	// Lesen der Zahl der Datensaetze (1. Zeile in der Datei)
		// Falls Datensaetze in Datei vorhanden, diese auslesen und in Feld ablegen
		if(studCnt != 0)			
		{
			geleseneStudenten = new Student[studCnt];
			for(int i=0; i < studCnt; i++) {
				geleseneStudenten[i] = new Student();
				geleseneStudenten[i].matrikelNummer = dis.readInt();
				geleseneStudenten[i].name = dis.readUTF();
				int leistCnt = dis.readInt();
				// Falls auch Pruefungsleistungen hinterlegt sind, diese ebenso auslesen und ablegen
				if(leistCnt != 0) {
					geleseneStudenten[i].leistungen = new Leistung[leistCnt];
					for(int j=0; j < leistCnt; j++) {
						geleseneStudenten[i].leistungen[j] = new Leistung();
						geleseneStudenten[i].leistungen[j].modul = dis.readUTF();
						geleseneStudenten[i].leistungen[j].note = dis.readDouble();
					}
				}
				else
					geleseneStudenten[i].leistungen = null;	
			}
		}
		else
			geleseneStudenten = null;

		dis.close();	// Schliessen der Streams
		fis.close();
		return geleseneStudenten;	// Rueckgabe des Feldes mit den Studentendaten
	}
}

Loes_Aufg_2_5.java

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class Loes_Aufg_2_5 {
    static final String [] vornamen = { "Mia","Ben","Emma","Jonas","Hannah","Leon","Sofia","Finn","Anna","Elias"};
    static final String [] nachnamen = {"Bauer","Becker","Fischer","Fuchs","Hartmann","Lang", "Jung","Hofmann","Huber"};
    static final String [] module = {"Analysis A","Lineare Algebra A","Analysis B","Lineare Algebra B","Numerik A",
    "Stochastik A","Stochastik B","Numerik partieller Differentialgleichungen 1","Numerik partieller Differentialgleichungen 2",
    "Baumechanik I (Statik starrer Koerper)","Baumechanik II (Elastomechanik)","Baumechanik III (Kinematik und Kinetik)",
    "Kontinuumsmechanik I","Modellbildung im Ingenieurwesen","Numerische Mechanik","Festkoerpermechanik","Finite Elemente II",
    "Grundlagen der Elektrotechnik","Umweltbiologie und -chemie","Stroemungsmechanik","Thermodynamik im Ueberblick",
    "Datenstrukturen, Algorithmen und Programmierung","Datenbanksysteme im Ingenieurwesen","Graphen und Netze","Baustoffkunde I",
    "Baustoffkunde II","Ausgleichungsrechnung und Statistik I","Ausgleichungsrechnung und Statistik II",
    "Projekte des Ingenieurwesens" };

	public void schreibeDemodaten(String dateiName, Student[] studenten) throws IOException {
		FileOutputStream fos = new FileOutputStream(dateiName);
		OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF8");	
		
		String toWrite;
		
		if(studenten != null) {
			// zu schreibenden Text aus einzelnen Elementen zusammensetzen
			toWrite = String.format("%d",studenten.length );
			// Elemente mit ; und Leerzeichen trennen
			toWrite += "; ";
			// Text als Zeile schreiben
			toWrite += "\n";
			osw.write(toWrite);
	
			for(int i=0; i < studenten.length; i++) {
				// neuen Text beginnen
				toWrite = String.format("%d; %s; ",
						studenten[i].matrikelNummer,
						studenten[i].name);
				if(studenten[i].leistungen != null) {
					// Text ergaenzen
					toWrite += String.format("%d; ",studenten[i].leistungen.length);

					for(int j=0; j < studenten[i].leistungen.length; j++) {
						toWrite += String.format("%s; %3.1f; ",
								studenten[i].leistungen[j].modul,
								studenten[i].leistungen[j].note);
					}
				}
				else
					toWrite += "0; ";
				// Text / Datensatz eines Studenten als Zeile ausgeben
				toWrite += "\n";
				osw.write(toWrite);
			}
		}
		else
		{
			toWrite = "0; \n";
			osw.write(toWrite);
		}
		osw.close();
		fos.close();
	}	
	
	public Student[] erzeugeDemodaten(int Zahl)
	{
		Student[] studentendaten = new Student[Zahl];
		
		for(int i=0; i= 1) {
				studentendaten[i].leistungen = new Leistung[notenZahl];
				for(int j=0; j < notenZahl; j++) {
					int mod_indx = (int)(Math.random()*module.length);
					studentendaten[i].leistungen[j] = new Leistung();
					studentendaten[i].leistungen[j].modul = module[mod_indx];
					studentendaten[i].leistungen[j].note = (int)(Math.random()*5) + 1;
				}
			}
			else
				studentendaten[i].leistungen = null;
		}
		return studentendaten;
	}
}

Loes_Aufg_3_1.java

class Person {
	String name;
	int alter;
	Kind [] kinder;				
}

class Kind {
	String name;
	int alter;
}

Loes_Aufg_5_1.java

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

import org.apache.http.HttpEntity;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class Loes_Aufg_5_1 {

	public static void main(String[] args) throws ClientProtocolException, IOException {
				
		CloseableHttpClient httpClient = HttpClients.createDefault();
		
		HttpGet httpGet = new HttpGet ("http://angewnwt.hof-university.de/example-1.php");
		CloseableHttpResponse response = httpClient.execute(httpGet);
		System.out.println(response.getStatusLine());
		HttpEntity entity = response.getEntity();
		InputStream netzwerkStream = entity.getContent();
		InputStreamReader netzwerkStreamReader = new InputStreamReader (netzwerkStream);
		
		BufferedReader bufNeRd = new BufferedReader (netzwerkStreamReader);
		
		String geleseneZeile;
		String such = "/article";	// gesuchter String
		while ((geleseneZeile = bufNeRd.readLine()) != null)
		{
			System.out.println(geleseneZeile); // empfangenen Text zeilenweise ausgeben
			int index = geleseneZeile.indexOf(such,0); // Zufallszahl befindet sich vor dem Tag < /article >
			
			if (index > -1)	// gesuchter String gefunden
				System.out.println("Die extrahierte Zufallszahl lautet: "+ geleseneZeile.substring(0, index-1));
                //index-1 schliesst die oeffnende spitze Klammer vor dem gesuchten Tag aus
		}
		
		EntityUtils.consume(entity);
		response.close();
	}
}

Loes_Aufg_5_2a.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URISyntaxException;

import org.apache.http.HttpEntity;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class Loes_Aufg_5_2a {

	public static void main(String[] args) throws ClientProtocolException, IOException, URISyntaxException {

				String URLstr = "http://angewnwt.hof-university.de/example-4.php";
		
				CloseableHttpClient httpclient = HttpClients.createDefault();
				
				HttpGet httpGet = new HttpGet(URLstr);
				CloseableHttpResponse response = httpclient.execute(httpGet);
				System.out.println(response.getStatusLine()); // --> HTTP/1.1 200 OK
				
				response = httpclient.execute(httpGet);
				HttpEntity entity = response.getEntity();
				InputStream httpStream  = entity.getContent();
				InputStreamReader httpStreamReader = new InputStreamReader(httpStream);
				BufferedReader httpBufferedReader = new BufferedReader(httpStreamReader);
						
				// empfangenen Text zeilenweise ausgeben
				String httpLine;
				while((httpLine = httpBufferedReader.readLine()) != null) {
					System.out.println(httpLine);
				}
				
				// Schliessen der Verbindung
				EntityUtils.consume(entity);
				response.close();
				httpBufferedReader.close();	
	}
}

Loes_Aufg_5_2b.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

public class Loes_Aufg_5_2b {

	public static void main(String[] args) throws ClientProtocolException, IOException, URISyntaxException {

				String URLstr = "http://angewnwt.hof-university.de/example-4.php";
		
				CloseableHttpClient httpclient = HttpClients.createDefault();
				
				// URIBuilder
				URIBuilder uri = new URIBuilder(URLstr);
				List  nvps = new ArrayList ();
			    nvps.add(new BasicNameValuePair("username", "Hans"));
			    nvps.add(new BasicNameValuePair("password", "Wurscht"));
			    uri.addParameters(nvps);
			    
				HttpGet httpGet = new HttpGet(uri.build());
				
				CloseableHttpResponse response = httpclient.execute(httpGet);
				HttpEntity entity = response.getEntity();
				InputStream httpStream  = entity.getContent();
				InputStreamReader httpStreamReader = new InputStreamReader(httpStream);
				BufferedReader httpBufferedReader = new BufferedReader(httpStreamReader);
						
				System.out.println(response.getStatusLine()); // --> HTTP/1.1 200 OK				
				
				// empfangenen Text zeilenweise ausgeben
				String httpLine;
				while((httpLine = httpBufferedReader.readLine()) != null) {
					System.out.println(httpLine);
				}
				
				// Schliessen der Verbindung
				EntityUtils.consume(entity);
				response.close();
				httpBufferedReader.close();	
	}
}

Loes_Aufg_5_3.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

public class Loes_Aufg_5_3 {

	public static void main(String[] args) throws ClientProtocolException, IOException {

				// URL, der die Authentifizierungsdaten uebergeben werden muessen
				String URLstr = "http://angewnwt.hof-university.de/login.php";
				
				// Mit POST nur Authentifizieren OHNE Abrufen der Webseite
		
				CloseableHttpClient httpclient = HttpClients.createDefault();
				CloseableHttpResponse response;
				 
				HttpPost httpPost = new HttpPost(URLstr);
				List  nvps = new ArrayList ();
			    nvps.add(new BasicNameValuePair("username", "Hans"));
			    nvps.add(new BasicNameValuePair("password", "Wurscht"));
			    nvps.add(new BasicNameValuePair("submit", "anmelden"));
			    httpPost.setEntity(new UrlEncodedFormEntity(nvps));
			    response = httpclient.execute(httpPost);
			    System.out.println(response.getStatusLine()); // --> HTTP/1.1 200 OK
			    
			    // Mit GET jetzt Webseite abrufen (nun keine Authentifizierung mehr noetig, da vorher schon geschehen)
						
				HttpGet httpGet = new HttpGet(URLstr);
				response = httpclient.execute(httpGet);
				System.out.println(response.getStatusLine()); // --> HTTP/1.1 200 OK
				HttpEntity entity = response.getEntity();
				InputStream httpStream  = entity.getContent();
				InputStreamReader httpStreamReader = new InputStreamReader(httpStream);
			    BufferedReader httpBufferedReader = new BufferedReader(httpStreamReader);
						
				// empfangenen Text zeilenweise ausgeben
			    String httpLine;
				while((httpLine = httpBufferedReader.readLine()) != null) {
					System.out.println(httpLine);
				}
			    
				// Schliessen der Verbindung
				EntityUtils.consume(entity);
				response.close();
				httpBufferedReader.close();    
	}
}

Loes_Aufg_7_1Client.java

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class Loes_Aufg_7_1Client {

	Socket linkZumServer;
	DataInputStream inFromServer;
	DataOutputStream outToServer;

	public Loes_Aufg_7_1Client(InetAddress address, int port) throws IOException {

		linkZumServer = new Socket(address,port); // mit Server verbinden
		System.out.println("Verbindung hergestellt");

		inFromServer = new DataInputStream(linkZumServer.getInputStream());

		outToServer = new DataOutputStream(linkZumServer.getOutputStream());
	}

	public void tuWas() throws IOException {

		InputStreamReader tastatur = new InputStreamReader(System.in);
		BufferedReader bufferedtastatur = new BufferedReader(tastatur);
		System.out.print("Zeichenkette eingeben: ");

		String eingabe = bufferedtastatur.readLine();

		outToServer.writeUTF(eingabe); // neuer String an Server

		String ausgabe = inFromServer.readUTF(); //String vom Server empfangen

		System.out.println("Zeichenkette empfangen: " + ausgabe);
	}

	public void disconnect() throws IOException {

		inFromServer.close();
		outToServer.close();
		linkZumServer.close();
	}

	public static void main(String[] args) throws UnknownHostException, IOException {

		Loes_Aufg_7_1Client meinClient = new Loes_Aufg_7_1Client(InetAddress.getByName("127.0.0.1"),4711);

		meinClient.tuWas();
		meinClient.disconnect();
	}
}

Loes_Aufg_7_1Server.java

import java.io.IOException;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Loes_Aufg_7_1Server {

	ServerSocket serverSocket;
	Socket linkZumClient;
	DataInputStream inFromClient;
	DataOutputStream outToClient;

	public Loes_Aufg_7_1Server( int port) throws IOException
	{
		serverSocket = new ServerSocket(port); // Socket erzeugen

		System.out.println("Server gestartet.");
		linkZumClient = serverSocket.accept(); // warten bis sich Client verbindet

		System.out.println("Verbindung hergestellt mit "+ serverSocket.getInetAddress());

		inFromClient = new DataInputStream(linkZumClient.getInputStream());

		outToClient = new DataOutputStream(linkZumClient.getOutputStream());
	}

	public void tuWas() throws IOException {

		String zeichenketteklein = null;
		String zeichenkettegross = null;

		zeichenketteklein = inFromClient.readUTF() ; //String vom Client empfangen

		System.out.print("Server Empfangen: "+ zeichenketteklein);

		zeichenkettegross = zeichenketteklein.toUpperCase();

		outToClient.writeUTF(zeichenkettegross);
		System.out.println(" gesendet: "+ zeichenkettegross);
	}

	public void disconnect() throws IOException {
		inFromClient.close();
		outToClient.close();
		linkZumClient.close();
		serverSocket.close();
	}

	public static void main(String[] args) throws IOException {

		Loes_Aufg_7_1Server meinServer = new Loes_Aufg_7_1Server(4711);
		meinServer.tuWas();
		meinServer.disconnect();

	}
}

Loes_Aufg_7_2Client.java

import java.io.IOException;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.net.InetAddress;

import java.net.Socket;
import java.net.UnknownHostException;

public class Loes_Aufg_7_2Client {
   
    Socket linkZumServer;
    DataInputStream inFromServer;
    DataOutputStream outToServer;
    
    public Loes_Aufg_7_2Client (InetAddress address, int port) throws IOException {
        
        linkZumServer = new Socket(address,port); // mit Server verbinden
        System.out.println("Verbindung hergestellt");
        
        inFromServer = new DataInputStream(new BufferedInputStream(linkZumServer.getInputStream()));
        outToServer = new DataOutputStream(new BufferedOutputStream(linkZumServer.getOutputStream()));
    }
    
    public void sendeDatei(String dateiName) throws IOException {
        int readByte;
        int numberOfBytes;
        
        // Datei zum Lesen oeffnen
        FileInputStream inFromFile = new FileInputStream(dateiName);
        System.out.println("Datei " + dateiName + "wird uebertragen");
        
        // Dateinamen uebertragen
        outToServer.writeUTF(dateiName);
        
        // Dateilaenge ermitteln und uebertragen
        numberOfBytes = inFromFile.available();
        outToServer.writeInt(numberOfBytes);
        System.out.println("Sende " + numberOfBytes + " Bytes.");
        
        // Datei byteweise einlesen und an Server schicken
        while((readByte = inFromFile.read()) >= 0) {
            outToServer.writeByte(readByte);
        }
        // evtl. noch im Puffer des BufferedOutputStreams befindliche Bytes an Server schicken
        outToServer.flush();
        inFromFile.close();
        
        // Bytezahl vom Server empfangen
        int anzempfbytes = inFromServer.readInt();
        System.out.println("Der Server hat folgende Anzahl empfangener Bytes gemeldet: " + anzempfbytes);
    }
    
    public void disconnect() throws IOException {
        outToServer.close();
        inFromServer.close();
        linkZumServer.close();
    }
   
    public static void main(String[] args) throws UnknownHostException, IOException {
        String dateiName;
        dateiName = "test.jpg";
        
        Loes_Aufg_7_2Client meinClient = new Loes_Aufg_7_2Client (InetAddress.getByName("127.0.0.1"),4711);
        
        meinClient.sendeDatei(dateiName);
        meinClient.disconnect();
    }
}

Loes_Aufg_7_2Server.java

import java.io.IOException;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Loes_Aufg_7_2Server {

	ServerSocket serverSocket;
	Socket linkZumClient;
	DataInputStream inFromClient;
	DataOutputStream outToClient;

	public Loes_Aufg_7_2Server( int port) throws IOException {

		serverSocket = new ServerSocket(port); // Socket erzeugen
		System.out.println("Server gestartet.");

		linkZumClient = serverSocket.accept(); // warten bis sich Client verbindet
		System.out.println("Verbindung hergestellt mit "+ linkZumClient.getInetAddress());

		inFromClient = new DataInputStream(new BufferedInputStream(linkZumClient.getInputStream()));
		outToClient = new DataOutputStream(new BufferedOutputStream(linkZumClient.getOutputStream()));
	}

	public void empfangeDatei() throws IOException {
		
        int readByte;
		String dateiName;
		int bytesToRead;

		// Dateinamen empfangen
		dateiName= inFromClient.readUTF();

		// Datei zum Schreiben oeffnen
		FileOutputStream outToFile = new FileOutputStream("Neu_" + dateiName);
		System.out.println("Empfange Datei "+ "Neu_" + dateiName);

		// Zahl der zu empfangenden Bytes empfangen
		bytesToRead = inFromClient.readInt();
		System.out.println("Lese "+bytesToRead+" Bytes.");

		int anzempfbytes = 0;

		// Byteweise empfangen und in Datei schreiben
		while(bytesToRead-- > 0) {
			readByte = inFromClient.readByte();
			outToFile.write(readByte);
			System.out.print("\rnoch "+bytesToRead);
			anzempfbytes ++;
		}
		outToFile.close();

		// Zahl der empfangenen Bytes an Client schicken
		outToClient.writeInt(anzempfbytes);
	}
    
	public void disconnect() throws IOException {
		outToClient.close();
		inFromClient.close();
		linkZumClient.close();
		serverSocket.close();
	}
    
	public static void main(String[] args) throws IOException {

		Loes_Aufg_7_2Server meinServer = new Loes_Aufg_7_2Server(4711);
		meinServer.empfangeDatei();
		meinServer.disconnect();
	}
}

Loes_Aufg_8_1.java

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;

public class Loes_Aufg_8_1 {
    InetAddress adresse;
    int port;
    DatagramSocket socket;
    byte[] bytePuffer;
    DatagramPacket udpPaket;
    
    public Loes_Aufg_8_1(InetAddress empfaengerAdresse, int empfaengerPort) throws IOException {
        
        socket = new DatagramSocket();
        System.out.println("UDPSender Socket erzeugt");
        bytePuffer = new byte[10];
        udpPaket = new DatagramPacket(bytePuffer,bytePuffer.length);
        System.out.println("UDPSender Datenpaket erzeugt");
        this.adresse = empfaengerAdresse;
        this.port = empfaengerPort;
    }
    
    public void tuWas(int startwert) throws IOException, InterruptedException {
        
        do {
            String zahl = String.valueOf(startwert);
            byte[] ziffern = zahl.getBytes();
            udpPaket.setData(ziffern);
            udpPaket.setLength(ziffern.length);
            udpPaket.setPort(port);
            udpPaket.setAddress(adresse);
            socket.send(udpPaket);
            System.out.println("UDPSender gesendet: "+zahl);
            Thread.sleep(1000);
            startwert++;
        }
        while(true);
    }
    
    public void disconnect() throws IOException {
        
        socket.close();
    }
    
    public static void main(String[] args) throws UnknownHostException, IOException, InterruptedException {
        
        Loes_Aufg_8_1 sender = new Loes_Aufg_8_1(InetAddress.getByName("127.0.0.1"),4711);
        sender.tuWas(1);
        sender.disconnect();
    }
}

Loes_Aufg_8_2.java

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;

public class Loes_Aufg_8_2 {
    InetAddress adresse;
    int port;
    DatagramSocket socket;
    byte[] bytePuffer;
    DatagramPacket udpPaket;
    
    public Loes_Aufg_8_2 (int empfaengerPort) throws IOException {
        
        socket = new DatagramSocket(empfaengerPort);
        System.out.println("UDPEmpfaenger Socket erzeugt");
        bytePuffer = new byte[10];
        udpPaket = new DatagramPacket(bytePuffer,bytePuffer.length);
        System.out.println("UDPEmpfaenger Datenpaket erzeugt");
    }
    
    public void tuWas() throws IOException {
        
        String zahl;
        do {
            socket.receive(udpPaket);
            zahl = new String(udpPaket.getData());
            System.out.println("Empfangen: "+zahl);
        }
        while(true);
    }
    
    public void disconnect() throws IOException {
        
        socket.close();
    }
    
    public static void main(String[] args) throws UnknownHostException, IOException {
        
        Loes_Aufg_8_2 empfaenger = new Loes_Aufg_8_2(4711);
        empfaenger.tuWas();
        empfaenger.disconnect();
    }
}