| Autor |
Beitrag |
Bruce
      
Beiträge: 80
|
Verfasst: Mo 25.07.05 16:04
Hallo,
ich habe mich jetzt mal "genauer" mit Klassen befasst, aber eines bleibt mir (wie vieles anderes auch  ) noch unklar: Welchen Zweck haben die Sichtbarkeitsattribute ("Private", "Public") genau?
Prinzipiell versteh ich das ja, nur wenn ich eine Klasse deklariere, dann stell ich mir bei jedem Element die Frage, wie es sichtbar sein soll, und dann weiss ich nicht weiter.
Ein einfaches Beispiel: 2 Units, in Unit1 wird eine Klasse deklariert die eine Prozedur "zählen" beinhaltet. Füge ich die Prozedur unter Public ein, kann ich sie aus der Unit2 aus aufrufen. Füge ich sie unter Private ein, dann nicht.
Nehmen wir an, ich muss die Prozedur nur aus Unit1 selbst aufrufen, dann könnte ich die als Private deklarieren. Aber ich könnte sie doch auch als Public deklarieren, das ändert doch dann nichts, oder? Im Gegenteil, am Anfang weiss ich doch noch nicht, ob ich sie nicht doch irgendwann mal "ausserhalb" aufrufen muss oder will?
Und warum gibt es überhaupt "Public", wenn die Deklarationen vor den Sichtbarkeitsattributen doch eh als Public eingestuft werden?
Irgendwie hapert´s beimir da noch
Moderiert von Christian S.: Topic aus Sonstiges verschoben am Di 26.07.2005 um 11:38
Moderiert von Tino: Überflüssige Zeilenumbrüche entfernt.
|
|
Luckie
Ehemaliges Mitglied
Erhaltene Danke: 1
|
Verfasst: Mo 25.07.05 16:20
Nehmen wir an du hast eine Methode Zählen, diese benötigt die Methode ZähleRichtig. ZähleRichtig alleine kann aber nichst sinnvolles ausführen. Daher wird man die Methode Zähle öffentlich machen und ZähleRichtig privat, damit man nicht in Verlegenheit kommt sie aufzurufen. Man würde sie eventuell als override dekalrieren, damit man sie in einer abgeleiteten Klasse übnerschreiben und dort eventuell verbessern kann.
|
|
Bruce 
      
Beiträge: 80
|
Verfasst: Mo 25.07.05 16:25
Luckie hat folgendes geschrieben: | | Nehmen wir an du hast eine Methode Zählen, diese benötigt die Methode ZähleRichtig. ZähleRichtig alleine kann aber nichst sinnvolles ausführen. Daher wird man die Methode Zähle öffentlich machen und ZähleRichtig privat, damit man nicht in Verlegenheit kommt sie aufzurufen. Man würde sie eventuell als override dekalrieren, damit man sie in einer abgeleiteten Klasse übnerschreiben und dort eventuell verbessern kann. |
Hmmm... dass heißt, die Methode "ZähleRichtig" würde von der Methode "Zähle" selbst aufgerufen, so dass ich weiterhin nur die Methode "Zähle" von aussen aufrufen muss?
Aber was würde sich denn ändern, wenn die "ZähleRichtig" auch Public wäre?
|
|
Udontknow
      
