Overrides und Overridable

  • VB.NET

Es gibt 17 Antworten in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

    Overrides und Overridable

    So, ich bins mal wieder mit einer Frage^^

    Hab mir jetzt ein paar Sachen angeguckt wofür man Prozeduren mit Overrides und Overridable betitelt.
    Nun versteh ich den Sinn dahinter nicht. Sofern ich das nicht falsch verstanden habe ist das dazu da:

    Es gibt zwei Funktionen, welche in verschiedenen Klassen sind. Wenn diese jetzt den gleichen Namen haben (z.B. Function Test()), stellt man vor einem ein Overrides und bei dem anderen ein Overridable dran. Jetzt werden die Funktionen "gefiltert" also, der Computer weiß welche Funktion in welcher Klasse gemeint ist.
    Aber man kann doch dann genauso gut einfach den Namen einer Funktion ändern und das wars?

    Vermutlich hab ich den Sinn dahinter nur nicht verstanden ^^
    Wäre aber trotzdem schön wenn ihn mir einer erklären könnte..

    Habe auch ein Beispiel versucht für alle die nicht verstehen was ich damit sagen will:

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
    3. Function2()
    4. End Sub
    5. Overridable Function Function2() As DialogResult
    6. Return MessageBox.Show("erste Klasse")
    7. End Function
    9. End Class
    10. Public Class Test
    11. Inherits Form1
    12. Overrides Function Function2() As DialogResult
    13. Return MessageBox.Show("zweite Klasse")
    14. End Function
    15. End Class


    aber ich könnte doch auch genausogut es so machen:

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
    3. Function2()
    4. End Sub
    5. Function Function2() As DialogResult
    6. Return MessageBox.Show("erste Klasse")
    7. End Function
    9. End Class
    10. Public Class Test
    11. Inherits Form1
    12. Function Function3() As DialogResult
    13. Return MessageBox.Show("zweite Klasse")
    14. End Function
    15. End Class

    Das ist der zusammen mit "MustOverride" ein Großteil dessen, was die Polymorphie ausmacht.
    Es gibt im Framework eine Klasse "Stream", die zum Lesen und Schreiben von Daten aus beliebigen Orten gedacht ist. Das bedeutet, jeder Stream besitzt eine Read und eine Write-Methode. Nun gibt es aber unterschiedlichste Arten von Streams, wie z.B. Memorystream, Filestream oder Networkstrem. Jeder dieser Streams funktioniert anders und muss daher auch anders lesen und schreiben. Der Memorystream Liest und Schreibt im dem Arbeitsspeicher, der Filestream Liest und schreibt auf der Festplatte und der Networkstream läd Daten hoch und runter. Es sind aber trotzdem alles Streams, mit denen man Lesen und Schreiben kann. Es ist z.B. möglich, eine Bitmap aus einem Stream zu erzeugen. Dafür ist es dann völlig unerheblich, ob die nun ein Memorystream, ein Filestream oder ein Networkstream ist, denn wie die Daten herangeschafft werden interessiert die Bitmap nicht, sie liest lediglich aus dem Stream.

    In etwa sieht das so aus:

    VB.NET-Quellcode

    1. Public MustInherit Class Stream
    2. Public MustOverride Function Read (<OutAttribute> buffer As Byte(), offset As Integer, count As Integer) As Integer
    3. End Class
    5. Public Class MemoryStream : Inherits Stream
    6. Public Overrides Function Read (<OutAttribute> buffer As Byte(), offset As Integer, count As Integer) As Integer
    7. 'aus dem RAM lesen
    8. End Sub
    9. End Class
    11. Public Class FileStream : Inherits Stream
    12. Public Overrides Function Read (<OutAttribute> buffer As Byte(), offset As Integer, count As Integer) As Integer
    13. 'von der Festplatte lesen
    14. End Sub
    15. End Class
    17. Public Class NetworkStream : Inherits Stream
    18. Public Overrides Function Read (<OutAttribute> buffer As Byte(), offset As Integer, count As Integer) As Integer
    19. 'etwas downloaden
    20. End Sub
    21. End Class

    Und wenn du dann eine Variable vom Typ Stream hast, dann kann da jeder mögliche Stream drin sein, aber du kannst definitiv daraus lesen. Ob dann im Hintergrund die Daten aus dem RAM, von der Festplatte, oder aus dem Internet kommen, macht keinen Unterschied.

    Ja, aber ginge dann auch nicht das:

    VB.NET-Quellcode

    1. Public Class Stream
    2. Public Function Read1(<OutAttribute()> buffer As Byte(), offset As Integer, count As Integer) As Integer
    4. End Function
    5. End Class
    6. Public Class MemoryStream
    7. Public Function Read2(<OutAttribute()> buffer As Byte(), offset As Integer, count As Integer) As Integer
    8. 'aus dem RAM lesen
    9. End Function
    10. End Class
    12. Public Class FileStream
    13. Public Function Read3(<OutAttribute()> buffer As Byte(), offset As Integer, count As Integer) As Integer
    14. 'von der Festplatte lesen
    15. End Function
    16. End Class
    18. Public Class NetworkStream
    19. Public Function Read4(<OutAttribute()> buffer As Byte(), offset As Integer, count As Integer) As Integer
    20. 'etwas downloaden
    21. End Function
    22. End Class


    Dann würde zwar die Zahl noch hintendran stehen (was unschön aussieht) aber es würde funktionieren?

    Aber du könntest nicht sowas hier machen:

    VB.NET-Quellcode

    1. Public Function UseStream(ByVal stream As Stream)
    2. Dim buffer As Byte()
    3. stream.Read(buffer, 0, 10) 'liest die ersten 10 Bytes aus dem Stream
    4. 'hier wird irgendwas mit diesen Bytes gemacht
    5. End Function
    7. Public Function Test()
    8. Dim memoryStream As MemoryStream
    9. Dim fileStream As FileStream
    10. Dim networkStream As NetworkStream
    11. 'hier die Streams initialisieren
    12. UseStream(memoryStream)
    13. UseStream(fileStream)
    14. UseStream(networkStream)
    15. End Function

    Wenn man statt Stream, Filestream / Memorystream oder Networkstream da eintragen würde?
    Ich mach jetzt nur Vermutung, weiß nicht obs funktioniert, wirst du wahrscheinlich eher wissen.


    VB.NET-Quellcode

    1. Public Function UseStream(ByVal stream As Filestream / Memorystream / Networkstream) '
    2. Dim buffer As Byte()
    3. Stream.Read(buffer, 0, 10) 'liest die ersten 10 Bytes aus dem Stream
    4. 'hier wird irgendwas mit diesen Bytes gemacht
    5. End Function
    7. Public Function Test()
    8. Dim memoryStream As MemoryStream
    9. Dim fileStream As FileStream
    10. Dim networkStream As NetworkStream
    11. 'hier die Streams initialisieren
    12. UseStream(memoryStream)
    13. UseStream(fileStream)
    14. UseStream(networkStream)
    15. End Function

    Mal abgesehen davon dass es unschön aussieht, wenn du dann fein von Stream erbst haste auf einmal 2 Methoden. Du kannst übrigens auch die zuüberschreibende Methode immernoch ausser Überschreibenden aufrufen, nicht aufs Beispiel bezogen.
    /
    Du könntest daraus natürlich ne template Funktion machen und prüfen obs von Stream erbt, trotzdem haste noch dein Read1,2,3

    Das geht natürlich, aber eben genau sowas ist aller größter Ranzcode vom feinsten. Dann musst du nämlich drei verschiedene Methoden schreiben, die vom Inhalt her fast identisch sind.
    Der Trick bei der Sache ist eben, dass die Methode gar nicht weiß, was für eine Art von Stream sie bekommt. Das ist aber auch nicht weiter schlimm, denn das muss sie auch nicht wissen. Sie weiß nur, dass irgendein Stream kommt und aus einem Stream kann gelesen werden.

    Hi
    hier noch ein paar Beispiele, die mir dazu so eingefallen sind:

    VB.NET-Quellcode

    1. Public Class Player
    2. Private _health As Integer
    4. Public Property Health As Integer
    5. Get
    6. Return _health
    7. End Get
    8. Set(value As Integer)
    9. If value < 0 Then Throw New ArgumentOutOfRangeException("Health", "Non-negative health expected.")
    10. Dim previous As Integer = Health
    11. value = ValidateHealth(value)
    12. _health = value
    13. OnHealthChanged(previous)
    14. If value = 0 Then
    15. OnPlayerDead()
    16. End If
    17. End Set
    18. End Property
    20. Public Property MaxHealth As Integer
    22. Public Sub ModHealth(amount As Integer)
    23. Health = Math.Min(Math.Max(Health + amount, 0), Math.Max(Health, MaxHealth))
    24. End Sub
    26. 'Überschreibbare Funktion, um Werte zu korrigieren
    27. Protected Overridable Function ValidateHealth(value As Integer) As Integer
    28. Return value
    29. End Function
    31. 'Überschreibbare Prozeduren, um ableitende Klassen über Änderungen zu informieren
    32. Protected Overridable Sub OnPlayerDead()
    33. End Sub
    35. Protected Overridable Sub OnHealthChanged(previous As Integer)
    36. End Sub
    37. End Class
    39. Public MustInherit Class Fruit
    40. Public MustOverride Sub Eat(player As Player)
    42. Public MustOverride ReadOnly Property Name As String
    44. 'Standardverhalten ist, dass aus Früchten keine Pflanzen wachsen können
    45. Public Overridable ReadOnly Property CanGrowNewPlant As Boolean
    46. Get
    47. Return False
    48. End Get
    49. End Property
    51. 'Somit wird auch eine Exception geworfen
    52. Public Overridable Function GrowNewPlant() As Plant
    53. Throw New NotSupportedException()
    54. End Function
    56. 'Fruit.ToString gibt jetzt für alle Früchte Name zurück. Es kann nicht mehr überschrieben werden (==> NotOverridable)
    57. Public NotOverridable Overrides Function ToString() As String
    58. Return Name
    59. End Function
    60. End Class
    62. Public Class Apple
    63. Inherits Fruit
    65. Public Overrides Sub Eat(player As Player)
    66. player.ModHealth(player.MaxHealth \ 10)
    67. End Sub
    69. 'Name ist hier bei der diskreten Klasse Apfel festgelegt als Apple, kann in Subklassen noch überschrieben werden
    70. Public Overrides ReadOnly Property Name As String
    71. Get
    72. Return "Apple"
    73. End Get
    74. End Property
    76. 'Aus Apfelkernen können Apfelbäume wachsen ==> das Verhalten wird überschrieben.
    77. ' Aus kernlosen Trauben könnten z.B. keine Pflanzen wachsen
    78. Public Overrides ReadOnly Property CanGrowNewPlant As Boolean
    79. Get
    80. Return True
    81. End Get
    82. End Property
    84. Public Overrides Function GrowNewPlant() As Plant
    85. Return New AppleTree()
    86. End Function
    87. End Class
    89. Public MustInherit Class PoisonousFruit
    90. Inherits Fruit
    92. 'Name ist abstrakt, der Spieler stirbt beim Essen einer giftigen Frucht
    94. Public Overrides Sub Eat(player As Player)
    95. player.Health = 0
    96. End Sub
    97. End Class
    99. Public MustInherit Class Plant
    100. Public MustOverride Sub SubmitTimePassed(time As TimeSpan)
    101. End Class
    103. Public Class AppleTree
    104. Inherits Plant
    106. Public Overrides Sub SubmitTimePassed(time As TimeSpan)
    107. 'neue Äpfel wachsen lassen, Baum wachsen lassen, whatever
    108. End Sub
    109. End Class


    Gruß
    ~blaze~

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „~blaze~“ ()

    Erstell Dir mal folgendes Beispiel:
    Basisklasse: EbeneGeometrie (oder so)
    abgeleitete Klassen: Kreis, Rechteck, Dreieck
    zu implementierende Funktionen: Fläche, Umfang
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Habs versucht:

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private Rechteck As Geometrie = New Rechteck
    3. Private Sub Form1_Paint(sender As Object, e As System.Windows.Forms.PaintEventArgs) Handles Me.Paint
    4. 'zeichnen
    5. End Sub
    6. End Class
    7. Public MustInherit Class Geometrie
    8. Public MustOverride Function Draw(ByVal rectangle As Rectangle, ByVal graphics As Graphics) As Rectangle
    9. End Class
    10. Public Class Kreis : Inherits Geometrie
    11. Public Overrides Function Draw(rectangle As System.Drawing.Rectangle, ByVal graphics As Graphics) As System.Drawing.Rectangle
    12. _Kreisfläche = rectangle
    13. With graphics
    14. .DrawEllipse(Pens.Black, Kreis)
    15. End With
    16. End Function
    17. Private _Kreisfläche As Rectangle
    18. Public ReadOnly Property Kreis As Rectangle
    19. Get
    20. Return _Kreisfläche
    21. End Get
    22. End Property
    23. End Class
    24. Public Class Rechteck : Inherits Geometrie
    25. Public Overrides Function Draw(rectangle As System.Drawing.Rectangle, ByVal graphics As Graphics) As System.Drawing.Rectangle
    26. _Rechtecksfläche = rectangle
    27. With graphics
    28. .DrawRectangle(Pens.Black, Rechteck)
    29. End With
    30. End Function
    31. Private _Rechtecksfläche As Rectangle
    32. Public ReadOnly Property Rechteck As Rectangle
    33. Get
    34. Return _Rechtecksfläche
    35. End Get
    36. End Property
    37. End Class


    so richtig??

    Ahja, Wie zeichnet man ein Dreieck? Gibts da nen Befehl für, oder muss man einfach nen array mit 3 Punkten nehmen und die verbinden?

    Ja das war jetzt nicht auf seinen post bezogen sondern allgemein auf das thema, ich probiers dann mal mit Fläche usw

    Damit ist aber gemeint, eine Funktion zum berechnen eines Kreis/Dreieck/Rechteck Umfangs bzw der Fläche?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „RushDen“ ()

    RushDen schrieb:

    Habs versucht:
    Was?
    Einn Dreieck ist ein Polygon.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

Facebook
Telefonspende