A
classe abstrata é um tipo de classe que somente pode ser herdada e não
instanciada. De certa forma podemos dizer que este tipo de classe é
conceitual, que pode definir funcionalidades para que as suas subclasses possam
implementá-las de forma não obrigatória, ou seja ao se definir um conjunto de
métodos na classe abstrata não é de total obrigatoriedade a implementação de
todos os métodos em suas subclasses.
Em
uma classe abstrata os métodos declarados podem ser abstratos ou não e suas
implementações devem ser obrigatórias na subclasse.
Quando
criamos um método em uma classe abstrata sua implementação é obrigatória pelas
classes herdadas. Caso você não implemente o mesmo, o compilador criará um erro
em tempo de compilação.
Exemplo de implementação
retirado do books online em C#.
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;
}
}
Uma classe abstrata é desenvolvida
para representar entidades e conceitos abstratos. A classe abstrata é sempre
uma superclasse que não possui instâncias. Ela define um modelo (template)
para uma funcionalidade e fornece uma implementação incompleta - a parte
genérica dessa funcionalidade - que é compartilhada por um grupo de classes
derivadas. Cada uma das classes derivadas completa a funcionalidade da classe
abstrata adicionando um comportamento específico.
Uma classe abstrata normalmente
possui métodos abstratos. Esses métodos são implementados
nas suas classes derivadas concretas com o objetivo de definir o comportamento
específico. O método abstrato define apenas a assinatura do método e, portanto,
não contém código.
Uma classe abstrata pode relacionar
via "implements" com uma interface e
implementar
parcialmente os métodos da interface e de suas superinterfaces. O programa abaixo
ilustra este ponto:
class programa{
public static void main(String[] arg){
i3 q=new c2();
q.m1();
q.m2();
q.m3();
}
}
interface i1{void m1();}
interface i2{void m2();}
interface i3 extends i1,i2{void m3();}
abstract class c1 implements i3{
public void m2(){System.out.println("m2");}
}
class programa{
public static void main(String[] arg){
i3 q=new c2();
q.m1();
q.m2();
q.m3();
}
}
interface i1{void m1();}
interface i2{void m2();}
interface i3 extends i1,i2{void m3();}
abstract class c1 implements i3{
public void m2(){System.out.println("m2");}
}
class c2 extends c1{
public void m1(){System.out.println("m1");}
public void m3(){System.out.println("m3");}
}
public void m1(){System.out.println("m1");}
public void m3(){System.out.println("m3");}
}
Por outro lado, as classes concretas
implementam todos os seus métodos e permitem a criação de instâncias. Uma
classe concreta não possui métodos abstratos e, geralmente, quando utilizadas
neste contexto, são classes derivadas de uma classe abstrata.
Uma
classe concreta (não abstrata) relacionada via “implements” com uma interface
tem a obrigação de implementar todos os métodos definidos pela interface. Uma
classe abstrata relacionada via “implements” com uma interface não tem a obrigação
de implementar todos os métodos definidos pela interface. De uma maneira mais
geral: somente a primeira classe concreta de uma hierarquia de classes abstratas
relacionadas com “implements” com interfaces é que tem a obrigação de implementar
todos os métodos das interfaces relacionadas com ela e com as ancestrais:
class tstAbstractClass{
public static void main(String[] arg){
C v=new C();
}
}
interface I1{void m1(); void m2();}
interface I2{void m3(); void m4();}
abstract class AC1 implements I1{public void m1(){}}
abstract class AC2 extends AC1 implements I2 {public void m3(){}}
class C extends AC2{public void m2(){} public void m4(){}}
class tstAbstractClass{
public static void main(String[] arg){
C v=new C();
}
}
interface I1{void m1(); void m2();}
interface I2{void m3(); void m4();}
abstract class AC1 implements I1{public void m1(){}}
abstract class AC2 extends AC1 implements I2 {public void m3(){}}
class C extends AC2{public void m2(){} public void m4(){}}
No
programa acima as pendências da hierarquia AC1->AC2->C só são resolvidas
pela classe concreta C.
O QUE É UMA CLASSE ESTÁTICA E QUAL
A SUA APLICAÇÃO
Uma classe
estática é basicamente a mesma que uma classe não-estática, mas há uma
diferença: uma classe estática não pode ser instanciada.Em outras palavras,
você não pode usar a Palavra-chave new para criar uma variável do tipo da
classe.Como não há nenhuma variável de instância, você acessa os membros de uma
classe estática usando o nome de classe propriamente dito.
Tal como
acontece com todos os tipos de classe, as informações do tipo para uma classe
estática são carregadas pelo .NET Framework common language runtime (CLR)
quando o programa que referencia a classe é carregado. O programa não pode
especificar exatamente quando a classe é carregada.No entanto, é garantido para
ser carregado e ter seus campos Inicializado e seu construtor estático chamado
antes que a classe é referida pela Primeiro vez no seu programa.Um construtor
estático é chamado Apenas uma vez e uma classe estática permanece na memória
para o Hora de vida do domínio do aplicativo no qual reside o seu programa.
Uma
classe Estática pode ser usada sistema autônomo um recipiente conveniente para
conjuntos de métodos que simplesmente operam nos parâmetros de entrada e não
precisará obter ou Conjunto sistema autônomo campos de instância interna.Por
exemplo, em translation from VPE for picture itExclMark estrutura Class
Biblioteca, o estático System.Mathclasse
contém vários métodos que executam operações matemáticas, sem qualquer
requisito de armazenamento ou recuperar dados que são exclusivos para uma
instância específica do Mathclasse.
A lista
a seguir fornece os principais recursos de uma classe Estática:
Contém apenas Membros estáticos.
Não pode ser instanciada.
É sealed.
Não pode conter do Construtores de
instância.
Criar
uma classe Estática é, portanto, basicamente o mesmo que Criar uma classe que
contém apenas membros estáticos e um construtor particular.Um construtor
particular impede que a classe seja instanciada.A vantagem de usar uma classe
Estática é que o compilador pede seleção para certificar-se de que nenhum membro
de instância acidentalmente seja adicionado.O compilador garante que as
instâncias dessa classe não podem ser Criadas.
Classes
estaticas são lacradas e, portanto, não podem ser herdadas.Eles não podem
herdar de qualquer classe, exceto o Object.Classes
static não podem conter um construtor de instância; no entanto, elas podem
conter um construtor estatico.Classes não-estático também devem definir um
construtor estático, se a classe contém membros estáticos que necessitam de
inicialização não trivial.
Estático Membros
Uma
classe Estático que não pode conter métodos estáticos, campos, propriedades ou
eventos. O membro estático é que pode ser chamado em uma classe, mesmo quando
nenhuma instância da classe foi criada.O membro estático sempre é acessado pelo
nome da classe, e não o nome da instância.Apenas uma copia de um membro
estático existe, independentemente de quantas instâncias da classe são
criadas.Propriedades e métodos Estático não podem Acesso non-Estático campos e
eventos em contendo o tipo e não tiverem permissão Acesso uma instância de variável
de qualquer objeto, a menos que explicitamente é passado um parâmetro do
método.
É mais
comum declarar uma classe non-static com alguns membros estáticos, que para
declarar uma classe inteira sistema autônomo estático.Dois usos comum de campos
estáticos são para manter uma conta do número de objetos que foi criada,
ou para armazenar valor comum que deve ser compartilhado entre todas as instâncias.
Métodos Estático podem ser
sobrecarregados mas não substituídos, pois elas pertencem à classe e não para
qualquer instância da classe.
Apesar
de um campo não pode ser declarado sistema autônomo static const, campo const é
essencialmente estático em seu comportamento.Ele pertence ao tipo, não às
instâncias do tipo.Portanto, const campos podem ser acessados usando a mesma ClassName.MemberNamenotação usada
para Estático campos.Nenhuma instância do objeto é Necessário.
Translation
from VPE for Csharp não oferece suporte a Estático variáveis locais (variáveis
sejam declaradas no escopo do método).
Membros
estáticos são inicializados antes que o membro estático é acessado pela
Primeiro Hora e antes do construtor estático, se houver algum, é chamado.Para acessar
um membro da classe Estático, Usar o nome da classe em vez de um nome de
variável para especificar o Localização do membro, sistema autônomo
Se sua
classe contenha campos estáticos, fornece um construtor estático,
inicializa-los quando a classe é carregada.
Uma
chamada para um método estático gera uma instrução de chamada na Microsoft
Intermediate LINGUAGEM (MSIL), enquanto uma chamada para um método de instância
gera um callvirtinstrução, que
também procura referências de um objeto nulo.No entanto, na maioria das vezes a
diferença de desempenho entre os dois não é significativa.
EXPLIQUE O QUE É UMA INTERFACE E QUAL
A SUA FINALIDADE
Interfaces são modelos para a construção de
outras classes. Diferentemente das classes abstratas, as interfaces não
carregam código algum dentro de sua estrutura, elas apenas definem métodos,
propriedades e permitem a declaração de constantes. Implicitamente os métodos
das interfaces têm seus acessos declarados como public e abstract.
Então, como se pode ver, uma interface
não tem aplicação sozinha. Ela contém apenas as definições de eventos,
indexadores, métodos e/ou propriedades. A razão pela qual as interfaces
fornecem apenas as definições é porque elas são implementadas por classes e
estruturas, as quais devem proporcionar uma aplicação para cada membro definido
dentro desta interface.
Para exemplificar a construção de
uma interface e classe derivada, utilizou-se a idéia de impressão e
edição, isto é, serão construídas duas interfaces. Veja o exemplo a
seguir:
interface Interf1{ public void
mostrar(); public void mostrarnoConsole();
}
Veja que os métodos não têm
codificação, apenas definições. Logo, qualquer classe que implementar a interface
terá o compromisso de criar o corpo dos métodos definidos na interface.
O escopo de uma classe que herda da interface Interf1 fica da seguinte
forma:
class
Pessoa: Interf1
Em CSharp não existe herança múltipla,
contudo é possível implementar as operações de múltiplas interfaces. Não é
contraditório dizer que não existe herança múltipla, mas pode implementar
múltiplas interfaces?
Quando
se diz que não há herança múltipla, é devido à impossibilidade de uma classe
herdar características de duas ou mais classes ou classes abstratas. Todas as
classes e classes abstratas contêm implementações, isto é, seus métodos são
criados dentro da sua classe, com exceção, é claro, dos métodos abstratos em
classes abstratas.
Nas
interfaces não existem corpos para os métodos, apenas seus escopos
(assinaturas), e não existem atributos com valores variáveis, apenas as
chamadas constantes, nas quais o valor nunca muda durante a execução do
programa.
Em resumo, quando uma classe herda
outra, pode reaproveitar ou especificar comportamentos de objetos em uma
hierarquia. Quando uma classe implementa uma interface,
ela não reaproveita código, uma vez que não existem tais códigos, todavia ela
se vê obrigada a seguir os comportamentos ditados pela interface.
Veja
como fica a declaração de uma classe que implementa duas interfaces:
interface Idemonstra
{
void Mostrar();
}
interface Idemonstra1
{
void Mostrar();
}
class
Implementa:Idemonstra,Idemonstra1
{
void Idemonstra.Mostrar()
{
Console.WriteLine("Show() method Implemented");
}
void Idemonstra1.Mostrar()
{
Console.WriteLine("Display() method Implemented");
}
public static void Main(string[] args)
{
Implementa InstClasse = new Implementa();
IsntClasse.Idemonstra.Mostrar();
IsntClasse.Idemonstra1.Mostrar();
}
}
REFERÊNCIAS
Nenhum comentário:
Postar um comentário
O que achou dessa postagem?