Vererbung Klassen vs. Schnittstellen

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 16 Antworten in diesem Thema. Der letzte Beitrag () ist von Artentus.

    Vererbung Klassen vs. Schnittstellen

    Hallo ich hoffe ihr könnt mir bei einem Verständnissproblem helfen betreffend der Vorteile bzw. Anwendung von Vererbung(Implementierung) von Schnittstellen gegenüber von der Vererbung von Klassen ist.
    Um zu erläutern wo genau ich Probleme habe, will ich folgendes Beispiel behandeln:
    Gegeben sind 2 Klassen Audi und BMW. Beide enthalten als Properties eine Durchschnittsgeschwindigkeit (Geschw_durch) und gefahrene Zeit (gefahrene_ZEit). Nun soll mit der Funktion "berechnen_weg()" der zurückgelegte Weg berechnet werden.

    Dabei steht im Zentrumt eine Sub der Art:

    VB.NET-Quellcode

    1. Sub strecke(Objekt)
    2. MessageBox.Show(Objekt.berechnung_weg())
    3. End sub

    Wobei für das Objekt Audi oder BMW stehen kann.

    Bisher dachte ich das wäre nur über eine Schnittstelle möglich der Form:

    VB.NET-Quellcode

    1. Sub Strecke(ByVal Auto As Schnittstelle.Iauto)
    2. MessageBox.Show(Auto.berechnung_weg)
    3. End Sub

    Jedoch ist dies auch mit der simplen Klassenverebung möglich:

    VB.NET-Quellcode

    1. Sub Strecke(ByVal Auto As Auto_K)
    2. MessageBox.Show(Auto.berechnung_weg)
    3. End Sub


    Dh. nach m.E sind die beiden Varianten funktionell ident.
    Meine Frage ist: Was ist mit "Schnittstellen-Vererbung" möglich was nicht mit der "Klassen-Vererbung" geht?
    Wäre super wenn ihr mein Beispiel weiterführen könnt, um den direkten Unterschied in deren Mächtigkeit zu zeigen.

    Hier noch der vollständige Code des Beispiels.
    Struktur des Beispiels:
    Vererbung von Schnitstelle:
    +Klassen Audi_S und Bmw_S inherits Klasse Auto_S
    +Klasse Auto_S Implements Schnittstelle Iauto (dh. 2 Klassen erben von einer anderen Klasse die wiederum eine Schnittstelle implementiert hat)
    Vererbung von Klasse:
    +Klassen Audi_K und Bmw_S inherits Klasse Auto_K


    VB.NET-Quellcode

    1. '========================= Schnittstellenvererbung======================
    2. Public Class Schnittstelle
    3. Interface Iauto
    4. Property Geschw_durch As Long
    5. Property gefahrene_ZEit As Long
    6. Function berechnung_weg() As Long
    7. End Interface
    8. End Class
    10. Public Class Auto_S
    11. Implements Schnittstelle.Iauto
    12. Dim _gefahrene_ZEit As Long
    13. Dim _Geschw_durch As Long
    15. Public Function berechnung_weg() As Long Implements Schnittstelle.Iauto.berechnung_weg
    16. Return Geschw_durch * gefahrene_ZEit
    17. End Function
    19. Public Property gefahrene_ZEit As Long Implements Schnittstelle.Iauto.gefahrene_ZEit
    20. Get
    21. Return _gefahrene_ZEit
    22. End Get
    23. Set(value As Long)
    24. _gefahrene_ZEit = value
    25. End Set
    26. End Property
    28. Public Property Geschw_durch As Long Implements Schnittstelle.Iauto.Geschw_durch
    29. Get
    30. Return _Geschw_durch
    31. End Get
    32. Set(value As Long)
    33. _Geschw_durch = value
    34. End Set
    35. End Property
    36. End Class
    38. Public Class BMW_S
    39. Inherits Auto_S
    40. Public Sub New()
    41. Geschw_durch = 100
    42. gefahrene_ZEit = 100
    43. End Sub
    44. End Class
    46. Public Class Audi_S
    47. Inherits Auto_S
    48. Public Sub New()
    49. Geschw_durch = 100
    50. gefahrene_ZEit = 200
    51. End Sub
    52. End Class
    54. '==============================Klassenvererbung==================================
    55. Public Class Auto_K
    56. Dim _Geschw_durch As Long
    57. Dim _gefahrene_ZEit As Long
    59. Public Function berechnung_weg() As Long
    60. Return Geschw_durch * gefahrene_ZEit
    61. End Function
    63. Public Property gefahrene_ZEit As Long
    64. Get
    65. Return _gefahrene_ZEit
    66. End Get
    67. Set(value As Long)
    68. _gefahrene_ZEit = value
    69. End Set
    70. End Property
    72. Public Property Geschw_durch As Long
    73. Get
    74. Return _Geschw_durch
    75. End Get
    76. Set(value As Long)
    77. _Geschw_durch = value
    78. End Set
    79. End Property
    80. End Class
    82. Public Class BMW_K
    83. Inherits Auto_K
    84. Public Sub New()
    85. Geschw_durch = 100
    86. gefahrene_ZEit = 100
    87. End Sub
    88. End Class
    90. Public Class Audi_K
    91. Inherits Auto_K
    92. Public Sub New()
    93. Geschw_durch = 100
    94. gefahrene_ZEit = 200
    95. End Sub
    96. End Class


    Eine Form mit 4 Buttons

    VB.NET-Quellcode

    1. Public Class Form1
    2. '=================Mit Schnittstellenvererbung=====================
    3. Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button1.Click
    4. Dim bmw_s As New BMW_S()
    5. Call Strecke_S(bmw_s)
    6. End Sub
    8. Private Sub Button2_Click(sender As System.Object, e As System.EventArgs) Handles Button2.Click
    9. Dim audi_s As New Audi_S()
    10. Call Strecke_S(audi_s)
    11. End Sub
    13. Sub Strecke_S(ByVal Auto As Schnittstelle.Iauto)
    14. MessageBox.Show(Auto.berechnung_weg)
    15. End Sub
    16. '=================Mit Klassenvererbung=============================
    18. Private Sub Button3_Click(sender As System.Object, e As System.EventArgs) Handles Button3.Click
    19. Dim bmw_k As New BMW_K()
    20. Call Strecke_K(bmw_k)
    21. End Sub
    23. Private Sub Button4_Click(sender As System.Object, e As System.EventArgs) Handles Button4.Click
    24. Dim audi_k As New Audi_K()
    25. Call Strecke_K(audi_k)
    26. End Sub
    28. Sub Strecke_K(ByVal Auto As AutoK)
    29. MessageBox.Show(Auto.berechnung_weg)
    30. End Sub
    32. End Class



    Gruß Foogo

    Eine Klasse beinhaltet die Member schon vollstaendig implementiert, das ist beim Interface nicht der Fall, denn das Interface gibt dem Programmierer vor, welche Member in die Klasse, die das Interface implementiert, reingehoeren.
    Du kannst also bei deinem Beispiel eine Klasse Auto machen und die Member dort implementieren, sofern sie fuer die gewuenschten "Erben"(/Unterklassen) komplett die Gleichen sind. Wenn jedoch fuer die eine Automarke etwas anders berechnet werden muss als fuer die andere Automarke, solltest/musst du Interfaces nehmen, denn die Klassen haben ja ihre eigene Berechnung und da koennen nicht beide von einer Klasse mit der gleichen Berechnung erben.
    Wie du ja schon angewendet hast, dann man die Interface auch als Parametertyp fuer andere Member nutzen, die alle Klassen, die auf dem Interface basieren, akzeptieren.

    (PS: Lass das Schluesselwort Call weg, ist sinnlos).

    Du kannst übrigens Schnittstellen auch selbstständig deklarieren, ohne groß Klassen anzulegen.
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    Schnittstellen brauchst du deshalb,da du in .Net keine Mehrfachverberung von Klassen hast, außer eben durch Vererbungshierarchien. Klasse A kann also nicht von Klasse B und Klasse C gleichzeitig erben,sondern nur von einer der beiden, deshalb wurden die Schnittstellen implementiert.

    Würde ich so nicht unbedingt sagen, denn Interfaces sind ja nur ein Kontrakt für eine Klasse und funktionieren ja anders als Vererbung.
    Ist halt imo nur ne Kontrolle über verschiedene Inhalte, die man jeder Zeit ganz einfach verwalten kann.
    Dabei steht halt das implementierte Interface oben in der Hierarchie, die Klassen "unterwerfen" sich halt dem Interface und implementieren dessen Methodensignaturen als ganze Methoden, die man selbst noch füllen muss.

    Ist zum Beispiel für Systeme praktisch, bei denen der User eine Vorschrift hat, was er tun muss, aber wie er es macht, ist ihm überlassen, zum Beispiel bei eigener GUI bei verschiedenen Aktionen könnte man sowas anwenden.

    Dafür wurden Interfaces imo geschaffen, mit Mehrfachvererbung haben sie denke ich eher wenig zu tun, da sie eigentlich komplett anders fungieren.
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    Jonas Jelonek schrieb:

    ....Wenn jedoch fuer die eine Automarke etwas anders berechnet werden muss als fuer die andere Automarke, solltest/musst du Interfaces nehmen, denn die Klassen haben ja ihre eigene Berechnung und da koennen nicht beide von einer Klasse mit der gleichen Berechnung erben....


    Angenommen die beiden Automarken haben 99 identische Funktionen und nur 1 unterschiedliche. Wäre der Programmieraufwand nicht erheblich mehr, wenn dann mit Interface diese 99 identischen Funktionen für beide implementiert werden müssten, um dann die eine abweichende reinzubekommen? Gibts da keinen besseren Weg?

    Foogo schrieb:

    Gibts da keinen besseren Weg?

    Man kann erben und Schnittstellen implementieren gleichzeitig.
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    99 identische Funktionen und nur 1 unterschiedliche.

    Um noch darauf aufmerksam zu machen: Man kann auch die 100 Funktionen in der Basisklasse implementieren und die eine, die in einer abgeleiteten Klasse anders ist, als Overridable deklarieren:

    VB.NET-Quellcode

    1. MustInherit Class Auto
    3. '99 gleichartige Funktionen ...
    5. Public Overridable ReadOnly Property Geschwindigkeit As Double
    6. Get
    7. 'Hier Standardimplementierung, die für die meisten Autos zutreffend ist.
    8. Return Math.Pi * Reifendurchmesser * Wellendrehzahl 'Nur als Beispiel
    9. End Get
    10. End Property
    12. End Class
    14. 'Bei einem Gokart beispielsweise könnte noch eine Kette dazwischenhängen, die eine gewisse Übersetzung bewirkt.
    15. Class Gokart
    16. Inherits Auto
    18. Public Overrides ReadOnly Property Geschwindigkeit As Double
    19. Get
    20. 'Hier spezielle Implementierung für genau diese Art von Auto.
    21. Return MyBase.Geschwindigkeit * (ZahnradA / ZahradB)
    22. End Get
    23. End Property
    25. End Class
    27. Class Pkw
    28. Inherits Auto
    30. End Class

    VB.NET-Quellcode

    1. Dim a As New Pkw()
    2. MessageBox.Show(a.Geschwindigkeit.ToString())
    3. Dim b As New Gokart()
    4. MessageBox.Show(b.Geschwindigkeit.ToString())
    Mal angenommen, bei a und b bestehen die gleichen Ausgangsbedingungen, dann kommt bei der ersten MessageBox z.B. 30 heraus, und bei der zweiten z.B. 28. Beim Pkw wird die implementierung aus der Auto-Klasse verwendet (30). Beim Gokart wird die über MyBase.Geschwindigkeit aufgerufen (auch 30) und dann wird nochmal was dazumultipliziert, deshalb kommt da 28 raus, und nicht 30.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

Facebook