dvg1 - 07 - methoden 1 methoden. 2 int dezi = integer.parseint(args[0]); boolean vz = (dezi>=0);...

DVG1 - 07 - MethodenDVG1 - 07 - Methoden 11

MethodenMethoden

22 DVG1 - 07 - MethodenDVG1 - 07 - Methoden

int dezi = Integer.parseInt(args[0]);boolean vz = (dezi>=0);dezi = Math.abs(dezi); String Bin = "";do{

} while (dezi !=0);

switch (dezi%16){

}

case 10 : Bin = "A"+Bin; break; case 11 : Bin = "B"+Bin; break; case 12 : Bin = "C"+Bin; break; case 13 : Bin = "D"+Bin; break; case 14 : Bin = "E"+Bin; break; case 15 : Bin = "F"+Bin; break; default : Bin = dezi%16+Bin;

Bin = "0x" + Bin;if (!vz) Bin="-"+Bin;

dezi = dezi/16;


int dezi = Integer.parseInt(args[0]);String Bin ="";

boolean vz=(dezi>=0);dezi=Math.abs(dezi); do{

if (dezi%16 < 10) Bin=dezi%16+Bin;else Bin= (´A´+dezi%16-10)+Bin;dezi=dezi/16;

} while (dezi !=0);Bin = "0x" + Bin;if (!vz) Bin="-"+Bin;




if (dezi%16 < 10) Bin=dezi%16+Bin;else Bin=(char)(´A´+dezi%16-10)+Bin;dezi=dezi/16;

} while (dezi !=0);Bin = "0x" + Bin;if (!vz) Bin="-"+Bin;




if (dezi%2 < 10) Bin=dezi%2 +Bin;else Bin=(char)(´A´+dezi%2 -10)+Bin;dezi=dezi/2 ;

} while (dezi !=0);Bin = "" + Bin;if (!vz) Bin="-"+Bin;




if (dezi%8 < 10) Bin=dezi%8 +Bin;else Bin=(char)(´A´+dezi%8 -10)+Bin;dezi=dezi/8 ;

} while (dezi !=0);Bin = "0" + Bin;if (!vz) Bin="-"+Bin;


// Parametrisierungint b = 16;String pref = "0X";int dezi = Integer.parseInt(args[0]);String Bin ="";{boolean vz=(dezi>=0);dezi=Math.abs(dezi); do{

if (dezi%b < 10) Bin=dezi%b +Bin;else Bin=(char)(´A´+dezi%b -10)+Bin;dezi=dezi/b ;

} while (dezi !=0);Bin = pref + Bin;if (!vz) Bin="-"+Bin;}


// Methode

static String convertBase ( int dezi, int b, String pref){String Bin ="";boolean vz=(dezi>=0);dezi=Math.abs(dezi); do{

if (dezi%b < 10) Bin=dezi%b +Bin;else Bin=(char)(´A´+dezi%b -10)+Bin;dezi=dezi/b ;

} while (dezi !=0);Bin = pref + Bin;if (!vz) Bin="-"+Bin;return Bin;}


Methoden-DefinitionMethoden-DefinitionDefinition:Definition:

public static mtyp name (typ p1, typ p2, ... , typ pN)public static mtyp name (typ p1, typ p2, ... , typ pN)

{{

.... // Koerper der Methode, beliebige Anweisungen.... // Koerper der Methode, beliebige Anweisungen

}}

mtyp mtyp definiert den Typ des Wertes der Methode, gibt die Methode keinen definiert den Typ des Wertes der Methode, gibt die Methode keinen Wert zurück muß Wert zurück muß voidvoid angegeben werden. angegeben werden.

p1, p2, ..., pNp1, p2, ..., pN sind die Parameter der Methode. sind die Parameter der Methode.

Im Körper von Methoden können beliebige Variablen definiert werden. Im Körper von Methoden können beliebige Variablen definiert werden. Diese sind nur innerhalb der Methode bekannt.Diese sind nur innerhalb der Methode bekannt.

