Starting

Comments: No Comments

Definitionen die in allen Obejektorientierten Sprachen ähnlich oder sogar gleich sind

Beispiel Code ist in c++ bzw c#

Achtung für Anfänger sind diese kurzen Notizen wenig geeignet. Sie sind von mir mal verfasst worden. Der Zusammenschrieb und die Erklärungen sind mehr zur wiederholung und auffrischung gedacht, keinesfalls zum lernen einer Programmiersprache! –> Schaut unter Buchtipps wenn ihr blutige Anfänger in der Welt der OOP seid! (auch wenn euch Objektoriernierte Programmierung (OOP) nichts sagt ;-) )

Grundsätzliches

Die using Direktive bietet den Vorteil das namespaces die dadurch in das Projekt eingebunden wurden, nicht mehr mit dem vollen Namen angesprochen werden müssen sondern nurnoch mit dem Typbezeichner.(zb ohne System.Console)
Bei Mehrdeutigkeit können Aliasnamen verwendet werden. (zb using Ausgabe = System.Console -> Ausgabe.Write())
Es gibt auch noch den :: -Operator welcher umleitet. (zb global :: System.Console.Write() ) Hierfür wird kein using System.Console benötigt es eignet sich daher nur wenn ein namespace nur sehr wenig benutzt wird.
Namespaces können auch inneinander verschachtelt werden. ( ns1{ ns2{ code2 } code1 } auruf: using ns1.ns2; )

Objekte (auch Klasseninstanzen oder nur Instanzen bezeichnet) sind Referenztypen und werden auf dem Heap gespeichert. Variablen wie Int, Double etc werden auf dem Stack gespeichert ( schneller & call by value )

Objektverknüpfung hat die Auswirkungen das durch obj1=obj2 sie verbunden werden.Ändert man einen wert wird der des anderen auch geändert nicht wie bei variablen des typs int etc… man spricht vom “verbiegen des Pointers”.

Instanzvariable sowie auch Instanzmethoden gehören den Klasseninstanzen bzw den Objekten, im Gegensatz zu Klassenvariablen(static) und Klassenmethoden(static) die der Klasse gehören und unabhänig von den Objekten sind.

Eigenschaften oder auch Properties sind Felder bzw Variablen welche mit Get/Set “erzeugt” werden.

const vs readonly Modifizierter: readonlys können direkt oder über einen Konstruktor zugewiesen werden daher können sie auch erst zur Laufzeit zugewiesen werden. Const müssen direkt zugewiesen werden. Const können nur über obj.constname zugegriffen werden ( bis auf bei string). Readonly können auch übergeben werden
int x = obj.readonlyname;

this: Wenn es variablen mit gleichen Namen gibt ( zb eins in der Klasse das andere in einer Methode dieser klasse) bezieht man sich mit this immer auf das Objekt und nicht auf die in der Methode definierte !

Der Destruktor

Der Destruktor ist das Pendant zum Konstruktor,( ~Klassenname(){ code } ) er zerstört Objekte (obj =null ) indem er die Referenz auf den Speicherbereich Löscht. Der Garbage Collector hat die Aufgabe diese objekte zu suchen und den speicherbereich wieder freizugeben.
Der GC schlägt zu wenn grade keine arbeit ansteht oder aber der Speicher fast voll ist. Ebenfalls kann er durch GC.Collect(); aufgerufen werden. Das Interface IDisposable mit der Methode Dispose gibt die sicherheit das nicht auf den GC gewartet werden muss. Die Dispose Funktion muss vom benutzer aufgeurfen werden, da dies nicht sichergestellt werden kann muss die Klasse auch für den GC eingerichtet werden. ( ~Klassenname() { Dispose(); } )–> S.195 in c#08

Die Sache mit der Vererbung

Die Ableitung bzw Vererbung ist eine ist-eine-Beziehung und nur sinnvoll wenn man sagen kann y ist ein Objekt von x.

