Rekursion – Einen String rückwärts ausgeben

Hilfe! Das böse Wort! Rekursion :-)

So wild ist das gar nicht, denn die Rekursion lässt sich optimal bei Problemen einsetzen, die eine gewisse Laufzeit haben, d.h. so ziemlich alles, was sich mit einer FOR-Schleife lösen lässt, kann ich auch rekursiv lösen.

Rekursiv heißt eigentlich nichts anderes, als das sich eine Methode bis zu einer gewissen Abbruchbedingung immer wieder selbst aufruft, bis eine Abbruchbedingung erreicht wird.

Als Beispiel habe ich einen String, der rückwärts ausgegeben werden soll.

	public static void rkw(String s)
	{
		if(s.length() > 0)
		{
			System.out.print(s.charAt(s.length()-1));
			rkw(s.substring(0, s.length()-1));
		}

Die Methode rkw erwartet als Übergabeparameter einen String. Wird dieser übergeben, überprüft rkw zuerst, ob die Länge größer 0 ist, wenn ja, dann wird die letzte Stelle des Strings mit System.out.print() ausgegeben.
Anschließend rufen wir rkw erneut auf, diesmal aber mit dem veränderten String s, dieser hat nämlich nun nur noch eine Länge von 0 bis Ende-1, d.h. es wird am Ende einfach das letzte Zeichen “abgeschnitten”. Das machen wir solange, bis der String komplett umgekehrt wurde, dann ist die Abbruchbedingung erreicht und wir verlassen die Methode wieder und das kleine Programm wird beendet.

Hier folgt der gesamte Quelltext:


public class rückwärts {

	public static void rkw(String s)
	{
		if(s.length() > 0)
		{
			System.out.print(s.charAt(s.length()-1));
			rkw(s.substring(0, s.length()-1));
		}

	}
	public static void main(String[] args) {

		String s = "Das ist ein String!";

		System.out.println(s);
		rkw(s);

	}

}

Ausgabe:

Das ist ein String!
!gnirtS nie tsi saD
Share

Beispiele für Methoden der Klasse String

Hier nur ein wirklich sehr leichtes Beispiel für die Methoden, die uns die Klasse String zur Verfügung stellt.

Bei Gelegenheit werde ich dazu noch ein ausführlicheres Beispiel präsentieren.

import java.io.*;
public class Zeichenketten {

	static BufferedReader br = new BufferedReader(
			new InputStreamReader(System.in));

	public static void main(String[] args)
	throws IOException
	{
		String vorname, name;

		System.out.println("Bitte geben Sie Ihren Vornamen ein: ");
		vorname = br.readLine();
		System.out.println("Bitte geben Sie Ihren Nachnamen ein: ");
		name 	= br.readLine();

		System.out.println("--------------------------------------------------------------");
		System.out.println("Einige Beispiele, was man mit Zeichenketten/Strings machen kann:");
		System.out.println("--------------------------------------------------------------");

		System.out.println("vollständige Ausgabe: " + vorname + " " + name);
		System.out.println("V. Name: " + vorname.charAt(0) +". " + name);
		System.out.println("Vorname N.: " + vorname +". " + name.charAt(0));
		System.out.println("V. N.: " + vorname.charAt(0) +". " + name.charAt(0) + ".");
		System.out.println("erster Buchstabe Vorname fehlt:" + vorname.substring(1));
		System.out.println("erster Buchstabe Nachname fehlt:" + name.substring(1));

	}

}

Viel Spaß beim Modifizieren und Ausprobieren!

Share

Einfache Tabelle mit ASCII-Zeichen

Hier ein Beispiel, wie man eine einfache Tabelle aus den Zeichen “+”, “-” und “|” erstellen kann.
Sie ist über die Variablen z (=Zeilen) und s (=Spalten) beliebig erweiterbar.

public class Tabelle {

	public static void main(String[] args) {

		int z=10; // Zeilen
		int s=5; // Spalten

		for(int i=0; i < z; ++i) // Zeilen
		{
			System.out.print("+");

			for(int k=0; k < s; ++k)
			{
				System.out.print("-------");
				System.out.print("+");
			}

			System.out.println();
			System.out.print("|");

			for(int k=0; k < s; ++k)
			{
				System.out.print("\t|");

			}

			System.out.println();
			System.out.print("|");
			for(int k=0; k < s; ++k)
			{
				System.out.print("\t|");

			}

			System.out.println();
		}
		System.out.print("+");

		for(int k=0; k < s; ++k)
		{
			System.out.print("-------");
			System.out.print("+");
		}

	}

}

Über einen BufferedReader oder Scanner, oder ganz einfach, über die Argumentsliste, könnte man auch die Werte für die Anzahl Zeilen/Spalten übergeben.

Share

Ein einfaches Beispiel für Minimal- / Maximal-Wert – Ermittlung

Mit diesem kleinen Programm ist es möglich, dass 2 Werte über die Konsole eingelesen werden und daraus jeweils das Minimum und Maximum ermittelt und ausgegeben wird.

// Es werden zwei Zahlen über die Konsole eingelesen und es
// wird das Minimum und Maximum ermittelt und ausgegeben
import java.io.*;
public class MinMax {

	static BufferedReader br = new BufferedReader(
			new InputStreamReader(System.in));

	public static void main(String[] args)
	throws IOException
	{
		int x, y, max, min;
		System.out.println("Geben Sie bitte 1. Wert ein: ");
		x = Integer.parseInt(br.readLine());
		System.out.println("Geben Sie bitte 2. Wert ein: ");
		y = Integer.parseInt(br.readLine());

		if(x < y)
		{
			max = y;
			min = x;
		}
		else
		{
			max = x;
			min = y;
		}
		System.out.println("X = " + x + " Y = " + y + "\n" +
				"Max-Wert: " + max + " Min-Wert: " + min);
	}

}

Sicher ist es noch nicht wirklich sinnvoll, Min und Max zwischen zwei Zahlen zu ermitteln, doch dieses einfache Beispiel dient der Veranschaulichung, wie es funktioniert.

Viel Spaß beim Ausprobieren.
P.S. Eine erweiterte Version folgt…

Share

Arbeiten mit Arrays

Ein kleiner Einschub bezüglich Arrays, die sind ja ganz oft sehr hilfreich und werden weit verbreitet eingesetzt.

Im unten aufgeführten Beispiel habe ich eine Klausuraufgabe nachgebildet, bei der 2 Zahlen per Konsole eingegeben werden sollen, ein Wert für die Anzahl der Schleifendurchläufe und ein Wert für die größte mögliche Zahl.

Weiterhin soll per MATH.random() eine Zahl zwischen 1 und der größten möglichen Zahl erzeugt und in einem Integer-Array abgespeichert werden, das wir uns hierzu erst einmal erzeugen müssen.

Am Ende soll die Anzahl der Zahlen zwischen 1 und max absolut und prozentual ausgegeben werden.

Es folgt der Quelltext:

import java.io.*;
public class Arrays {

	static BufferedReader br = new BufferedReader(
			new InputStreamReader(System.in));

	public static void main(String[] args)
	throws IOException
	{
		int anzahl, max, x;
		System.out.println("Bitte die Anzahl eingeben: ");
		anzahl = Integer.parseInt(br.readLine());
		System.out.println("Bitte max-Wert eingeben: ");
		max = Integer.parseInt(br.readLine());

		int[] a = new int[max];

		for(int i=0; i<anzahl; ++i)
		{
			x = (int) (Math.random() * max) + 1;
			++a[x-1];
		}
		for(int i=0; i<max; ++i)
		{
			System.out.println(i+1 + ": " + a[i] + "-mal " +
					Math.round(a[i] * 100.0 / anzahl) * 1000 / 1000. + " %");
		}

	}

}

Ihr könnt das Beispiel ja gern selbst erweitern oder auch mal verändern.
Viel Spaß!

Share

OOP – Das Girokonto – Teil 1

Wie versprochen, sind hier die ersten Quellcodezeilen für unser Girokonto.

public class Girokonto {

	// Instanzvariablen
	protected String k_vname, k_name, k_adresse, k_ort;
	protected byte k_plz, k_tel, k_hausNr;
	protected int k_kartenPin, k_telPin, k_kontoNr;
	protected double k_kontoStand, k_dispo;

	// Konstruktoren
	public Girokonto()
	{

	}

	public Girokonto(String vn, String nn, String adr,
        String ort, byte k_plz, byte k_tel, byte k_hausNr,
        double k_dispo, int k_kontoNr)
	{
		this.k_adresse 		= adr;
		this.k_hausNr 		= k_hausNr;
		this.k_name			= nn;
		this.k_vname		= vn;
		this.k_ort			= ort;
		this.k_plz			= k_plz;
		this.k_tel			= k_tel;
		this.k_dispo		= k_dispo;
		this.k_kontoStand	= 0.00;
		this.k_kontoNr		= k_kontoNr;
	}

	// Getter
	public double getKontoStand()
	{
		return k_kontoStand;
	}

	public double getDispo()
	{
		return k_dispo;
	}

	// Compute-Methoden
	public void einzahlen(double betrag)
	{
		k_kontoStand += betrag;
		this.getKontoStand();
	}

	public void ueberweisung(double betrag, int k_kontoNr)
	{
		if(getKontoStand() &gt; betrag)
		{
			k_kontoStand -= betrag;
			this.getKontoStand();
		}
		else if(getKontoStand() == betrag)
		{
			k_kontoStand -= betrag;
			this.getKontoStand();
		}
		else if(getKontoStand() = betrag)
			{
				k_kontoStand 	-= betrag;
				k_dispo			-= betrag;
				this.getKontoStand();
			}
			else
				System.out.println("Leider reicht Ihr Guthaben nicht aus!");
		}
	}
}

