Solidity Vererbung: Basics einfach erklärt

Solidity Vererbung einfach erklärt
Nun haben wir einen einfachen Smart Contract mit ein paar Get und Set Funktionen erstellt. Nun können wir unseren einfachen Vertrag durch Vererbung erweitern. Dadurch erreichen wir eine allgemeine Erweiterung der Funktionalitäten von einem Vertrag zum nächsten.

Solidity Vererbung

Wir wollen nun von unserem ersten Vertrag „MyFirstContract“ vererben. Dadurch wird dieser zur sogenannten Oberklasse. Alle Klassen bzw. Verträge, die von diesem erben, werden automatisch zu dessen Unterklasse. Dabei erben die Unterklassen alle Methoden, Eigenschaften und Felder von der Oberklasse, ohne das diese neu angelegt werden müssen.
Wir müssen dadurch in unserem eigenen Vertrag keine weiteren Funktionen definieren, sondern können ganz einfach auf Funktionen der Oberklassen zugreifen.

Basierend auf unserem einfachen Smart Contract „MyFirstContract“ erstellen wir nun in Solidity einen neuen Vertrag namens „Bank“. Bank ist somit eine Unterklasse von „MyFirstContract“. Damit nun unseren „MyFirstContract“-Vertrag von „Bank“ die Funktionen erben kann, brauchen wir das Keyword „is“. Dieses wird dann einfach zwischen der Oberklasse und unserer Unterklasse eingefügt.
Das sieht dann wie folgt aus:


pragma solidity ^0.4.0;

contract MyFirstContract is Bank {

}

Erstelle einen Bankaccount

Nun müssen wir noch einen Smart Contract vom Typ „contract“ anlegen. Dieser funktioniert wie unser Bankaccount. Unser Bankaccount hat je nach Höhe der Geldeinzahlung ein bestimmten Wert, eine Möglichkeit Einzahlungen zu tätigen und das Geld wieder abzuheben.

Zunächst erstellen wir den Smart Contract „Bank“ mit einem unbestimmten Wert. Für diesen unbestimmten Wert legen wir ein neues privates Feld vom Typ „uint“ an und nennen diesen „_value“. Diesen Datentyp benutzen wir, da wir nur positive Werte wollen und es keinen Sinn machen würde, einen negativen Betrag einzahlen zu wollen. Solche Fälle können auch mit Hilfe einer Plausibilitätsprüfung abgefangen werden.


pragma solidity ^0.4.0;

contract Bank {

      uint private _value;
}

Erstellen einer Einzahlungsfunktion

Danach brauchen wir eine Funktion, mit der wir Geld auf das Konto einzahlen können. Die Funktion bekommt nun von außen (d.h. zum Beispiel durch eine Eingabe von der Konsole) einen Parameter vom Typ „unit“, welchen wir mit „amount“ deklarieren. Dabei wird folgendes passieren: Wenn man nun Geld einzahlen möchte, bekommt die Funktion „Deposit“ von außen einen bestimmten Wert zugewiesen. Innerhalb dieser Funktion führen wir nun folgende Berechnung aus.


pragma solidity ^0.4.0;

contract Bank {

uint private _value;

     function deposit(unit amount) {

     _value += amount;
     }
}

Der Wert des Bank Account ist dabei die Summe aller Einzahlungen die wir getätigt haben, also die Werte die „amount“ unserer Funktion weitergibt + unser aktuelles Bankguthaben. Deshalb verwenden wir „value+=amount;“.

Erstelle eine Abhebefunktion

Jetzt müssen wir noch in der Lage sein, Geld wieder abzuheben. Dafür schreiben wir eine „Withdraw“-Funktion.


pragma solidity ^0.4.0;

contract Bank {

      uint private _value;
 
      function deposit(unit amount) {

         _value += amount; 
      }

      function withdraw(unit amount) {

         _value -= amount; 
      }
}

Funktionieren tut diese Funktion eigentlich genau so wie unsere „Deposit“-Funktion. Nur ziehen wir innerhalb der Funktion den ausbezahlten Betrag von unserem Konto ab.

Der Wert des Accounts wird hierbei um den Wert „amount“ reduziert.

Erstellen einer Salden Funktion

Nun brauchen wir noch eine Funktion, um unseren derzeitigen Kontostand abfragen zu können. Dafür erstellen wir die Funktion „Balance“ die uns einen Integer-Wert zurückgeben soll. Hierbei benutzen wir nicht den Datentyp „uint“, da wir mit unserem Guthaben natürlich auch ins Negative gehen können.

