Groovy~Groovy的面向对象

63 阅读 0 评论 42 点赞

我是靠谱客的博主整齐曲奇，最近开发中收集的这篇文章主要介绍Groovy~Groovy的面向对象，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Groovy类是数据的集合和对该数据进行操作的方法
Groovy中的类声明了该类定义的对象的状态（数据）和行为

class Student {
    int StudentID
    String StudentName

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

二、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()
    }
}

三、实例方法

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

四、继承

继承可以定义为一个类获取另一个类的属性（方法和字段）的过程。通过使用继承，信息以分级顺序可管理。继承其他属性的类成为子类（派生类，子类），属性继承的类称为超类（基类，父类）

五、扩展

extends是用于继承类的属性的关键字

class Person{
    public String name
    public Person(){}
}

class Student extends Person{
    int StudentID;
    int Marks1;

    public Student(){
        super();
    }
}

class FirstTest{
    static void main(String[] args) {
        Student st = new Student();
        st.StudentID = 1;

        st.Marks1 = 10;
        st.name = "Joe";

        println(st.name)
    }
}

六、内部类

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

class Outer{
    String name

    def callInnerMethod(){
        new Inner().methodA()
    }

    class Inner{
        def methodA(){
            println (name)
        }
    }
}

class FirstTest{
    static void main(String[] args) {
        Outer outobj = new Outer()
        outobj.name = "Joe"
        outobj.callInnerMethod()
    }
}

七、抽象类

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

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

八、接口

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

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