Methoden können nur in Klassen definiert werden. ==> Es gibt keine Methoden können nur in Klassen definiert werden. ==> Es gibt keine Methoden innerhalb von Methoden.Methoden innerhalb von Methoden.

Hat die Methode keine Parameter, ist die leere Parameterliste Hat die Methode keine Parameter, ist die leere Parameterliste ()() anzugeben.anzugeben.


Methoden-AufrufMethoden-AufrufKlassenname.Methodenname(p1, p2, ..., pN) Klassenname.Methodenname(p1, p2, ..., pN) innerhalb von Ausdrücken oderinnerhalb von Ausdrücken oder

Klassenname.Methodenname(p1, p2, ..., pN); Klassenname.Methodenname(p1, p2, ..., pN); auch möglich wenn die Methode einen Wert zurückgibt, auch möglich wenn die Methode einen Wert zurückgibt, dieser wird dann ignoriert.dieser wird dann ignoriert.

p1, p2, ..., pN p1, p2, ..., pN können beliebige Ausdrücke seinkönnen beliebige Ausdrücke sein

Die Ausdrücke werden berechnet und auf „Hilfsvariable“ Die Ausdrücke werden berechnet und auf „Hilfsvariable“ zugewiesen.zugewiesen.

Die Hilfsvariablen werden der Methode übergeben „call by Die Hilfsvariablen werden der Methode übergeben „call by value“.value“.

Die Werte außerhalb der Methode werden nicht geändert.Die Werte außerhalb der Methode werden nicht geändert.


return-Anweisungreturn-Anweisung

Wenn Wenn mtyp==voidmtyp==void angegeben wurde, kann die angegeben wurde, kann die Anweisung Anweisung returnreturn; zum Verlassen der Methode ; zum Verlassen der Methode verwendet werden. Fehlt die verwendet werden. Fehlt die returnreturn-Anweisung -Anweisung wird die Methode am Ende verlassen. wird die Methode am Ende verlassen.

Wenn Wenn mtyp!=voidmtyp!=void angegeben wurde, muß angegeben wurde, muß mindestens eine Anweisung mindestens eine Anweisung return return ausdruck; ausdruck; enthalten sein die den Wert der enthalten sein die den Wert der Methode berechnet und die Methode verläßt. Methode berechnet und die Methode verläßt. ausdruckausdruck wird in den Typ wird in den Typ mtypmtyp konvertiert. konvertiert.


public static String convBase(int dezi, int b, String pref){ boolean vz=(dezi>=0); dezi=Math.abs(dezi); String Bin =""; do { if (dezi%b < 10) { Bin=dezi%b+Bin; } else { Bin=(char)('A'+dezi%b-10)+Bin; } dezi=dezi/b; } while (dezi !=0); Bin =pref+Bin; if (!vz) Bin="-"+Bin; return Bin;}public static void main (String[]args){int dezi = Integer.parseInt(args[0]);System.out.println(dezi+" ist in binaer:"+convBase(dezi,2,""));System.out.println(dezi+" ist in oktal: "+convBase(dezi,8,"0"));System.out.println(dezi+" ist in hexadezimal: "+convBase(dezi,16,"0X"));}


Überladene MethodenÜberladene Methoden

Methoden können überladen werden, d.h. es gibt Methoden können überladen werden, d.h. es gibt innerhalb einer Klasse mehrere Methoden mit innerhalb einer Klasse mehrere Methoden mit gleichem Namen, aber unterschiedlicher gleichem Namen, aber unterschiedlicher Parameterliste, d.h. mit unterschiedlicher Anzahl von Parameterliste, d.h. mit unterschiedlicher Anzahl von Parametern oder unterschiedlichen Typen. Der Typ Parametern oder unterschiedlichen Typen. Der Typ der Methode spielt für die Unterscheidung der der Methode spielt für die Unterscheidung der Methoden keine Rolle.Methoden keine Rolle.