Beiträge: 2596
Win7
D2006 WIN32, .NET (C#)
|
Verfasst: Mo 25.07.05 16:25
Ein Beispiel:
Stelle dir eine Klasse vor, die du schreibst, um innerhalb der Anwendung eindeutige Nummern zu vergeben.
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14:
| type TIDGenerator=class(TObject) private FID:Integer; public function GenerateID:Integer; end;
implementation
function TIDGenerator.GenerateID:Integer; begin Result:=FID; Inc(FID); end; |
Warum ist nun der Zähler als private deklariert? Damit er von aussen nicht manipulierbar ist, du kannst nur GenerateID aufrufen, FID aber direkt nicht verändern. Dies ist insofern relevant, daß es dich daran hindert, Fehler zu begehen (indem du von aussen beispielsweise einmal zuerst die Zahl ausliest, diese als ID nimmst und dann erst inkrementierst, beim anderen Mal aber bereits vorher inkrementierst und die Zahl dann erst als ID nimmst. Das würde dann zu Nichteindeutigkeiten führen).
Es gilt in der OOP, daß man eben eine Methode eines Objekts aufruft, ohne sich um die internen Vorgänge innerhalb des Objekts kümmern zu müssen (zu dürfen).
Cu,
Udontknow
|
|
Bruce 
      
Beiträge: 80
|
Verfasst: Mo 25.07.05 16:57
Also da hat´s jetzt schon "Click" gemacht bei mir Udontknow
(Aber noch nicht so richtig  ).
Ich schütze mich also selbst davor, Fehler zu begehen. Allerdings, innerhalb der eigenen Unit (also die in der der die Klasse deklariert ist), habe ich doch Zugriff auf "FID", da bin ich doch vor dem Beispiel-Fehler nicht gefeit, oder?
Dein Beispiel ist jetzt fast zu eindeutig für dieses theoretische Beispiel, aber wenn ich später doch von außen auf FID zugreifen müsste, was mach ich dann? Ich weiß das doch nicht immer im Vorraus?
| Zitat: | | Es gilt in der OOP, daß man eben eine Methode eines Objekts aufruft, ohne sich um die internen Vorgänge innerhalb des Objekts kümmern zu müssen (zu dürfen). |
Ein schöner Satz  der mich in meinem Verständnis von OOP bestärkt. Noch hab ich OOP im Innersten nicht begriffen (merk ich selbst). Mal ganz konkret, ich bin gerade dabei, mit einem Freund an einem Pong-Spiel zu arbeiten (wobei man wirklich viel lernen kann).
Mein Ansatz ist jetzt, daß der Ball als Objekt sich um seinen "Kram" selbst kümmert, also wie er fliegt und wie er auf Kollisionen reagiert (und das regel ich alles in der Klasse "Ball"); Ich könnte ja auch dem Ball sagen, wie er reagiert, wenn er auf die Wand trifft, aber dem Schläger sagen, wie der Ball zu reagieren hat, wenn der Schläger Kontakt mit dem Ball hat. Das wäre aber doch inkonsequent. Der Ball ist ein Objekt und reagiert "autark" auf seine Umwelt...
Ist das der richtige Ansatz bei OOP?
Mich verwirrt nämlich immer noch die Aussage: "Diese oder jene Programmiersprache ist nicht 100% Objekt-Orientiert". Ist Objekt-Orientierung nicht hauptsächlich Sache des Programmierers, sofern die Programmiersprache die Bormittel zur Verfügung stellt?
Auf jeden Fall schon mal Danke und liebe Grüße...
|
|
Tastaro
      
Beiträge: 414
Erhaltene Danke: 23
|
Verfasst: Di 26.07.05 08:28
Bruce hat folgendes geschrieben: | Ich schütze mich also selbst davor, Fehler zu begehen. Allerdings, innerhalb der eigenen Unit (also die in der der die Klasse deklariert ist), habe ich doch Zugriff auf "FID", da bin ich doch vor dem Beispiel-Fehler nicht gefeit, oder?
|
Deshalb macht es Sinn für jede Klasse eine eigene Unit zu verwenden bzw. in jeder Unit nur eine Klasse zu schreiben.
Bruce hat folgendes geschrieben: |
Mein Ansatz ist jetzt, daß der Ball als Objekt sich um seinen "Kram" selbst kümmert, also wie er fliegt und wie er auf Kollisionen reagiert (und das regel ich alles in der Klasse "Ball"); Ich könnte ja auch dem Ball sagen, wie er reagiert, wenn er auf die Wand trifft, aber dem Schläger sagen, wie der Ball zu reagieren hat, wenn der Schläger Kontakt mit dem Ball hat. Das wäre aber doch inkonsequent. Der Ball ist ein Objekt und reagiert "autark" auf seine Umwelt...
Ist das der richtige Ansatz bei OOP?
|
Ich überlege mir immer vorher, was ein Objekt über sich selbst wissen kann und was es selbst tun kann. Danach wird die Klassse angelegt. Alles andere muss Über Methoden ablaufen.
Der von dir genannte Ball weiß seine Größe, seine Position und ggf seine Richtung und Geschwindigkeit, wenn er sich bewegt. Wie er in Bewegung kommt kann dem Ball erst mal egal sein. Das muss man ihm also von außen (über Methoden) mitteilen.
Bruce hat folgendes geschrieben: |
Mich verwirrt nämlich immer noch die Aussage: "Diese oder jene Programmiersprache ist nicht 100% Objekt-Orientiert". Ist Objekt-Orientierung nicht hauptsächlich Sache des Programmierers, sofern die Programmiersprache die Bormittel zur Verfügung stellt?
Auf jeden Fall schon mal Danke und liebe Grüße... |
Wie du schon sagst: Eine Programmiersprache muss die Voraussetzung (Vererbung, Instanzierung usw.) liefern, dass man objektorientiert programmieren kann. Allerdings kann man in so ziemlich allen objektorientierten Programmiersprachen die objektorientierte Programmierung auch umgehen. In Delphi und C++ können Funktionen und Variablen auch außerhalb von Klassen existieren. Java erlaubt das meines Wissens nicht. Aber dafür hat es Klassenmethoden und -variablen, mit denen man das Ganze auch wieder aushebeln kann.
Beste Grüße
Tastaro
|
|
Luckie
Ehemaliges Mitglied
Erhaltene Danke: 1
|
Verfasst: Di 26.07.05 09:27
Bruce hat folgendes geschrieben: |
Ich schütze mich also selbst davor, Fehler zu begehen. Allerdings, innerhalb der eigenen Unit (also die in der der die Klasse deklariert ist), habe ich doch Zugriff auf "FID", da bin ich doch vor dem Beispiel-Fehler nicht gefeit, oder?
|
Unter C++ geht das nicht. Dort kann man aber eine sogenannte Friend-Beziehung schaffen. Diese Sichtbarkeit schafft Delphi automatisch, wenn die Klassen in ein und der selben Unit liegen. Man kann sich jetzt darüber streiten, ob das gut oder schlecht ist. Die C++ Lösung wäre mir aber lieber, denn dann kann ich selbst bestimmen, wie sich die Klassen 'sehen' dürfen.
| Zitat: |
Dein Beispiel ist jetzt fast zu eindeutig für dieses theoretische Beispiel, aber wenn ich später doch von außen auf FID zugreifen müsste, was mach ich dann? Ich weiß das doch nicht immer im Vorraus?
|
Dann arbeitet man mit Getter und Setter Methoden und Properties.
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9:
| type TMyClass = class private FFoo: Integer; procedure SetFoo(Value: Integer); function GetFoo: Integer; public property Foo: Integer read GetFoo write SetFoo; end; |
Alternativ kann man auch auf die Getter und Setter verzichten:
Delphi-Quelltext 1:
| property Foo: Integer read FFoo write FFoo; |
Ist aber unschön. Getter und Setter nimmt man deshalb, um eine Möglichkeit zu haben den Wert vorher zu validieren. Nehmen wir an, du musst durch FFoo teilen. Ist FFoo 0 kommt es zu einer Exception. Der Getter könnte jetzt so aussehen:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7:
| function TMyClass.GetFoo: Integer; begin if FFo = 0 then raise MyFooIsZeroException else result := FFoo; end; |
| Zitat: |
Ein schöner Satz der mich in meinem Verständnis von OOP bestärkt. Noch hab ich OOP im Innersten nicht begriffen (merk ich selbst). Mal ganz konkret, ich bin gerade dabei, mit einem Freund an einem Pong-Spiel zu arbeiten (wobei man wirklich viel lernen kann).
|
Das ist eine gute Idee.
| Zitat: |
Mein Ansatz ist jetzt, daß der Ball als Objekt sich um seinen "Kram" selbst kümmert, [..] Ist das der richtige Ansatz bei OOP?
|
Jupp. Guck dir diesbezüglich mal mein Vier Gewinnt an: www.luckie-online.de...er/Delphi/Programme/ -> FourInARow / VierGewinnt. Dort steckt auch alles in der Klasse, so dass sich das eigentliche Programm auf ein paar wenige Zeilen reduziert.
| Zitat: |
Mich verwirrt nämlich immer noch die Aussage: "Diese oder jene Programmiersprache ist nicht 100% Objekt-Orientiert". Ist Objekt-Orientierung nicht hauptsächlich Sache des Programmierers, sofern die Programmiersprache die Bormittel zur Verfügung stellt?
|
Jaein. Die Delphi language ist zum Beispiel nicht 100% OOP. Datentypen gehören zum Beispiel keiner Klasse an. In .NET hingegen sind selbst Datentypen Klasse und bringe ihre eigenen Methoden mit. So hat zum Beispiel die Integer Klasse eine eigenen Methode, um die Variable in einen String zu konvertieren:
Pseudo-Code
Delphi-Quelltext 1: 2: 3: 4:
| var i: TInteger; begin ShowMessage(i.tostr); |
Interessant wäre für dich eventuell noch mein Tutorial über Klassen in Delphi: delphitutorials.luckie-online.de
|
|
Bruce 
      
Beiträge: 80
|
Verfasst: Sa 30.07.05 12:54
Hallo,
danke für die tollen Antworten und sorry, daß ich bis jetzt nicht zum Antworten kam
@Luckie: Dein Tutorial hab ich doch schon längst gelesen
Ich denke mal, wir wie immer wird sich der Sinn wohl am besten in der Praxis erschliessen, also mach
ich einfach mal soweiter, wie ich angefangen habe.
Eine Frage hab ich aber noch an Tastaro:
| Zitat: | | Der von dir genannte Ball weiß seine Größe, seine Position und ggf seine Richtung und Geschwindigkeit, wenn er sich bewegt. Wie er in Bewegung kommt kann dem Ball erst mal egal sein. Das muss man ihm also von außen (über Methoden) mitteilen. |
Du würdest also Elemente wie die Kollision nicht zum Objekt Ball zählen? Ich habe die Prozedure in die Klasse "Ball" geschrieben, weil mir das logisch erscheint. Der Ball weiss doch am besten, dass er auf etwas geprallt ist denke ich.
Oder hab ich den Satz nur falsch interpretiert?
Gruss,
Bruce
|
|
F34r0fTh3D4rk
      
Beiträge: 5285
Erhaltene Danke: 29
Win Vista (32), Win 7 (64)
Eclipse, SciTE, Lazarus
|
Verfasst: Sa 30.07.05 13:21
wenn jetzt zb dein ball eine kollisionsprozedur hat, aber dein schläger die kollisionsabfrage, dann muss der schläger die kollision des balles aufrufen, diese machst du dann public. alles was man nicht verändern darf private
OOP ist manchmal etwas knifflig, wenn man zB wissen muss WELCHEN Ball man jetzt erwischt hat. TBall.Collide; muss dann der richtige sein, falls mehrere vorhanden sind. Das steckt dann alles in der Abfrage.
|
|
Bruce 
      
Beiträge: 80
|
Verfasst: Sa 30.07.05 14:12
| Zitat: | | wenn jetzt zb dein ball eine kollisionsprozedur hat, aber dein schläger die kollisionsabfrage |
Widerspräche das nicht dem konsequenten Prinzip eines Objektes? Momentan mache ich das so, dass der Ball selbst "merkt", dass er auf etwas geprallt ist und dann seine Richtung ändert. Dabei ist es wurscht, ob er auf eine Wand oder einen Schläger prallt... obwohl ich mir selbst nicht sicher bin, ob der Schläger irgendwann mal auch eine Kollisionsabfrage mit dem Ball braucht (weil wir das Spielprinzip erweitern wollen, wenn das Grundspiel steht).
Noch ein wenig und der Ball fliegt selbständig, wobei er an allem im 45-Grad-Winkel abprallt. Aber dann geht´s los:
Wie kriegt man das hin, dass der Ball "physikalisch korrekt" abprallt (also anschneiden mit dem Schläger)? Wie soll der Schläger bewegt werden (Maus find ich doof, aber wie soll man mit Tasten die Geschwindigkeit des Schlägers kontrollieren (die "Drehknop-Joysticks) damals waren irgendwie schon geil  )?
Und was weiss ich noch was da alles kommt
Schon Wahnsinn, was dahinter steckt, wenn man mal hinter die Fassade der Grafik blickt...
Na ja, da waren Sie wieder, meine drei Probleme, aber hauptsache es macht Spass
Gruss,
Bruce
|
|
F34r0fTh3D4rk
      
Beiträge: 5285
Erhaltene Danke: 29
Win Vista (32), Win 7 (64)
Eclipse, SciTE, Lazarus
|
Verfasst: Sa 30.07.05 17:07
physikalisch korrekt ist einfallswinkel = ausfallswinkel, wenn dein schläger unten ist, und der ball von oben kommt, invertierst du die geschwindigkeit des balles auf der y achse, also wenns vorher 1 war, dann ist es -1. damit wirst du aber nicht viel freude haben, bei einem richtigen pong ist es so, das der ball, je weiter er am rand des schlägers auftrifft, flacher abgestoßen wird, trifft der ball in der mitte auf den schläger ist der winkel 90°.
Berechnen kannst die Resultierende Geschwindigkeit mit dem Satz des Pythagoras:
Quelltext 1: 2: 3: 4: 5: 6: 7: 8:
| y-geschwindiggkeit
^ |\ | \ Resultierende Geschwindigkeit | \ | \ |-----> x-geschwindigkeit |
Diese muss immer Konstant bleiben, da es sonst physikalisch unrealistisch wäre und außerdem nicht förderlich für den Spielspass.
Mein Pong war eigentlich richtig geil, mit effekten usw. aber es gab da ein problem das spiel zurückzusetzen, bzw die blöcke zu entfernen, naja viel erfolg 
|
|
|