abstract bedeutet es ist keine Instanzbildung möglich, durch public abstract class ist es zu erkennen.
Methoden & variablen können ebenfalls abstract sein,dies bedeutet sie haben keinen Code bzw wert, dadurch wird allerdings auch die ganze Klasse abstract!
Abstrakte Klassen könnnen nur abgeleitet werden und alle die als abstract gekennzeichnet sind müssen von der ableitung überschrieben werden. Statische methoden können nicht abstrakt sein!

Klassen die sealed oder static sind
können garnicht abgeleiget werden, Methoden können auch sealed sein (nur in verbindung mit protected !) d.h. Bei ableitung wird sie vererbt kann allergins nicht mit override sondern nur mit new überdeckt werden!

Die Polymorphie sorgt dafür das der aufruf einer Methode richtig zugeordnet wird, wird er in der Subklasse nicht gefunden wird in der Basisklasse gesucht, dies kann hoch bis zur Objekt Klasse gehen. Methoden die als virtual in der Basis klasse deklariert sind können mit override in der Subklasse überschrieben werden.Die Zuordnung erfolgt über die Implementierung des Objekts. Wenn eine Methode mit new überdeckt wird, fällt das polymorphe verhalten weg.
klasse obj1 = new klasseabgel(); klasse obj2 = new klasse(); wenn sie die gleichen Methoden implementieren, werden jetzt bei obj1 die von der abgeleiteten und bei obj2 die von der basisklasse aufgerufen.

Die Aggregation ist eine hat-eine-Beziehung das bedeutet das ein untergeordnetes Objekt eine übergeordnete Klasse hat. Das Objekt wird im Konstruktor der übergeordneten angelegt welcher auch die variablen entgegen nimmt und dann den Konstruktor des untergeordneten Objekts aufruft. Der Zugriff erfolgt also über objÜber.objUnter.Methode(); Wenn er intern nicht weitergeleitet wird (d.h. eine Methode der übergeordneten Klasse die Methode der untergeordneten aufruft und dadurch das Objekt versteckt).
Die zweite Möglichkeit ist die Klassen zu verschachteln. klasse1{ klasse2{code2} code1 }. Die Instanzierung erfolgt genau wie oben, über den Konstruktor von klasse1. Der einzige unterschied ist hier das klasse2 als private deklariert werden kann und somit der zugriff nur über klasse1 möglich ist (Methodenaufrufe der klasse2 müssen von 1 weitergeleitet werden)

Die Sache mit den Interfaces

Interfaces, auch Schnittstellen genannt, bieten die möglichkeit eine Art Vertrag zu unterschreiben sie werden durch public interface name { code } gebildet. Klassen die Schnittstellen Implementieren garantieren das die Klasse die Methoden bereitstellen. Die übernommenen Methoden dürfen abstract oder virual jedoch nicht const oder static, auserdem werden sie mitvererbt. Wenn Methoden mit dem gleichen namen vorhanden sind können sie mit vorranstellen des namens eindeutig benannt werden (zb Iname –> obj von Iname, Iobj.funk1() ).Interfaces können natürlich selbst andere Interfaces Implementieren ( wie vererbung, also keine wiederholung der Methode nötig)

Der is-Operator liefert ture oder false. Mit ihm kann gecheckt werden ob das Objekt von einem typ ist, oder ob zb eine Schnittstelle implementiert wird. (zb if( obj is Iname) oder if(obj is System.Objekt ) )
Der as-Operator kann ähnlich genutzt werden, jedoch nimmt er gleich die Form an oder ist null.
( zb if(obj as Iname != null) oder obj = obj2 as System.Objekt wird also entweder null oder obj2 ist vom typ Sys.Obj ).



Strukturen sind sonderformen von Klassen. Grundsätzlich sind Stukturen als Sammlungen von verschiedenen Wertetypen gedacht sie werden von der Laufzeitumgebung als Wertetyp behandelt und schonen somit Systemresourcen d.h. es muss nicht mit klasse obj = new klasse(); eine Instanz gebildet werden sondern es reicht strukur obj;
Es wird allerdings dann kein Konstuktor aufgerufen und die direkte Zuweißung ( zb public int x =0; ) ist bei Strukts nicht erlaubt, in diesem fall müsste das obj dann mit obj.x =0; zugewiesen werden. Einsatz von Konstuktoren,Methoden, Verschachtelungen und Implementieren von Schnittstellen ist genauso wie bei Klassen möglich.
Allerdings ist der Hauptunterschied das weder vererbt noch geerbt werden kann.

