JAVA - Code Konvention

Übungen Informatik I
JAVA
- Code Konvention
- Grundtypen
http://www.fbi-lkt.fh-karlsruhe.de/lab/info01/Tutorial
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 1
JAVA
Code-Konvention
Motivation
Code-Konventionen sind wichtig für Entwickler:
80% der Kosten einer Software entstehen durch Pflege.
Kaum ein Stück Software wird von einem Entwickler
während der gesamten Lebensdauer gepflegt.
Konventionen erhöhen die Lesbarkeit und erleichtern es
damit den Entwicklern, neuen Code zu verstehen.
Code-Konventionen sind Richtlinien, nach denen man Code
schreiben kann (nicht muss).
Es gibt gute Sourcecode-Formatierer als Freeware.
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 2
JAVA
Code-Konvention
Motivation
Vorher:
// Quick and dirty...
public void run(int[] a){int hold;for(int pass=1;pass<a.length; pass++)for(int
i=0;i<a.length-1;i++)if(a[i]>a[i+1]){hold=a[i]; a[i]=a[i+1];a[i+1]=hold;}}
Nachher:
/**
* Sorts an integer array.
* Algorithm used: Bubble-Sort.
* Recommended for next version: quick sort
*
* @param values An unsorted array
*
The sorted values are stored in the same array.
*/
public void run (int[] values) {
int hold;
for( int pass = 1; pass < values.length; pass++ ) {
for( int i = 0 ; i < values.length - 1; i++ ) {
if( values[ i ] > values[ i + 1 ] ) {
hold
= values[ i ];
values[ i ]
= values[ i + 1 ];
values[ i + 1 ] = hold;
}
}
}
}
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 3
JAVA
Code-Konvention
Source-Dateien
Datei-Endungen
Datei-Typ
Endung
Java-Quelltext
.java
Java-Bytecode
.class
Java-Archiv
.jar oder .zip
Datei-Namen
Der Dateiname für Quelltextdateien entspricht dem
Namen der öffentlichen Klasse, welche in der Datei
enthalten ist.
Pro Datei ist nur eine öffentliche Klasse erlaubt.
Datei-Größe
Quelltextdateien sollten nicht länger als 2000 Zeilen und
nicht breiter als 80 Spalten sein.
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 4
JAVA
Code-Konvention
Sortierung innerhalb der Quelltextdatei:
Kommentar (Klassenname, Version, Copyright)
Package-Name (optional)
Pakete kommen noch!
Import-Anweisungen (weniger ist mehr!)
kommt
noch!
Deklaration der Klassen (und Schnittstellen)
Dokumentationskommentar
class-Anweisung
statische Attribute der Klasse (public, protected,
private)
Attribute (public, protected, private)
Konstruktoren
Methoden, gruppiert nach Funktionalität und nicht
nach Gültigkeitsbereichen (public, protected, private)
Jeder öffentlichen Klasse oder Methode sollte ein
Dokumentationskommentar vorangestellt sein.
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 5
JAVA
Code-Konvention
Einrückungen
Eine Einrückungsstufe: 2 oder 4 Leerzeichen
Tabulator: eine Einrückungsstufe
Tipp: Im Editor einstellen, dass Tabulatoren in Leerzeichen
umgewandelt werden.
Zeilenumbruch
Umbruch sollte erfolgen:
nach einem Komma
vor einem Operator
Beispiel:
method (long longExpression1, long longExpression2,
long longExpression3);
longName1 = longName2 + longName3 + longName4
+ longName5;
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 6
JAVA
Code-Konvention
Dokumentationskommentare
Für Klassen, Interfaces, Methoden und deren Parameter.
Die Dokumentationskommentare werden durch /** eingeleitet:
/**
* The example class provides...
*/
public class Example {
/**
* comment
*/
public void test (int times) {
}
}
Die Kommentare sollten zusätzliche Tags erhalten, die durch das
Programm javadoc ausgewertet werden können.
Damit kann beispielsweise eine komplette HTML-Dokumentation
aller öffentlichen Methoden generiert werden.
Die Java-API-Dokumentation wird so erstellt.
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 7
JAVA
Code-Konvention
Dokumentationstags:
Klassen und Interfaces
Konstruktoren und Methoden
@author
Name
@param
Name description
@version
1.0, 20 Sep. 2001
@return
description
@since
JDK 1.0
@exception
classname descr.
@see
classname
@see
classname
@deprecated
@deprecated
Beispiel:
/**
* Sorts an array of integer values.
* @param values Unsorted array of values.
* @return Sorted array of values.
* @exception NullPointerException Thrown, if values is null.
* @see
java.util.Arrays.sort (int[] a)
*/
int[] sort (int[] values) throws NullPointerException
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 8
JAVA
Aufbau des Quelltextes
•
„Java Bezeichner“
Bezeichner
Ein Bezeichner ist eine Sequenz von Zeichen, die dazu dient, die
Namen von Variablen, Klassen oder Methoden zu spezifizieren.
-
Ein Bezeichner muss immer mit einem Unicode-Buchstaben (Das
sind die Zeichen 'a'-'z', 'A'-'Z', '_', '0'-'9' und '$') beginnen und
darf dann weitere Buchstaben oder Ziffern enthalten.
('_' und '$' sollen nur aus historischen Gründen, bzw. bei
maschinell generiertem Java-Code verwendet werden)
-
Ein Bezeichner darf weder ein Schlüsselwort, ein Boole'sches
Literal noch ein null-Literal sein.
-
Alle Stellen des Bezeichners sind signifikant.
-
Groß- und Kleinschreibung werden unterschieden.
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 9
JAVA
Aufbau des Quelltextes
„Java Literale“
Literale sind Werte eines primitiven Datentyps, eines Strings oder null.
Literale dienen dazu, in einem Javaprogramm Konstanten aufzuschreiben. (Sie sind nicht
zu verwechseln mit den Konstantendeklarationen).
Java kennt folgende Typen von Literalen:
Ganze Zahlen:
Float-Zahlen:
Double-Zahlen:
Logische Literale:
Referenz-Literale:
Character-Literale:
0;
123;
0xDadaCafe
3.2f;
-3e-22f
3.2;
-3e-22
true;
false
null; this; super
'A'‚
Zeichenketten-Literale:
""; "\""; "Hello World"
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 10
JAVA
Java-Literale
„Integer-Literal“
Integer-Literal: ganzzahliger Integerwert
Ganze Zahlen:
0; 123; 0xDadaCafe
Konstanter ganzzahliger Wert, der dezimal, hexadezimal (sedezimal) oder
oktal angegeben werden kann.
Automatische Typvergabe
int, long usw.
Manuelle Typvergabe: Endung L oder l für long, Beispiel: 42l
Standardtyp ist int
Kann in folgender Form geschrieben werden:
dezimal:
keine besondere Angabe, erlaubt sind die Ziffern 0-9
und ein Vorzeichen, Beispiel: -1234
hexadezimal:
vorangestelltes 0x (Ziffer 0), erlaubt sind die Ziffern
0-9 sowie die Buchstaben A-F, Beispiel: 0x1C2A
Oktal:
vorangestellte 0 (Ziffer 0), erlaubt sind die Ziffern
0-7, Beispiel: 01234
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 11
JAVA
Java-Literale
„Fließkomma-Literal“
Fließkomma-Literal: Gleitkommawert
Float-Zahlen:
3.2f; -3e-22f
Double-Zahlen:
3.2; -3e-22
Konstanter Fließkomma-Wert, der nach der IEEE-Norm 754 abgelegt wird.
Es werden einfache Genauigkeit mit 32 Bit (float) und doppelte
Genauigkeit mit 64 Bit (double) unterstützt.
Verschiedene Zahlenformate sind erlaubt, Beispiele:
0.31415:
3e-2:
-3e2:
entspricht der Zahl
0,31415
entspricht der Zahl 3*10-2 = 0,03
entspricht der Zahl -3 * 102 = -300
Standardtyp ist double => Ohne extra Suffix handelt es sich immer
um doppelte Genauigkeit. Um die Genauigkeit zu steuern, kann ein
sog. Suffix angehängt werden:
·f,F: Einfache Genauigkeit (float), Beispiel: 3e2f
·d,D: Doppelte Genauigkeit (double, redundante Angabe),
Beispiel:
3e2d
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 12
JAVA
Java-Literale
„Boole‘sches-Literal“
Boole'sches-Literal logischer Datentyp
Logische Literale:
“boolean“:
true; false
Konstanter Wahrheitswert (wahr oder falsch).
Nur zwei Werte sind möglich:
true: wahr.
false: falsch.
Hinweis: Eine Umwandlung in Integer-Literale wie in C++ ist nicht
möglich.
null-Literal: Konstanter Wert, der anzeigt, dass eine Objektreferenz auf
kein Objekt zeigt
kommt später.
Zeichen-Literal (“char“): Konstanter Zeichenwert für ein einzelnes
Zeichen des Typs char.
Ein Zeichen-Literal ist ein 16 Bit Wert, dargestellt durch UnicodeZeichen.
Schreibweise: in einfachen Anführungszeichen.
Beispiel: 'A‘ oder ‘\u0041‘
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 13
JAVA
Java-Literale
„Referenz-Literale“
null;
Referenz-Literale:
this; super
null:
Konstanter Wert, der anzeigt, dass eine Objektreferenz auf kein
Objekt zeigt
kommt später
this:
Die symbolische Referenz this ist eine Referenz auf das eigene
Objekt
super:
kommt später
Mit der Referenz
super kann auf Methoden und Attribute von
übergeordneten Basisklassen zugegriffen werden.
kommt später
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 14
JAVA
Java-Literale
Referenztypen
public class AsterixUndRoemer {
public static void main ( String [] args ) {
// Zwei Variablen vom Typ der Klasse String
String ga, ro;
// werden deklariert
int r;
ga = "Asterix";
// Variable r vom Typ int wird deklariert
// der Variablen ga wird eine Referenz auf
// String “Asterix“ zugewiesen
ro = "Roemer";
// der Variablen ro wird eine Referenz auf
// String “Roemer“ zugewiesen
r = 1+1;
System.out.println (ga + " sieht " + r + " "+ro);
}
}
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 15
JAVA
Java-Literale
„Character, Zeichenketten-Literale“
Character- und Zeichenketten-Literale werden intern in Unicode kodiert. :
Character-Literal („char“):
'A'‚
Konstanter Zeichenwert für ein einzelnes Zeichen des Typs char.
Ein Zeichen-Literal ist ein 16 Bit Wert, dargestellt durch Unicode-Zeichen.
Schreibweise: in einfachen Anführungszeichen.
Beispiel: 'A‘ oder ‘\u0041‘
Zeichenketten-Literal:
""; "\"";
Konstanter Wert für eine Folge von Zeichen.
"Hello World“
String-Literale werden durch einzelne Unicode-Zeichen repräsentiert.
Schreibweise: in doppelten Anführungszeichen. Beispiel: "Hallo"
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 16
JAVA
Java-Literale
„Escape-Sequenzen“
Um Zeichen darstellen zu können, deren Eingabe mit einfachen Editoren nicht möglich ist
oder sie sonst syntaktisch nicht möglich wären, verwendet man sogenannte EscapeSequenzen:
Escape-Sequenzen:
Unicode
\b
\t
backspace
tab
\n
\f
\r
\“
\‘
\\
\uabcd
linefeed
\u000a
formfeed
\u000c
carriage return
\u000d
Anführungszeichen \u0022
Apostroph
\u0027
Backslash
\u005c
hexadezimaler Unicode abcd
Helga Gabler, Holger Vogelsang, Christian Pape
\u0008
\u0009
Übungen Informatik 1
Wirkung
Rückschritt
horizontaler Tabulator
neue Zeile
Seitenumbruch
Wagenrücklauf
Darstellung von “
Darstellung von ‘
Darstellung von \
Folie 17
JAVA
Java-Literale
„Character- und Zeichenketten-Literale“
public class HalloJava {
public static void main ( String [] args ) {
System.out.println ();
System.out.println ("Hallo Java");
System.out.println ("Er sagt: \"Hallo\nJava\" ");
System.out.println ();
}
}
Zeichenketten-Literale können sich nicht über mehrere Quelltextzeilen erstrecken, sie
müssen stets vor Zeilenenden enden. Benötigt man längere Zeichenketten-Literale, so
müssen Teile mit + verkettet werden.
System.out.println (“Hallo Java\r und sagt“
+ “danach\"Hallo\nJava\" ");
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 18
JAVA
Java-Literale
„Unicode“
Unicode-Escapesequenzen für nicht-darstellbare Zeichen
Ein Java-Programm besteht aus einer Folge von Unicode-Zeichen. Der Unicode
umfaßt derzeit 34000 Zeichen (max = 65536 ).
Der numerische Wert eines Zeichens im Unicode-Format kann direkt eingegeben
werden. Format der Eingabe: \uxxxx, wobei x eines der Zeichen im Bereich von
0-9 oder A-F ist (hexadezimal).
Beispiel:
char a;
a = 97; a = 'a'; a = '\u0061‘
Die drei Zuweisungen haben dieselbe Semantik.
Die Unicode-Zeichen im Bereich von 0-128 entsprechen den Zeichen des ASCIIFormats. Im Bereich 129 -255 ist der Zeichensatz identisch mit ISO 8859-1 (Latin-1:
westeuropäische Sonderzeichen -> weiter Infos zu Zeichensätzen unter
http://www.odinet.de/slovo/codep.htm oder http://www.unicode.org )
public class HalloUnicode {
public static void main ( String [] args ) {
System.out.println ("\u0048\u0061\u006C\u006C\u006F");
}
}
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 19
JAVA
Java-Literale
„Unicode“
public class UnicodeAnwendung {
public static final char SZ = '\u00df';
public static void main(String[] args) {
System.out.println( Integer.toHexString('ß') );
System.out.println( “Ich hei" + SZ + "e");
}
}
Integer.toString (‘ß‘, 16) oder
Integer.toHexString ( ‘ß‘ )
liefert den Unicode in hex-Schreibweise für das Zeichen ß.
System.out.println ("\u00df”);
gibt immer ein ß aus; egal von welcher Plattform aus das Java-Programm übersetzt wird
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 20
JAVA
Java-Literale
4 Typen:
2 Typen:
1 Typ:
1Typ:
„8 Grundtypen“
(byte, short, int, long) für ganzzahlige Integerwerte
(float, double)
für Fließkommawerte (Gleitpunktwerte)
(char)
für Character- oder Zeichenwerte
(boolean)
für Wahrheitswerte (boolesche Werte)
Integrale Datentypen
Typ
Bit
von
bis einschließlich
boolean
8
false
true
byte
8
-128
127
short
16
-215 = -32.768
215 -1 = 32.767
int
32
-231 = -2.147.483.648
231 -1 = 2.147.483.647
long
64
-263 = -9.223.372.036.854.775.808
263 -1 = 9.223.372.036.854.775.807
char
16
0
65.535
Fließkomma-Datentypen
Typ
float
double
Größe Genauigkeit
von
32 Bit 6-7 Stellen
1.4E-45
64 Bit 15-16 Stellen 4.9E-324
Helga Gabler, Holger Vogelsang, Christian Pape
bis einschl.
3.4028235E38
1.7976931348623157E308
Übungen Informatik 1
Folie 21
JAVA
Java-Literale
„erweiterte Typkonvertierung“
Java wandelt automatisch einen kleineren (niederwertiger) in einen
größeren (höherwertiger) Datentyp um
byte
short
char
int
int
long
float
double
Wenn in einer Operation zwei unterschiedliche Typen enthalten sind:
z.B. System.out.println (integerZahl * longZahl);
autom. Umwandlung von int in long
Wenn in einer Operation gleiche Datentypen enthalten sind, die kleiner sind als
integer, wird das Resultat mindestens vom Typ integer sein.
z.B.: System.out.println (char * char);
Ergebnis vom Typ int
double x=10;
10 wird in double konvertiert
char c=‘a‘;
int i;
i=c;
char wird in int konvertiert
x=c;
char wird in double konvertiert
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
(‘a‘ => 97)
(‘a‘ => 97.0)
Folie 22
JAVA
Java-Literale
„erweiterte Typkonvertierung“
public class Typen01 {
public static void main (String[] args)
int ersteZahl;
long zweiteZahl =999999;
ersteZahl = 999999;
{
System.out.println (ersteZahl * ersteZahl);
/*Java bestimmt, dass das Ergebnis vom Typ int sein wird
deshalb hier: falsches Ergebnis (zu groß für Integer, s. Tabelle)
*/
System.out.println (ersteZahl * zweiteZahl);
/* Java bestimmt, dass das Ergebnis vom Typ long sein wird (s.o.),
automatische Typkonvertierung von int nach long, weil zweiteZahl eine
long-Variable ist )
}
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 23
JAVA
Java-Literale
„eingeschränkte Typkonvertierung“
Umwandlung vom größeren (höherwertiger) in einen kleineren
(niederwertiger) Datentyp geschieht in Java mit dem
cast-(Konvertierungs-) Operator
„eingeschränkte Konvertierung“
cast : = voranstellen, vorstellen-Operator, gibt den Zieltyp an (typ)
byte
short
char
int
int
long
float
double
Ziel-Typ in runden Klammern
i
= (int) 99.9999; double-wert 99.9999 wird nach int
konvertiert, der Nachkommateil wird abgeschnitten.
abc = (byte) xyz;
Helga Gabler, Holger Vogelsang, Christian Pape
char-Wert xyz wird nach byte konvertiert
Übungen Informatik 1
Folie 24
JAVA
Java-Literale
„eingeschränkte Konvertierung“
public class Typen02 {
public static void main(String[] args) {
byte aZahl = 2;
byte bZahl = 5;
byte cZahl;
// FEHLER!
// das Ergebnis ist vom Typ integer,
// obwohl als byte deklariert
cZahl = (byte) aZahl * bZahl;
// FEHLER!
cZahl = aZahl * bZahl;
cZahl = (byte) (aZahl * bZahl); // cZahl soll vom Typ byte sein
// Typumwandlung per Cast
// bzahl=bZahl*aZahl
// effektiv -> ohne Zwischenergebnis
bZahl *= aZahl;
System.out.println(cZahl);
System.out.println(bZahl);
}
}
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 25
JAVA
Java-Literale
“Konstanten“
final float MEHRWERTSTEUER = 16.0
final char EURO;
EURO = ‘€‘
wurde der Wert der final-Variable (hier €) einmal festgelegt,
ist eine spätere Änderung nicht mehr möglich.
die Variable kann wie eine Konstante eingesetzt werden.
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 26
JAVA
Aufbau des Quelltextes
„Operatoren“
Operatoren
Operatoren werden für Vergleiche und Berechnungen verwendet.
Die Operatoren sind:
Arithmetische Operatoren:
Relationale Operatoren:
Logische Operatoren:
+
>
!
Bit Operatoren:
Zuweisungs Operatoren:
~ | & ^ >> >>> <<
= += -= *= /= %=
|= ^= <<= >>= >>>=
Sonstige Operatoren:
?: [ ] . (parameterliste)
(type) new instanceof +
- * /
>= <
&& ||
%
<=
==
!=
&=
Prioritäten : http://java.rrzn.uni-hannover.de/tkji/javakurs/start-frame.html
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 27
JAVA
Variablen
Variablen dienen dazu, Daten im Hauptspeicher eines Programms abzulegen und
gegebenenfalls zu lesen oder zu verändern. In Java gibt es drei Arten von Variablen:
Lokale Variablen:
müssen explizit initialisiert werden
Deklaration und Gültigkeit:
innerhalb einer Methode oder innerhalb eines Blocks einer Methode
(kommt später, im 2. Semester)
Instanzvariablen:
Existieren zusammen mit den Instanzen der Klasse
Modifikatoren sind zulässig
werden beim Erzeugen der Instanz initialisiert
Deklaration:
innerhalb des Rumpfes einer Klasse
(kommt später, im 2. Semester)
Klassenvariablen
Existieren unabhängig von den Instanzen der Klasse
Modifikatoren sind zulässig
werden beim Laden der Klasse initialisiert
Deklaration:
innerhalb des Rumpfes einer Klasse und
explizit mit static als Klassenvariable vereinbart.
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 28
JAVA
Variablen
Alle Variablen müssen in Java deklariert werden,
bevor man sie verwendet
Variablen werden wie folgt gebildet:
Modifikator(en) – Typ – Name – Wert
Modifikatoren: Sichtbarkeitsbereich und Lebensdauer
Typ:
Grundtyp oder Referenztyp
Name:
Java-Bezeichner
Bei der Deklaration können Variablen gleich initialisiert werden
int
float
char
static final float
String
Helga Gabler, Holger Vogelsang, Christian Pape
ivar1, ivar2, ivar3;
wurzel;
cv1=‘a‘, cv2=10; cv3;
PI = 3.14F;
zeile; (Referenztypvariable)
Übungen Informatik 1
Folie 29
JAVA
Gültigkeitsbereich von Variablen
public class BlockDemo {
// Anfang Block der Klasse BlockDemo
public static void main(String[] args) { // Anfang Block Methode main
String blk = "Main-Block";
System.out.println(blk); {
// ein Block (Block 1)
String blk1 = " Block 1";
System.out.println(blk + blk1);
}
{
/* noch ein Block , blk1 aus Block 1 ist
in diesem Block nicht "sichtbar„ */
String blk2 = " Block 2";
System.out.println(blk + blk2);
// System.out.println(blk1);
}
}
}
// Ende main()
// Ende class BlockDemo
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 30
JAVA
Java-Befehle
„Beispiele“
// Deklaration
// Zuweisung
/* Zuweisung a = a+1: Abk + effekt. Anweisung,
*/ weil kein Zwischenergebnis gebildet wird.
// Methodenaufruf
int ivar1, ivar2;
a=b+c;
a++;
System.out.println(a,b);
if (a==b)
a=c;
oder
if (a==b){
a=c;
}
if (a==0) {
b=10;
c=20;
}
int c;
if (a==c){
b=a;
c=b;
System.out.println(a,b);
// Schlüsselwort if
// dasselbe über mehrere Zeilen
// hier kein Semikolon
// Block
// zusammengesetzter Befehl:
// blocklokale Variable
}
Helga Gabler, Holger Vogelsang, Christian Pape
Übungen Informatik 1
Folie 31