einf hrung in die programmierung datensammlung l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Einführung in die Programmierung Datensammlung PowerPoint Presentation
Download Presentation
Einführung in die Programmierung Datensammlung

Loading in 2 Seconds...

play fullscreen
1 / 40

Einführung in die Programmierung Datensammlung - PowerPoint PPT Presentation


  • 220 Views
  • Uploaded on

Fakultät für Wirtschaftswissenschaften. Einführung in die Programmierung Datensammlung. Uwe Lämmel. www.wi.hs-wismar.de/~laemmel Uwe.Laemmel@hs-wismar.de. Inhalt . Verwalten mehrerer Objekte: Sammlungen (Collections) ArrayList Array Arbeiten mit Sammlungen: Wiederholung (Iteration)

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

Einführung in die Programmierung Datensammlung


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
einf hrung in die programmierung datensammlung

Fakultät für Wirtschaftswissenschaften

Einführung in die ProgrammierungDatensammlung

Uwe Lämmel

www.wi.hs-wismar.de/~laemmel

Uwe.Laemmel@hs-wismar.de

inhalt
Inhalt
  • Verwalten mehrerer Objekte:Sammlungen (Collections)
    • ArrayList
    • Array
  • Arbeiten mit Sammlungen:
    • Wiederholung (Iteration)
    • Iteratoren
    • Schleifen ( for–each, while–do, for)
sammlungen
Sammlungen

Typische Aufgabe der Wirtschaftsinformatik:

  • Verwalten mehrerer (beliebig vieler) Objekte :
    • Personal
    • Termine
    • Aufträge
    • Rechnungen
  • Aktionen:
    • Elemente hinzufügen
    • Elemente entfernen
    • Element suchen
beispiel notizbuch
Beispiel: Notizbuch

Anforderungen / Erwartungen:

  • Notizen speichern
  • keine Begrenzung für die Anzahl
  • Anzahl gespeicherter Notizen angeben
  • Einzelne Notizen anzeigen
  • Alle Notizen anzeigen

 Machen Sie sich mit dem Notizbuch-Projekten vertraut!!

klassen bibliotheken
Klassen-Bibliotheken
  • nicht alles muss neu programmiert werden:
  • es gibt nützliche, bereits "fertige" Klassen:Java – API: Application Programming Interface
  • Bibliothek in Java: package
  • java.util packagebietet Klassen für Objekt-Sammlungen
  • Wir nutzen Klasse ArrayList

 Machen Sie die Java – API für sich verfügbar!Schauen Sie sich die Klasse ArrayList an!

klasse notizbuch

erst ab Java 1.5

Klasse Notizbuch

import java.util.ArrayList;

/**

* ...

*/

public class Notizbuch {

// Speicher für beliebige Anzahl von Notizen

private ArrayList <String> notizen;

/**

* Initialisierung für ein Notizbuch

*/

public Notizbuch( ) {

notizen = new ArrayList<String>();

} // Konstruktor

...

} // Notizbuch

klasse arraylist
Klasse ArrayList
  • es wird definiert:
    • Typ der Sammlung: ArrayList
    • Typ der Elemente: <String>
    • Name der Sammlung: notizen

private ArrayList <String> notizen;

ArrayList<String> – "Array-Liste von Zeichenketten"

objekt struktur
Objekt-Struktur

 Was passiert beim Einfügen einer weiteren Notiz?

benutzen der sammlung
Benutzen der Sammlung

class Notizbuch {

private ArrayList <String> notizen;

...

publicvoid speichereNotiz(String notiz) {

notizen.add(notiz);

} // speichereNotiz

publicint anzahlNotizen() {

return notizen.size();

} // anzahlNotizen

...

} // Notizbuch

Hinzufügen einer Notiz

Gibt Anzahl der Elemente in der ArrayList zurück

add, size : Methoden der Klasse ArrayList, siehe API

ermitteln einer notiz
Ermitteln einer Notiz

Gültigkeit des Index prüfen!

publicvoid zeigeNotiz(int notiznummer){

if ( notiznummer >= 0

&& notiznummer < anzahlNotizen() ) {

System.out.println(notizen.get(notiznummer));

} // if

} // zeigeNotiz

  • vordefinierte Methode!
  • Parameter: Aufruf einer Methode!
