【Groovy】类和对象

1 类的结构

​    Groovy 是面向对象编程语言，与 Java 语言类似，都有类、对象、属性、构造函数、成员函数，都有封装、继承、多态三大特性。
1.1 执行顺序

​    如下，Student 类是一个自定义的类，里面包含了一个类的基本结构。

1. class Student {
2.     private static String tag = "Student"
4.     private String name = "zhang san"
5.     private int age = 18
7.     static {
8.         println("static code, tag=$tag")
9.     }
11.     {
12.         println("non-static code, name=$name")
13.     }
15.     Student() { // 无参构造函数
16.         println("create-1, name=$name, age=$age")
17.     }
19.     Student(String name, int age) { // 有参构造函数
20.         println("create-2, name=$name, age=$age")
21.         this.name = name
22.         this.age = age
23.     }
25.     void study() { // 成员函数
26.         println("study...")
27.     }
28. }
30. def stu1 = new Student()
31. stu1.study()
32. println("-----------------------------------------")
33. def stu2 = new Student("li si", 23)

复制代码

​    运行程序后，打印如下。

1. static code, tag=Student
2. non-static code, name=zhang san
3. create-1, name=zhang san, age=18
4. study...
5. -----------------------------------------
6. non-static code, name=li si
7. create-2, name=li si, age=23

复制代码

​    类的初始化顺序如下：
​    父类静态代码块 → 子类静态代码块 → 父类属性初始化 → 父类非静态代码块 → 父类构造函数 → 子类属性初始化 → 子类非静态代码块 → 子类构造函数。
1.2 Setter 和 Getter 方法

1. class User {
2.     String name
4.     User(String name) {
5.         this.name = name
6.     }
8.     void setName(String name) {
9.         this.name = "xxx_$name"
10.     }
12.     String getName() {
13.         return "yyy_$name"
14.     }
15. }
17. User user = new User("zhang san")
18. println(user.@name) // 打印: zhang san
19. println(user.name) // 打印: yyy_zhang san
21. user.@name = "li si"
22. println(user.@name) // 打印: li si
23. println(user.name) // 打印: yyy_li si
25. user.name = "wang wu"
26. println(user.@name) // 打印: xxx_wang wu
27. println(user.name) // 打印: yyy_xxx_wang wu

复制代码

​    说明：user.name 调用的是 name 属性的 Setter / Getter 方法，user.@name 是直接修改 / 访问 name 属性。
2 封装

​    封装是指将相关联的属性和函数封装到同一个类中，并且可以控制这些属性和函数的访问权限，它通过隐藏内部细节和提供清晰的接口，提高了代码的安全性、可维护性和可理解性，它是面向对象编程中的重要概念之一。
​    在 Groovy 中，有四种访问权限修饰符：private、default、protected 和 public。这些修饰符控制了代码中类、函数、属性等成员的可见性和访问权限。

• private：只能在类内部访问。
  
• default：如果没有指定访问修饰符，默认为包级私有，只能在同一个包内访问。
  
• protected：只能在类内部、子类以及同一包内访问。
  
• public：可以在任何地方访问。
  

3 继承

​    继承是指一个类（称为子类或派生类）基于另一个类（称为父类或基类）创建新类，子类继承了父类的属性和函数，并且可以在此基础上进行扩展或修改，它是面向对象编程中的重要概念之一。在 Groovy 中，继承使用 extends 来表示，Object 类是所有类的基类。

1. class People {
2.     String name
3.     int age
5.     {
6.         println("People non-static code, name=$name, age=$age") // 1
7.     }
9.     People(String name, int age) {
10.         println("People constructor-1, name=$name, age=$age") // 2
11.         this.name = name
12.         this.age = age
13.         println("People constructor-2, name=$name, age=$age") // 3
14.     }
15. }
17. class Student extends People {
18.     int id
20.     {
21.         println("Student non-static code, name=$name, age=$age, id=$id") // 4
22.     }
24.     Student(String name, int age, int id) {
25.         super(name, age)
26.         println("Student constructor-1, name=$name, age=$age, id=$id") // 5
27.         this.id = id
28.         println("Student constructor-2, name=$name, age=$age, id=$id") // 6
29.     }
30. }
32. def stu = new Student("zhang san", 23, 1001)

