Groovy - 面向对象

  • 简述

    在 Groovy 中,就像在任何其他面向对象的语言中一样,有类和对象的概念来表示编程语言的面向对象的性质。Groovy 类是数据和操作该数据的方法的集合。类的数据和方法一起用于表示问题域中的一些现实世界对象。
    Groovy 中的类声明该类定义的对象的状态(数据)和行为。因此,Groovy 类描述了该类的实例字段和方法。
    以下是 Groovy 中的一个类的示例。班级的名称是 Student,它有两个字段 – StudentIDStudentName。在 main 函数中,我们正在创建此类的对象并为该对象的StudentIDStudentName 赋值
    
    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 都被标记为私有,这意味着他们不能从课堂外访问。
    • 每个实例成员都有自己的 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 类中定义的名称实例成员在 Student 类中被继承。
    • 在 Student 类构造函数中,我们调用基类构造函数。
    • 在我们的 Student 类中,我们添加了 2 个额外的 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 的字符串。
    • 在我们的外部类中创建一个内部类或嵌套类。
    • 请注意,在内部类中,我们能够访问在外部类中定义的名称实例成员。
    
    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。在接口中使用受保护或私有方法是错误的。
    以下是 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