Polymorphie Überladen Definition Methodennamen überladen Konstruktoren überladen Operatoren überladen Beispiele Dr. Beatrice Amrhein

Definition

Definition: Überladen (von Namen) Überladen bedeutet, dass ein Methodenname in einer Klasse für mehrere Methoden verwendet wird. Damit das Überladen möglich ist, muss wenigstens eine der beiden Voraussetzungen erfüllt sein: Der Datentyp mindestens eines Übergabeparameters ist anders als in den anderen gleichnamigen Methoden. Die Anzahl der Übergabeparameter ist unterschiedlich. Beispiel, überladen des Namens add int add( int a, int b ){ return a+b; } float add( int a, int b, float c ){ return a+b+c; }

Beispiele in C# Die Klasse Console hat verschiedene WriteLine Methoden mit verschiedenen Argumenten: Console.WriteLine(); Console.WriteLine("Abc"); Console.WriteLine(5.35); Console.WriteLine("Ausgabe {0}", 17); Console.WriteLine("Ausgabe {0}", 3.14); Die Klasse String hat verschiedene Format Methoden mit verschiedenen Argumenten: String.Format("Argumente: {0}", a1); String.Format("Argumente: {0}, {1}", a1, a2); String.Format("Argumente: {0}, {1}, {3}", a1, a2, a3);

Eigene Methodennamen überladen

Regeln für das Überladen Methoden, welche den gleichen Namen, aber eine unterschiedliche Parameterliste haben, heissen überladene Methoden. Die zwei Methoden dürfen sich nicht nur durch den Rückgabewert oder den Zugriffs-Modifizierer (public, private, …) unterscheiden. Die verschiedenen Methoden müssen verschiedene Parameter-Typen haben (unterschiedliche Signatur!).