Beim Aufruf einer überladenen Methode wird die Beim Aufruf einer überladenen Methode wird die Menge aller bekannten Methoden in folgenden Menge aller bekannten Methoden in folgenden Schritten eingeschränkt:Schritten eingeschränkt:


• Name der Methode stimmt überein• Anzahl der Parameter stimmt überein• Wenn es genau eine Methode gibt deren Parameter dem Typ nach genau mit dem Aufruf übereinstimmen, so wird diese gewählt. ==> Ende• Die berechneten Parameter können in die entsprechenden Typen der Methoden-Definition umgewandelt werden. • Erfüllt keine Methode diese Bedingungen, ist der Aufruf unzulässig. ==> Ende• Existiert für eine Methode eine andere Methode, sodaß alle Parameter der einen Methode in die Typen der anderen konvertiert werden können, wird die andere gestrichen.• Bleibt genau eine Methode übrig, so wird diese aufgerufen. ==> Ende• Wenn mehrere Methoden übrigbleiben, ist der Aufruf unzulässig. ==> Ende


Beispiel:Beispiel:

public static void m (int p1, double p2){...} // m1public static void m (int p1, double p2){...} // m1

public static void m (double p1, int p2){...} // m2public static void m (double p1, int p2){...} // m2

public static void m (double p1, double p2){...} // m3public static void m (double p1, double p2){...} // m3

int i1=0, i2=0; float f1=0f, f2=0f; double d1=0, d2=0;int i1=0, i2=0; float f1=0f, f2=0f; double d1=0, d2=0;

m(i1,d1); // m1m(i1,d1); // m1

m(d1,i1); // m2m(d1,i1); // m2

m(d1,d2); // m3m(d1,d2); // m3

m(f1,f2); // m3m(f1,f2); // m3

m(i1,f2); // m1m(i1,f2); // m1

m(i1,i2); // unzulässigm(i1,i2); // unzulässig

alle Methoden haben passende Parameter, alle Methoden haben passende Parameter, m3m3 wird eliminiert, da wird eliminiert, da m1m1 spezifischer istspezifischer ist

m1m1 und und m2m2 erfüllen alle Bedingungen, damit ist der Aufruf nicht erfüllen alle Bedingungen, damit ist der Aufruf nicht entscheidbar, also unzulässig.entscheidbar, also unzulässig.


public static int max (int x, int y)

{ return (x>y)?x:y; }

public static long max (long x, long y)


public static float max (float x, float y)


public static double max (double x, double y)



wert = methode(ausdr1, ausdr2, ... , ausdrN);

h2 = ausdr2

hN = ausdrN

h1 = ausdr1

wert = h0

aufrufende Methode aufgerufene Methode

Anweisungen derMethode „methode“

werden abgearbeitet,dabei werden dieformalen Parametermit den Wertenh1, h2, ... , hN

belegt

h0=return ausdruck;


public class testfak{public static long fakultaet (long n){ long fak=1; while (n>1) fak*=n--; return fak;}public static void main (String [] args){ long n = Long.parseLong(args[0]); long f = fakultaet(n); System.out.println(n + "! = " + f);}}


System.out.println(n + "! = " + f);

long f = h0;

h1>1

long fak=1;

long n = Long.parseLong(args[0]);

h1=n;

fak*=h1--;

true

h0=fak;

false


SeiteneffekteSeiteneffekteHaupteffekte:Haupteffekte: Eingaben über ParameterEingaben über Parameter Ausgaben über den WertAusgaben über den Wert

Seiteneffekte:Seiteneffekte: Lesen aus DateienLesen aus Dateien Lesen im DialogLesen im Dialog Beeinflussung der Arbeitsweise einer Methode durch globale Beeinflussung der Arbeitsweise einer Methode durch globale

VariableVariable Schreiben in DateienSchreiben in Dateien Ausgaben im DialogAusgaben im Dialog Verändern von globalen VariablenVerändern von globalen Variablen


Methode

