Orientação a Objetos

CLASSES E OBJETOS

Classes

São modelos para a criação de objetos de alguns tipos determinados a partir de sistemas reais ou imaginários, podendo conter atributos ou métodos, ou os dois.

Na figura, a seguir, exibimos instâncias para a classe Estudante (cujos atributos são nome, curso e matrícula) – beltrano, fulano e ciclano. E, ainda, para um dos objetos, mostramos a sua estrutura, salientando que o estado do objeto ciclano compreende valores para o seu nome, curso e matrícula.

Classes são formadas por uma declaração, atributos (inicializados ou não), construtores e métodos. A declaração de classes deve seguir a sintaxe apresentada a seguir.

O modificadorDeAcesso e o qualificador são opcionais. O modificadorDeAcesso determinada o nível de acessibilidade a partir de outras classes à classe declarada (public, por exemplo) enquanto o qualificador especifica um tratamento especial para a classe (final e abstract, por exemplo). Já class denota que o bloco delimitado por { e } corresponde a uma declaração de classe.

Objetos

Possuem um estado e um comportamento. O estado é representado pelo conjunto de valores referentes aos atributos enquanto os métodos representam o comportamento de um objeto.

Objetos podem conter Objetos, ou seja, os atributos de um objeto podem ser objetos da mesma classe ou de classes distintas. Os métodos podem receber objetos como argumentos, retornar objetos para quem os invocou e declarar objetos como variáveis locais.

Um exemplo de como pode ser feita a criação do exemplo a seguir:

**Criação de um objeto do tipo String**

String objetoString = new String("Este é o conteúdo da String");

*"objetoString" é a referência do objeto a classe String**

Ao instanciar uma classe, utiliza-se a palavra reservada new – que invoca o construtor daquela classe, criando assim um objeto e associando a este, uma referência – em uma variável de referência ao objeto, que contém o endereço do objeto na memória.

Atributos

A sintaxe básica para atributos (ou variáveis de instância) determina que pode-se considerar um modificador de acesso <opcional>, um qualificador <opcional>, um tipo "primitivo ou classe" e o identificador – estes dois últimos realmente obrigatórios, na sequência que segue. Alguns exemplos serão demonstrados, a seguir.

1. // Declarando atributos
2. public String nome; // atributo público 
3. long matricula;  // atributo acessível apenas no pacote
4. public static int numeroDeEstudante;  // atributo público estatico

Na linha 2, declara-se um atributo público (modificador de acesso public), do tipo da classe String (um objeto da classe String, portanto), cujo identificador é nome. Na linha 3, declara-se um atributo sem modificador de acesso e qualificador – o que determina um atributo acessível apenas ao pacote que contém a classe à qual os atributos pertencem, do tipo primitivo long e identificador matricula. Na linha 4, o atributo declarado é público e estático (qualificador static) indicando que é válido para todos as classes.

Construtores

Construtores, na verdade, são métodos especiais, no qual descreve-se como objetos podem ser criados.

Entre as suas peculiaridades, pode-se destacar o fato de que construtores não possuem valor de retorno, afinal não é invocado um construtor para um objeto e sim, para criar um objeto. A sintaxe básica é apresentada a seguir.

   modificadorDeAcesso identificadorDaClase(<parametros>){
   		corpo;
   }

Verifica-se que modificadores de acesso são opcionais, assim como também os argumentos. Lembre-se que o IdentificadorDaClasse deve ser exatamente o mesmo para o nome da classe e o nome do construtor.

No exemplo a seguir, foram implementados 2 construtores para a classe Estudante, observe:

public class Estudante{
	
    // atributos
    
    String nome;
    String curso;
    
    //construtores
    
    public Estudante(String nomeE, String cursoE){
    	
        nome = nomeE;
        curso = cursoE;
    	
    }
    
    public Estudante(){
    	
        nome = " ";
        curso = " ";
    
    }
    
}

No construtor declarado na linha 9, há 2 argumentos do tipo String, efetuando as devidas atribuições enquanto na linha 14, declara-se outro construtor sem argumentos, que atribui strings vazias aos atributos da classe. Ambos os construtores são válidos para a classe Estudante.

Métodos

Métodos, em Java, têm uma sintaxe simples, de acordo com a figura. No entanto, modificadores de acesso e qualificadores são opcionais.

modificadorDeAcesso qualificador tipoDeRetorno identificadorDoMetodo(<parametro>){
    // comandos;
}

Os modificadores de acesso denotam as permissões de acessos externos ao método (por exemplo public, private, protected); o qualificador especializa de alguma forma o método (static e final, por exemplo); o tipo de retorno indica o tipo primitivo de dados ou a classe que representa o tipo do valor (ou objeto, respectivamente) que o método retorna ao ser invocado; o nome do método é definido por identificadorDoMetodo que deve estar de acordo com as regras para a criação de identificadores em Java; argumentos correspondem à lista de tipos (primitivos ou classes) e argumentos específicos para o método.

Em Java, void é usado para indicar que o método não possui tipo de retorno específico. Usa-se a palavra reservada return antes do valor do tipo primitivo ou do objeto para indicar o seu retorno. A seguir, alguns exemplos

