Groovy - 面向对象

上一页
下一页

在 Groovy 中，与任何其他面向对象语言一样，存在类和对象的概念来表示编程语言的面向对象特性。Groovy 类是数据及其操作数据的函数的集合。类的数据和方法一起用于表示来自问题域的某个现实世界对象。

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

以下是一个 Groovy 类示例。类的名称为 Student，它有两个字段 - **StudentID** 和 **StudentName**。在主函数中，我们正在创建此类的对象并将值分配给对象的 **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 是一个具有内置逻辑的附加实例方法。

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

继承

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

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

扩展

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

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

  • 创建一个名为 Student 的类，它扩展自 Person 类。请注意，在 Person 类中定义的 name 实例成员在 Student 类中被继承。

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

  • 在我们的 Student 类中，我们添加了 StudentID 和 Marks1 的 2 个其他实例成员。

实时演示 
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 类内部创建一个内部或嵌套类。
  • 请注意，在内部类中，我们能够访问在 Outer 类中定义的 name 实例成员。
实时演示 
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

接口

接口定义了一个类需要符合的契约。接口仅定义需要实现的方法列表，但不定义方法的实现。接口需要使用 interface 关键字声明。接口仅定义方法签名。接口的方法始终为 **public**。在接口中使用 protected 或 private 方法是错误的。

以下是一个 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
打印页面
上一页
下一页
广告