Groovy - Objektorientiert
In Groovy gibt es wie in jeder anderen objektorientierten Sprache das Konzept von Klassen und Objekten, um die objektorientierte Natur der Programmiersprache darzustellen. Eine Groovy-Klasse ist eine Sammlung von Daten und den Methoden, die mit diesen Daten arbeiten. Zusammen werden die Daten und Methoden einer Klasse verwendet, um ein reales Objekt aus der Problemdomäne darzustellen.
Eine Klasse in Groovy deklariert den Status (Daten) und das Verhalten von Objekten, die von dieser Klasse definiert wurden. Daher beschreibt eine Groovy-Klasse sowohl die Instanzfelder als auch die Methoden für diese Klasse.
Es folgt ein Beispiel für eine Klasse in Groovy. Der Name der Klasse ist Student, der zwei Felder hat -StudentID und StudentName. In der Hauptfunktion erstellen wir ein Objekt dieser Klasse und weisen dem Wert zuStudentID und StudentName des Objekts.
class Student {
int StudentID;
String StudentName;
static void main(String[] args) {
Student st = new Student();
st.StudentID = 1;
st.StudentName = "Joe"
}
}Getter- und Setter-Methoden
In jeder Programmiersprache ist es immer üblich, die Instanzmitglieder mit dem privaten Schlüsselwort auszublenden und stattdessen Getter- und Setter-Methoden bereitzustellen, um die Werte der Instanzvariablen entsprechend festzulegen und abzurufen. Das folgende Beispiel zeigt, wie dies gemacht werden kann.
class Student {
private int StudentID;
private String StudentName;
void setStudentID(int pID) {
StudentID = pID;
}
void setStudentName(String pName) {
StudentName = pName;
}
int getStudentID() {
return this.StudentID;
}
String getStudentName() {
return this.StudentName;
}
static void main(String[] args) {
Student st = new Student();
st.setStudentID(1);
st.setStudentName("Joe");
println(st.getStudentID());
println(st.getStudentName());
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
1
JoeBeachten Sie die folgenden wichtigen Punkte zum obigen Programm:
In der Klasse sind sowohl die studentID als auch der studentName als privat markiert, was bedeutet, dass von außerhalb der Klasse nicht auf sie zugegriffen werden kann.
Jedes Instanzmitglied hat seine eigene Getter- und Setter-Methode. Die Getter-Methode gibt den Wert der Instanzvariablen zurück, z. B. die Methode int getStudentID (), und die Setter-Methode legt den Wert der Instanz-ID fest, z. B. die Methode - void setStudentName (String pName).
Instanzmethoden
Normalerweise ist es selbstverständlich, mehr Methoden in die Klasse aufzunehmen, die tatsächlich eine Art Funktionalität für die Klasse ausführen. In unserem Schülerbeispiel fügen wir Instanzmitglieder von Marks1, Marks2 und Marks3 hinzu, um die Noten des Schülers in 3 Fächern zu kennzeichnen. Wir werden dann eine neue Instanzmethode hinzufügen, die die Gesamtpunktzahl des Schülers berechnet. Im Folgenden sehen Sie, wie der Code aussehen würde.
Im folgenden Beispiel ist die Methode Total eine zusätzliche Instanzmethode, in die eine Logik integriert ist.
class Student {
int StudentID;
String StudentName;
int Marks1;
int Marks2;
int Marks3;
int Total() {
return Marks1+Marks2+Marks3;
}
static void main(String[] args) {
Student st = new Student();
st.StudentID = 1;
st.StudentName="Joe";
st.Marks1 = 10;
st.Marks2 = 20;
st.Marks3 = 30;
println(st.Total());
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
60Mehrere Objekte erstellen
Man kann auch mehrere Objekte einer Klasse erstellen. Es folgt das Beispiel, wie dies erreicht werden kann. Hier erstellen wir 3 Objekte (st, st1 und st2) und rufen ihre Instanzmitglieder und Instanzmethoden entsprechend auf.
class Student {
int StudentID;
String StudentName;
int Marks1;
int Marks2;
int Marks3;
int Total() {
return Marks1+Marks2+Marks3;
}
static void main(String[] args) {
Student st = new Student();
st.StudentID = 1;
st.StudentName = "Joe";
st.Marks1 = 10;
st.Marks2 = 20;
st.Marks3 = 30;
println(st.Total());
Student st1 = new Student();
st.StudentID = 1;
st.StudentName = "Joe";
st.Marks1 = 10;
st.Marks2 = 20;
st.Marks3 = 40;
println(st.Total());
Student st3 = new Student();
st.StudentID = 1;
st.StudentName = "Joe";
st.Marks1 = 10;
st.Marks2 = 20;
st.Marks3 = 50;
println(st.Total());
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
60
70
80Erbe
Vererbung kann als der Prozess definiert werden, bei dem eine Klasse die Eigenschaften (Methoden und Felder) einer anderen Klasse erhält. Durch die Verwendung der Vererbung werden die Informationen in einer hierarchischen Reihenfolge verwaltet.
Die Klasse, die die Eigenschaften anderer erbt, wird als Unterklasse (abgeleitete Klasse, untergeordnete Klasse) bezeichnet, und die Klasse, deren Eigenschaften vererbt werden, wird als Oberklasse (Basisklasse, übergeordnete Klasse) bezeichnet.
Erweitert
extendsist das Schlüsselwort, mit dem die Eigenschaften einer Klasse geerbt werden. Im Folgenden wird die Syntax des erweiterten Schlüsselworts angegeben. Im folgenden Beispiel machen wir die folgenden Dinge -
Erstellen einer Klasse namens Person. Diese Klasse hat ein Instanzmitglied namens name.
Erstellen einer Klasse namens Student, die sich aus der Person-Klasse erstreckt. Beachten Sie, dass das in der Person-Klasse definierte Namensinstanzmitglied von der Student-Klasse geerbt wird.
Im Student-Klassenkonstruktor rufen wir den Basisklassenkonstruktor auf.
In unserer Student-Klasse fügen wir 2 zusätzliche Instanzmitglieder von StudentID und Marks1 hinzu.
class Example {
static void main(String[] args) {
Student st = new Student();
st.StudentID = 1;
st.Marks1 = 10;
st.name = "Joe";
println(st.name);
}
}
class Person {
public String name;
public Person() {}
}
class Student extends Person {
int StudentID
int Marks1;
public Student() {
super();
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
JoeInnere Klassen
Innere Klassen werden in anderen Klassen definiert. Die einschließende Klasse kann die innere Klasse wie gewohnt verwenden. Auf der anderen Seite kann eine innere Klasse auf Mitglieder ihrer einschließenden Klasse zugreifen, selbst wenn sie privat sind. Andere Klassen als die umschließende Klasse dürfen nicht auf innere Klassen zugreifen.
Das Folgende ist ein Beispiel für eine äußere und innere Klasse. Im folgenden Beispiel machen wir die folgenden Dinge -
- Erstellen einer Klasse namens Outer, die unsere äußere Klasse sein wird.
- Definieren einer Zeichenfolge namens name in unserer Outer-Klasse.
- Erstellen einer inneren oder verschachtelten Klasse innerhalb unserer äußeren Klasse.
- Beachten Sie, dass wir in der inneren Klasse auf das in der äußeren Klasse definierte Namensinstanzmitglied zugreifen können.
class Example {
static void main(String[] args) {
Outer outobj = new Outer();
outobj.name = "Joe";
outobj.callInnerMethod()
}
}
class Outer {
String name;
def callInnerMethod() {
new Inner().methodA()
}
class Inner {
def methodA() {
println(name);
}
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
JoeAbstrakte Klassen
Abstrakte Klassen stellen generische Konzepte dar, daher können sie nicht instanziiert werden und werden erstellt, um in Unterklassen unterteilt zu werden. Ihre Mitglieder umfassen Felder / Eigenschaften und abstrakte oder konkrete Methoden. Abstrakte Methoden sind nicht implementiert und müssen von konkreten Unterklassen implementiert werden. Abstrakte Klassen müssen mit dem Schlüsselwort abstract deklariert werden. Abstrakte Methoden müssen auch mit dem Schlüsselwort abstract deklariert werden.
Beachten Sie im folgenden Beispiel, dass die Person-Klasse jetzt zu einer abstrakten Klasse gemacht wird und nicht instanziiert werden kann. Beachten Sie auch, dass es in der abstrakten Klasse eine abstrakte Methode namens DisplayMarks gibt, die keine Implementierungsdetails enthält. In der Schülerklasse müssen die Implementierungsdetails hinzugefügt werden.
class Example {
static void main(String[] args) {
Student st = new Student();
st.StudentID = 1;
st.Marks1 = 10;
st.name="Joe";
println(st.name);
println(st.DisplayMarks());
}
}
abstract class Person {
public String name;
public Person() { }
abstract void DisplayMarks();
}
class Student extends Person {
int StudentID
int Marks1;
public Student() {
super();
}
void DisplayMarks() {
println(Marks1);
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
Joe
10
nullSchnittstellen
Eine Schnittstelle definiert einen Vertrag, dem eine Klasse entsprechen muss. Eine Schnittstelle definiert nur eine Liste der Methoden, die implementiert werden müssen, definiert jedoch nicht die Methodenimplementierung. Eine Schnittstelle muss mit dem Schlüsselwort interface deklariert werden. Eine Schnittstelle definiert nur Methodensignaturen. Methoden einer Schnittstelle sind immerpublic. Es ist ein Fehler, geschützte oder private Methoden in Schnittstellen zu verwenden.
Das Folgende ist ein Beispiel für eine Schnittstelle in Groovy. Im folgenden Beispiel machen wir die folgenden Dinge -
Erstellen einer Schnittstelle mit dem Namen Marks und Erstellen einer Schnittstellenmethode mit dem Namen DisplayMarks.
In der Klassendefinition verwenden wir das Schlüsselwort implements, um die Schnittstelle zu implementieren.
Da wir die Schnittstelle implementieren, müssen wir die Implementierung für die DisplayMarks-Methode bereitstellen.
class Example {
static void main(String[] args) {
Student st = new Student();
st.StudentID = 1;
st.Marks1 = 10;
println(st.DisplayMarks());
}
}
interface Marks {
void DisplayMarks();
}
class Student implements Marks {
int StudentID
int Marks1;
void DisplayMarks() {
println(Marks1);
}
}Wenn wir das obige Programm ausführen, erhalten wir das folgende Ergebnis:
10
null