Groovy - Orientado a Objetos

Em Groovy, como em qualquer outra linguagem orientada a objetos, existe o conceito de classes e objetos para representar a natureza orientada a objetos da linguagem de programação. Uma classe Groovy é uma coleção de dados e os métodos que operam nesses dados. Juntos, os dados e métodos de uma classe são usados para representar algum objeto do mundo real do domínio do problema.

Uma classe no Groovy declara o estado (dados) e o comportamento dos objetos definidos por essa classe. Portanto, uma classe Groovy descreve os campos de instância e os métodos dessa classe.

A seguir está um exemplo de uma classe em Groovy. O nome da turma é Aluno, que possui dois campos -StudentID e StudentName. Na função principal, estamos criando um objeto desta classe e atribuindo valores para oStudentID e StudentName do objeto.

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

Métodos getter e setter

Em qualquer linguagem de programação, é sempre uma prática ocultar os membros da instância com a palavra-chave privada e, em vez disso, fornecer os métodos getter e setter para definir e obter os valores das variáveis da instância de acordo. O exemplo a seguir mostra como isso pode ser feito.

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

Quando executamos o programa acima, obteremos o seguinte resultado -

1 
Joe

Observe os seguintes pontos-chave sobre o programa acima -

Na classe, o studentID e o studentName são marcados como privados, o que significa que não podem ser acessados de fora da classe.
Cada membro da instância tem seu próprio método getter e setter. O método getter retorna o valor da variável de instância, por exemplo, o método int getStudentID () e o método setter define o valor do ID da instância, por exemplo o método - void setStudentName (String pName)

Métodos de Instância

Normalmente é natural incluir mais métodos dentro da classe, o que realmente faz algum tipo de funcionalidade para a classe. Em nosso exemplo do aluno, vamos adicionar membros de instância de Marks1, Marks2 e Marks3 para denotar as marcas do aluno em 3 disciplinas. Em seguida, adicionaremos um novo método de instância que calculará as notas totais do aluno. A seguir está a aparência do código.

No exemplo a seguir, o método Total é um método de instância adicional que possui alguma lógica incorporada.

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

Quando executamos o programa acima, obteremos o seguinte resultado -

Criação de vários objetos

Também se pode criar vários objetos de uma classe. A seguir está o exemplo de como isso pode ser alcançado. Aqui, estamos criando 3 objetos (st, st1 e st2) e chamando seus membros de instância e métodos de instância de acordo.

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

Quando executamos o programa acima, obteremos o seguinte resultado -

60 
70 
80

Herança

A herança pode ser definida como o processo em que uma classe adquire as propriedades (métodos e campos) de outra. Com o uso de herança, as informações são gerenciáveis em uma ordem hierárquica.

A classe que herda as propriedades de outra é conhecida como subclasse (classe derivada, classe filha) e a classe cujas propriedades são herdadas é conhecida como superclasse (classe base, classe pai).

Estende

extendsé a palavra-chave usada para herdar as propriedades de uma classe. A seguir está a sintaxe da palavra-chave extends. No exemplo a seguir, estamos fazendo o seguinte -

Criando uma classe chamada Person. Esta classe possui um membro de instância chamado nome.
Criando uma classe chamada Aluno que se estende da classe Pessoa. Observe que o membro da instância name que é definido na classe Person é herdado na classe Student.
No construtor da classe Student, estamos chamando o construtor da classe base.
Em nossa classe Student, estamos adicionando 2 membros de instância adicionais de StudentID e 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();
   } 
}

Quando executamos o programa acima, obteremos o seguinte resultado -

Joe

Classes internas

As classes internas são definidas em outras classes. A classe envolvente pode usar a classe interna normalmente. Por outro lado, uma classe interna pode acessar membros de sua classe envolvente, mesmo se eles forem privados. Classes diferentes da classe envolvente não têm permissão para acessar classes internas.

A seguir está um exemplo de uma classe externa e interna. No exemplo a seguir, estamos fazendo o seguinte -

Criando uma classe chamada Outer que será nossa classe externa.
Definindo uma string chamada name em nossa classe Outer.
Criando uma classe interna ou aninhada dentro de nossa classe externa.
Observe que na classe interna podemos acessar o membro da instância de nome definido na classe externa.

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

Quando executamos o programa acima, obteremos o seguinte resultado -

Joe

Classes abstratas

As classes abstratas representam conceitos genéricos, portanto, não podem ser instanciadas, sendo criadas para serem subclasses. Seus membros incluem campos / propriedades e métodos abstratos ou concretos. Métodos abstratos não têm implementação e devem ser implementados por subclasses concretas. As classes abstratas devem ser declaradas com a palavra-chave abstract. Os métodos abstratos também devem ser declarados com a palavra-chave abstract.

No exemplo a seguir, observe que a classe Person agora é transformada em uma classe abstrata e não pode ser instanciada. Observe também que há um método abstrato chamado DisplayMarks na classe abstrata que não possui detalhes de implementação. Na aula do aluno é obrigatório adicionar os detalhes de implementação.

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

Quando executamos o programa acima, obteremos o seguinte resultado -

Joe 
10 
null

Interfaces

Uma interface define um contrato ao qual uma classe precisa estar em conformidade. Uma interface apenas define uma lista de métodos que precisam ser implementados, mas não define a implementação dos métodos. Uma interface precisa ser declarada usando a palavra-chave interface. Uma interface apenas define assinaturas de método. Os métodos de uma interface são semprepublic. É um erro usar métodos protegidos ou privados em interfaces.

A seguir está um exemplo de uma interface no groovy. No exemplo a seguir, estamos fazendo o seguinte -

Criação de uma interface chamada Marks e criação de um método de interface chamado DisplayMarks.
Na definição da classe, estamos usando a palavra-chave implements para implementar a interface.
Como estamos implementando a interface, temos que fornecer a implementação para o método 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);
   }
}

Quando executamos o programa acima, obteremos o seguinte resultado -

10
null