zusammenfassung
Zusammenfassung
  • Elemente können hinzugefügt /entfernt werden
  • Jedes Element hat eine Nummer / Index: 0, 1 …
  • Wichtige Methoden der Klasse ArrayList sind:add, get, remove, size
  • ArrayList ist ein parametrisierter/generischer Datentyp
  • ArrayList-Objekte speichern beliebig viele Objekte
  • Java - API enthält packages mit vordefinierten Klassen: java.util.ArrayList, java.lang.String, java.lang.System
wiederholung iteration
Wiederholung = Iteration
  • oft sind Aktionen mehrfach auszuführen:
    • z.B. Ausgabe aller Notizen des Notizbuchs
  • die meisten Programmiersprachen bieten: Schleifen–Anweisungen (loop statements)
  • mehrere Schleifen-Formen in Java.
    • beginnen mit for–each–Schleife.
for each schleife
for–each–Schleife

Schlüsselwort for

Schleifen-Kopf

for ( ElementTyp element : Sammlung) {

Schleifen-Körper

} // for-each

Anweisungen, die wiederholt werden

Bedeutung:Für jedes element aus der Sammlung, führe die Anweisungen im Schleifen-Körper aus.

for each beispiel
for–each–Beispiel

/**

* Gib alle Notizen eines Notizbuchs aus

*/

public void notizenAusgeben() {

for(String notiz : notizen) { // Schleifen-Kopf

System.out.println(notiz); // Schleifen-Körper

} // for

} //notizenAusgeben

for each note in notes, print out note

while schleife
while–Schleife

Schlüsselwort while

Schleifenkopf: Bedingung

while(bedingung) {

Schleifen-Körper

}//while

Anweisungen, die wiederholt werden

Bedeutung:Solange die bedingung wahr (true) ist, führe die Anweisungen im Schleifen-Körper aus.

while schleife beispiel
while-Schleife: Beispiel

/**

* Gib alle Notizen eines Notizbuchs aus

*/

publicvoid notizenAusgeben() {

int index = 0;

while(index < notizen.size()) {

System.out.println(notizen.get(index));

index++;

} //while

}//notizenAusgeben

um 1 erhöhen

Bedeutung:while the value of index is less than the size of the collection, print the next note, and then increment index

while schleife17
while–Schleife

while (Bedingung) { Anweisungen }

  • while-Schleife ist anfangsgesteuert:
    • Bedingung wird zuerst geprüft  mind. einmal!
  • wird benutzt, falls:
    • die Zahl der Durchläufe unbestimmt und
    • Test der Bedingung vor dem Bearbeiten des Körpers erforderlich:
      • z.B. in Sammlungen: Gibt es überhaupt ein Element?
  • Anweisungen im Schleifen–Körper müssen Bedingung beeinflussen, z.B. i++;
for each versus while
for–each versus while

for–each:

  • einfacher aufzuschreiben
  • sicher: stoppt garantiert!
  • stets für alle Elemente der Sammlung

while:

  • nicht notwendig, die gesamte Sammlung zu bearbeiten
  • kann auch ohne Sammlung benutzt werden
  • Gefahr unendlicher Wiederholungen!
while ohne eine objektsammlung
while – ohne eine Objektsammlung
  • Gib alle geraden Zahlen zwischen 0 und 30 aus.
  • Berechne alle Teiler einer Zahl.
  • Bestimme die Quersumme einer Zahl.
  • Bestimme den größten gemeinsamen Teiler zweier Zahlen.
suche in einer sammlung von objekten
Suche in einer Sammlung von Objekten

int index = 0; // Nr. des aktuellen Elements

boolean gefunden = false; // schon gefunden?

// index < Größe der Sammlung UND noch nicht gefunden

while(index < notizen.size() && !gefunden) {

String notiz = notizen.get(index); // aktuelles Element

if(notiz.contains(suchString)) { // siehe API: lang.String

gefunden = true; // gefunden: Zeichenkette ist enthalten

} //if

else {

index++; // nächster Index=>nächstes Element

} //else

} //while

// Entweder gefunden oder gesamte Sammlung durchsucht

if(!gefunden) index = –1; // index für nicht gefunden

/** * Kopf der Methode (Signatur) sucheText

* @param suchString Zeichenkette nach der gesucht wird

* @return Index der Notiz, die text enthält, oder –1 */

public int sucheNotiz( String suchString ) {

return index;

} // sucheNotiz

schleife mittels iterator objekt
Schleife mittels Iterator-Objekt

Iterator<Elementtyp> it = meineSammlung.iterator();

