Ooa

nasir

New member
Ich habe in 2 Wochen mündliche Abitur Prüfung und muss jetzt schon anfangen zu lernen, damit ich irgendwie noch mein Abi krieg.
Ich hab das Thema OOA (Objektorientierte Analyse)

Ich versteh den Unterschied zwischen überschreiben und überlagern nicht.
Bei der Analyse muss ich auf Vererbung heran gehen. Was hat "Base" mit der Vererbung zu tun.

hat jemand aufgabenstellung zu OOA, womit ich üben könnte?
Ich werde wahrscheinlich in der Prüfung ein Klassendiagramm oder sowas ähnliches bekommen, dass ich dann analyiseren muss.

Es wäre auch wirklich sehr hilfreich, wenn es zu dem noch gute Anleitungen, Tutorials gibt.

bis dann

nasir
 

Machine

Member
Überschreiben bedeutet, dass du eine geerbte Funktion in deiner abgeleiteten Klasse neu schreibst.

Mit "überlagern" meinst du sicherlich "überladen".
Das bedeutet du hast mehrere Funktionen mit dem gleichen Namen aber mit unterschiedlichen Parametern.

z.B.:
Code:
void CMyClass::DoSomething(const CString* sString)
{
    //blabla
}

bool CMyClass::DoSomething(const char* szString)
{
    //blablabla
}

Da ist DoSomething dann eine überladene/überlagerte Funktion.

Ich kann das nicht so gut erklären, sorry.
 

Binäru$

gelöscht
Ich gestatte mir eine kleine Korrektur vorzunehmen :D

Also zum Thema Überladung:
Man spricht nur dann von einer Methodenüberladung wenn:
1. Der Methodenname Ident ist
2. Der Rückgabedatentyp ident ist
3. Sich die Parameter an der Anzahl , bzw am Datentyp unterscheiden
 

System.I/O

New member
Dann gestatte ich mir die Korrektur zu korrigieren :p

Der Rückgabetyp hat bei der Überladung von Methoden keine gewichtung,
lediglich Methodenname und Anzahl als auch Reihenfolge der Parameter werden zur Bildung der Signatur verwendet.

MfG
 

Binäru$

gelöscht
Guten Nachmittag ;)

Thx nochmal für die Korrektur der Korrektur (Überladung) :D
Aber bei C# .Net muss man meines Wissens den selben Rückgabedatentyp wählen bei einer Überladung.
Wollt nur fragen ob das in anderen Programmiersprachen nicht der fall ist? Habs nämlich auch grad ausprobiert nicht das ich hier mit falschen Fakten um mich werfe. :p

MFG
 

System.I/O

New member
Hi,

also ich habs jetzt extra nochmal Probiert und folgende Klasse hat 3 Überladungen (also 4 "gleiche" Methoden):
Code:
using System;

namespace testing
{	
	public class Test
	{
		public Test() {}
		
		public void DoSomething(int input) {
			
		}
		
		public int DoSomething(int inputInt, string inputStr) {
			return int.MinValue;
		}
		
		public int DoSomething(string inputStr, int inputInt) {
			return int.MinValue;
		}
		
		public string DoSomething(object inputObj) {
			return string.Empty;
		}
	}
}
Dem zu folge verhält sich C# genau so wie alle anderen Sprachen.
Vorallem wie will der Compiler feststellen welchen Rückgabetyp du gerade benötigst.
Denn die Rückgabe musst du ja nicht zwingend einer Variablen zuweissen.
Ebenso könnte die Rückgabe in einer Variable gespeichert werden die anhand eines Interface ihren Datentyp zugewiesen bekommen hat.
Also ist die Sache für den Compiler nicht eindeutig und somit is der Rückgabetyp für die Signatur nicht geeignet.
Hoffe das war verständlich ausgedrückt.

MfG
 

t3rr0r.bYt3

New member
Beim überladen ist der Rückgabetyp irrelevant. Kleines Beispiel: a+b ist ein gültiger Ausdruck für a,b von Typ Int(eger) (Addition), oftmals aber auch für a,b vom Typ String (Konkatenation). Rückgabetyp ist hierbei wieder Int bzw. String, also ungleich.
/edit: Das ist hier gerade Überlagern von Operatoren, aber bei Funktionen geht das analog: Der Rückgabetyp ist irrelevant, die Parameter-Typen und -Anzahl sind entscheident (und natürlich der gleiche Funktionen / Operatoren-Name).

Ich versteh den Unterschied zwischen überschreiben und überlagern nicht.

Ich hab keine Ahnung, ob diese Begriffe überall einheitlich gehandhabt werden, aber "Überlagern" kenn ich als Synonym für "Verschatten": Du deklarierst eine Variable einmal außerhalb eines Kontextes (z.b. einer Schleife) und einmal innerhalb - Innerhalb des Kontextes ist nun die innere Deklaration gültig, die äußere wird überlagert.

Überschreiben meint wohl das Redefinieren von Funktionen / Methoden in Erben-Klassen (in Java z.b. die Annotation @Override).

Aber nochmal der Hinweis, das muss nicht eiheitlich gehandhabt sein, ich habe "Überlagern" auch schonmal im hier als "Überschreiben" dargestellten Sinne gelesen.
Eine Klärung wird wohl nur erfolgen, wenn du dein Skript ließt. Solltest du dort etwas nicht verstehen, dann zitiere es hier ruhig, irgendwer wird dir schon helfen können.
 
Oben