Es ist nun also möglich ein Girokonto mittels des Konstruktors

public Girokonto(String vn, String nn, String adr,
        String ort, byte k_plz, byte k_tel, byte k_hausNr,
        double k_dispo, int k_kontoNr)
{
...
}

zu erstellen. Über diesem Konstruktor gibt es noch einen leeren, der einfach nur ein Objekt der Klasse Girokonto erzeugt, aber keinerlei Wertzuweisung vornimmt. Den habe ich nur mit in das Beispiel aufgenommen, um zu zeigen, das auch ein leerer Konstruktor möglich ist.

Wenn wir unser Girokonto-Objekt erzeugt haben, stehen uns derzeit die Methoden

public double getKontoStand()
{
      return k_kontoStand;
}

public double getKontoStand()
{
      return k_dispo;
}

public void einzahlen(double betrag)
{
...
}

public void ueberweisen(double betrag, int k_kontoNr)
{
...
}

zur Verfügung.

Die Methoden getKontoStand(), getDispo() und einzahlen() bedürfen sicherlich keiner weiteren Erklärung, wenn doch, dann schreibt mir einfach einen Kommentar oder eine Mail.

Die Methode ueberweisen(double betrag, int k_kontoNr) ist da schon etwas interessanter. In dieser Version wird aktuell nur überprüft, ob das Konto ausreichend Deckung aufweist, ist dies der Fall, wird der Betrag derzeit vom Kontostand abgezogen und der Kontostand wird nach der Transaktion ausgegeben.
Ist das Konto nicht ausreichend gedeckt, wird versucht die Überweisung mit Hilfe des Dispokredits durchzuführen, klappt das, wird der Betrag vom Konto abgezogen und zusätzlich vom Dispo, sonst steht er bei der nächsten Überweisung wieder der volle Dispo zur Verfügung und das wäre im realen Leben ja auch nicht der Fall.
Reicht auch der Dispo nicht, wird eine Fehlermeldung ausgegeben.