1.  // metodo public com arqumentos
  
2.  public int soma(int valorInteiro1, int valorInteiro2){
3.  		return valorInteiro1+valorInteiro2;
4.  }
5.
6.  //metodo sem argumento e tipo de retorno
7.  void motraMensagem(){
8.  		System.out.println("Mostra uma Mensagem");
9.  }
10.  
11.  String toString(){
12.  		return "Uma String";
13.  }

Na linha 2, um método é declarado com modificador de acesso public, sem qualificador, com tipo de retorno e argumentos do tipo int. Verificar o uso do comando return na linha 3, para retornar ao invocador do método, a soma de valores inteiros passados como argumentos.

Na linha 7, a declaração do método mostraMensagem(), sem tipo de retorno – declarado como void, e sem argumentos. Já na linha 11, o tipo de retorno do método toString() é String denotando que será retornado pelo método, um objeto do tipo ou 'da classe' String, conforme vemos na linha 12.

Passagem de Argumentos

Ao se passar um argumento para um método, passa-se uma cópia deste, na verdade, pois em Java, argumentos são passados 'por valor'. Sendo assim, as alterações efetuadas sob o valor no corpo do método não afetam os valores originais. Veja um exemplo para esclarecer tal questão.

 1. float valorFloat = 10.10f;
 
 2. System.out.println("O cosseno de " +valorFloat+ " e " + Math.cos(valorFloat));

A variável valorFloat, declarada na linha 1, contém o valor 10.10f e, na linha 2, uma cópia do valor é passado como argumento para o método cos() da classe Math. Qualquer mudança efetuada sob a cópia do valor pelo

Math.cos()

não representa alteração no valor original em valorFloat.

Nos próximos dois exemplos, serão demonstrados mais detalhadamente essa passagem 'por valor'. Primeiro, é declarado o método incrementaValorByte, que recebe como parâmetro um valor do tipo primitivo byte e o incrementa.

 1. public void incrementaValorByte(byte valorByte){
 2.		valorByte++;
 3. }

No fragmento de código a seguir é demonstrada essa passagem 'por valor'. Na linha 2, é invocado o método incrementaValorByte() passando como argumento, na verdade, uma cópia de outroValorByte.

 1. byte outroValorByte = 20;
 2. incrementoValorByte(outroValorByte); 
 3. System.out.println("O valor final é" +outroValorByte);

As observações feitas acerca de passagem de argumentos valem também para os casos nos quais o argumento é um objeto ao invés de uma variável ou valor de um tipo primitivo; todavia, o efeito é diferente. Ao tratar a passagem de objetos a métodos, em particular, é considerado o conceito de referência a objeto.

Ao instanciar uma classe, ou seja, criar um objeto, o construtor retorna uma referência ao objeto. Referência esta que identifica unicamente aquele objeto.

É o que pode se destacar no exemplo, a seguir, no qual meuNome armazena a referência ao objeto criada ao instanciar a classe String, usando o construtor String().

 1. String meuNome = new String();

Sendo assim, é importante compreender que ao armazenar objetos em variáveis ou passar objetos como argumentos para métodos, armazena-se ou passa-se referências a objetos, respectivamente.

A seguir, um fragmento de código, no qual invoca-se o método modificaString() que, por sua vez, cria um outro objeto String e armazena a referência ao objeto em minhaString.

Para esclarecer o tratamento de referências a objetos e passagem de argumentos em Java, considere o método declarado, a seguir.

 1. public void modificaString(String minhaString){
 2.	  minhaString = new String("Esta é uma String armazenada em minhaString"); 
 3.}

A seguir, um fragmento de código, no qual é invocado o método modificaString() que, por sua vez, cria um outro objeto String e armazena a referência ao objeto em minhaString.

 
 1. String meuNome = new String("Esta é uma String armazenada em meuNome"); 
 2. modificaString(meuNome);
 3. System.out.println(meuNome);

Neste último exemplo, é criada uma string na linha 1 e armazenada a referência ao objeto em meuNome. Na linha 2, é passado uma cópia da referência ao objeto como argumento para o método modificaString(). Todavia, meuNome não é afetado após a execução do método modificaString(), já que o método modificaString cria uma outra referência a objeto; com isso, na linha 3, é mostrado o valor armazenado em meuNome, isto é, "Esta é uma string armazenada em meuNome".

Método main()

O ponto de entrada para aplicações em Java é o método main(). Sua declaração é apresentada na figura a seguir.

 1. // Declaração  do método main(); 
 2. public static void main(String args[]) 
 3.		//corpo do metodo
 4. }

A partir da figura, é observado que o método main() é público (public), por convenção; estático (static) para que seja executado sem a necessidade de criar uma instância da classe correspondente; não possui tipo de retorno específico (void); e, como argumento aceita um array unidimensional de objetos do tipo String – é relevante observar que o nome args é apenas um identificador e pode ser, portanto, substituído por qualquer identificador que atenda às regras estipuladas em Java.

