Grundlagen des Programmierens Leseprobe
Werbung
Leseprobe Blakowski Grundlagen des Programmierens INFORMATIK Studienbrief 2-050-0207-D 1. Auflage 2003 HDL HOCHSCHULVERBUND DISTANCE LEARNING Verfasser: Prof. Dr. Gerold Blakowski Professor für Wirtschaftsinformatik, insbesondere Telekommunikation und Multimedia im Fachbereich Wirtschaft an der Fachhochschule Stralsund Der Studienbrief wurde auf der Grundlage des im Ergebnis der Evaluation weiterentwickelten Curriculums für das Studienfach Informatik verfasst. Die Bestätigung des Curriculums erfolgte durch den Fachausschuss Wirtschaftsingenieurwesen, dem folgende Professorinnen und Professoren Dr. Albers (FH Magdeburg), Dr. Altmann (HTWK Leipzig), Dr. Capelle (FH Braunschweig/ Wolfenbüttel), Dr. Heiserich (TFH Berlin), Dr. Hentschel (HTWK Leipzig), Dr. Heyden (FH Anhalt), Dr. Heyne (FH Jena), Dr. Hofmann (WH Zwickau), Dr. Klein (FHTW Berlin), Dr. Kuhrt (FHTW Berlin), Dr. Neubert (HTW Dresden), Dr. Söhnchen (FH Merseburg), Dr. Teichmann (TFH Wildau), Dr. Ungvári (TFH Wildau), Dr. Weiß (FH Schmalkalden), Dr. Witt (HS Wismar), Dr. Witzel (FH Merseburg) sowie die Leiter der an der Evaluation beteiligten Arbeitsgruppen Prof. Demske, Prof. Dr. Eibner, Prof. Dr. Mottl, Prof. Stein (alle FH Jena), Prof. Dr. Heger (FHTW Berlin) und RA Dr. Vock (HTW Dresden) angehörten. Redaktionsschluss: Januar 2003 1. Auflage 2003 „ 2003 by Service-Agentur des Hochschulverbundes Distance Learning mit Sitz an der FH Brandenburg. Das Werk ist urheberrechtlich geschützt. Die dadurch begründeten Rechte, insbesondere das Recht der Vervielfältigung und Verbreitung sowie der Übersetzung und des Nachdrucks, bleiben, auch bei nur auszugsweiser Verwertung, vorbehalten. Kein Teil des Werkes darf in irgendeiner Form ohne schriftliche Genehmigung der Service-Agentur des HDL reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfältigt oder verbreitet werden. Service-Agentur des HDL (Hochschulverbund Distance Learning) Leiter: Dr. Reinhard Wulfert c/o Agentur für wissenschaftliche Weiterbildung und Wissenstransfer e. V. Magdeburger Straße 50, 14770 Brandenburg Tel.: 0 33 81 - 35 57 40 Fax: 0 33 81 - 35 57 49 E-Mail: [email protected] Internet: http://www.aww-brandenburg.de Informatik Grundlagen der Programmierung Inhaltsverzeichnis Einleitung.................................................................................................................................... 5 Literaturempfehlung .................................................................................................................. 6 1 1.1 1.1.1 1.1.2 1.1.3 1.2 1.3 1.4 Programmiersprachen und Programmierumgebungen............................................ 7 Programmiersprachen .................................................................................................. 7 Imperative Programmiersprachen................................................................................. 8 Weitere Paradigmen................................................................................................... 17 Sprachen für spezielle Anwendungen......................................................................... 19 Softwareentwicklungsumgebungen ............................................................................ 20 Ausführung von Programmen .................................................................................... 21 Die Programmiersprache Java .................................................................................... 22 2 2.1 2.2 2.3 2.3.1 2.3.2 2.3.3 2.4 Objektorientierte Modellierung und Programmierung .......................................... 25 Einordnung in den Softwareentwicklungsprozess ....................................................... 25 UML Modelling Language......................................................................................... 26 Implementierung und Test ......................................................................................... 26 Programmieren im Kleinen ........................................................................................ 26 Implementierungsprinzipien....................................................................................... 27 Testen von Programmen............................................................................................. 28 Exemplarische Programmentwicklung ....................................................................... 33 3 3.1 3.2 3.2.1 3.2.2 3.2.3 3.2.4 3.2.5 3.3 3.4 3.4.1 3.4.2 3.4.3 3.4.4 Grundelemente von Java-Programmen .................................................................. 38 Programmstruktur ...................................................................................................... 38 Bezeichner, Variablen und primitive Datentypen........................................................ 39 Bezeichner................................................................................................................. 39 Variablen ................................................................................................................... 40 Primitive Datentypen ................................................................................................. 41 Zeichenketten (String) ............................................................................................... 44 Ausdrücke, Zuweisung und Typkompatibilität ........................................................... 45 Arrays........................................................................................................................ 49 Anweisungen, Selektion und Iteration ........................................................................ 52 Anweisungen ............................................................................................................. 52 Selektion.................................................................................................................... 52 Iteration ..................................................................................................................... 57 Verlassen von Schleifen............................................................................................. 61 4 4.1 4.1.1 4.1.2 4.1.3 4.1.4 4.1.5 4.1.6 4.1.7 4.1.8 4.1.9 4.1.10 4.1.11 Objektorientierte Java-Anwendungen .................................................................... 62 Einfache objektorientierte Programme ....................................................................... 62 Objekte in Java .......................................................................................................... 62 Klassen ...................................................................................................................... 62 Instanzvariablen......................................................................................................... 63 Klassenvariablen (statische Variablen)....................................................................... 66 Methoden................................................................................................................... 67 Klassenmethoden (statische Methoden)...................................................................... 72 Überladen von Methoden ........................................................................................... 72 Konstruktoren ............................................................................................................ 73 Statische Initialisierungsblöcke .................................................................................. 75 Lebensdauer von Objekten ......................................................................................... 75 finalizer ..................................................................................................................... 75 Grundlagen der Programmierung Informatik 4.1.12 4.1.13 4.1.14 4.2 4.2.1 4.2.2 4.2.3 4.2.4 4.2.5 4.2.6 4.2.7 4.2.8 Regeln für die Sichtbarkeit von Bezeichnern ............................................................. 76 Sichtbarkeit von Klassen, Methoden und Attributen .................................................. 77 Wrapper-Klassen für primitive Datentypen................................................................ 78 Fortgeschrittene objektorientierte Java-Anwendungen ............................................... 79 Vererbung ................................................................................................................. 79 Konstruktoren bei der Vererbung............................................................................... 81 Abstrakte Klassen und Methoden .............................................................................. 84 Dynamisches Binden ................................................................................................. 85 Verhindern von Vererbung und Überschreiben .......................................................... 87 Klasse Object ............................................................................................................ 87 Interface.................................................................................................................... 88 Verschachtelte Klassen.............................................................................................. 92 5 5.1 5.2 5.2.1 5.2.2 5.2.3 5.3 5.4 Umfangreiche Anwendungen .................................................................................. 95 Pakete und Java APIs ................................................................................................ 95 Ein-/Ausgabe, Dateihandhabung................................................................................ 96 Byteorientierte Streams ............................................................................................. 97 Zeichenorientierte Streams .......................................................................................101 Fehlerbehandlung .....................................................................................................102 Collection Framework ..............................................................................................104 Benutzeroberflächen.................................................................................................106 Antworten und Lösungen .......................................................................................................118 Literaturverzeichnis ...............................................................................................................125 Anlagen ...................................................................................................................................126 Sachwortverzeichnis ...............................................................................................................127 Verzeichnis der Randsymbole B D K P S Ü Z 4 Beispiel Definition Kontrollfragen Programmbeispiel Studienziele Übungsaufgaben Zusammenfassung Informatik Grundlagen der Programmierung Einleitung Die Entwicklung und als Teil davon die Programmierung von Softwaresystemen gehören zu den Kernaufgaben der Informatik. Der Einsatz der Objektorientierung in der Analyse, im Entwurf und in der Programmierung ist in den vergangenen Jahren zur vorherrschenden Technologie geworden. Java als objektorientierte Programmiersprache hat sehr große Bedeutung in der Entwicklung kommerzieller Systeme gewonnen, insbesondere bei Internet-basierten und Electronic-BusinessAnwendungen. Schwerpunkt des Studienbriefs ist die Implementierungsphase im Softwareentwicklungsprozess bei Nutzung der Programmiersprache Java, das heißt die Umsetzung eines Programmentwurfs in ein konkretes Java-Programm, auch Programmieren im Kleinen genannt. Bei konsequentem Anwenden der Objektorientierung sind die Phasen Analyse, Entwurf und Implementierung bei der Entwicklung von Softwaresystemen durch die einheitliche Begriffswelt und Methodik eng miteinander verknüpft. Der Entwurf kann dabei so detailliert erfolgen, dass der Rahmen des JavaProgramms automatisiert erzeugt werden kann. Zur Darstellung dieses Zusammenhangs werden auch die Phasen Analyse und Entwurf im Studienbrief kurz vorgestellt und bei Bedarf mit in die Darstellung einbezogen. • Der Leser soll nach Durcharbeiten des Studienbriefs die wesentlichen Aspekte der objektorientierten Programmierung kennen und die Sprachelemente und grundlegenden Konzepte von Java verstehen, um kleinere Programme eigenständig entwickeln und sich in komplexere Anwendungen und Klassenbibliotheken für Java einarbeiten zu können. S • Zudem soll er einen Einblick in den gesamten Prozess der objektorientierten Softwareentwicklung besitzen. Der Studienbrief ist folgendermaßen aufgebaut: – In Kapitel 1 erfolgt eine Einführung in Programmiersprachen. Vertieft werden dabei die Konzepte der Objektorientierung und Eigenschaften von Java. – Kapitel 2 behandelt die objektorientierte Modellierung und besondere Aspekte der Implementierungsphase. – Kapitel 3 stellt die Grundstruktur von Programmen in Java dar. Es werden die grundlegenden Sprachelemente von Java eingeführt. – In Kapitel 4 wird die objektorientierte Programmierung in Java behandelt. – Kapitel 5 gibt einen Einblick in die Nutzung von Klassenbibliotheken anhand der Ein-/ Ausgabe, der Nutzung von dynamischen Datenstrukturen und der Realisierung einer graphischen Benutzerschnittstelle. Für das Erlernen der Programmierung ist es sehr wichtig, Übungen durchzuführen. Es ist angeraten, zunächst die Beispielprogramme im Text detailliert nachzuvollziehen und ablaufen zu lassen. Experimentieren Sie mit den Beispielen! Sehen Sie sich dazu auch die Spezifikation der Klassen in der Java Application Programming Interface (API)-Dokumentation an [13]. Dann sollten die Programmieraufgaben bearbeitet werden. Nehmen Sie sich hierzu ausreichend Zeit. Bei der Programmierung gilt ganz besonders, dass man aus den eigenen Fehlern lernt. Lösungshinweise zu den Aufgaben finden Sie im Studienbrief, und die Beispiele aus dem Text und die kompletten kommentierten Lösungen der Übungen befinden sich auf dem beiliegenden Datenträger. 5 Grundlagen der Programmierung Informatik Zur Durchführung der Aufgaben benötigen Sie eine Java-Entwicklungsumgebung. Es sind zahlreiche freie Entwicklungsumgebungen für den privaten Gebrauch über das Internet erhältlich. Grundlegend ist das Java Development Kit von Sun [14]. Es beinhaltet alle für die Entwicklung benötigten Programme und Klassenbibliotheken, besitzt jedoch keine graphische Benutzerschnittstelle und muss über die Kommandozeile bedient werden. Komfortable Entwicklungsumgebungen mit graphischer Oberfläche gibt es z. B. von Sun [21] und Borland [16]. Die Verwendung dieser Produkte ist mit einem höheren Einarbeitungsaufwand verbunden, sie erleichtern dann jedoch erheblich die Programmierung. Sie umfassen auch eine integrierte Dokumentation der Java APIs, so dass nicht online darauf zugegriffen werden muss. Die Programme des Studienbriefs sind unabhängig von der Entwicklungsplattform lauffähig, da nur Standardklassenbibliotheken verwendet werden. Eine sehr gute und frei verfügbare Plattform ist JBuilder 8 Personal Edition von Borland [17], die auch in einer deutschen Version aus dem Internet heruntergeladen oder für einen günstigen Preis bestellt werden kann. Auf der dem Studienbrief beiliegenden CD finden sie neben den Quellcodes der Programmbeispiele eine kurze Einweisung in die Benutzung dieser Entwicklungsumgebung als Word-Dokument. Literaturempfehlung Zur Programmiersprache Java sind zahlreiche sehr umfangreiche Lehrbücher erschienen, die detailliert auf Sprachelemente eingehen und die zur Verfügung stehenden Klassenbibliotheken erläutern. – Das „Handbuch der Java-Programmierung“ von Guido KRÜGER [7] beschreibt sehr ausführlich auf über 1000 Seiten mit vielen Beispielen die Programmierung und die Verwendung von Standardbibliotheken, z. B. zur Gestaltung von Oberflächen und zur Netzwerkprogrammierung. Eine Onlineversion ist unter [18] verfügbar. – „Thinking in Java, 2nd ed.“ von Bruce ECKEL [4] ist eine stark an der objekt-orientierten Denkweise ausgerichtete ausführliche Darstellung von Java. Es ist ebenfalls eine OnlineVersion verfügbar [19]. – http://java.sun.com ist die Homepage von Sun zur Programmiersprache Java. Dort sind Programme, Dokumentationen der Fa. Sun zu Java und den Java APIs [13] verfügbar, sowie ein Online-Tutorial [11]. Zur Vertiefung der Objektmodellierung und der Verwendung von UML sind folgende praxisorientierte Bücher zu empfehlen: – In „UML konzentriert“ von M. FOWLER / K. SCOTT [6] wird die Verwendung der Modellierungssprache UML mit zahlreichen Beispielen dargestellt. – „Das Lehrbuch der Objektmodellierung. Analyse und Entwurf“ von Heide BALZERT [2] ist eine sehr praxisorientierte mit Beispielen unterlegte Darstellung der objektorientierten Modellierung von Softwaresystemen. – Das Thema Testen von Software wird ausführlich behandelt in „Software-Test. Verifikation und Validation“ von Georg Erwin THALLER [10]. – Programmiersprachenunabhängige Algorithmen und Datenstrukturen, die bei der Programmierung verwendet werden können, finden sich im gleichnamigen Studienbrief [9]. 6 Grundlagen der Programmierung 4 Informatik Objektorientierte Java-Anwendungen Die allgemeinen Grundzüge der Objektorientierung wurden bereits in den Kapiteln 1 und 2 eingeführt. In diesem Kapitel wird die Objektorientierung in Java anhand kleiner Beispielprogramme besprochen. Zunächst wird auf die Umsetzung von Objekten, Klassen, Attributen und Operationen in Java eingegangen. Dann werden fortgeschrittene Konzepte, insbesondere die Vererbung, behandelt. • Nach Durcharbeiten des Kapitels sollen die Konzepte zur objektorientierten Programmierung in Java bekannt sein, so dass einfache objektorientierte Programme selbst entwickelt und komplexe verstanden werden können. S 4.1 Einfache objektorientierte Programme 4.1.1 Objekte in Java Für ein Objekt in Java gelten folgende Bedingungen: – Objekte werden mit new dynamisch zur Laufzeit unter Angabe ihrer Klasse erzeugt. Dieser Vorgang wird als Instanziierung bezeichnet. Ein Objekt gehört zu genau einer Klasse und wird als Instanz seiner Klasse bezeichnet. – Ein Objekt kann beliebig viele Attribute beliebigen Typs enthalten, die als Objekt- oder Instanzvariablen bezeichnet werden. – Die Operationen auf den Objekten werden als Methoden bezeichnet. – Der Zugriff auf Objekte erfolgt über Verweisvariablen. – Wenn keine Verweisvariable mehr auf ein Objekt verweist, kann auf das Objekt nicht mehr zugegriffen werden und das Objekt kann durch die Speicherbereinigung gelöscht werden. Die Vereinbarung, welche Variablen und Methoden zu einem Objekt gehören, erfolgt in den Klassen. 4.1.2 Klassen Die Hauptkomponenten einer Klasse (class) sind: – Instanzvariablen: Diese Variablen werden für jedes Objekt der Klasse bei der Instanziierung erzeugt. – Klassenvariablen: Diese Variablen existieren nur einmal für alle Objekte der Klasse. – Instanzmethoden: Methoden implementieren das Verhalten der Objekte. In Instanzmethoden kann auf Instanz- und Klassenvariablen zugegriffen werden. Es gibt zwei spezielle Arten von Instanzmethoden: – Konstruktoren: Diese Methoden werden bei der Objekterzeugung aufgerufen und können z. B. zur Initialisierung der Instanzvariablen bei der Objekterzeugung verwendet werden. – Finalizer: Die Methode namens finalize() wird aufgerufen, wenn ein Objekt gelöscht wird. Diese Methode wird benötigt, falls beim Löschen des Objektes "Aufräumarbeiten" stattfinden müssen. 62 Informatik Grundlagen der Programmierung – Klassenmethoden: Diese Methoden werden nicht auf einem Objekt, sondern auf der Klasse aufgerufen. In ihnen kann nur auf Klassenvariablen zugegriffen werden. Eine Klassenvereinbarung (Bild 4.1) beginnt mit dem Schlüsselwort class, gefolgt vom Bezeichner der Klasse und der Vereinbarung der Variablen und Methoden. class Bezeichner { Bild 4.1 Syntax Klassenvereinbarung 4.1.3 Instanzvariablen Variablen/Methoden } ; Im folgenden einführenden Beispiel werden für die Bibliotheksverwaltung die Instanzvariablen der Klasse Buch betrachtet. In diesem Fall wird der Zugriff auf die Variablen durch die Klasse Bibliotheksverwaltung im gleichen Paket erlaubt und verwendet. In der main()-Methode der Bibliotheksverwaltung werden Buch-Objekte erzeugt und die Instanzvariablen von Buch initialisiert. P 4.1 //********************************************************* package bibliothek; // Zunächst import der benötigten Klasse aus der Klassenbibliothek util P // um den Datentyp GregorianCalendar verfügbar zu machen. import java.util.GregorianCalendar; public class Buch { // Instanzvariablen String verfasser; // Verfasser String titel; // Titel String signatur; // Signatur int verlagsnummer; // Nummer kennzeichnet Verlag GregorianCalendar ausleihfrist; // Datum Ende der Ausleihe Benutzer ausleiher; // Verweis auf Ausleiher } //******************************************************** public class Bibliotheksverwaltung { private Buch bestand[]; private Benutzer bibliotheksbenutzer[]; public static void main(String[] args) { // Variablenvereinbarung Buch grass,boell; // Instanzen erzeugen grass = new Buch(); 63 Grundlagen der Programmierung Informatik boell = new Buch(); // Instanzvariablen initialisieren grass.signatur = "ST234G25"; grass.verfasser = "Günter Grass"; grass.titel = "Die Blechtrommel"; grass.verlagsnummer = 165; boell.signatur = "ST234B48"; boell.verfasser = "Heinrich Böll"; boell.titel = "Ansichten eines Clowns"; boell.verlagsnummer = 234; } } Es werden zunächst in der Methode main() zwei Verweisvariablen grass und boell vereinbart. Es werden dann die Buchobjekte mit new erzeugt. Das Ergebnis ist in Bild 4.2 zu sehen. Nach Variablenvereinbarung: grass null boell null Nach Erzeugen der Objekte boell Objekt Buch Objekt Buch verfasser null verfasser null titel null titel null signatur null signatur null verlagsnummer 0 verlagsnummer 0 ausleihfrist null ausleihfrist null ausleiher null ausleiher null Bild 4.2 64 grass Schematische Darstellung der Objektstruktur nach der Erzeugung der Buchobjekte. Unten ist die Objektstruktur in der Debuggeransicht einer Entwicklungsumgebung zu sehen. Informatik Grundlagen der Programmierung Im nächsten Schritt wird zur Initialisierung auf die Instanzvariablen zugegriffen. Die Notation hierfür ist: Verweisvariable.Instanzvariable. Den Punkt kann man dabei als Verfolgen des Verweises auffassen. Im obigen Beispiel wird z. B. über die Verweisvariable grass mit grass.verfasser auf die Instanzvariable verfasser zugegriffen und dieser Instanzvariable wird ein Verweis auf das String-Objekt mit dem Wert "Günter Grass" zugewiesen. Bild 4.3 zeigt die Objektstruktur nach Abschluss der Initialisierung. grass boell Objekt Buch Objekt Buch verfasser verfasser titel titel signatur signatur verlagsnummer 165 verlagsnummer 234 ausleihfrist null ausleihfrist null ausleiher null ausleiher null Bild 4.3 Objekt String Objekt String ST234G25 ST234B48 Objekt String Objekt String Die Blechtrommel Ansichten eines Clowns Objekt String Objekt String Günter Grass Heinrich Böll Schematische Darstellung der Objektstruktur nach der Initialisierung. Unten ist wiederum die Objektstruktur in der Debuggeransicht einer Entwicklungsumgebung zu sehen. In Bild 4.3 sind die String-Objekte vereinfacht dargestellt. Ein String-Objekt selbst besteht aus mehreren Instanzvariablen (count, hash, offset) und einem char-Array, welches den Text beinhaltet. Bild 4.4 zeigt das String-Objekt in der Debuggeransicht. 65 Grundlagen der Programmierung Bild 4.4 4.1.4 Informatik Das String-Objekt in der Debugger-Ansicht Klassenvariablen (statische Variablen) Neben den Instanzvariablen, die für jedes Objekt separat existieren, können Klassenvariablen vereinbart werden, die nur einmal für alle Objekte einer Klasse existieren. Sie können sowohl über ein Objekt, als auch über den Klassennamen angesprochen werden. Gekennzeichnet werden Klassenvariablen dadurch, dass das Schlüsselwort static bei der Vereinbarung als Modifikator vorangestellt wird. Klassenvariablen werden beim Laden der Klasse (i.d.R. beim Programmstart) instanziiert. Sie werden zum Beispiel benutzt, wenn Daten über alle Objekte erfasst werden sollen. Das Programmbeispiel 4.2 zeigt, wie in einer Variablen die jeweils aktuelle Anzahl an Büchern gespeichert wird. Hierzu wird die Klassenvariable anzBuecher verwendet. P P 4.2 public class Buch { // Klassenvariablen static int anzBuecher = 0; // Instanzvariablen ... } Aufruf in main() von Klassenbibliothek: ... grass = new Buch(); grass.anzBuecher++; // Äquivalent zu Buch.anzBuecher++ boell = new Buch(); boell.anzBuecher++; // Äquivalent zu Buch.anzBuecher++ System.out.println(Buch.anzBuecher); ... 66 // Ausgabe: 2 Informatik Bild 4.5 Grundlagen der Programmierung Debuggeransicht der Klasse Buch Klassenvariablen gehören zu den Daten der Klasse und sind deshalb in der Debuggeransicht in Bild 4.5 in der Ansicht für Klassen (konkret Buch) und statische Daten zu sehen und nicht bei den einzelnen Objekten. Die Abbildung verdeutlicht zudem, dass eine Klasse als Objekt in der JavaLaufzeitumgebung verwaltet wird. 4.1.5 Methoden Eine Methode gehört immer zu einem Objekt bzw. einer Klasse. Sie ist ein parametrisierter Anweisungsblock, welcher von anderen Methoden angerufen werden kann. Nach dem Aufruf der Methode werden die Anweisungen des Anweisungsblocks ausgeführt. Nach Beenden der Ausführung der Methode wird das Programm an der Stelle des Methodenaufrufs fortgesetzt. Die Syntax der Methodenvereinbarung ist in Bild 4.6 dargestellt. Der Methodenname ist ein beliebiger Bezeichner. Die Parameterliste enthält die Datentypen und Bezeichner der Parameter. Die Parameter in der Methodenvereinbarung werden als formale Parameter bezeichnet. Es kann ein Rückgabedatentyp vereinbart werden. In diesem Fall muss ein Wert dieses Datentyps mit dem Schlüsselwort return in der Methode zurückgeben werden. Falls als Rückgabedatentyp void angegeben wird, darf kein Wert zurückgegeben werden. Rückgabedatentyp { Methodenname Programmtext ( Parameterliste ) } Methodenvereinbarung , Datentyp Parametername Parameterliste Bild 4.6 Syntax der Methodenvereinbarung 67