Aufzählungen auch Enumerationen genannt sind Sammlungen vom gleichen Datentyp.Unterstüzt werden nur byte,short,int oder long. Sie sorgen dafür das zb Obst nicht mit Farben verglichen werden kann. Die Zuordnung erfolgt über public enum Obst : long { Apfel, Birne, Kirsche}, ohne der Zuordnung über den :-Operator ist der typ int. Sie müssen durch Komma getrennt werden, die Werte werden durchgezählt wenn nicht definiert. Wenn kein Startwert festgelegt wird (zb Apfel =-5, ) ist der Startwert Wert 0. Enumerationen können nicht innerhalb von Methoden zugewiesen werden.
Zugriff über zb Obst.Apfel (Wert Apfel). Auslesen der Werte (long)Obst.Apfel; (Wert -5 )
Durchlaufen aller Werte ist mit foreach möglich. foreach (Obst ob in Enum.GetValues(typeof(Obst)))

Delegates, zuerst komisch dann echt praktisch

Delegates ( Funktionszeiger) leiten Mehtodenaufrufe weiter, indem es den Zeiger auf eine Objektmethode schiebt. Delegates werden zB mit public delegate int Operation (int wert1,int wert2) definiert. Durch anlegen eines Objektes (Operation prozess; ) kann dann mit prozess = new Operation(Methodenname) die Auswahl stattfinden. Wenn jetzt prozess(wert1,wert2); aufgerufen wird, landet man bei der Methode “Methodenname”. Delegates müssen keine Argumente und auch keinen Rückgabewert besitzen. Der eigentliche Vorteil von Delegates ist die multicast Fähigkeit, durch einen aufruf können so mehrere Methoden aufgerufen werden Operation[] proz = new Operation[2]; die zuordnung erfolgt über proz[0] = new Operation(Methode1); proz[1] = new Operation(Methode2); wenn jetzt der Befehl Operation array = (Operation)Delegate.Combine(proz); aufgerufen wird werden sie verbunden. Wird jetzt array(wert1,wert2); aufgerufen, werden beide Methoden gestartet. Combine kann entweder einen Array vom Typ Delegate oder 2 objekte dieses typs entgegennehmen.
Entfernen: Remove(Delegate source, Delegate value); ( zb proz1 = Delegate.Remove(proz1,proz2); )
Delegates können auch anonyme Methoden aufrufen zb prozess = delegate(int x,inty) { code }; aufruf davon folgt wie gewohnt mit prozess(wer1,wer2);anonyme Methoden dürfen contine,break oder goto nicht enthalten !

Eventhandler dienen dazu eine Methode auszuführen falls ein bestimmtes Ereigniss eintrifft,

Operatoren können überladen werden,( +,-,*,/,~,!,++,true,false,&,^,<,<= usw ). Die überladung geht durch
"public static Rückgabetyp operator Operator(Operand1,Operand2)".Oftmals ist es möglich wenn sie nur Paarweiße überladen werden können, wird == überladen muss dies auch mit != geschehen. Die überladung kann genutzt werden um zb auf einfache Art objekte mit >= zu vergleichen. public static bool operator >=(Klasse1 obj1, Klasse1 obj2) { code }

Auch Wertetypen wie int oder double könnenüberladen werden bei implicit braucht es kein boxing bei explicit schon.
“public static implicit operator Zieldatentyp(Eingabedatentyp){ return intWert; }”. Auruf: ( int x = obj ) bzw ( int x =(int)obj )
Dies gilt auch für die übergabe von Objekten von selbst definierten Klassen “public static implicit operator Klasse1(Klasse2 obj1)”. Bei der Konvertierung durch implizit können datenverluste auftreten bei explizit nicht.

Die Seite kann natürich mit einem Surfstick jeder Zeit auch mobil erreicht werden.

No Comments - Leave a comment

Leave a comment

Your email address will not be published. Required fields are marked *

*


*

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

Welcome , today is Friday, August 22, 2014