1. WIKI教程
2. 学习Groovy
3. Groovy - 面向对象(Object Oriented)

Groovy - 面向对象(Object Oriented)

在Groovy中，与任何其他面向对象语言一样，有类和对象的概念来表示编程语言的面向对象性质。 Groovy类是数据的集合以及对该数据进行操作的方法。 同时，类的数据和方法用于表示来自问题域的一些现实世界对象。

Groovy中的类声明状态（数据）和该类定义的对象的行为。 因此，Groovy类描述了该类的实例字段和方法。

以下是Groovy中的类的示例。 该类的名称是Student，它有两个字段 - StudentID和StudentName 。 在main函数中，我们创建了此类的对象，并将值分配给对象的StudentID和StudentName 。

class Student {
   int StudentID;
   String StudentName;
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.StudentName = "Joe"     
   } 
}

getter和setter方法

在任何编程语言中，始终使用private关键字隐藏实例成员，而是提供getter和setter方法来相应地设置和获取实例变量的值。 以下示例显示了如何完成此操作。

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());
   } 
}

当我们运行上述程序时，我们将得到以下结果 -

1 
Joe 

请注意以下有关上述计划的要点 -

• 在类中，studentID和studentName都标记为private，这意味着无法从类外部访问它们。

• 每个实例成员都有自己的getter和setter方法。 getter方法返回实例变量的值，例如方法int getStudentID（）和setter方法设置实例ID的值，例如方法 - void setStudentName（String pName）

实例方法

在类中包含更多方法通常是很自然的，这些方法实际上为类提供了某种功能。 在我们的学生示例中，让我们添加Marks1，Marks2和Marks3的实例成员来表示3个科目中学生的分数。 然后，我们将添加一个新的实例方法，该方法将计算学生的总分。 以下是代码的外观。

在下面的示例中，方法Total是一个附加的Instance方法，它内置了一些逻辑。

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());
   }
}

当我们运行上述程序时，我们将得到以下结果 -

60

创建多个对象

人们还可以创建一个类的多个对象。 以下是如何实现这一目标的示例。 在这里，我们创建了3个对象（st，st1和st2）并相应地调用它们的实例成员和实例方法。

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());
   } 
} 

当我们运行上述程序时，我们将得到以下结果 -

60 
70 
80 

继承 (Inheritance)

继承可以定义为一个类获取另一个类的属性（方法和字段）的过程。 通过使用继承，可以按层次顺序管理信息。

继承其他属性的类称为子类（派生类，子类），其属性被继承的类称为超类（基类，父类）。

Extends

extends是用于继承类属性的关键字。 下面给出的是extends关键字的语法。 在以下示例中，我们正在执行以下操作 -

• 创建一个名为Person的类。 该类有一个名为name的实例成员。

• 创建一个名为Student的类，它从Person类扩展而来。 请注意，Person类中定义的名称实例成员将在Student类中继承。

• 在Student类构造函数中，我们调用基类构造函数。

• 在我们的Student类中，我们添加了另外两个StudentID和Marks1的实例成员。

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();
   } 
}   

当我们运行上述程序时，我们将得到以下结果 -

Joe

内在的类

内部类在另一个类中定义。 封闭类可以像往常一样使用内部类。 另一方面，内部类可以访问其封闭类的成员，即使它们是私有的。 封闭类以外的类不允许访问内部类。

以下是外部和内部类的示例。 在以下示例中，我们正在执行以下操作 -

• 创建一个名为Outer的类，它将成为我们的外部类。
• 在我们的Outer类中定义一个名为name的字符串。
• 在我们的Outer类中创建一个Inner或嵌套类。
• 请注意，在内部类中，我们能够访问在Outer类中定义的名称实例成员。

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); 
      } 
   } 
}   

当我们运行上述程序时，我们将得到以下结果 -

Joe

抽象类

抽象类表示通用概念，因此，它们无法实例化，被创建为子类。 他们的成员包括字段/属性和抽象或具体方法。 抽象方法没有实现，必须由具体的子类实现。 必须使用abstract关键字声明抽象类。 抽象方法也必须使用abstract关键字声明。

在下面的示例中，请注意Person类现在变为抽象类，无法实例化。 另请注意，抽象类中有一个名为DisplayMarks的抽象方法，它没有实现细节。 在学生班中，必须添加实施细节。

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); 
   }  
} 

当我们运行上述程序时，我们将得到以下结果 -

Joe 
10 
null

Interfaces

接口定义了类需要遵循的契约。 接口仅定义需要实现的方法列表，但不定义方法实现。 需要使用interface关键字声明接口。 接口仅定义方法签名。 接口的方法总是public 。 在接口中使用受保护或私有方法是错误的。

以下是groovy中的接口示例。 在以下示例中，我们正在执行以下操作 -

• 创建一个名为Marks的接口，并创建一个名为DisplayMarks的接口方法。

• 在类定义中，我们使用implements关键字来实现接口。

• 因为我们正在实现接口，所以我们必须为DisplayMarks方法提供实现。

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);
   }
}

当我们运行上述程序时，我们将得到以下结果 -

10
null