Groovy面向对象和泛型

面向对象

      1.总结：1）.基本和java一样，几个重要的关键概念：类（对象的抽象化），实例（对象的具体话），方法（对象的行为），数据（对象的属性） 

                    2）.介绍下C++是面向算法和结构的编程，java是面向对象的编程，一切以类为主（groovy是java的衍生，思想上可以按照java的方式考虑问题）

                    3）.面向对象的特性：封装，继承，多态，抽象

 

       2.定义：在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"    
                                }
                         }

          3.getter和setter方法

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

              例子：

                      class Student {
                               private int StudentID;
 
                               void setStudentID(int pID) {
                                      StudentID = pID;
                                 }
 
                              int getStudentID() {
                                     return this.StudentID;
                               }
 
                           static void main(String[] args) {
                                Student st = new Student();
                                st.setStudentID(1);
     
                                println(st.getStudentID());
                            }
                      }

           4.实例方法

               作用：在类中包含更多的方法通常是一个很自然的事情，它实际上为类实现了一些功能。

               例子：

                    int Total() {
                          return Marks1+Marks2+Marks3;
                      }

            5.创建多个对象

               定义：对一个类的多个实例化

            6.继承

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

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

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

               例子：                     

                     (1)创建一个名为Person的类。这个类有一个名为name的实例成员。
                     (2)创建一个名为Student的类，它从Person类继承。请注意，在Person类中定义的名称实例成员在Student类中继承。
                     (3)在Student类构造函数中，我们调用了基类构造函数。
                      (4)在我们的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();
                    }
              }

          7.内部类

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

           8.抽象类

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

               关键修饰词：abstract

           9.接口

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

               关键修饰词：interface

              

  泛型

        1.概念：在定义类，接口和方法时，泛型使能类型（类和接口）作为参数。与在方法声明中使用的更熟悉的形式参数非常类似，类型参数提供了一种方法，可以为不同的输入重复使用相同的代码。区别在于形式参数的输入是值，而类型参数的输入是类型。

        2.使用

           集合的通用：

                可以对集合类（如List类）进行一般化，以便只有该类型的集合在应用程序中被接受。比如将都是String类型的集合可以泛指所有类型（List<String> 到List<T>）

           泛型类

                整个类也可以泛化。这使得类更灵活地接受任何类型，并相应地与这些类型工作。

                

步骤：
  （1）我们正在创建一个名为ListType的类。注意放置在类定义前面的<T>关键字。这告诉编译器这个类可以接受任何类型。因此，当我们声明这个类的一个对象时，我们可以在声明期间指定一个类型，并且该类型将在占位符<T>。
  （2）泛型类有简单的getter和setter方法来处理类中定义的成员变量。
  （3）在主程序中，注意我们能够声明ListType类的对象，但是不同类型的对象。第一个类型是Integer类型，第二个类型是String类型。 
 

     class Example {
       static void main(String[] args) {
          // Creating a generic List collection
          ListType<String> lststr = new ListType<>();
          lststr.set("First String");
          println(lststr.get());
       
          ListType<Integer> lstint = new ListType<>();
          lstint.set(1);
          println(lstint.get());
       }
    }

    public class ListType<T> {
       private T localt;
     
       public T get() {
          return this.localt;
       }
     
       public void set(T plocal) {
          this.localt = plocal;
       }
    }

 

  输出结果：
     First String
     1