Parameter 1 Parameter NParameter 2

Wert

Globale Variable

Dateien

Globale Variable

Dateien


public class testfak{static boolean debug = false;public static long fakultaet (long n){ long fak=1; if (debug) System.out.println(“fak(“+n+“)“); while (n>1) fak*=n--; return fak;}public static void main (String [] args){ long n = Long.parseLong(args[0]); long f = fakultaet(n); System.out.println(n + "! = " + f);}}


rekursive Methodenrekursive MethodenMethoden die sich direkt oder indirekt selbst aufrufen.Methoden die sich direkt oder indirekt selbst aufrufen.

direkte Rekursion: Methode ruft sich selbst aufdirekte Rekursion: Methode ruft sich selbst auf

z.B.: Berechnung der Fakultät mit n!=n*(n-1)!z.B.: Berechnung der Fakultät mit n!=n*(n-1)!

public static long fakultaet(long n)public static long fakultaet(long n)

{ return (n>0)?n*fakultaet(n-1):1; }{ return (n>0)?n*fakultaet(n-1):1; } indirekte Rekursion: Methode ruft eine andere Methode auf, die indirekte Rekursion: Methode ruft eine andere Methode auf, die

dann die erste Methode aufruftdann die erste Methode aufruft

z.B.: Az.B.: Ann=B=Bnn+B+Bn-1n-1 , B , Bnn=2*A=2*An-1n-1+B+Bn-2n-2 wenn n>1, A wenn n>1, A00=A=A11=B=B00=B=B11=1=1

public static long A(long n)public static long A(long n)

{ return (n>1)?B(n)+B(n-1):1; }{ return (n>1)?B(n)+B(n-1):1; }

public static long B(long n)public static long B(long n)

{ return (n>1)?2*A(n-1)+B(n-2):1; }{ return (n>1)?2*A(n-1)+B(n-2):1; }


Es muß vom Programmierer sichergestellt werden, daß Es muß vom Programmierer sichergestellt werden, daß keine unendlichen Rekursionen auftreten. Z.B. durch keine unendlichen Rekursionen auftreten. Z.B. durch Indizes und Abbruchbedingungen (in den Beispielen „n“).Indizes und Abbruchbedingungen (in den Beispielen „n“).

Rekursive Aufrufe erfordern einen sehr hohen Rekursive Aufrufe erfordern einen sehr hohen Systemaufwand. Man sollte sie nur nutzen, wo es sinnvoll Systemaufwand. Man sollte sie nur nutzen, wo es sinnvoll ist.ist.

z.B.:z.B.: fakultaet(n) ==> fakultaet(n-1) ==> ... ==> fakultaet(0)fakultaet(n) ==> fakultaet(n-1) ==> ... ==> fakultaet(0)

also n+1 Aufrufe o.k. (?)also n+1 Aufrufe o.k. (?) A(n) ==> B(n), B(n-1) ==> (A(n-1),B(n-2)),(A(n-2),B(n-3)) A(n) ==> B(n), B(n-1) ==> (A(n-1),B(n-2)),(A(n-2),B(n-3))

==> ...==> ...

also ca. 2also ca. 2nn Aufrufe ==> nur für kleine n realistisch !!!! Aufrufe ==> nur für kleine n realistisch !!!!

Die Methoden werden sehr oft mit den gleichen Die Methoden werden sehr oft mit den gleichen Parametern aufgerufen.Parametern aufgerufen.

Rekursionen lassen sich immer vermeiden.Rekursionen lassen sich immer vermeiden.


public static long A (long n){long ak=1, akm1=1;long bk=1, bkm1=1 , bkm2;for (long k=2;k<=n;k++){ bkm2=bkm1; bkm1=bk; akm1=ak; bk=2*akm1+bkm2; ak=bk+bkm1;}return ak;}

public static long A(long n){ return (n>1)?B(n)+B(n-1):1; }public static long B(long n){ return (n>1)?2*A(n-1)+B(n-2):1; }


