Place New

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 c2 extends c1{
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(){}}

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