DV
G1 - 0
7 - M
eth
oden
1
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;
DV
G1 - 0
7 - M
eth
oden
2
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;
DV
G1 - 0
7 - M
eth
oden
3
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=(char)(´A´+dezi%16-10)+Bin;dezi=dezi/16;
} while (dezi !=0);Bin = "0x" + Bin;if (!vz) Bin="-"+Bin;
DV
G1 - 0
7 - M
eth
oden
4
int dezi = Integer.parseInt(args[0]);String Bin ="";
boolean vz=(dezi>=0);dezi=Math.abs(dezi); do{
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;
DV
G1 - 0
7 - M
eth
oden
5
int dezi = Integer.parseInt(args[0]);String Bin ="";
boolean vz=(dezi>=0);dezi=Math.abs(dezi); do{
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;
DV
G1 - 0
7 - M
eth
oden
6
// 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;}
DV
G1 - 0
7 - M
eth
oden
7
// 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;}
DVG1 - 07 - Methoden 8
Methoden
DV
G1 - 0
7 - M
eth
oden
9
Methoden-Definition Definition:
public static mtyp name (typ p1, typ p2, ... , typ pN)
{
.... // Koerper der Methode, beliebige Anweisungen
} mtyp definiert den Typ des Wertes der Methode, gibt die Methode
keinen Wert zurück muß void angegeben werden. p1, p2, ..., pN sind die Parameter der Methode. Im Körper von Methoden können beliebige Variablen definiert werden.
Diese sind nur innerhalb der Methode bekannt. Methoden können nur in Klassen definiert werden. ==> Es gibt keine
Methoden innerhalb von Methoden. Hat die Methode keine Parameter, ist die leere Parameterliste ()
anzugeben.
DV
G1 - 0
7 - M
eth
oden
10
Methoden-Aufruf Klassenname.Methodenname(p1, p2, ..., pN) innerhalb
von Ausdrücken oder Klassenname.Methodenname(p1, p2, ..., pN); auch
möglich wenn die Methode einen Wert zurückgibt, dieser wird dann ignoriert.
p1, p2, ..., pN können beliebige Ausdrücke sein Die Ausdrücke werden berechnet und auf „Hilfsvariable“ zugewiesen. Die Hilfsvariablen werden der Methode übergeben „call by value“. Die Werte außerhalb der Methode werden nicht geändert.
DV
G1 - 0
7 - M
eth
oden
11
return-Anweisung Wenn mtyp==void angegeben wurde, kann die Anweisung return;
zum Verlassen der Methode verwendet werden. Fehlt die return-Anweisung wird die Methode am Ende verlassen.
Wenn mtyp!=void angegeben wurde, muß mindestens eine Anweisung return ausdruck; enthalten sein die den Wert der Methode berechnet und die Methode verläßt. ausdruck wird in den Typ mtyp konvertiert.
DV
G1 - 0
7 - M
eth
oden
12
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"));}
DV
G1 - 0
7 - M
eth
oden
13
Überladene Methoden Methoden können überladen werden, d.h. es gibt innerhalb einer Klasse
mehrere Methoden mit gleichem Namen, aber unterschiedlicher Parameterliste, d.h. mit unterschiedlicher Anzahl von Parametern oder unterschiedlichen Typen. Der Typ der Methode spielt für die Unterscheidung der Methoden keine Rolle.
Beim Aufruf einer überladenen Methode wird die Menge aller bekannten Methoden in folgenden Schritten eingeschränkt:
DV
G1 - 0
7 - M
eth
oden
14
• 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
DV
G1 - 0
7 - M
eth
oden
15
Beispiel:
public static void m (int p1, double p2){...} // m1
public static void m (double p1, int p2){...} // m2
public static void m (double p1, double p2){...} // m3
int i1=0, i2=0; float f1=0f, f2=0f; double d1=0, d2=0;
m(i1,d1); // m1
m(d1,i1); // m2
m(d1,d2); // m3
m(f1,f2); // m3
m(i1,f2); // m1
m(i1,i2); // unzulässig
alle Methoden haben passende Parameter, m3 wird eliminiert, da m1 spezifischer ist
m1 und m2 erfüllen alle Bedingungen, damit ist der Aufruf nicht entscheidbar, also unzulässig.
DV
G1 - 0
7 - M
eth
oden
16
public static int max (int x, int y)
{ return (x>y)?x:y; }
public static long max (long x, long y)
{ return (x>y)?x:y; }
public static float max (float x, float y)
{ return (x>y)?x:y; }
public static double max (double x, double y)
{ return (x>y)?x:y; }
DV
G1 - 0
7 - M
eth
oden
17
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;
DV
G1 - 0
7 - M
eth
oden
18
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);}}
DV
G1 - 0
7 - M
eth
oden
19
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
DV
G1 - 0
7 - M
eth
oden
20
Seiteneffekte
Haupteffekte: Eingaben über Parameter Ausgaben über den Wert
Seiteneffekte: Lesen aus Dateien Lesen im Dialog Beeinflussung der Arbeitsweise einer Methode durch globale
Variable Schreiben in Dateien Ausgaben im Dialog Verändern von globalen Variablen
DV
G1 - 0
7 - M
eth
oden
21
Methode
Parameter 1 Parameter NParameter 2
Wert
Globale Variable
Dateien
Globale Variable
Dateien
DV
G1 - 0
7 - M
eth
oden
22
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);}}
DV
G1 - 0
7 - M
eth
oden
23
rekursive Methoden
Methoden die sich direkt oder indirekt selbst aufrufen. direkte Rekursion: Methode ruft sich selbst auf
z.B.: Berechnung der Fakultät mit n!=n*(n-1)!
public static long fakultaet(long n)
{ return (n>0)?n*fakultaet(n-1):1; } indirekte Rekursion: Methode ruft eine andere Methode auf, die
dann die erste Methode aufruft
z.B.: An=Bn+Bn-1 , Bn=2*An-1+Bn-2 wenn n>1, A0=A1=B0=B1=1
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; }
DV
G1 - 0
7 - M
eth
oden
24
Es muß vom Programmierer sichergestellt werden, daß keine unendlichen Rekursionen auftreten. Z.B. durch Indizes und Abbruchbedingungen (in den Beispielen „n“).
Rekursive Aufrufe erfordern einen sehr hohen Systemaufwand. Man sollte sie nur nutzen, wo es sinnvoll ist.
z.B.: fakultaet(n) ==> fakultaet(n-1) ==> ... ==> fakultaet(0)
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)) ==> ...
also ca. 2n Aufrufe ==> nur für kleine n realistisch !!!!
Die Methoden werden sehr oft mit den gleichen Parametern aufgerufen.
Rekursionen lassen sich immer vermeiden.
DV
G1 - 0
7 - M
eth
oden
25
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; }
DV
G1 - 0
7 - M
eth
oden
26
Beispiel: Binomialkoeffizienten
knkn
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
DV
G1 - 0
7 - M
eth
oden
27
!!
!
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
DV
G1 - 0
7 - M
eth
oden
28
neue Rekursionsformel:
1
1
!11!1
!1
!!
!
k
n
k
n
knk
n
k
n
knk
n
k
n
DV
G1 - 0
7 - M
eth
oden
29
k
n
k
n
k
n
k
n
knk
n
k
n
1
1
1
1
1
!!
! 3
2
1
mögliche Berechnungsformeln
DV
G1 - 0
7 - M
eth
oden
30
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);}}
DV
G1 - 0
7 - M
eth
oden
31
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);}}
DV
G1 - 0
7 - M
eth
oden
32
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);}}
DV
G1 - 0
7 - M
eth
oden
33
Vergleich
Methode 1 einfache Formel nur für kleine n, da n! berechnet wird sehr schnell, da keine Rekursion
Methode 2 liefert auch für recht große n und k brauchbare Werte schnell, da nur k-fache Rekursion Achtung: Reihenfolge wichtig
Methode 3 funktioniert prinzipiell für den größten Bereich für mittlere n nicht mehr brauchbar wegen der großen Rechenzeit
2n-fache Rekursion
Top Related