Introdução a Orientação a Objetos - Parte 2

Este artigo a idéia de encapsulamento, propriedades, métodos e de sobrecarga de métodos.

por Marden Menezes

Olá pessoal, continuando nosso caminho no objetivo de aprender Orientação a Objetos, vejam nesse artigo a idéia de encapsulamento, propriedades, métodos e de sobrecarga de métodos. Estejam à vontade para me enviar e-mails com dúvidas! Boa diversão!

Modificadores de acesso

Para evitar que as informações contidas em cada objeto sejam acessíveis abertamente, o desenvolvedor pode modificar o nível de proteção de cada membro (atributo, método) contido em um objeto. Os modificadores de acesso que podem ser usados em C# são:

» public: permite que o membro seja acessado por qualquer outro objeto;
» private: o membro só pode ser acessado internamente na classe onde foi declarado;
» protected: o membro só pode ser acessado na classe onde foi declarado ou em classes filhas (que herdam dessa classe);
» internal: o membro só pode ser acessado por objetos de classes que estejam no mesmo assembly da classe onde foi declarado;

Os modificadores permitem então que o desenvolvedor possa controlar o nível de acesso de cada membro, permitindo que as características de cada objeto sejam modificadas de uma forma segura e vistas de uma forma necessária ao sistema.

Uma forma de customizar totalmente a forma de acesso a atributos de classe é usar Propriedades. As propriedades são formas de permitir ao desenvolvedor modificar o modo com que o atributo será modificado ou acessado . Dessa forma, temos o bloco get que descreve como o atributo será acessado e o bloco set que descreve como o atributo será modificado.

A forma geral de uma propriedade é a seguinte:

<modificadorDeAcesso> <retornoDoGet> <Nome> {
     get { 
            //algum código
    }
     set { 
            //algum código
    }
}

Veja abaixo um código de uma classe Pessoa que possui os atributos privador Nome e Endereço e que se utiliza de propriedades para gerenciá-los:

public class Pessoa
	{
		public Pessoa(string n, string e) 
		{
			Nome = n;
			Endereco = e;
		}
		
		private string nome;
		private string endereco;

		public string Nome 
		{
			get { return nome; } 
			set { nome = value; }
		}

		public string Endereco 
		{
			set { endereco = value; }
		}
	}

Perceba que no construtor nós já usamos as propriedades para modificar os atributos. Como estamos atribuindo informações as propriedades, automaticamente .NET percebe que o método set da propriedade deve ser usado. Caso estivéssemos utilizando a propriedade com a intenção de retornar o valor, o bloco get seria usado automaticamente.

Outra informação importante é a palavra chave value utilizada no bloco set. Ela é uma palavra reservada de C# e representa o valor que será passado para a propriedade no momento da atribuição. Quando, por exemplo, utilizamos o código no construtor:

Nome = n;

É como se tivéssemos utilizado o seguinte código:

value = n;
nome = value;

Esse processo é feito automaticamente por C#.

Métodos

Toda linguagem atual permite a criação de blocos de código que serão chamados em outro lugar do código com a finalidade de evitar repetição de trabalho e código. Em C# nós temos a oportunidade de utilizar métodos para esse fim.

A maneira de declarar métodos segue a seguinte forma:

<modificadorDeAcesso> <retornoDoMetodo> <Nome> ( <parâmetros>) {
	//algum código
  //caso o método retorne algum valor, devemos utilizar a palavra chave return
}

O método passa então a pertencer a um objeto da classe onde foi declarado. Cada vez que criarmos um objeto da classe, poderemos chamar um método desse objeto da seguinte forma:

<nomeDoObjeto>.<nomeDoMétodo>(<parâmetros>);

Veja um código abaixo de uma declaração de método e do uso do mesmo, ainda utilizando a classe Pessoa descrita anteriormente:

private string retornaString(string nomeDaPessoa) 
		{
			Console.WriteLine("Olá, " + nomeDaPessoa); 
		}

		public void Escreve() 
		{
          		Pessoa p = new Pessoa("Josué","endereco");
			p.retornaString(p.Nome);
		}

