Este
é mais um artigo que submeto ao Linha de Código, dando sequência a uma série de
material, resultado obtido através de pesquisas e laboratórios com meus alunos
da UTFPR, campus Medianeira. Reforço o empenho e dedicação destes alunos, que
foi extremamente comprometido com a pesquisa e aprendizado durante os semestres
que mantivemos contato próximo nas disciplinas que a eles eu ministrava. Isso
me motivou muito e fazer com que o resultado dos trabalhos deles aparecesse
para o mundo e, nada melhor do que o Linha de Código para isso.
|
|
Neste
artigo apresento o Fernando Henrique dos Santos Gomes, que pode ser
contactado pelo email fernandogomes_ti@hotmail.com. O Fernando foi meu aluno em
algumas disciplinas de sua graduação. O Fernando, apesar de ter trabalhado
comigo neste artigo sobre .NET tem uma grande experiência no desenvolvimento
de aplicações WEB e Aplicações Distribuídas com Java. Desta forma, estejam a
vontade em solicitar o curriculum dele.
|
Introdução
Pode-se
dizer que o escopo de uma variável é a região da aplicação (programa) em que
ela é vista/utilizável. Aplica-se a métodos, classes e variáveis. Diz-se também
que escopo é a visibilidade de uma variável. O escopo de uma variável é determinado
na declaração da mesma e é relativo a esta localização.
Modificadores de acesso dos membros
A tabela abaixo apresenta os
níveis de acesso existentes (modificadores de escopo) para a linguagem C#.
|
Modificadores de acesso
|
Descrição
|
|
public
|
Membro
é acessado de qualquer lugar
|
|
private
|
Membro
pode ser acessado somente dentro da classe que o define
|
|
internal
|
Membro
pode ser acessado por qualquer membro que esteja no assemblv
|
|
protected
|
Pode
ser acessado dentro da classe que o define e pelas classes que a herdam
|
|
protected internal
|
Pode
ser acessado por todos membros do assembly ou por membros que o herdem.
|
O modificador public
permite que o membro seja visível fora da classe, desta forma todos os objetos
podem acessar campos e métodos que utilizem o modificador público. De forma
contrária, todos que utilizem o modificador private só podem ser vistos dentro da
classe que o definiu.
O modificador de acesso internal
faz
com que membros possam ser acessados por qualquer classe que esteja
no mesmo assembly, mas não podem ser acessados por objetos fora deste.
Conforme escrito por Almir
Farias Rivas Junior em http://www.juliobattisti.com.br/tutoriais/, o modificador protected permite que o membro seja
acessado por qualquer código dentro da classe que o criou e por tipos que a
herdem.O modificador protected internal proporciona um nível de acesso que
representa a união entre o modificador protected e o internal.
Se nenhum modificador de acesso for usado no Visual C#, o membro tem o mesmo
escopo de variáveis que utilizam o modificador private.
Métodos não precisam obrigatoriamente
de nenhum modificador. Caso nenhum modificador for utilizado, o método é private por padrão, nas classes ou estruturas
do C#, como exemplificado na Figura 1.
|
/// sem um modificador automaticamente o método é tratado como
private
int getIdade()
{
return 21;
}
|
|
Figura 1 – Método sem modificador em C#
|
O exemplo apresentado na Figura 2 mostra
como usar os modificadores de acesso.
|
// Classe com modificador de escopo
publico
public class MinhaClasse
{
// variável que pode ser acessada de qualquer lugar do
programa
public int meuInteger;
// método que so pode ser invocado de dentro desta classe
ou por membros do mesmo assembly
internal void metodo() {
}
// variável que só pode ser acessada de dentro desta classe
private string nome;
// método que pode ser acessado de dentro desta classe e de
outras que a herdem.
private int getIdade()
{
return 21;
}
// variável que pode ser acessada de dentro da classe, das
classes que herdam, e membros do mesmo assembly
internal protected long
valor;
}
|
|
Figura 2 – Modificadores de Acesso C#
|
Modificadores de acesso de tipos
Classes em C# também podem ter
modificadores, estes modificadores controlam como a classe pode ser instanciada
e são semelhantes aos modificadores para membros. Uma classe com o modificador public pode
ser acessada por qualquer objeto dentro da aplicação, ja uma classe utilizando
modificador internal pode
ser criada por qualquer membro do assembly, mas não por objetos externos a este.
Podemos observar o funcionamento desses modificadores analisando a Figura 3.
|
namespace x
{
// esta classe é visivel a toda a aplicação
public class a
{
// esta classe é visivel apenas internamente à classe
"a"
private class
b {}
}
}
namespace y
{
public class c
{
protected class d{}
}
public class e:c
{
// a class "d" é visível apenas para a classe
"c" e suas subclasses como esta.
}
}
namespace x
{
public class f
{
// Esta classe é
visivel a classe "a" por estarem no mesmo
// assembly, e no entanto
invisível a classe "c"
protected internal class g {}
}
}
|
|
Figura 3 – Modificadores de Acesso em classes C#
|
Segundo Almir Farias Rivas
Junior em http://www.juliobattisti.com.br/tutoriais/, uma classe que utilize o
modificador private e protected só pode ser instanciada internamente.
Uma classe que utiliza o modificador private só pode ser instanciada por objetos
dentro do seu próprio código ou por classes encadeadas (classes declaradas
dentro de classes). Classes encadeadas podem utilizar modificadores protected ou protected internal que permitem que classes herdadas de
sua classe mãe tenham acesso a elas. Modificadores protected
e internal são visíveis também por outros membros do assembly. Se
nenhum modificador de acesso é especificado para uma classe ou estrutura ela é
considerada public.
Abstract Class
A classe abstrata somente
pode ser herdada e não instanciada. Pode-se dizer que este tipo de classe é uma
classe conceito, definindo funcionalidades para as suas subclasses implementá-las.
Porém, diferente da interface nem todas as funcionalidades definidas na classe
abstrata precisam ser implementadas.. Em uma classe abstrata os métodos
declarados podem ser abstratos ou não, contendo implementações. Quando criamos
um método abstrato em uma classe abstrata sua implementação é obrigatória, caso
você não o implemente o compilador disparará, em tempo de compilação, o
seguinte erro : “Error 'x.z' does not implement inherited abstract member
'x.y.metodo()'”. Métodos declarados e implementados na classe abstrata podem
ser sobreescritos em uma subclasse. Para ilustrar a criação de uma classe
abstrata segue a Figura 4.
|
abstract class formaClasse
{
abstract
public int
Area();
}
class quadrado
: formaClasse {
int x, y;
// Se não for implementado
o método Area()
// será gerado um
compile-time error.
public override
int Area() {
return x * y;
}
}
|
|
Figura 4 – Implementação de abstract class
|
Interface
Pela definição de Rudson Kiyoshi Souza Carvalho em
http://construindooaprender.blogspot.com/ as interfaces são fundamentais em um
sistema orientado a objetos. Quando se diz que um objeto é a instância de uma
classe, na verdade quer-seizer, que este objeto
implementa a interface definida pela classe, ou seja uma interface define as
operações que um objeto será obrigado a implementar. Para cada operação
declarada por um objeto deve ser especificado o nome da operação, os objetos
aceitos como parâmetro e o tipo de valor retornado pela operação; este conjunto
de informações sobre uma determinada operação tem o nome de assinatura, e um
conjunto de assinaturas de operações dá-se o nome de interface.
Rudson Kiyoshi Souza Carvalho em http://construindooaprender.blogspot.com/ diz
que é importante lembrar que uma interface nunca contém implementação, ou em
uma interface não se pode definir os atributos, pois o mesmo é uma
implementação de um atributo objeto, a interface também não permite
construtores, pois em um construtor temos as instruções usadas para inicializar
campos. Apesar de não se poder definir atributos, a interface aceita a
declaração de constantes.
Para se usar uma interface deve-se criar uma classe ou estrutura e
herdar da interface como observado na Figura
5, com
isso é obrigatório implementar todos os métodos da interface.
|
interface IExemploInterface
{
void
ExemploMetodo();
}
class Implementacaoclasse
: IExemploInterface
{
// Implementação da
interface
void IExemploInterface.ExemploMetodo()
{
// Implementação
do método
}
static void Main()
{
// Declarando
uma instancia de uma interface
IExemploInterface
obj = new Implementacaoclasse();
// chame o
método.
obj.SampleMethod();
}
}
|
|
Figura 5 – Código exemplificando a interface e sua
implementação
|
Sealed Class
Quando uma classe é definida como sealed, está classe não poderá ser herdada,
preservando-se assim as características da mesma. Ao tentar herdar de uma
classe selada o compilador dispara um erro em tempo de compilação. Depois de
criada uma classe sealed, pode-se observar que o intelisense não mostra o nome
da mesma quando tentamos criar uma herança. A seguir na Figura 6 observa-se a criação de uma classe sealed.
|
sealed class ClasseSelada
{
public int x;
public int y;
}
class MainClass
{
static void Main()
{
ClasseSelada sc = new
ClasseSelada();
sc.x = 110;
sc.y = 150;
Console.WriteLine("x
= {0}, y = {1}", sc.x, sc.y);
}
}
|
|
Figura 6 – Código
exemplificando a classe selada
|
Conclusão
Interfaces podem ser comparadas a contratos, são funcionalidades fixas que tem
de ser implementadas obrigatoriamente por aquela que a implementa, contrata. As
classes abstratas funcionam como modelos que já contêm algumas funcionalidades,
e outras que podem ser modificadas conforme a implementação especifica. Caso
você queria disponibilizar suas bibliotecas ou aplicação, você pode optar por
selar suas classes, para que não sejam estendidas. Deve-se também pensar e
avaliar o escopo de seus métodos e variáveis, a visibilidade ou não de um
destes poderá ter grande repercussão. É muito importante analisar o contexto da
aplicação, e das funcionalidades a serem implementadas para decidir qual
alternativa certa a usar.
Referências