🍪 Privacy & Transparency

We and our partners use cookies to Store and/or access information on a device. We and our partners use data for Personalised ads and content, ad and content measurement, audience insights and product development. An example of data being processed may be a unique identifier stored in a cookie. Some of our partners may process your data as a part of their legitimate business interest without asking for consent. To view the purposes they believe they have legitimate interest for, or to object to this data processing use the vendor list link below. The consent submitted will only be used for data processing originating from this website. If you would like to change your settings or withdraw consent at any time, the link to do so is in our privacy policy accessible from our home page..

Vendor List | Privacy Policy
Skip to content

Technik Blog

Programmieren | Arduino | ESP32 | MicroPython | Python | Raspberry PI

Menu
  • Projekte
    • LED’s
    • Servo & Schrittmotoren
    • Sound
    • LCD’s
    • Kommunikation
    • Sicherheit
    • Weekend Project
  • Arduino
    • Tutorials
    • ProMini
      • Anschließen & Programmieren
    • Nano
      • Arduino Nano – Übersicht
    • UNO
      • Übersicht
    • MEGA 2560
      • Übersicht
    • Leonardo
      • Übersicht
    • NodeMCU
      • NodeMCU – “Einer für (fast) Alles!”
    • Lilypad
      • Arduino: Lilypad “Jetzt Geht’s Rund!”
    • WEMOS
      • WEMOS D1 – Arduino UNO kompatibles Board mit ESP8266 Chip
      • WEMOS D1 Mini – Übersicht
      • Wemos D1 mini Shields
    • STM32x
      • STM32F103C8T6 – Übersicht
    • Maker UNO
      • Maker UNO – Überblick und Test
    • ATTiny85
      • Mini Arduino mit ATTiny85 Chip
      • ATtiny85 mit dem Arduino UNO beschreiben
  • Android
  • Über mich
  • DeutschDeutsch
  • EnglishEnglish
Menu

Apache Groovy #8: objektorientierte Programmierung

Posted on 31. August 202229. April 2023 by Stefan Draeger

In diesem Beitrag möchte ich dir die objektorientierte Programmierung mit Apache Groovy näher bringen.

OOP mit Apache Groovy - Teil 1
OOP mit Apache Groovy – Teil 1

Bisher haben wir unsere Groovy Skripte lediglich in einer Datei geschrieben, welche einfach ausgeführt wurde. Das ist für kleine Skripte völlig okay, wenn wir jedoch große Business-Anwendungen entwickeln wollen, dann sollten wir eine gewisse Struktur einbauen und unseren Code aufteilen.

Die offizielle Dokumentation zur objektorientierten Programmierung in Apache Groovy findest du unter https://groovy-lang.org/objectorientation.html.

  • Erzeugen einer Klasse
    • private Felder in Klassen
  • Vererbung

Erzeugen einer Klasse

Eine Groovy Klasse ist der Java Klasse sehr ähnlich und auch voll kompatibel mit Java. D.h. du kannst eine Java Klasse aus Groovy importieren und ableiten.

Eine Groovy Klasse erzeugen wir mit dem Schlüsselwort „class“ jedoch entfällt der aus Java ggf. bekannte Accessmodifier „public“, da in Groovy generell alle Klassen „public“ sind.

Innerhalb dieser Klasse können wir nun Felder und Funktionen definieren, welche die Klasse auszeichnen.

class Person {
	
	String firstname
	String lastname
	
	def greeting() {
		"Hello from $firstname $lastname"
	}
}

Erzeugen wir uns nun ein erstes Objekt:

println new Person(firstname:"Stefan", lastname:"Draeger").greeting()

Die Ausgabe in der Konsole ist wie folgt:

Hello from Stefan Draeger

Was einem auffällt, ist der Konstruktor, welchen wir für die Erzeugung unserer Klasse verwenden, hier nutzen wir die Feldnamen als Parameter und können diesen, so die Werte übergeben.