Beispiel Klasse Addierer Die Klasse Addierer habe für verschiedene Typen verschiedene add- Methoden public class Addierer { public int add(int a, int b) { return a + b; } public int add(int a, int b, int c) // drei Parameter, ok { return a + b + c; } public float add(float a, float b) // andere Typen, ok //Unterscheidung nur durch Rückgabewert und Modifizierer private void add(int a, int b) // Fehler!! { Console.WriteLine(a + b); } }

Beispiel Klasse Information Die Methode Ausgabe der Klasse Information soll verschiedenartige Daten ausgeben. class Information { public String Ausgabe(String s, int a) { return String.Format("{0}: {1}", s, a); } public String Ausgabe(String s, int a, int b) { return String.Format("{0}: {1}, {2}", s, a, b); } //Syntaktisch in Ordnung, aber schlechter Stil public void Ausgabe(int a, String s) { Console.WriteLine("{0}: {1}", s, a); } //Unterscheidung nur durch Parametername public String Ausgabe(String s, int e) // Fehler!!! { return String.Format("{0}: {1}", s, e); } } gleiche Funktionalität mit mehr Parameter, ok andere Funktionalität und andere Reihenfolge

Stil-Regeln für das Überladen Überladene Methoden müssen Varianten der gleichen Funktionalität bereitstellen (alle Methoden machen etwas ähnliches) Es ist guter Stil, wenn die Namen und die Reihenfolge der gemeinsamen Parameter möglichst gleich bleiben. Es ist erlaubt, aber schlechter Stil, wenn sich die Methoden nur durch die Reihenfolge der Parameter-Typen unterscheiden. // korrekt, aber schlechter Stil public float add(int a, float b) { return a + b; } public float add(float a, int b) { return a + b; }

Stil-Regeln für das Überladen Schlechter Stil: Beliebige, verschiedene Parameternamen Beliebige Parameter-Reihenfolge Unterschiedliche Funktionalität bei gleichem Namen public float add(int a, float b) { return a + b; } public float add(float e, int c, int d) { return c + d + e; } // andere Reihenfolge und Namen public float add(int a, int b, float c) { return c*(d + e); } // andere Funktionalität

Überladen von Konstruktoren

Standard-Konstruktor Konstruktoren werden benötigt um mit dem Aufruf new ein neues Objekt dieser Klasse zu erzeugen. Konstruktoren haben denselben Namen wie die Klasse und initialisieren normalerweise die Felder des neuen Objekts. Wenn eine Klasse keinen Konstruktor enthält, wird vom Compiler automatisch ein leerer Standard-Konstruktor erzeugt.

Beispiel-Konstruktoren Beim Aufruf von new Beispiel1() wird ein Objekt vom Typ Beispiel1 mit dem Feld id erzeugt und mit 0 initialisiert. Der leere Konstruktor ist optional und könnte weggelassen werden. class Beispiel1 { int id = 0; public Beispiel1() { } //optionaler, leerer Konstruktor } class Beispiel2 int id; public Beispiel2() { id = 0; } // Initialisierung von id

Überladener Konstruktor Auch Konstruktoren können überladen werden. Für Sie gilt die gleiche Regel. Die Typen der Parameter der verschiedenen Konstruktoren müssen sich unterscheiden (verschiedene Signatur). class Beispiel { private int id; private String name; public Beispiel(int i) id = i; } public Beispiel(int i, String n) id = i; name = n;

Überladener Konstruktor Die verschiedenen Konstruktoren können sich mit dem Schlüsselwort this() gegenseitig aufrufen. class Beispiel { private int id; private String name; public Beispiel(int i) { id = i; } public Beispiel(int i, String n) : this(i) name = n; }

Beispiel Klasse Person mit drei Konstruktoren public class Person { static private int id; private String firstName="-"; private String lastName="-"; private int year = 0; public Person( ) { id++; } public Person(String f, String l) : this() { firstName = f; lastName = l; } public Person(String f, String l, int y) : this(f, l) { year = y; } public String getInfo() String result = String.Format("{0}: {1} {2}", id, firstName, lastName); if (year != 0) result += ", " + year; return result; } //ohne Parameter //zwei Parameter //drei Parameter

Leih-Objekte Bibliothek

Basisklasse für Leih Objekte (Bücher / DVDs) public class LeihObjekt { private int id; private String title; public static int counter = 0; protected LeihObjekt(String t) id = ++counter; title = t; Console.Write("LeihObjekt"); } public String BaseInfo() { return "\n" + id + ". " + title; }

Print Medium public class PrintMedium : LeihObjekt { protected String verlag; protected int seiten; public PrintMedium(String t, String p) : base(t) verlag = p; Console.Write("--> PrintMedium"); } public PrintMedium(String t, String p, int s) : this(t, p) { seiten = s; } public String PrintMediumInfo() { return BaseInfo() + " des Verlags " + this.verlag; } public String PrintMediumInfo(String s) { return this.PrintMediumInfo() + s + this.seiten; }

Die Klasse Buch public class Buch : PrintMedium { private String autor; private Einband einband; public Buch(String t, String p, String a) : base(t, p) this.autor = a; Console.Write("--> Buch"); } public Buch(String t, String p, String a, Einband e) : this(t, p, a) { this.einband = e; } public String BuchInfo() { return PrintMediumInfo() + ", Autor: " + autor; } public String BuchInfo(String s) { return PrintMediumInfo() + s + this.einband; }

Die Klasse DVD public class DVD : LeihObjekt { private String regisseur; private int laenge; public DVD(String t, String r) : base(t) regisseur = r; Console.Write("--> DVD"); } public DVD(String t, String r, int l) : this(t, r) { this.laenge = l; } public String DVDInfo() { return BaseInfo() + ", Regisseur: " + regisseur; } public String DVDInfo(String s) { return this.DVDInfo() + s + this.laenge; }

Ausgabe

Geometrische Figuren

Das Klassendiagramm

Basisklasse GeomFigur public abstract class GeomFigur { protected int[] seiten; protected static int counter; protected string message; protected GeomFigur(int[] s) counter++; seiten = s; message += "GeomFigur"; } public void ShowMessage() MainWindow.ShowMessage(GeomFigur.counter, message);

Klasse Polygon public class Polygon : GeomFigur { public Polygon(int[] s) : base(s) base.message += " - Polygon"; } public void Zeichne(MainWindow window, Brush b) window.DrawPolygon(seiten, b); public void Zeichne(MainWindow window) this.Zeichne(window, Brushes.Yellow);

Klasse Rechteck public class Rechteck : GeomFigur { public Rechteck(int[] s) : base(s) base.message += " - Rechteck"; } public void Zeichne(MainWindow window, Brush b) window.DrawRectancle(base.seiten[0], base.seiten[1], b); public void Zeichne(MainWindow window) this.Zeichne(window, Brushes.Green);

Nach dem Handbuch der .NET 4.0-Programmierung, Rolf Wenger, 2012 Klasse Ellipse public class Ellipse : GeomFigur { public Ellipse(int[] s) : base(s) base.message += " - Ellipse"; } public void Zeichne(MainWindow window, Brush s) window.DrawEllipse(base.seiten[0], base.seiten[1], s); public void Zeichne(MainWindow window) this.Zeichne(window, Brushes.Blue); Nach dem Handbuch der .NET 4.0-Programmierung, Rolf Wenger, 2012

Nach dem Handbuch der .NET 4.0-Programmierung, Rolf Wenger, 2012 Klasse Kreis public class Kreis : Ellipse { public Kreis(int[] s) : base(s) base.message += " - Kreis"; base.seiten[1] = s[0]; } Nach dem Handbuch der .NET 4.0-Programmierung, Rolf Wenger, 2012

Main Klasse Rechteck r = new Rechteck(s1); r.Zeichne(window); r.Zeichne(window, Brushes.Violet); Polygon p = new Polygon(s1); p.Zeichne(window, Brushes.Red); Dreieck d = new Dreieck(s1); d.Zeichne(window); Ellipse e = new Ellipse(s1); e.Zeichne(window, Brushes.Chocolate); k.Zeichne(window); k.ShowMessage();

Überladen von Operatoren

Überladen von Operatoren C# erlaubt auch das Überladen von Operatoren wie +, -, *, /, %, &, … Definiert wird die Überladung mit Hilfe des operator Schlüsselworts Überladen der + Zeichens: public static Type operator +(Type c1, Type c2) { return new Type( … op-Definition … ); }

Beispiel: Komplexe Zahlen public class Complex { private double real; private double img; public Complex(double r, double i) { real = r; img = i; } public static Complex operator +(Complex c1, Complex c2) return new Complex(c1.real + c2.real, c1.img + c2.img); } public static Complex operator -(Complex c1, Complex c2) return new Complex(c1.real - c2.real, c1.img - c2.img); Überladen von + und – Zeichen für komplexe Zahlen

Beispiel: Brüche public class Rational { public Rational(int z, int n) private int nenner; private int zaehler; public Rational(int z, int n) { zaehler = z; nenner = n; } public static Rational operator *(Rational r1, Rational r2) return new Rational(r1.zaehler * r2.zaehler, r1.nenner * r2.nenner); } public static Rational operator /(Rational r1, Rational r2) return new Rational(r1.zaehler * r2.nenner, r1.nenner * r2.zaehler);

Verwendung der Operatoren Addieren von zwei komplexen Zahlen: Complex c1 = new Complex(1.0, 0.5); Complex c2 = new Complex(0.5, 1.5); Complex c3 = c1 + c2; Muliplizieren und Dividieren von Brüchen Rational r1 = new Rational(1, 2); Rational r2 = new Rational(2, 3); Rational r3 = new Rational(2, 1); Rational r4 = r1 * r2 / r3;