while(it.hasNext()) {

ElementTyp el = it.next();// nächstes Element

Anweisungen "machen etwas" mit Element el

} //while

Beispiel:

public void notizenAusgaben() {

Iterator<String> it = notizen.iterator();

while ( it.hasNext() ) {

String el = it.next();

System.out.println(el);

} //while

} //notizenAusgeben

schleifen und objektsammlungen
Schleifen und Objektsammlungen
  • for–each:
    • wenn alle Elemente bearbeitet werden
  • while–Schleife:
    • falls nur einige Elemente bearbeitet werden
    • wird durch Bedingung gesteuert
    • für Wiederholungen ohne Sammlungen
  • Iterator–Objekt:
    • falls nur einige Elemente zu bearbeiten
    • insbesondere für Sammlungen ohne Index
    • alle Sammlungen (collections) der API stellen Iterator bereit
  • Iteration / Schleife ist wichtiges Programmier-Muster (pattern)
array sammlungen fester gr e
Array: Sammlungen fester Größe
  • häufig Obergröße für Objekt-Sammlungen bekannt
  • Programmiersprachen bieten:
    • spezielle Konstruktion: array
    • spezielle Schreibweise (Syntax):

typ[ ] bzw. element[index]

  • Arrays in Java speichern Objekte oder Werte einfacher Datentypen .
array

0

1

2

3

4

5

Array

feste Anzahl von Elementen eines Typs

  • Arrays sind Objekte: mit new-Methode erzeugen
  • Elemente eines Array beliebig aber fest:
  • Attribut length gibt Anzahl der Elemente an:

System.out.writeln(feld.length); // ausgegeben wird 6

  • Zugriff:
  • int[ ] feld = new int[6];

feld[0] = 17;

feld[1] = 35;

for(int i=0; i<feld.length; i++) feld[i]=2*i+1;

array arbeitsweise
Array: Arbeitsweise
  • Deklaration: int[ ] folge;int zfolge; // Zeiger Füllstand
  • Erzeugung: folge = newint[100];
  • Initialisierung: for(int i=0;i<max;i++) folge[i]=0;
  • Zugriff nur zwischen 0…max Index möglich!
    • Lesen: a = folge[z]; System.out.println(folge[2]); for(int i=1; i<zfolge; i++) summe +=folge[i];
    • Schreiben: folge[z] = b;
weblog analyse
Weblog–Analyse
  • Auswertung der Zugriffe je Stunde
  • vereinfacht
    • Zugriffe = Eingabe der Stunde durch Nutzer:Eingabe 14 = ein Zugriff in 14:00 – 14:59
  • notwendig:
    • Sammlung für 24 Werte (int)
    • Methode zum Einlesen von Werten
klasse weblog
Klasse Weblog

class Weblog {

// Instanz-Variabeln

private int[ ] zugriffInStunde;

private int maxSt;

public Weblog () {

maxSt = 24;

zugriffInStunde = new int[maxSt];

for(int i=0; i<maxSt; i++) zugriffInStunde[i] = 0;

} //Weblog

public int getZugriffInStunde(int st) { return zugriffInStunde[st];}

public int summeZugriffe(){ … }

} //Weblog

methode einlesen
Methode Einlesen

publicvoid liesZugriffe() {

wiederhole:

Sag Nutzer, dass Stunde einzugeben ist.

Lies Stunde ein.

Wenn gültige Stunde,

dann erhöhe Anzahl Zugriffe in der Stunde um eins.

bis Ende (Nutzer hat –1 eingegeben)

} //liesZugriffe

ein ausgabe klasse lineio
Ein–, Ausgabe: Klasse LineIO

Sammlung von Methoden für Ein-, Ausgabe:

  • write, writeln für String, int, double, …io.writeln("zahl= "+z);
  • formatierte Ausgabe:io.write(betrag,7,2);
  • Eingabe für Sring, double, int, char:zahl = io.readInt("Bitte Zahl eingeben: ");
  • KEIN Bestandteil der API!Datei LineIO.class muss im Verzeichnis stehen
nutzung von lineio
Nutzung von LineIO
  • LineIO.java kopieren in BlueJ: Edit > Add class from file
  • E/A-Objekt in Methode erzeugen: LineIO io = new LineIO();
  • Methoden nutzen: st = io.readInt(" Zahl eingeben");
    • werden Eingaben programmiert, dann:publicvoid einlesen() throws Exception …

 Schauen Sie sich LineIO.java an, welche Methoden es gibt!