Soviel für heute. Wer sich versuchen möchte, kann ja gern ein Objekt erzeugen und schon ein paar Buchungen machen.

Share

OOP Projekt – Das Girokonto

Als neues Objekt möchte ich euch eine Girokonto-Klasse vorstellen, auf die Idee kam ich, als ich heute durch ein Forum surfte und die Frage nach einer Methode zum Prüfen des Dispo-Kredits aufkam.

Als erstes machen wir uns einige Gedanken, wie wir das Ganze objektorientiert lösen können.

1. es wird eine Klasse Girokonto benötigt
2. es sollen Methoden zum Einzahlen, Auszahlen, Überweisen, Umbuchen und zum erteilen von Daueraufträgen sowie Abrufen des aktuellen Kontostands zur Verfügung gestellt werden
3. Kontoauszüge sollen als Bildschirmausgabe zur Verfügung stehen
4. beim Erstellen/Eröffnen des Kontos, soll die Möglichkeit bestehen, einen Dispo-Kredit einzurichten, dieses Maximum muss bei jeder Überweisung/Abbuchung vom Konto überprüft werden. Ist das Konto überzogen und der Dispo ausgereizt, soll eine Meldung ausgegeben werden und die Transaktion darf nicht ausgeführt werden

Zur Speicherung der Transaktionen kann ein Array verwendet werden.

