Java-Code

//©2012 by Julius J. Hoffmann
//written with Eclipse

import java.util.*;		//Importiert Scanner zum Einlesen der Eingabe

public class Euklid {		//die "ausführende" Klasse

	static int old(int a, int b)		//Methode zur Berechnung des klass. Algorithmus
	{									//mit Übergabe  von 2 int-Variablen
		if (a==0) return b;				//Bedingung: a = 0 -> Rückgabe b; Ende der Methode
		while (b!=0)					//Initiierung einer while-Schleife mit b nicht 0 als Bedingung
		{
			if (a > b) a = a-b;			//Subtraktion der kleinern von der kleineren Zahl, wenn a größer
			else b = b-a;				//wenn b kleiner, iterative Berechnung
		}
		return a;						//Rückgabe a (wenn b = 0)
	}
	
	static int modern (int a, int b)	//Methode zur Berechnung des modernen Algorithmus
	{
		if (b==0) return a;				//wenn b = 0, Rückgabe a; Ende der Methode
		return modern(b, a%b); 			//rekursiver Aufruf der Funktion, mit b, Rest von a/b
	}
	
	public static void main(String[] args) 							//main-Methode
	{
		Scanner s = new Scanner(System.in);							//Anlegen des Scanner-Objektes
		System.out.print("Geben Sie die 1. natürliche Zahl an: ");	//Ausgabe des Strings
		int x = s.nextInt();										//Einlesen der Benutzereingabe
		System.out.print("Geben Sie die 2. natürliche Zahl an: ");	//Ausgabe des Strings
		int y = s.nextInt();										//Einlesen der Benutzereingabe
		System.out.println("alter Euklid: " + old(x,y));			//Ausgabe String, Aufruf von old()
		System.out.print("moderner Euklid: " + modern(x,y));		//Ausgabe String, Aufruf von modern
	}

}

Java-Code

import java.util.Scanner;

public class EuklidAlg {
	
	static Scanner sc;
	static int a, b;
	
	public static void main(String[] args) {
		sc = new Scanner(System.in);
		
		System.out.println("Bitte erste Zahl eingeben.");
		a = sc.nextInt();
		
		System.out.println("Bitte zweite Zahl eingeben.");
		b = sc.nextInt();
		
		System.out.println("a: " + a + "\n" +
							"b: " + b);
		
		int ggTold = euklidOld(a, b);
		System.out.println("Ergebnis klassischer Algorithmus: " + ggTold);
		
		int ggTnew = euklidNew(a, b);
		System.out.println("Ergebnis moderner Algorithmus: " + ggTnew);
	}
	
	public static int euklidOld(int a, int b) {
		if(a == 0) {
			return b;
		} else {
			while(b != 0) {
				if(a > b) {
					a = a - b;
				} else {
					b = b - a;
				}
			}
		}
		return a;
	}
	
	public static int euklidNew(int a, int b) {
		if(b == 0) {
			return a;
		} else {
			return euklidNew(b, a % b);
		}
	}

}

Java-Code

[CODE]package ÜbungsAufgaben;

import javax.swing.JOptionPane;

public class Aufgabe08 {

	public static void main(String[] args) {
		Aufgabe08 m = new Aufgabe08();

		int zahl1 = Integer.parseInt(JOptionPane
				.showInputDialog("Eingabe der ersten Zahl:"));// Aufnahme der ersten zu teilenden Zahl.
		int zahl2 = Integer.parseInt(JOptionPane
				.showInputDialog("Eingabe der zweiten Zahl:"));// Aufnahme der zweiten zu teilenden Zahl.

		JOptionPane.showMessageDialog(
				null,
				"ggT nach dem klassen Euklidischen Algorithmus: "
						+ m.klassischerAlgorithmus(zahl1, zahl2));// Ausgabe des ggT nach klassischer Art.
		JOptionPane.showMessageDialog(
				null,
				"ggT nach dem modernen Euklidischen Algorithmus: "
						+ m.modernerAlgorithmus(zahl1, zahl2));// Ausgabe des ggT nach moderner Art.
	}

	int klassischerAlgorithmus(int zahl1, int zahl2) {
		if (zahl1 == 0) {
			return zahl2;
		} else {
			while (zahl2 != 0) {
				if (zahl1 > zahl2) {
					zahl1 -= zahl2;
				} else {
					zahl2 -= zahl1;
				}
			}
		}
		return zahl1;
	}

