Einführung in Java, Teil 4

Einführung in Java, Teil 7
(a) Weitere grundlegende Konzepte, und
(b) Applikationen
Vorlesung Informatik I, 8 & 13.12.2005,
Daniel Huson
Grundtypen und ihre „Wrapper“Klassen
• Die Grunddatentypen in Java sind:
– boolean, byte, char, int, long, float, double
• Zu jedem Grunddatentyp gibt es eine
passende „Wrapper“-Klasse im Paket
java.lang:
• Boolean, Byte, Character, Integer, Long,
Float, Double
Grundtypen und ihre Klassen
• Objekte der Grundtypen und ihre Klassen
können ineinander überführt werden, z.B.:
Integer elf1=new Integer(11);
int elf2= elf1.intValue();
• Die Hilfsklassen enthalten auch Methoden, um
Strings zu parsen, z.B:
int i=Integer.parseInt(“999“);
double d=Double.parseDouble(“1.443“);
boolean ok=Boolean.parseBoolean(“true“);
Grundtypen und ihre Klassen
• Wrapper-Klassen enthalten wichtige
Konstanten, z.B:
Double.MIN_VALUE und
Double.MAX_VALUE,
die kleinste und größte doppeltgenaue
Fliesskommazahl, die repräsentierbar ist
Autoboxing und Unboxing
• Ganz neu in Java 1.5: Unter Auto-Boxing und –Unboxing
versteht mit die automatische Unwandlung zwischen
Grunddatentyp und Wrapper-Klasse, e.g.:
Integer a=new Integer(5);
Integer b=new Integer(6);
Integer c=new Integer(a.intValue()+b.intValue());
int d=c.intValue();
geht auch so:
Integer a=5;
Integer b=6;
Integer c=a+b;
int d=c;
Lebensdauer und Sichtbarkeit von
Variablen
• Der „Scope“ eine Variable ist der Bereich im Programm,
in dem die Variable sichtbar ist und ihren Wert behält
• Lokale Variablen werden innerhalb einer Methode in
einem { }-Block deklariert und der Scope ist dieser { }Block
• Objekt-Variablen werden innerhalb eines Objektes
definiert, aber ausserhalb aller Methoden, und der Scope
ist das Objekt
• Klassen-Variablen werden innerhalb einer Klasse mit
dem Schüsselwort „static“ definiert. Diese Variablen
existieren wärend der ganzen Laufzeit und sind für alle
Objekte der Klasse sichtbar.
Beispiel Lokale Variable
...
public int getSum (int[] values)
{
int sum=0;
for(int i=0;i<values.length;i++)
{
sum+=values[i];
}
return sum;
}
...
Scope
(Sichtbarkeit
und Lebensdauer)
von i
Scope
(Sichtbarkeit
und Lebensdauer)
von sum
Beispiel Objekt-Variable
public class Counter {
private int count=0;
public void increment ()
{
count++;
}
public int getCount ()
{
return count;
}
}
Sichtbarkeit
von count
Beispiel Klassen-Variable
public class Cat {
private static int count=0; // Klassenvariable
private String name;
// Objektvariable
public Cat (String name) // Konstruktor
{
count++;
this.name=name;
}
public static int getNumberOfCatsConstructed ()
{
return count;
}
public String getName ()
{
return name;
}
Sichtbarkeit
von name
und count
}
Jedes Objekt hat eine eigene Variable „name“, aber die Klasse Cat hat
nur einen Zähler „count“, der festhält, wieviele Cats konstruiert wurden
Methodenparameter
public class Cat {
private static int count=0; // Klassenvariable
private String name;
// Objektvariable
int age;
public Cat (String name,int age) // Konstruktor
Da age als int Variable ein
{
Grundtyp ist, wird hier nur ein
count++;
Wert übergeben. age ist
this.name=name;
eine lokale Variable, die mit dem
this.age=age;
Übergabewert initialisiert wird.
}
...
Die Variable name ist nur innerhalb der Methode
sichtbar. Diese Variable wird mit eine
Referenz auf ein Objekt initialisiert, das ausserhalb der
Methode existiert und nach Beendigung des
Methodenaufrufes weiterexistieren wird.
Applikationen vs Applets
• Ein Applet läuft im Rahmen eines Webbrowsers
• Eine Applikation ist ein vollwertiges „Standalone“
Programm
• Haupteinstiegpunkt ist eine Methode mit der Signatur
„public static void main (String[] args)“
• „Zeilenorientierte“ Programme lesen von der Konsole
und schreiben zur Konsole, z.B. wichtig für die Erstellung
von Verarbeitungspipelines
• „GUI-orientierte“ Programme werden mittels einer
graphischen Benutzeroberfläche (GUI) bedient
Die String Klasse
Zeichenketten können mittels Arrays
gespeicht werden:
• byte[] : 8-Bit Kode (ASCII),
• char[] : 16-Bit Kode (unicode)
• Um Zeichenketten (strings) zu verarbeiten,
bietet Java jedoch eine eigene String
Klasse, sowie einige Hilfsklassen
Die String Klasse
• Java bietet eine spezielle String Klasse, um
Zeichenketten zu repräsentieren
• Die Zeichenkette eines String-Objektes wird bei
der Konstruktion des Objekts festgelegt und
kann danach nicht verändert werden
• Die String-Klasse bietet also keine Methoden an,
um die repräsentierte Zeichenkette zu
verändern.
• Strings können wie folgt explizit angegeben
werden:
“Hallo Paul, wie geht es Dir?“
Die String Klasse
• Konstruktoren:
String s=“wort“;
• Umständlich, aber gleichwertig:
String s=new String(“wort“);
• Strings können aneinandergeht werden:
String name=“Paul“;
String s=“Hallo “+name+“, wie geht es Dir?“;
• Der String s repräsentiert dann:
“Hallo Paul, wie geht es Dir?“
Der Vergleich von Strings
• Beispiele:
String a=“hallo“, b=“hallo“, c=“Hallo“, d=c;
• a==b liefert false, da Referenzen zu verschiedenen
Objekten
•
•
•
•
a.equals(b) liefert true
a.equals(c) liefert false
a.equalsIgnoreCase(c) liefert true
c==d liefert true
Der Vergleich von Strings
• Die Methode a.compareTo(String b) liefert
-1,
0,
1,
falls Zeichenkette von a lexikographisch kleiner als die von b
falls beide gleich
falls die Zeichenkette von a lexikographisch größer als die von b
• Beispiel:
String a=“Peter“, b=“Petra“, c=“Petal“;
• a.compareTo(b) liefert -1
• a.compareTo(c) liefert 1
• a.compareTo(a) liefert 0
StringBuffer
• Zeichenketten können Mithilfe der StringBuffer
Klasse nach-und-nach konstruiert werden,
Beispiel:
• StringBuffer sb=new StringBuffer();
• sb.append(“Hallo “);
• sb.append(“Paul,“);
• sb.append(“ wie geht es Dir?“);
• String s=sb.toString();
• Der String s repräsentiert dann:
“Hallo Paul, wie geht es Dir?“
StringWriter
• Zeichenketten können Mithilfe der StringWriter
Klasse nach-und-nach geschrieben werden,
Beispiel:
• StringWriter sw=new StringWriter ();
• sw.write(“Hallo “);
• sw.write(“Paul,“);
• sw.write(“ wie geht es Dir?“);
• String s=sw.toString();
• Der String s repräsentiert dann:
“Hallo Paul, wie geht es Dir?“
Darstellung von Klassen als Strings
• Jede Klasse hat eine toString() Methode
(von der Object-Klasse geerbt), um eine
String-Darstellung des Objekts zu liefern. Beim
Programmiern sollte man diese Methode mit
eigenem Code überschreiben.
• Die Verwendung ist dann z.B. so:
Integer i=new Integer(55);
System.out.println(“Wert=“+i);
• Hier wird die Methode i.toString()
aufgerufen!
Zeilenorientiertes Programm
Beispiel: einfaches Statistikprogramm
• Eingabe: Liste von Zahlen, mit „.“ beendet
• Ausgabe:
– Anzahl, Summe, Minimum, Maximum,
Mittelwert
Beispiel Statistik
Zahlen eingeben, mit '.' beenden:
34
567
56
6
.
Anzahl: 4
Summe: 663.0
Min:
6.0
Max:
567.0
Mittel: 165.75
import …
// Einfache Statistiken, Daniel Huson, 12.2005
public class Statistik {
public static void main (String[] args) throws Exception
{
int anzahl=0;
double summe=0;
double min=Double.MAX_VALUE;
double max=Double.MIN_VALUE;
Beispiel Statistik
System.out.println("Zahlen eingeben, mit '.' beenden:");
// Lese Zeilen von der Konsole
BufferedReader r=new BufferedReader(new
InputStreamReader(System.in));
for(String aLine=r.readLine(); aLine!=null; aLine=r.readLine())
{
if(aLine.equals("."))
break; // Eingabe beendet
if(aLine.length()==0)
continue; // Leere Zeile, zum Ende des Blocks springen
double value=Double.parseDouble(aLine);
anzahl++;
summe+=value;
if(value<min)
min=value;
if(value>max)
max=value;
}
double mittel=0;
if(anzahl>0)
mittel=summe/anzahl;
System.out.println("Anzahl: "+anzahl);
System.out.println("Summe: "+summe);
System.out.println("Min:
"+min);
System.out.println("Max:
"+max);
System.out.println("Mittel: "+mittel);
}
}