{"id":55000015,"date":"2015-04-01T00:00:00","date_gmt":"2020-03-27T19:16:27","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=15"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Objektorientierte_Programmierung_Grundlagen_II","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Objektorientierte_Programmierung_Grundlagen_II\/","title":{"rendered":"Objektorientierte Programmierung: Grundlagen II"},"content":{"rendered":"

Im ersten Teil dieser Artikelreihe haben wir uns die Grundlagen zur objektorientierten Programmierung mit C# angesehen – zum Beispiel die Klasse Program, das Erstellen neuer Klassen, die Verwendung von Eigenschaften und von Methoden. Dies greifen wir im zweiten Teil auf und gehen auf verschiedene Arten der Eigenschaftsdefinition, Kontruktoren, aufgeteilte Klassen, Objektreferenzen, Überladung von Methoden und verschiedene Parameter-Techniken ein.<\/b><\/p>\n

Öffentliche Variablen oder “Felder”<\/h2>\n

Wenn eine Eigenschaft einer Klasse nur gelesen und geschrieben werden soll, ohne dass beim Lesen oder Schreiben weitere Aktionen erfolgen sollen, können Sie diese theoretisch einfach als öffentliche Variable deklarieren:<\/p>\n

class Person_VornameOeffentlich\r\n{\r\n     public string Vorname;\r\n}<\/pre>\n
Sie greifen dann lesend und schreibend auf die Variable zu:<\/p>\n
public void OeffentlicheVariableTesten()\r\n{\r\n     Person_VornameOeffentlich person = \r\n         new Person_VornameOeffentlich();\r\n     person.Vorname = \"André\";\r\n     Console.WriteLine(\"Vorname: {0}\", person.Vorname);\r\n}<\/pre>\n
Eine solche Variable\/Eigenschaft nennt man auch Feld.<\/p>\n
Eigenschaft kapseln<\/h2>\n
Meist ist aber kein derart unkontrollierter Zugriff auf eine solche Variable erwünscht. Dann deklariert man die Variable als private Variable und erstellt eine öffentliche Eigenschaft, die einen get<\/b>– und einen set<\/b>-Block enthält. In der Kurzform sieht dies so aus:<\/p>\n
private string vorname;<\/pre>\n
Dies ist die öffentliche Variable mit dem get<\/b>– und dem set<\/b>-Block – get <\/b>liefert den aktuellen Wert der privaten Variablen vorname <\/b>aus und set <\/b>stellt diesen beim Zuweisen eines Wertes für die Eigenschaft auf den Inhalt der Variablen value <\/b>ein:<\/p>\n
public string Vorname\r\n{\r\n     get { return vorname; }\r\n     set { vorname = value; }\r\n}<\/pre>\n
Damit halten Sie sich die Möglichkeit offen, den Wert der Eigenschaft auch innerhalb der Klasse für andere Zwecke einzusetzen – etwa für Berechnungen weiterer Eigenschaftswerte oder zum Zusammensetzen von Ausdrücken. Gegebenenfalls benötigen Sie dies gar nicht und wollen nur von außen den Wert der Eigenschaft eintragen und diesen später wieder auslesen.<\/p>\n
Ein weiterer Vorteil der Kapselung ist: Sie können damit auch festlegen, dass eine Eigenschaft nur schreibend oder nur lesend genutzt werden kann. Wenn die Eigenschaft Vorname beispielsweise nur lesend genutzt werden soll, lassen Sie einfach den set<\/b>-Teil weg:<\/p>\n
public string Vorname\r\n{\r\n     get { return vorname; }\r\n}<\/pre>\n
Für einen ausschließlich schreibenden Zugriff bleibt hingegen der get<\/b>-Teil außen vor:<\/p>\n
public string Vorname\r\n{\r\n     set { vorname = value; }\r\n}<\/pre>\n
Getter und Setter schnell erstellen<\/h2>\n
Benötigen Sie get<\/b>– und set<\/b>-Block, wollen aber keine Einschränkungen vornehmen wie etwa eine Prüfung der Eingabe und benötigen auch keine Variable, auf die Sie von der Klasse aus zugreifen wollen, können Sie diese verkürzte Variante nutzen:<\/p>\n
class Person_AutomatischImplementiert\r\n{\r\n     public string Vorname { get; set; }\r\n     public string Nachname { get; set; }\r\n}<\/pre>\n
Der Zugriff auf die beiden Eigenschaften der Klasse erfolgt dann genau wie bei der vorherigen Version.<\/p>\n
Unterstützung durch Visual Studio<\/h2>\n
Beim schnellern Erstellen von Eigenschaften unterstützt Visual Studio Sie mit Shortcuts. Dazu geben Sie in einer leeren Zeile in der gewünschten Klasse zunächst die vier Buchstaben prop <\/b>ein. Nun erscheinen bereits weiterführende Möglichkeiten in der IntelliSense-Liste (siehe Bild 1). Für uns sind aktuell zwei Varianten interessant. Die erste erfordert die Eingabe von prop + Tab + Tab <\/b>und liefert die folgende Vorlage:<\/p>\n
\"Schnelles<\/p>\n
Bild 1: Schnelles Erstellen einer Property<\/span><\/b><\/p>\n
public int MyProperty { get; set; }<\/pre>\n
Dabei werden int und MyProperty <\/b>gelb hinterlegt und können mit der Tabulator-Taste durchlaufen werden. Auf diese Weise können Sie die Platzhalter leicht durch den Datentyp und den Namen der Eigenschaft ersetzen.<\/p>\n
Die zweite Variante ist die Eingabe von propfull + Tab + Tab <\/b>(es reicht auch propf + Tab + Tab <\/b>aus). Dies liefert die folgende Vorlage:<\/p>\n
private int myVar;\r\npublic int MyProperty\r\n{\r\n     get { return myVar; }\r\n     set { myVar = value; }\r\n}<\/pre>\n
Hier können Sie den Datentyp (int<\/b>), den Variablennamen (myVar<\/b>) und den Eigenschaftsnamen (MyProperty<\/b>) per Tabulatortaste erreichen und ändern.<\/p>\n
Klassen mit Konstruktor<\/h2>\n
Unter VBA gibt es keine Möglichkeit, gleich beim Erstellen einer Klasse einen oder mehrere Werte zu übergeben. Dazu muss man nach dem Erstellen dafür vorgesehene Eigenschaften nutzen. Das ist schon ein Nachteil, wenn für das Verwenden der Klasse bestimmte Pflichtinformationen übergeben werden müssen, bevor man etwa bestimmte Methoden dieser Klasse nutzt.<\/p>\n
Das heißt, dass man vor dem Ausführen der Methode immer noch prüfen muss, ob die Pflichtinformationen überhaupt übergeben wurden. Davon abgesehen ist es natürlich auch viel einfacher, die wichtigsten Eigenschaften gleich beim Initialisieren des Objekts zu übergeben statt mühsam Eigenschaft für Eigenschaft zu übergeben.<\/p>\n
Unter C# und anderen objektorientierten Programmiersprachen gibt es deshalb die sogenannten Konstruktoren. Das sind Parameter, die gleich beim Erstellen einer Klasse übergeben werden müssen beziehungsweise können.<\/p>\n
Bevor Sie eine Klasse mit einem Konstruktor erstellen, müssen Sie sich überlegen, welche Varianten Sie für die Initialisierung mit oder ohne Parameter zur Verfügung stellen wollen. Eine Klasse Person <\/b>mit den beiden Eigenschaften Vorname <\/b>und Nachname <\/b>kann beispielsweise diese beiden Eigenschaften beim Initialisieren per Parameter entgegennehmen.<\/p>\n
Die Definition der Klasse sieht dann etwa wie folgt aus:<\/p>\n
class Person {\r\n     private string vorname;\r\n     private string nachname;\r\n     public Person() {}\r\n     public Person(string Vorname, \r\n             string Nachname) {\r\n         vorname = Vorname;\r\n         nachname = Nachname;\r\n     }\r\n     public string Vorname {\r\n         get { return vorname; }\r\n         set { vorname = value; }\r\n     }\r\n     public string Nachname {\r\n         get { return nachname; }\r\n         set { nachname = value; }\r\n     }<\/pre>\n
Hier sehen Sie die beiden privat deklarierten Variablen vorname <\/b>und nachname<\/b>. Außerdem sind natürlich die beiden Eigenschaftsmethoden Vorname <\/b>und Nachname <\/b>mit den get<\/b>– und set<\/b>-Blöcken vorhanden.<\/p>\n
Neu ist zunächst die folgende Zeile:<\/p>\n
public Person() {}<\/pre>\n
Dies ist der erste Konstruktor. Er ermöglicht die Initialisierung eines Objekts auf der Basis der Klasse Person<\/b>, ohne direkt eine der beiden Eigenschaften Vorname <\/b>oder Nachname <\/b>übergeben zu müssen. Der Konstruktor hat genau den gleichen Namen wie die Klasse selbst. Der Unterschied zu einer normalen öffentlichen Variablen ist, dass Sie hinter dem Bezeichner erstens ein rundes Klammernpaar (()<\/b>) und dann noch ein geschweiftes Klammernpaar finden ({}<\/b>).<\/p>\n
Der zweite Konstruktor erwartet die Übergabe von Werten für die beiden Parameter Vorname <\/b>und Nachname<\/b>. Er heißt ebenfalls genauso wie die Klasse, enthält aber in Klammern eine Liste der Parameter, die beim Initialisieren übergeben werden müssen. Dahinter folgt ein Paar geschweifter Klammern, innerhalb derer die übergebenen Parameter Vorname <\/b>und Nachname <\/b>den Variablen vorname <\/b>und nachname <\/b>übergeben werden:<\/p>\n
public Person(string Vorname, string Nachname) {\r\n     vorname = Vorname;\r\n     nachname = Nachname;\r\n}<\/pre>\n
Die Eigenschaften der Klasse können Sie nun gleich beim Initialisieren übergeben:<\/p>\n
Person person;\r\nperson = new Person(\"André\", \"Minhorst\");\r\nConsole.WriteLine(\"{0} {1}\", person.Vorname, \r\n     person.Nachname);\r\n\/\/Ausgabe:\r\n\/\/André Minhorst<\/pre>\n
Wir können das Objekt aber, da wir ja auch einen parameterlosen Konstruktor angelegt haben, auch ohne Übergabe von Parametern initialisieren und Vorname <\/b>und Nachname <\/b>erst später übergeben.<\/p>\n
Wenn es Pflichteigenschaften gibt, ohne welche die Methoden einer Klasse nicht sinnvoll genutzt werden können, können Sie natürlich auch entscheiden, dass die Eigenschaften auf jeden Fall direkt beim Initialisieren des Objekts gefüllt werden müssen. Dann legen Sie einfach nur einen Konstruktor an, der alle notwendigen Eigenschaften als Parameter erwartet und lassen den parameterlosen Konstruktor weg.<\/p>\n
Von Class_Initialize zum Konstruktor<\/h2>\n
Für alle, die von VBA kommen: Unter VBA gibt es in Klassen die beiden Ereignisprozeduren Class_Initialize <\/b>und Class_Terminate<\/b>. Diese werden, soweit implementiert, beim Initialisieren und beim Zerstören der Klasse ausgelöst – also beim Setzen der letzten Objektvariablen mit einer Referenz auf die Klasse auf den Wert Nothing<\/b>.<\/p>\n
Sie raten richtig: Der beziehungsweise die Konstruktoren ersetzen das Ereignis Initialize <\/b>(zum Terminate<\/b>-Ereignis kommen wir später). Das heißt also, dass Sie im Konstruktor auch solche Anweisungen unterbringen sollten, die immer beim Initialisieren der Klasse ausgeführt werden sollen – beispielsweise das Einlesen von Informationen aus Datenbanken, das Erstellen weiterer Objekte et cetera. Wenn eine Klasse keinen Konstruktor benötigt, der beim Initialisieren Parameter zur Verfügung stellt, aber zu diesem Zeitpunkt dennoch Anweisungen ausführen wollen, verwenden Sie den oben bereits vorgestellten Konstruktor ohne Parameter:<\/p>\n
public Person() {}<\/pre>\n
Diesem können Sie natürlich beliebige Anweisungen hinzufügen:<\/p>\n
public Person() {\r\n     \/\/... wichtige Anweisungen beim Initialisieren\r\n}<\/pre>\n
Umleitung eines Konstruktoraufrufs<\/h2>\n
Stellen wir uns nun vor, wir möchten dem Benutzer auch die Möglichkeit geben, nur den Nachnamen der Person beim Initialisieren an die Klasse Person<\/b> zu übergeben. Dazu fügen wir einen weiteren Konstruktor zur Klasse hinzu, der nur diesen einen Parameter verwendet:<\/p>\n
public Person_KonstruktorUmleiten(string Nachname)\r\n{\r\n     nachname = Nachname;\r\n}<\/pre>\n
Damit haben wir nun eine Möglichkeit mehr, die Klasse zu initialisieren:<\/p>\n
Person person = new Person(\"Minhorst\");<\/pre>\n
Was hat das nun mit der Umleitung eines Konstruktoraufrufs zu tun Nun: wir kommen hier wieder auf die Funktion des Konstruktors als die beim Starten ausgelöste Methode zurück, in der Sie Anweisungen zur Vorbereitung des Objekts unterbringen. Diese möchten Sie sicherlich nur in einem Konstruktor unterbringen und nicht in jedem einzelnen. Dazu wählen Sie dann logischerweise den Konstruktor aus, der die wenigsten Parameter entgegennimmt (im Optimalfall gar keinen).<\/p>\n
Verwendet die initialisierende Klasse diesen Konstruktor, läuft alles nach Plan. Aber was geschieht, wenn einer der Konstruktoren genutzt wird, der einen oder mehrere Parameter verwendet Es würde naheliegen, von diesem aus dann den Konstruktor mit den Anweisungen zu starten, die bei jeder Initialisierung aufgerufen werden sollen.<\/p>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t