Quellcode gibt es morgen.

Share

Ein gesundes neues Jahr

Ich wünsche allen Lesern ein wundervolles, gesundes und erfolgreiches neues Jahr 2012!

Mögen all eure Wünsche in Erfüllung gehen!

Share

Fenster schließen mit dem FensterAbhoerer

Wie hier versprochen, zeige ich jetzt wie einfach das erzeugte Fenster wieder geschlossen und die Applikation somit beendet werden kann.

Ich stelle erst den WindowListener vor, der als Interface von Java zur Verfügung gestellt wird und einfach in die von mir dafür erstellte Klasse “FensterAbhoerer” per implements eingebunden wird.

import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

class FensterAbhoerer implements WindowListener
{

	@Override
	public void windowActivated(WindowEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void windowClosed(WindowEvent e) {

	}

	@Override
	public void windowClosing(WindowEvent e) {
		System.exit(0);
	}

	@Override
	public void windowDeactivated(WindowEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void windowDeiconified(WindowEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void windowIconified(WindowEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void windowOpened(WindowEvent e) {
		// TODO Auto-generated method stub

	}

}

Diese, und die anderen Methoden…


	@Override
	public void windowClosing(WindowEvent e) {
		System.exit(0);
	}

werden von Eclipse automatisch “importiert” und müssen von uns noch ausprogrammiert werden.
Ich habe, damit wir das Fenster mit dem [x] in der Leiste schließen können, habe ich nun die Zeile

System.exit(0);

reingeschrieben. Die restlichen Methoden können wir erst einmal außer Acht lassen und lassen Sie einfach so im Quellcode stehen.

Hier noch einmal der gesamte Quellcode im Zusammenhang:

import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

class FensterAbhoerer implements WindowListener
{

	@Override
	public void windowActivated(WindowEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void windowClosed(WindowEvent e) {

	}

	@Override
	public void windowClosing(WindowEvent e) {
		System.exit(0);
	}

	@Override
	public void windowDeactivated(WindowEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void windowDeiconified(WindowEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void windowIconified(WindowEvent e) {
		// TODO Auto-generated method stub

	}

	@Override
	public void windowOpened(WindowEvent e) {
		// TODO Auto-generated method stub

	}

}

public class Fenster extends Frame
{
// Instanzvariablen
private String name;
private int x, y;

   // Konstruktor
   public Fenster(String name, int x, int y, boolean v)
   {
      this.name = name;
      this.x = x;
      this.y = y;

      this.setSize(x, y);
      this.setVisible(v);
   }

   // Main-Methode
   public static void main(String[] args) {
	  WindowListener ah = new FensterAbhoerer();
      Fenster window = new Fenster("Fenster 1", 640, 480, true);
      window.addWindowListener(ah);
   }
}

Nun können wir das Fenster wieder schließen und damit die Applikation beenden. Im nächsten Artikel werde ich dann ein paar Elemente, wie z.B. Buttons und Textfelder, einfügen.

Also dran bleiben.

Share

Erste Schritte mit grafischer Programmierung in Java

Nach dem ich gestern eine Mini-Applikation geschrieben habe, die auf der Konsole “Hallo Welt” ausgeben konnte, brennt sicherlich jeder Leser drauf, zu sehen, wie leicht sich mit Java auch grafische Anwendungen programmieren lassen.

Also, hier folgt der Programmcode, den ihr braucht, um ein Fenster zu erzeugen.

import java.awt.Frame;
public class Fenster extends Frame
{
// Instanzvariablen
private String name;
private int x, y;
;

   // Konstruktor
   public Fenster(String name, int x, int y, boolean v)
   {
      this.name = name;
      this.x = x;
      this.y = y;

      this.setSize(x, y);
      this.setVisible(v);
   }

   // Main-Methode
   public static void main(String[] args) {
      Fenster window = new Fenster("Fenster 1", 640, 480, true);
   }
}

Damit kannst du nun schon ein Fenster erzeugen.

Das Ergebnis sollte in etwa so aussehen:
einfaches Fenster in Java
Im nächsten Artikel werden wir dann eine Möglichkeit hinzu fügen, dass das Fenster mit dem [x] geschlossen werden kann.
Außerdem werden wir die Klasse Fenster um ein- oder zwei Buttons erweitern.
Es bleibt spannend, also dran bleiben!

Share