	int modernerAlgorithmus(int zahl1, int zahl2) {
		int n;
		while (zahl2 != 0) {
			n = zahl1 % zahl2;
			zahl1 = zahl2;
			zahl2 = n;
		}
		return zahl1;
	}
}[/CODE]

Java-Code

/* @Author H.K.
 * @Date 22.02.2016
 * 
 * Programmbeschreibung:
 * Ermittlung des größten gemeinsamen Teiler durch den modernen Euklidischen Algorithmus
 */

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

	
public class mainprogram {

	public static void main ( String args[] ) throws IOException {
		System.out.println("--- Euklidischer Algorithmus ---");
		System.out.println("--- Es werden zwei Ganze Zahlen abgefragt und der ggT von diesen ermittelt ---\n\n");
		int zahl = 0;
		int ggT = 0;
		int a = 0;
		int b = 0;
		a = zahlenabfrage(zahl, a);
		zahl = 0;
		b = zahlenabfrage(zahl, a);
		
		ggT = ggT(a, b, ggT);
		
	}
	
	public static int zahlenabfrage(int zahl, int a) throws IOException {
		while (zahl == 0) {
			if (a == 0) {
				System.out.println("Bitte die erste Ganze Zahl eingeben: ");
			} else {
				System.out.println("Bitte die zweite Ganze Zahl eingeben: ");
			}
		
		BufferedReader input = new BufferedReader ( new InputStreamReader ( System.in ) );
	    String inputString = input.readLine();
	    if (inputString.matches("-?\\d+?")) {
	    	zahl = Integer.parseInt(inputString);
		} else {
	    	System.out.println("Eingabe ist keine Zahl!");
	    }
		}
		return zahl;
    }

	public static int ggT(int a, int b, int ggT) {
		int largernumber = 0;
		int smallernumber = 0;
		int rest = 1;
		int calcrest = rest;
		
		if (a > b) {
			largernumber = a;
			smallernumber = b;
		} else {
			largernumber = b;
			smallernumber = a;
		}
		
		while (rest != 0) {
			rest = largernumber%smallernumber;
			if (rest == 0)  {
				System.out.println("Der ggT ist: " +calcrest);
			} else {
				calcrest = rest;
				largernumber = smallernumber;
				smallernumber = rest;
			}
		}
		
		return ggT;
	}

}

Java-Code

import java.util.*;

public class EuklidischerAlg {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int zahl1, zahl2, alt, neu;
		
		System.out.print("Erste natürliche Zahl:\t");
		zahl1 = scanner.nextInt();
		System.out.print("\nZweite natürliche Zahl:\t");
		zahl2 = scanner.nextInt();
		alt = eucleid_old(zahl1, zahl2);
		System.out.println("\nAlter Eukleid:\t" + alt);
		neu = eucleid_modern(zahl1, zahl2);
		System.out.println("\nModerner Eukleid:\t" + neu);
		
		scanner.close();		
	}
	
	public static int eucleid_old(int a, int b) {
		int erg;
		
		if (a == 0) erg = b;
		else
		{
			while(b != 0) {
				if(a > b) a = a - b;
				else b = b - a;
			}
			erg = a;
		}
		return erg;
	}
	
	public static int eucleid_modern(int a, int b) {
		int erg, h;
		
		while(b != 0) {
			h = a % b;
			a = b;
			b = h;
		}
		erg = a;
		return erg;
	}
}

Java-Code

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.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class EuklidischerAlgorithmus {
	public static void main(String[] args) {
		FrEuklidischerAlg frEuklidischerAlg = new FrEuklidischerAlg("Euklidischer Algorithmus");
	}
}

class FrEuklidischerAlg extends JFrame implements ActionListener {

	JLabel lblErsteZahl = new JLabel("erste Zahl: ");
	JTextField tfErsteZahl = new JTextField(15);
	JPanel pErsteZahl = new JPanel();
	JLabel lblZweiteZahl = new JLabel("zweite Zahl: ");
	JTextField tfZweiteZahl = new JTextField(15);
	JPanel pZweiteZahl = new JPanel();
	JButton bModern = new JButton("    Modern    ");
	JButton bKlassisch = new JButton("   Klassisch   ");
	JPanel pButton = new JPanel();
	JTextArea taAusgabe = new JTextArea(20, 30);