复制代码

​    说明：子类必须直接或间接调用一下父类的一个构造函数，否则编译报错；如果用户没有显式调用父类构造函数，编译后会自动调用父类的无参构造函数，如果父类没有无参构造函数，就会编译报错。
​    运行程序后，打印如下。

1. People non-static code, name=zhang san, age=23
2. People constructor-1, name=zhang san, age=23
3. People constructor-2, name=zhang san, age=23
4. Student non-static code, name=zhang san, age=23, id=1001
5. Student constructor-1, name=zhang san, age=23, id=1001
6. Student constructor-2, name=zhang san, age=23, id=1001

复制代码

4 多态

​    多态是指同一个函数可以在不同的对象上表现出不同的行为，这种行为通常通过继承和接口来实现。多态使得代码更加灵活和可扩展，是面向对象编程中的重要概念之一。
4.1 覆盖函数

1. class People {
2.     String name
4.     People(String name) {
5.         this.name = name
6.     }
8.     void say() {
9.         println("People say")
10.     }
11. }
13. class Student extends People {
14.     int id
16.     Student(String name, int id) {
17.         super(name)
18.         this.id = id
19.     }
21.     @Override
22.     void say() {
23.         println("Student say")
24.     }
25. }
27. People peo = new Student("li si", 1002)
28. peo.say() // 打印: Student say

复制代码

4.2 类型智能转换

1. class People {
2. }
4. class Student extends People {
5.     void study() {
6.         println("study...")
7.     }
8. }
10. People peo = new Student()
11. peo.study() // 打印: study...

复制代码

​    说明：Java 没有智能转换特性，需要进行强制类型转换。Groovy是一种动态类型语言，它在运行时进行类型检查和方法解析。
5 抽象类（abstract class）

​    使用 abstract 修饰的类称为抽象类，抽象类中可以有抽象函数，这些函数被添加了 abstract 修饰符，父类不能实现，子类必须重写实现（子类如果也是抽象类除外）。抽象类不能被实例化，只能实例化其具化子类，抽象类中允许有具化的函数。

1. abstract class People {
2.     String name = "xiao min"
3.     abstract void say()
4. }
6. class Student extends People {
7.     @Override
8.     void say() {
9.         println("$name: Hello")
10.     }
11. }
13. //def peo = new People() // 编译报错, 抽象类不能被实例化
14. def stu = new Student()
15. stu.say() // 打印: xiao min: Hello

复制代码

6 接口（interface）

​    接口与抽象类有些类似，接口里只有常量和抽象函数（函数允许有默认实现），Groovy 中允许一个类实现多个接口，但最多只能继承一个类。

1. interface A {
2.     String x = "xxx"
3.     default void aFun() {
4.         println("A, x=$x")
5.     }
6. }
8. interface B {
9.     void bFun()
10. }
12. class C implements A, B {
13.     @Override
14.     void bFun() {
15.         println("bFun")
16.     }
17. }
19. def c = new C()
20. c.aFun() // 打印: A, x=xxx
21. c.bFun() // 打印: bFun

复制代码

​    运行程序后，打印如下。

1. A, x=xxx
2. bFun

复制代码

7 枚举类型（enum）

1. enum Color {
2.     RED("red") {
3.         @Override
4.         void test() {
5.             println("test, $tag")
6.         }
7.     },
8.     GREEN("green") {
9.         @Override
10.         void test() {
11.             println("test, $tag")
12.         }
13.     },
14.     BLUE("blue") {
15.         @Override
16.         void test() {
17.             println("test, $tag")
18.         }
19.     }
21.     final String tag
23.     Color(String tag) {
24.         this.tag = tag
25.     }
27.     void printColor() {
28.         println("color=$tag")
29.     }
31.     abstract void test()
32. }

复制代码

​    声明：本文转自【Groovy】类和对象。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！