Natürlich könnten wir auch zuerst nur eine leere Hülle erzeugen und die Werte per Setter setzen.

Person p1 = new Person()
p1.setFirstname("Max")
p1.setLastname("Mustermann")
println p1.greeting()

Was einem erfahrenen Javaentwickler auffallen wird ist, dass wir Funktionen verwenden, welche in der Klasse nicht definiert sind. In Groovy werden für alle öffentliche Felder getter & setter automatisch bereitgestellt (dieses können wir durch eine Annotation steuern).

private Felder in Klassen

Wenn wir jedoch ein Feld mit dem Accessmodifier „private“ markieren, dann haben wir keinen Zugriff mehr über einen Setter auf diesen, sondern nur noch über den Konstruktor. Wir müssten also den Setter (und Getter) selber schreiben.

Im nachfolgenden Beispiel habe ich das Feld „lastname“ auf „private“ gesetzt und erhalte beim Ausführen des Skriptes dann eine Exception das, die Funktion „setLastname()“ nicht gefunden wurde.

class Person {
	
	String firstname
	private String lastname
	
	def greeting() {
		"Hello from $firstname $lastname"
	}
}
Person p1 = new Person()
p1.setFirstname("Max")
p1.setLastname("Mustermann")
println p1.greeting()
Caught: groovy.lang.MissingMethodException: No signature of method: person.Person.setLastname() is applicable for argument types: (String) values: [Mustermann]

Vererbung

Mit Vererbung können wir öffentliche Attribute (Felder, Funktionen) von einer anderen Klasse erben und wiederverwenden.

Nehmen wir zunächst ein einfaches Beispiel, wir wollen ein Fahrzeugpool pflegen, dort haben wir diverse Kraftfahrzeuge (LKW, Auto, Motorrad) enthalten. Allen diesen Kraftfahrzeugen ist gleich, dass diese folgende Attribute haben:

  • Anzahl X Räder,
  • Anzahl X Sitzplätze,
  • Farbe,
  • PS,
  • Gewicht,
  • Zulässiges Gesamtgewicht

Jetzt könnte man einfach für jeden der genannten Typen Kraftfahrzeuge eine Klasse mit den oben genannten Attributen erstellen, das würde funktionieren, hätte jedoch nichts mit objektorientierte Programmierung zu tun.

import groovy.transform.ToString

@ToString
class Kraftfahrzeug {
	
	int anzahlRaeder;
	int anzahlSitzplaetze;
	String farbe;
	int ps;
	double gewicht;
	double zulGesamtgewicht;
}

Wir können nun beliebig viele Instanzen von dieser Klasse erzeugen und so unseren Fahrzeugpool aufbauen.

Kraftfahrzeug lkw = new Kraftfahrzeug()
lkw.setAnzahlRaeder(8)
lkw.setAnzahlSitzplaetze(3)
lkw.setFarbe("blau")
lkw.setPs(800)
lkw.setGewicht(1.7)
lkw.setZulGesamtgewicht(40)

Kraftfahrzeug auto = new Kraftfahrzeug()
auto.setAnzahlRaeder(4)
auto.setAnzahlSitzplaetze(5)
auto.setFarbe("rot")
auto.setPs(112)
auto.setGewicht(1.5)
auto.setZulGesamtgewicht(3.5)

Kraftfahrzeug motorad = new Kraftfahrzeug()
auto.setAnzahlRaeder(2)
auto.setAnzahlSitzplaetze(2)
auto.setFarbe("schwarz")
auto.setPs(130)
auto.setGewicht(250)
auto.setZulGesamtgewicht(1)

println lkw
println auto
println motorad

Ausgabe in der Konsole:

Kraftfahrzeug(8, 3, blau, 800, 1.7, 40.0)
Kraftfahrzeug(2, 2, schwarz, 130, 250.0, 1.0)
Kraftfahrzeug(0, 0, null, 0, 0.0, 0.0)