Considerando, em particular, o array args[ ], observe um exemplo, no qual executa o programa chamado MeuPrimeiroProgramaJava.

Para exemplificar classes completas com seus componentes, vamos considerar a classe Estudante, seus atributos, construtor e método, a seguir.

 1. public class Estudante{
 2.   // Declaração dos atributos
 3.	  String nome;
 4.	  long matricula;
 5.	  String curso;
 6.	  // declaração de construtor de instancias de Estudante 	
 7.	  public Estudante(String nomeE, long matriculaE, String cursoE){
 8.       nome = nomeE;
 9.       matricula = matriculaE;
 10.      curso = cursoE;
 11.  }
 12.  // declaração de metodo
 13.  public String toString(){//retornando o estado do objeto 
 14.      return "Nome: " +nome+ "Matricula: " +matricula+ "Curso: "+curso;
 15   }
 16.}

No código da classe Estudante, pode-se observar a declaração de atributos (nome, matrícula e curso), de um construtor para instâncias desta classe e de um método denominado toString().

THIS (instrução this em Java)

Quando é desejado referenciar o objeto corrente no corpo da declaração de um método, usa-se a palavra reservada this, que significa "o objeto para o qual esse código está sendo executado". Também pode-se usar a referência this para fazer invocações de métodos para o objeto corrente. A referência this deve ser aplicada apenas a métodos não-estáticos (sem static em sua declaração). O exemplo a seguir, demonstrará a aplicação do this.

 
 1. public class Estudante{
 2.   // Declaração dos atributos
 3.	  String nome;
 4.	  String curso;
 5.	  // declaração de construtor de instancias de Estudante 	
 6.	  public Estudante(String nome, String curso){
 7.       this.nome = nome;
 8.       this.curso = curso;
 9.  }
 10.  
 11.  // declaração de metodo
 12.  public String toString(){//retornando o estado do objeto 
 13.      return "Nome: " +this.nome+ "Curso: "+this.curso;
 14.  }
 15.}

No construtor da classe Estudante e no método toString() desta, observe o uso de this. No construtor, linha 8, nota-se que o this é usado para atribuir novos valores aos atributos da classe. E no método da linha 13, o this é usado para referenciar novamente os atributos da classe, numa concatenação de strings. Todas as construções são válidas em Java e, assim, elimina-se possíveis ambiguidades entre os nomes dos atributos da classe e os nomes dos argumentos de um método, como por exemplo, fazer a atribuição nome = nome ao invés de this.nome = nome, na linha 7.

Acesso aos Atributos e Métodos de Objetos

Para acessar os atributos e métodos de um objeto, é usado a seguinte notação.

 referenciaAoObjeto.atributo;
 referenciaAoMetodo.metodo(<argumentos>);

Observe que o separador ponto (.) é utilizado sempre para os acessos aos membros de uma classe.

Objetos se comunicando com outros objetos, invocando os seus métodos. Sendo assim, a invocação de métodos é similar à forma usada para acessar atributos, com exceção dos parênteses com a lista de argumentos – o que é expresso pelos <> para lembrar que estes são opcionais e seu uso depende da declaração do método. Portanto, os parênteses após o nome do método, mesmo que sem argumentos, devem estar presentes nas invocações.

É mostrado a seguir um exemplo mais amplo, considerando a classe Estudante mostrada a seguir, e o acesso aos seus membros.

 
 1. public class Estudante{
 2.   // Declaração dos atributos
 3.	  String nome;
 4.	  String curso;
 5.	  // declaração de construtor de instancias de Estudante 	
 6.	  public Estudante(String nome, String curso){
 7.       this.nome = nome;
 8.       this.curso = curso;
 9.  }
 10.  
 11.  // declaração de metodo
 12.  public String toString(){//retornando o estado do objeto 
 13.      return "Nome: " +this.nome+ "Curso: "+this.curso;
 14.  }
 15.}

 1.  public class Universidade{
 2.
 3.      public static void main(String args[]){
 4.
 5.         // criando um objeto usando o construtor declarado em Estudante
 6.         Estudante objetoFulano = new ("Eduardo", "JAVA");
 7.        
 8.         // acessando atributos e metodos
 9.	    System.out.println("Nome do Estudante "+objetoFulano.nome);
 10.        System.out.println(objetoFulano.toString());
 11.     }
 12. }

A classe Estudante possui 2 atributos, um construtor e um método. Na classe Universidade, na linha 6, é criado um objeto do tipo Estudante, usando o construtor desta classe. Após a criação, pode-se então, acessar diretamente os membros do objetoFulano, utilizando o separador ponto (.).

Com intuito de apoiar o aprendizado sobre Orientação a Objeto, sugere-se assistir a videoaula para o aperfeiçoamento no conhecimento deste conteúdo.

Atividade de Fixação

No intuito de fixar a aprendizagem iniciada por meio deste módulo e verificar como está sua compreensão sobre o mesmo, são sugeridos alguns exercícios de fixação para serem resolvidos. Clique no link de exercícios ao lado, pois será por meio dele iniciada a lista de exercícios sobre os conteúdos estudados até este momento. Boa revisão sobre os mesmos!!