	FrEuklidischerAlg(String titel) {
		super(titel);
		setVisible(true);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(460, 600);
		setLocation(500, 200);
		setLayout(new FlowLayout(FlowLayout.RIGHT, 60, 25));

		tfErsteZahl.setHorizontalAlignment(JTextField.RIGHT);
		tfZweiteZahl.setHorizontalAlignment(JTextField.RIGHT);
		taAusgabe.setEditable(false);
		taAusgabe.setLineWrap(true);
		taAusgabe.setWrapStyleWord(true);

		bModern.addActionListener(this);
		bModern.setActionCommand("modern");
		bKlassisch.addActionListener(this);
		bKlassisch.setActionCommand("klassisch");

		pErsteZahl.add(lblErsteZahl);
		pErsteZahl.add(tfErsteZahl);
		pZweiteZahl.add(lblZweiteZahl);
		pZweiteZahl.add(tfZweiteZahl);
		pButton.add(bModern);
		pButton.add(bKlassisch);

		add(pErsteZahl);
		add(pZweiteZahl);
		add(pButton);
		add(taAusgabe);
	}

	public String berechneModern(String stZahl1, String stZahl2) {
		String stAusgabe;
		StringBuilder sbAusgabe = new StringBuilder();
		int rest = 1;
		int faktor;
		int temp;

		try {
			int zahl1 = Integer.parseInt(stZahl1);
			int zahl2 = Integer.parseInt(stZahl2);

			if (zahl1 == 0 || zahl2 == 0) {
				stAusgabe = "Es gibt keinen gemeinsamen Teiler";
				return stAusgabe;
			}

			if (zahl2 > zahl1) {
				temp = zahl1;
				zahl1 = zahl2;
				zahl2 = temp;
			}

			sbAusgabe.append("ggT (" + zahl1 + ", " + zahl2 + ")" + "\n");

			do {
				faktor = zahl1 / zahl2;
				rest = zahl1 % zahl2;
				sbAusgabe.append(zahl1 + " = " + faktor + "*" + zahl2 + "+" + rest + "\n");
				zahl1 = zahl2;
				zahl2 = rest;
			} while (rest != 0);
			sbAusgabe.append("der größte gemeinsame Teiler: " + zahl1);
			stAusgabe = sbAusgabe.toString();
		} catch (NumberFormatException e) {
			stAusgabe = "Bitte Ganzzahlen eingeben!";
		}
		return stAusgabe;
	}

	public String berechneKlassisch(String stZahl1, String stZahl2) {
		String stAusgabe;
		StringBuilder sbAusgabe = new StringBuilder();
		int differenz = 0;
		int temp;

		try {
			int zahl1 = Integer.parseInt(stZahl1);
			int zahl2 = Integer.parseInt(stZahl2);

			if (zahl1 == 0 || zahl2 == 0) {
				stAusgabe = "Es gibt keinen gemeinsamen Teiler";
				return stAusgabe;
			}

			if (zahl2 > zahl1) {
				temp = zahl1;
				zahl1 = zahl2;
				zahl2 = temp;
			}
			sbAusgabe.append("ggT (" + zahl1 + ", " + zahl2 + ")");

			do {
				sbAusgabe.append("\n" + zahl1);
				differenz = zahl1;
				do {
					sbAusgabe.append("-" + zahl2);
					differenz = differenz - zahl2;
				} while (differenz > zahl2);
				sbAusgabe.append("=" + differenz);
				zahl1 = zahl2;
				zahl2 = differenz;
			} while (differenz != 0);
			sbAusgabe.append("\n" + "der größte gemeinsame Teiler: " + zahl1);
			stAusgabe = sbAusgabe.toString();
		} catch (NumberFormatException e) {
			stAusgabe = "Bitte Ganzzahlen eingeben!";
		}

		return stAusgabe;
	}

	@Override
	public void actionPerformed(ActionEvent evt) {
		if (evt.getActionCommand().equals("modern"))
			taAusgabe.setText(berechneModern(tfErsteZahl.getText(), tfZweiteZahl.getText()));
		if (evt.getActionCommand().equals("klassisch"))
			taAusgabe.setText(berechneKlassisch(tfErsteZahl.getText(), tfZweiteZahl.getText()));
	}
}