Wir haben aber das Problem, dass wir diese Objekte nicht unterscheiden können, ob es ein Lkw, Auto oder Motorrad ist. Hier müssten wir also entweder ein zusätzliches Feld pflegen oder wir nutzen die objektorientierte Programmierung und erben von der Klasse „Kraftfahrzeug“.

Fangen wir mit der Klasse „Auto“ an, hier erben wir nur von der Klasse „Kraftfahrzeug“ und fügen zunächst keine weiteren Felder oder Funktionen hinzu.

import groovy.transform.ToString

@ToString
class Auto extends Kraftfahrzeug{
	
}

Da ich an der Klasse Kraftfahrzeug die Annotation @ToString gesetzt habe, muss ich diese auch an die neue Klasse Auto setzen, da sonst die toString Methode der Klasse Kraftfahrzeuge aufgerufen wird und dieses zu Verwirrung führen kann.

Wenn wir nun ein Objekt vom Typ Auto erzeugen, dann wird in der Konsole die Ausgabe erzeugt, dass wir zwei unterschiedliche Objekte haben.

Kraftfahrzeug lkw = new Kraftfahrzeug()
lkw.setAnzahlRaeder(8)
lkw.setAnzahlSitzplaetze(3)
lkw.setFarbe("blau")
lkw.setPs(800)
lkw.setGewicht(1.7)
lkw.setZulGesamtgewicht(40)

Auto auto = new Auto();
auto.setAnzahlRaeder(4)
auto.setAnzahlSitzplaetze(5)
auto.setFarbe("rot")
auto.setPs(112)
auto.setGewicht(1.3)
auto.setZulGesamtgewicht(3.5)

println lkw
println auto
de.draegerit.firstprj.oop.Kraftfahrzeug(8, 3, blau, 800, 1.7, 40.0)
de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4)

Nun können wir uns eine Liste mit den Kraftfahrzeugen aufbauen und verwalten.

List<Kraftfahrzeug> kfzPool = new ArrayList<>()

Kraftfahrzeug lkw = new Kraftfahrzeug()
lkw.setAnzahlRaeder(8)
lkw.setAnzahlSitzplaetze(3)
lkw.setFarbe("blau")
lkw.setPs(800)
lkw.setGewicht(1.7)
lkw.setZulGesamtgewicht(40)

Auto auto = new Auto()
auto.setAnzahlRaeder(4)
auto.setAnzahlSitzplaetze(5)
auto.setFarbe("rot")
auto.setPs(112)
auto.setGewicht(1.3)
auto.setZulGesamtgewicht(3.5)

for(int i=0;i<5;i++) {
	kfzPool.add(lkw)
	kfzPool.add(auto)
}

println kfzPool

Wir haben nun eine Liste mit 6 Kraftfahrzeugen erzeugt und diese können mir nun mit dem Schlüsselwort „instanceof“ auf den Typ prüfen.

kfzPool.each { kfz -> if(kfz instanceof Auto) println kfz }
de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4)
de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4)
de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4)
de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4)
de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4)

Schreibe einen Kommentar Antworten abbrechen

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

Kategorien

Tools

  • 8×8 LED Matrix Tool
  • 8×16 LED Matrix Modul von Keyestudio
  • 16×16 LED Matrix – Generator
  • Widerstandsrechner
  • Rechner für Strom & Widerstände
  • ASCII Tabelle

Meta

  • Videothek
  • Impressum
  • Datenschutzerklärung
  • Disclaimer
  • Kontakt
  • Cookie-Richtlinie (EU)

Links

Blogverzeichnis Bloggerei.de Blogverzeichnis TopBlogs.de das Original - Blogverzeichnis | Blog Top Liste Blogverzeichnis trusted-blogs.com
©2023 Technik Blog | Built using WordPress and Responsive Blogily theme by Superb