Perceba que o método retornaString() é um método privado, que não pode ser acessado fora da classe Pessoa. Ele retorna uma string e recebe uma string com o nome da Pessoa como parâmetro. Como o método retornaString() é privado, criamos um método Escreve que é público , podendo ser acessado de qualquer outro classe, mas que não retorna nada (o que é definido pela palavra chave void ) e também não recebe nenhum parâmetro. O método Escreve() simplesmente cria um objeto do tipo Pessoa e chama o método retornaString() passando como parâmetro o nome da pessoa identificado pela propriedade Nome do objeto.

Veja abaixo o código de uma calculadora que utiliza métodos privados e públicos:

public class Calculadora
	{
		public Calculadora(int n1, int n2) 
		{
			Numero1 = n1;
			Numero2 = n2;
		}
		
		private int n1;
		private int n2;

		public int Numero1
		{
			get { return n1; } 			
		}

		public int Numero2
		{
			get { return n2; } 			
		}
		
		private int somar() 
		{
			return Numero1 + Numero2;
		}

		private int subtrair() 
		{
			return Numero1 - Numero2;
		}

		private int multiplicar() 
		{
			return Numero1 * Numero2;
		}

		private int dividir() 
		{
			return Numero1 / Numero2;
		}

		public void Calcular() 
		{
			Console.WriteLine("O valor da soma é: " + somar());
			Console.WriteLine("O valor da subtração é: " + subtrair());
			Console.WriteLine("O valor da multiplicação é: " + multiplicar());
			Console.WriteLine("O valor da divisão é: " + dividir());

		}
	}

Algum outro objeto poderia chamar o método calcular da seguinte forma:

Calculadora calc = new Calculadora(12,3);
calc.Calcular();

Sobrecarga de métodos

Sobrecarregar um método traz a possibilidade de termos diferentes versões do mesmo método ou propriedade que, mesmo possuindo o mesmo nome, aceitam um número diferente de parâmetros ou parâmetros de tipos diferentes. Isso nos dá a oportunidade de utilizar o mesmo nome para métodos mas utiliza-los de formas diferentes. Veja o exemplo no código abaixo do método Cadastrar() que pode receber apenas o nome de uma pessoa, o nome e a data de nascimento, ou o nome, data de nascimento e endereço. Temos então 3 opções de métodos com quantidades de parâmetros.

using System;

namespace Sobrecarga
{
	public class CadastroPessoa 
	{
		//método que recebe apenas o nome da pessoa
		public void Cadastrar(string nome) 
		{
			//código para cadastrar pessoa
		}

		//método que recebe apenas o nome e data de nascimento
		public void Cadastrar(string nome, DateTime dataNascimento) 
		{
			//código para cadastrar pessoa
		}

		//método que recebe apenas o nome da pessoa, data de nascimento e 
		//endereço, retornando um valor inteiro ao invés de ser void
		public int Cadastrar(string nome, DateTime dataNascimento, string endereco) 
		{
			//código para cadastrar pessoa
			return 0;	
		}
	}

	public class App 
	{
		public static void Main() 
		{
		CadastroPessoa cadastro = new CadastroPessoa();
		cadastro.Cadastrar("Bill Gates");
		cadastro.Cadastrar("Bill Gates", new DateTime(1980,1,1));
		int valor = cadastro.Cadastrar("Bill Gates", new DateTime(1980,1,1),"Rua 12, n° 1");
		}
	}
}

Perceba que na classe App, no método Main(), temos a possibilidade de chamar 3 versões diferentes do método Cadastrar(), dependendo da quantidade de parâmetros que estamos passando. A terceira sobrecarga do método Cadastrar(), que recebe três parâmetros, também possui o diferencial de retornar um inteiro ao invés de ser void. Isto nos permite poder modificar o retorno do método dependendo da sua implementação, trazendo uma maior flexibilidade ao programa.

É isso aí pessoal, espero tê-los ajudado um pouco. No próximo artigo irei abordar herança, interfaces, classes abstratas e polimorfismo! Até lá!