Beispiel: BinomialkoeffizientenBeispiel: Binomialkoeffizienten knk

n

k

n yxk

nyx

0

nknkn

k

n

knkn

k

knkn

k

knkn

k

knkn

k

knkn

k

nn

xn

nyx

k

n

k

ny

n

yxk

nyx

k

n

yxk

nyx

k

n

yxk

nyx

yxyxyx

1

11

1

1

0

1

1

1

1

11

1)(

)(

1

1

1

01

1

0

111

0

11

0

1

11

1

0

1

1

1,

1

1

1,

0

1

0

n

n

n

n

k

n

k

n

k

nnn


!!

!

knk

n

k

n

Beweis durch vollständige Induktion:

1für gilt Formel: annahmeInduktions

trivial:1:anfangInduktions

n

n

!!

!

!!

!1

!!

!1

!1!

!1

!11!1

!1

1

1

1

: nk1,0n

trivial:oder 0,1

knk

n

knk

nkn

knk

nk

knk

n

knk

n

k

n

k

n

k

n

nkkn


neue Rekursionsformel:

1

1

!11!1

!1

!!

!

k

n

k

n

knk

n

k

n

knk

n

k

n


k

n

k

n

k

n

k

n

knk

n

k

n

1

1

1

1

1

!!

! 3

2

1

mögliche Berechnungsformeln


public class binomial1{static boolean debug = true;public static long fakultaet(long n){ long fak=1; if (debug) System.out.print("fakultaet("+n+") = "); while (n>1) fak*=n--; if (debug) System.out.println(fak); return fak;}public static long binomial (long n, long k){ if (debug) System.out.println("binomial("+n+","+k+")"); return fakultaet(n)/(fakultaet(k)*fakultaet(n-k));}public static void main (String [] args){ long n = Long.parseLong(args[0]); long k = Long.parseLong(args[1]); long b = binomial(n,k); System.out.println("binomial("+n+","+k+") = "+b);}}


public class binomial2{static boolean debug = true;public static long binomial (long n, long k){ if (debug) System.out.println("binomial("+n+","+k+")"); if (k>0) return n*binomial(n-1,k-1)/k; return 1;}public static void main (String [] args){ long n = Long.parseLong(args[0]); long k = Long.parseLong(args[1]); long b = binomial(n,k); System.out.println("binomial("+n+","+k+") = "+b);}}


public class binomial3{static boolean debug = true;public static long binomial (long n, long k){ if (debug) System.out.println("binomial("+n+","+k+")"); if ((n>k)&(k>0)) return binomial(n-1,k-1)+binomial(n-1,k); return 1;}public static void main (String [] args){ long n = Long.parseLong(args[0]); long k = Long.parseLong(args[1]); long b = binomial(n,k); System.out.println("binomial("+n+","+k+") = "+b);}}


VergleichVergleichMethode 1Methode 1

einfache Formeleinfache Formel nur für kleine n, da n! berechnet wirdnur für kleine n, da n! berechnet wird sehr schnell, da keine Rekursionsehr schnell, da keine Rekursion

Methode 2Methode 2 liefert auch für recht große n und k brauchbare Werteliefert auch für recht große n und k brauchbare Werte schnell, da nur k-fache Rekursionschnell, da nur k-fache Rekursion Achtung: Reihenfolge wichtigAchtung: Reihenfolge wichtig

Methode 3Methode 3 funktioniert prinzipiell für den größten Bereichfunktioniert prinzipiell für den größten Bereich für mittlere n nicht mehr brauchbar wegen der großen Rechenzeit für mittlere n nicht mehr brauchbar wegen der großen Rechenzeit

22nn-fache Rekursion-fache Rekursion

dvg1 - 07 - methoden 1 methoden. 2 int dezi = integer.parseint(args[0]); boolean vz = (dezi>=0);...

Documents

bin dezi

bin bin

bin return bin

vz bin

bin folie

dezi 3dvg1

dezi 4dvg1

switch dezi