Erstellt wird diese Funktion wie folgt: Zuerst schreiben wir das Schlüsselwort „function“, da es sich ja um eine Funktion handelt. Anschließend geben wir der Funktion einen Namen, in unserem Fall „Balance“. Direkt danach kommen 2 leere runde Klammern. Hätten wir noch Parameter, welche die Funktion von außen bekommen würde (siehen Funktion „Deposit“ oder „Withdraw“), müssten wir diese innerhalb der runden Klammern definieren. Als letztes kommt die Rückgabe der Funktion, welche mit dem Schlüsselwort „returns“ erfolgt anschließend der Datentyp der zurückgegeben werden soll.
Innerhalb der Funktion geben wir einfach den in unsere obigen Funktionen berechneten Wert „value“ zurück.


1 pragma solidity ^0.4.0;
2
3 contract Bank {
4      uint private _value;
5 
6      function deposit(unit amount) {
7         _value += amount; 
8      }
9
10      function withdraw(unit amount) {
11         _value -= amount; 
12      }
13 }

Die Funktion soll uns hierbei den aktuellen Wert unseres Bankkontos anzeigen.

Erstellen einer Prüfwertfunktion

Damit niemand Geld abhebt, welches er nicht besitzt, müssen wir zum Schluss noch eine Funktion erstellen die genau das überprüft. Dafür schreiben wir eine Funktion „CheckValue“ die uns einen „Boolean“ zurückgeben soll. Dieser Datentyp hat zwei Zustände, true oder false.
Aufgebaut ist die Funktion genauso wie unsere „Balance“- Funktion, nur kriegen wir diesmal einen Boolean zurück.


pragma solidity ^0.4.0;

contract Bank {

      uint private _value;
 
      function deposit(unit amount) {

         _value += amount; 
      }

      function withdraw(unit amount) {

         _value -= amount; 
      }

      function balance() returns(unit) {

         return _value;
      }

      function checkValue(uint amount) returns(bool) {

         return _value >= amount;
      }
}

Die Funktion soll überprüfen, ob der Betrag der abgehoben wird größer ist als der Wert des Bank Accounts.

Erstellen einer Plausibilitätsprüfung

Jetzt müssen wir noch unsere „Withdraw“- Funktion ändern, damit du nur dann Geld abheben kannst, wenn du auch genügend auf dem Konto hast. Wir erstellen hierfür eine Plausibilitätsprüfung. Diese funktionieren immer nach dem gleichen Prinzip. Da wir eine Funktion nur dann durchführen wollen, wenn alle Prüfungen erfolgreich waren, schreiben wir unsere Prüfung immer am Anfang einer Funktion. Mit Hilfe eines „if-Statements“ können wir unsere eben geschrieben Funktion „CheckValue“ in runden Klammern nach dem „if“ reinschreiben. Als Parameter bekommt diese Funktion nun den Betrag, den wir abheben wollen, also wird der Wert in „amount“ der Funktion übergeben. Ist die Prüfung in Ordnung, wird ein „true“ zurückgeliefert und wir arbeiten den Code innerhalb des „If-Statements“ ab. Alternativ würde auch „CheckValue(amount) == true“ funktionieren. Falls die Funktion jedoch „false“ liefert, würde die Berechnung nicht ausgeführt werden und das Bankkonto bleibt unberührt.

Diese sieht dann wie folgt aus:


pragma solidity ^0.4.0;

contract Bank {

      uint private _value;
 
      function deposit(unit amount) {

         _value += amount; 
      }

      function withdraw(unit amount) {

         if (checkValue(amount)) {

         _value -= amount;
         }
      }

      function balance() returns(unit) {

         return _value;
      }

      function checkValue(uint amount) returns(bool) {

        return _value >= amount;
      }
}

Unser Vertrag erbt von Bank

Damit ist unser virtueller Bank Account fertig. Wir können nun Geld ein- und auszahlen. Da unser Smart Contract „MyFirstContract“ von „Bank“ erbt, hat dieser nun auch die Funktionen „Deposit“, „Withdraw“ und „Balance“. Mit Solidity Vererbung kann nun ganz einfach eine Erweiterung der Funktionalitäten des Vertrags erreicht werden.

Dir gefiel unser Artikel „Solidity Vererbung“ und möchtest mehr wissen? Hier erfährst du alles über Solidity Mofidier.
Wenn du über die neusten Artikel informiert werden möchtest, folge uns auf Facebook, Pinterest und Steemit.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.