methode einlesen32
Methode Einlesen

publicvoid liesZugriffe() throws Exception {

IntIO io = new IntIO(); // Ein- Ausgabe-Objekt

int st = -1; // einzulesende Stunde

io.writeln(" Weblog: Eingabe der Stunden. Ende mit –1 ");

do {

st=io.readInt("Zugriff in Stunde: ");

if(st>=0 && st<=maxSt) { // Test auf gueltige Stunde

zugriffInStunde[st]++; // Anzahl Zugriffe erhöhen

}

else if(st!= -1){ // falls keine Stunde (s.o.) und kein Ende

io.writeln("Ungueltige Stundenangabe!");

} //if

}

while(st!=-1); // wiederhole solange nicht Ende

} //liesZugriffe

iteration do while schleife
Iteration: do–while–Schleife

do {

zahl = io.readInt("Zahl: ");

if (zahl >0) summe = summe +zahl;

}

while (zahl != -1);

do { Anweisungen } while (Bedingung);

  • endgesteuert
  • eingesetzt, falls:
    • Zahl der Durchläufe unbestimmt ist, und
    • Körper mindestens einmal durchlaufen werden muss.
    • typisch: Nutzerdialog

Interpretation:Führe die Anweisungen wiederholt aus, solange die Bedingung wahr ist.

iteration for schleife
Iteration: for–Schleife

int fak = 1;

for (int i=1;i<=zahl; i++) {

fak = fak * i;

}//for

for (Initialisierung; Bedingung; EndeAnweisung) { Anweisungen

} //for

  • anfangsgesteuert
  • eingesetzt, falls:
    • Zahl der Schleifendurchläufe bekannt ist und
    • durch eine Zählvariable gezählt werden kann

Interpretation:Führe die Initialisierung aus, führe dann die Anweisungen des Körpers wiederholt aus, solange die Bedingung gilt. Nach jeder Ausführung des Schleifenkörpers wird die EndeAnweisung einmal ausgeführt.

beispiel
Beispiel

for(int index = 0; index < zugriffeInStunden.length; index++) {

io.writeln(index + ": " + zugriffeInStunden[index]);

} //for

Wirkung identisch!

int index = 0;

while(index < zugriffeInStunden.length) {

io.writeln(index + ": " + zugriffeInStunden [index]);

index++;

} //while

zusammenfassung sammlung
Zusammenfassung Sammlung
  • Arraylist
    • Sammlung: Elemente (Objekte) mit Index 0,1,…
    • import java.util.Arraylist;
    • API enthält die Infos über Methoden
    • wichtige Methoden: add, delete, get, size
  • Arrays für Sammlungen mit fester Obergrenze
    • Sammlung: Elemente mit Index 0,1,…
    • Elemente sind Objekte oder einfache Datentypen
    • Arrays sind Objekte  mit new erzeugen
    • haben spezielle Syntax: eckige Klammern [ ]
zusammenfassung schleifen
Zusammenfassung – Schleifen
  • while(!gefunden) { … }
  • do { … } while(!ende);
  • for(Notiz n:notizen) … //for-each
  • for(int i= 0,i<zfolge, i++) { folge[i] … }
  • // iterator:Iterator<Notiz> it = notizen.iterator();while (it.hasNext()) …
aufgabe sieb des eratosthenes
Aufgabe - Sieb des Eratosthenes
  • Zahl n einlesen
  • Array mit Elementen von 0..n erzeugen;
    • Alle Komponenten auf true setzen
  • Mit 2 beginnen bis n: alle Vielfachen im Array „streichen“, d.h. auf false setzen
  • Ausgabe der Primzahlen zwischen 0..n

 Programmieren Sie den Algorithmus in einer ausführbaren Klasse (main-Methode)

aufgabe studenten team

0

1

2

3

4

5

Aufgabe Studenten–Team

Student[ ] team;int zst;

Felder/Array kann beliebigen Typ enthalten!

team = new Student[anzahl];

team[zst] = new Student(name, matrikel);zst++;

 Entwickeln Sie eine Klasse Team, in der ein Studenten–Team verwaltet werden kann. Benutzen Sie eine Klasse Student und verwalten Sie die Team-Mitglieder in einem Array! Die maximale Teamgröße wird beim Erzeugen eines Teams festgelegt.