Classe (programação de computadores) - Class (computer programming)

Da Wikipédia, a enciclopédia livre

Em programação orientada para o objecto , uma classe é um programa de código-de modelo extensível, para a criação de objectos , proporcionando valores iniciais para o estado ( variáveis membro ) e as implementações de funções de comportamento (ou membro métodos ). Em muitas línguas, o nome da classe é usado como o nome para a classe (o próprio template), o nome para o padrão construtor da classe (a sub-rotina que cria objetos), e como o tipo de objetos gerados por instanciar a classe; estes conceitos distintos são facilmente confundidas.

Quando um objeto é criado por um construtor da classe, o objeto resultante é chamado de uma instância da classe, e as variáveis de membro específicos para o objeto são chamados de variáveis de instância , para contrastar com as variáveis de classe compartilhados entre a classe.

Em algumas línguas, as classes são apenas uma característica de tempo de compilação (novas classes não pode ser declarada em tempo de execução), enquanto em outros idiomas aulas são cidadãos de primeira classe , e geralmente são objetos em si (tipicamente do tipo Classe ou similar). Em línguas, uma classe que cria classes é chamado de metaclass .

tipo de classe vs.

Em uso casual, as pessoas muitas vezes referem-se a "classe" de um objeto, mas objetos estritamente falando tem tipo : a interface, ou seja, os tipos de variáveis de membro, as assinaturas de funções membro (métodos) e propriedades estes satisfazem. Ao mesmo tempo, uma classe tem uma aplicação (especificamente a aplicação dos métodos), e pode criar objectos de um determinado tipo, com uma dada implementação. Nos termos da teoria tipo, uma classe é uma-um implementação concreta estrutura de dados e recolha de sub-rotinas-enquanto um tipo é uma interface de . Diferentes (betão) classes podem produzir objectos com o mesmo (resumo) tipo (dependendo do tipo de sistema); por exemplo, o tipo de pilha pode ser implementado com duas classes - SmallStack (rápido para pilhas pequenas, mas escalas mal) e ScalableStack (escamas bem, mas lá no alto para pequenas pilhas). Da mesma forma, uma dada classe pode ter vários construtores diferentes.

Tipos geralmente representam substantivos, como uma pessoa, lugar ou coisa, ou algo nominalizado , e uma classe representa uma implementação destes. Por exemplo, um Banana tipo pode representar as propriedades e funcionalidades de bananas em geral, enquanto os ABCBanana e XYZBanana aulas representaria formas de bananas produtores (por exemplo, fornecedores de bananas ou estruturas de dados e funções para representar e desenhar bananas em um jogo de vídeo). O ABCBanana classe poderia, então, produzir bananas particulares: instâncias do ABCBanana classe seria objetos do tipo Banana . Muitas vezes apenas uma única implementação de um tipo é dada, caso em que o nome da classe muitas vezes é idêntica à designação do tipo.

Design e implementação

As aulas são compostas de componentes estruturais e comportamentais. As linguagens de programação que incluem classes como a oferta de suporte construção de programação, para vários recursos relacionados com a classe, e a sintaxe necessária para usar esses recursos varia muito de uma linguagem de programação para outra.

Estrutura

UML notação para classes

Uma classe contém dados descrições de campo (ou propriedades , campos , dados membros , ou atributos ). Estes são geralmente os tipos de campos e nomes que serão associadas com variáveis de estado em tempo de execução do programa; estas variáveis de estado ou pertencem às instâncias de classe ou específicas da classe. Na maioria das linguagens, a estrutura definida pela classe determina o layout da memória usada por suas instâncias. Outras implementações são possíveis: por exemplo, os objectos em Python usar recipientes de valor-chave associativos.

Algumas linguagens de programação suportam a especificação de invariantes como parte da definição da classe, e aplicá-las através do sistema tipo. Encapsulamento de estado é necessário para ser capaz de cumprir as invariantes da classe.

Comportamento

O comportamento de classe ou seus exemplos é definida utilizando métodos . Os métodos são sub-rotinas com a capacidade de operar em objetos ou classes. Estas operações podem alterar o estado de um objeto ou simplesmente fornecer formas de acessá-lo. Muitos tipos de métodos existem, mas o suporte para eles varia entre idiomas. Alguns tipos de métodos são criados e chamado pelo código de programador, enquanto que outros métodos, tais como construtores especiais, destruidores, e conversão-operadores são criados e chamado pelo código gerado pelo compilador. A linguagem também pode permitir que o programador para definir e chamar esses métodos especiais.

O conceito de interface de classe

Cada classe implementos (ou percebe ) uma interface, fornecendo estrutura e comportamento. Estrutura consiste de dados e estado, e comportamento consiste de código que especifica como métodos são implementados. Há uma distinção entre a definição de uma interface e a implementação dessa interface; no entanto, esta linha é borrada em muitas linguagens de programação, porque declarações de classe definir e implementar uma interface. Algumas línguas, no entanto, fornecer recursos que separam interface e implementação. Por exemplo, uma classe abstrata pode definir uma interface sem fornecer implementação.

Linguagens que suportam a herança de classe também permite que as classes para herdar as interfaces das classes que são derivadas.

Por exemplo, se "classe A" herda de "classe B" e se "classe B" implementa a interface de "interface de B" em seguida "classe A" também herda a funcionalidade (constantes e métodos declaração) fornecido por "interface de B".

Em linguagens que suportam especificadores de acesso , a interface de uma classe é considerada como o conjunto de membros públicos da classe, incluindo ambos os métodos e atributos (através implícita métodos getter e setter ); quaisquer membros particulares ou estruturas de dados internos não se destinam a ser dependia por código externo e, portanto, não fazem parte da interface.

metodologia de programação orientada a objeto determina que as operações de qualquer interface de uma classe devem ser independentes um do outro. Isso resulta em um design em camadas, onde os clientes de uma interface usar os métodos declarados na interface. Uma interface coloca nenhuma exigência para os clientes para invocar as operações de uma interface em qualquer ordem particular. Esta abordagem tem a vantagem de que o código do cliente pode presumir que as operações de uma interface estão disponíveis para uso sempre que o cliente tem acesso ao objeto.

Exemplo

Os botões na parte frontal do seu aparelho de televisão são a interface entre você ea fiação elétrica do outro lado de seu invólucro de plástico. Você pressiona o botão "power" para alternar a televisão ligada e desligada. Neste exemplo, a televisão em particular é a instância, cada método é representado por um botão, e todos os botões juntos compõem a interface. (Outros aparelhos de televisão que são do mesmo modelo como o seu teria a mesma interface.) Em sua forma mais comum, uma interface é uma especificação de um grupo de métodos relacionados sem qualquer implementação associado dos métodos.

Um aparelho de televisão tem também uma miríade de atributos , tais como tamanho e se apoia a cor, que em conjunto compreendem a estrutura. A classe representa a descrição completa de uma televisão, incluindo seus atributos (estrutura) e botões (interface).

Obtendo o número total de televisores fabricados poderia ser um método estático da classe televisão. Este método é claramente associada com a classe, no entanto, está fora do domínio de cada caso individual da classe. Outro exemplo seria um método estático que encontra uma instância específica fora do conjunto de todos os objetos de televisão.

acessibilidade membro

O seguinte é um conjunto comum de especificadores de acesso :

  • Privada (ou classe-privada ) restringe o acesso para a própria classe. Somente métodos que fazem parte da mesma classe pode acessar membros privados.
  • Protegido (ou de classe protegida ) permite a si e todas as suas subclasses classe para acessar o membro.
  • Público significa que qualquer código pode acessar o membro pelo seu nome.

Embora muitas linguagens orientadas a objeto apoiar os especificadores de acesso acima, sua semântica podem ser diferentes.

Design orientado a objetos usa os especificadores de acesso em conjunto com design cuidadoso de implementações de métodos públicos para impor classe invariantes-restrições sobre o estado dos objetos. Um uso comum de especificadores de acesso é para separar os dados internos de uma classe de sua interface: a estrutura interna é feita particular, enquanto públicas métodos de acesso pode ser utilizado para inspeccionar ou alterar esses dados privados.

Especificadores de acesso não necessariamente controlar a visibilidade , em que mesmo os membros privados podem ser visíveis para o código externo cliente. Em alguns idiomas, um membro do inacessível, mas visível pode ser referido em tempo de execução (por exemplo, por um ponteiro retornado de uma função de membro), mas uma tentativa de usá-lo por referindo-se ao nome do membro a partir do código cliente será evitada pelo verificador de tipos.

As várias linguagens de programação orientada a objeto impor acessibilidade membro e visibilidade aos vários graus, e dependendo da linguagem do sistema Tipo de políticas e compilação, aplicadas em cada tempo de compilação ou tempo de execução . Por exemplo, o Java linguagem não permite que o código do cliente que acessa os dados privados de uma classe para compilar. No C ++ linguagem, métodos privados são visíveis, mas não acessível na interface; no entanto, eles podem ser feitas invisíveis por declarar explicitamente as classes totalmente abstratas que representam as interfaces da classe.

Algumas línguas têm outros esquemas de acessibilidade:

  • Instância vs. acessibilidade classe : o Ruby suporta instância-privadas e protegidas por exemplo especificadores de acesso em vez de classe-privada e protegida de classe, respectivamente. Eles diferem em que eles restringir o acesso com base no próprio exemplo, em vez de classe da instância.
  • Amigo : C ++ suporta um mecanismo em que uma função explicitamente declarada como uma função de amigo da classe podem acessar os membros designados como privada ou protegida.
  • Baseado em caminhos : Java suporta restringir o acesso a um membro dentro de um pacote de Java , que é o caminho lógico do arquivo. No entanto, é uma prática comum ao estender um framework Java para implementar classes no mesmo pacote como uma classe quadro a fim de acessar membros protegidos. O arquivo de origem pode existir em um local completamente diferente, e pode ser implantado em um arquivo .jar diferente, e ainda estar no mesmo caminho lógico na medida em que a JVM está em causa.

relações de classe Inter

Além do projeto das classes independentes, as linguagens de programação pode apoiar design de classe mais avançada baseada em relações entre classes. As capacidades de design relacionamento inter-classe comumente prestados são de composição e hierárquica .

composicional

As classes podem ser compostos de outras classes, estabelecendo assim uma relação de composição entre a classe envolvente e as suas classes incorporadas. Relação de composição entre as classes também é vulgarmente conhecido como uma tem-um relacionamento. Por exemplo, uma classe "Carro" poderia ser composto de e contêm uma "Motor" de classe. Portanto, um carro tem um motor. Um aspecto da composição é a contenção, que é o invólucro de objectos componentes por exemplo o que lhes tem. Se um objecto de inclusão contém objectos componentes por valor, os componentes e o seu objecto vedante ter uma semelhante vida . Se os componentes estão contidos por referência, que não pode ter um tempo de vida semelhantes. Por exemplo, em Objective-C 2.0:

@interface Car : NSObject

@property NSString *name;
@property Engine *engine
@property NSArray *tires;

@end

Este carro classe tem uma instância de NSString (a seqüência de objeto), Motor , e NSArray (um objeto array).

hierárquica

As classes podem ser derivados a partir de uma ou mais classes existentes, estabelecendo assim uma relação hierárquica entre o derivado da partir de classes ( classes de base , classes pai ousuperclasses ) e a classe de derivados ( classe criança ou subclasse ). A relação da classe derivada para o derivado da partir de classes é vulgarmente conhecido como uma é-um relacionamento. Por exemplo, um 'botão' de classe pode ser derivada a partir de uma classe 'de controlo'. Portanto, um botão é um controle. Os elementos estruturais e comportamentais das classes pai são herdadas pela classe criança. As classes derivadas pode definir elementos estruturais adicionais (campo de dados) e os membros de comportamento (métodos) em adição àqueles que herdam e são, portanto, especializações de seus superclasses. Além disso, as classes derivadas pode override métodos herdados se o idioma permite.

Nem todos os idiomas suporta herança múltipla. Por exemplo, Java permite que uma classe para implementar várias interfaces, mas apenas herdar de uma classe. Se herança múltipla é permitido, a hierarquia é um gráfico acíclico dirigido (ou DAG para abreviar), caso contrário, é uma árvore . A hierarquia tem aulas como nós e relacionamentos de herança como links. Classes no mesmo nível são mais susceptíveis de ser associado do que as classes em diferentes níveis. Os níveis desta hierarquia são chamadas camadas ou níveis de abstração .

Exemplo (simplificado código Objective-C 2.0, a partir de iPhone SDK):

@interface UIResponder : NSObject //...
@interface UIView : UIResponder //...
@interface UIScrollView : UIView //...
@interface UITableView : UIScrollView //...

Neste exemplo, um UITableView é um UIScrollView é um UIView é um UIResponder é um NSObject.

Definições de subclasse

Conceitualmente, uma superclasse é um super conjunto de suas subclasses. Por exemplo, uma hierarquia de classe comum envolveria GraphicObject como uma superclasse de Retângulo e Elipse , enquanto Praça seria uma subclasse de retângulo . Estas são todas as relações subconjunto na teoria dos conjuntos, bem como, ou seja, todos os quadrados são rectângulos, mas nem todos os retângulos são quadrados.

Um erro conceitual comum é confundir uma parte de relação com uma subclasse. Por exemplo, um carro e caminhão são os dois tipos de veículos e seria apropriado para modelá-los como subclasses de uma classe de veículo. No entanto, seria um erro para modelar as partes componentes do carro como as relações de subclasse. Por exemplo, um carro é composto por um motor e do corpo, mas não seria apropriado para modelar motor ou corpo como uma subclasse de carro.

Na modelação orientada a objectos esses tipos de relações são tipicamente modelado como propriedades do objecto. Neste exemplo, a classe carro teria uma propriedade chamada partes . partes seria digitado para manter uma coleção de objetos, tais como instâncias de corpo, motor, pneus, ... . Linguagens de modelagem de objetos, tais como UML incluem capacidades para modelar vários aspectos da parte e outros tipos de relações. Dados como a cardinalidade dos objetos, restrições sobre os valores de entrada e saída, etc. Estas informações podem ser utilizadas por ferramentas de desenvolvimento para gerar código adicional ao lado das definições de dados básicos para os objetos. As coisas tais como a verificação de erros em métodos get e set.

Uma questão importante na modelagem e implementação de um sistema de classes de objetos é se uma classe pode ter um ou mais superclasses. No mundo real, com conjuntos de reais seria raro encontrar conjuntos que não se cruzam com mais de um outro conjunto. No entanto, enquanto alguns sistemas, como Sabores e CLOS fornecer uma capacidade para mais de um pai a fazê-lo em tempo de execução introduz complexidade que muitos na comunidade orientada a objetos consideram antiético para os objetivos do uso de classes de objetos em primeiro lugar. Entendimento qual classe será responsável por lidar com uma mensagem pode ficar complexo quando se lida com mais de uma superclasse. Se usado descuidadamente esse recurso pode introduzir algum do mesmo sistema de classes de complexidade e ambiguidade foram projetados para evitar.

A maioria das modernas linguagens orientadas a objeto como Smalltalk e Java requerem herança simples em tempo de execução. Para essas línguas, herança múltipla pode ser útil para a modelagem, mas não para uma implementação.

No entanto, Web Semântica objetos da aplicação tem várias superclasses. A volatilidade do Internet requer esse nível de flexibilidade e os padrões de tecnologia, como a Web Ontology Language (OWL) são projetados para apoiá-lo.

Um problema semelhante é se ou não a hierarquia de classes pode ser modificada em tempo de execução. Linguagens como Flavors, CLOS, e Smalltalk tudo suporta este recurso como parte de seus protocolos de meta-objeto . Como as classes são eles próprios objetos de primeira classe, é possível tê-los dinamicamente alterar a sua estrutura, enviando-lhes as mensagens apropriadas. Outros idiomas que se concentrar mais em tipagem forte, como Java e C ++ não permitem a hierarquia de classe a ser modificada em tempo de execução. Objetos de web semântica tem a capacidade para mudanças tempo de execução para classes. O racional é semelhante à justificação para permitir múltiplas superclasses, que a Internet é tão dinâmica e flexível que as mudanças dinâmicas na hierarquia são obrigados a administrar esta volatilidade.

Ortogonalidade do conceito de classe e herança

Embora linguagens baseadas em classes são assumidos comumente para suportar herança, herança não é um aspecto intrínseco do conceito de classes. Algumas línguas, muitas vezes referida como " linguagens baseadas em objeto ", aulas de apoio ainda não suportam herança. Exemplos de linguagens baseadas em objetos incluem versões anteriores do Visual Basic .

Dentro de análise orientada a objetos

Na análise orientada para o objecto e em UML , uma associação entre duas classes representa uma colaboração entre as classes ou suas instncias correspondentes. Associações têm sentido; por exemplo, uma associação de bi-direccional entre as duas classes indica que ambas as classes estão conscientes da sua relação. Associações podem ser rotulados de acordo com o seu nome ou propósito.

Um papel associação é dada extremidade de uma associação e descreve o papel da classe correspondente. Por exemplo, um papel "assinante", descreve a forma como as instâncias da classe "Person" participar de um "subscreve-a" associação com a classe "Revista". Além disso, a "Revista" tem o papel de "revista subscrito" na mesma associação. Associação papel multiplicidade descreve como muitos casos correspondem a cada instância da outra classe da associação. multiplicidades comuns são "0..1", "1..1", "1 .. *" e "0 .. *", onde o "*" especifica qualquer número de instâncias.

Taxonomia de aulas

Há muitas categorias de classes, alguns dos quais se sobrepõem.

Abstrato e concreto

Em uma linguagem que suporta herança, uma classe abstrata , ou classe base abstrata (ABC), é uma classe que não pode ser instanciado porque ele é ou rotulado como abstrato ou simplesmente especifica métodos abstratos (ou métodos virtuais ). Uma classe abstrata pode fornecer implementações de alguns métodos, e também pode especificar métodos virtuais via assinaturas que estão a ser implementadas pelos descendentes diretos ou indiretos da classe abstrata. Antes de uma classe derivada de uma classe abstrata pode ser instanciado, todos os métodos abstratos de suas classes pai deve ser implementado por alguma classe na cadeia de derivação.

A maioria das linguagens de programação orientadas a objetos permitem ao programador especificar quais classes são considerados abstrato e não vai permitir que estes sejam instanciado. Por exemplo, em Java , C # e PHP , a palavra-chave abstract é usada. Em C ++ , uma classe abstracta é uma classe que tem, pelo menos, um método resumo dada pela sintaxe apropriada em que a língua (uma função virtual puro na linguagem C ++).

Uma classe que consiste em apenas métodos virtuais é chamado um puro Sumário classe base (ou ABC Puro ) em C ++ e também é conhecido como uma interface de pelos utilizadores da língua. Outras línguas, nomeadamente Java e C #, apoiar uma variante de classes abstratas chamado de Interface através de uma palavra-chave na língua. Em línguas, herança múltipla não é permitida, mas uma classe pode implementar várias interfaces. Tal classe só pode conter abstratas métodos de acesso público.

A classe concreta é uma classe que pode ser instanciado , ao contrário de classes abstratas, que não pode.

Local e interior

Em alguns idiomas, aulas podem ser declaradas em escopos diferentes do escopo global. Existem vários tipos de tais classes.

Uma classe interna é uma classe definida dentro de uma outra classe. A relação entre uma classe interna e a sua classe contendo também pode ser tratada como um outro tipo de associação de classe. Uma classe interna é tipicamente nem associada com ocorrências da classe envolvente nem instanciado juntamente com a sua classe envolvente. Dependendo do idioma, que pode ou não ser possível para se referir à classe de fora da classe delimitador. Um conceito relacionado é tipos interiores , também conhecido como tipo de dados interna ou tipo nested , que é uma generalização do conceito de classes internas. C ++ é um exemplo de uma língua que suporta ambas as classes e tipos interiores interiores (via typedef declarações).

Outro tipo é uma classe local , que é uma classe definida dentro de um procedimento ou função. Isso limita as referências ao nome de classe para dentro do escopo onde a classe é declarada. Dependendo das regras semânticas da língua, pode haver restrições adicionais sobre classes locais, em comparação com os não-locais. Uma restrição comum é para não permitir métodos de classe para aceder a locais variáveis locais da função de inclusão. Por exemplo, em C ++, uma classe local pode referir-se a variáveis estáticas declaradas dentro de sua função delimitador, mas não pode acessar variáveis automáticas da função.

metaclasses

Metaclasses são classes cujas instâncias são classes. A metaclass descreve uma estrutura comum de uma coleção de classes e pode implementar um padrão de projeto ou descrever tipos particulares de classes. Metaclasses são muitas vezes utilizados para descrever estruturas .

Em algumas linguagens, tais como Python , rubi ou Smalltalk , uma classe é também um objecto; Assim, cada classe é uma instância de uma metaclass única que é construído dentro da linguagem. O Common Lisp Object System (CLOS) fornece protocolos metaobjeto (MOPS) para implementar essas classes e metaclasses.

Não-sub-classe

Classes não-sub-classe permitem aos programadores criar classes e hierarquias de classes em que, em algum nível na hierarquia, mais derivação é proibida. (Uma classe autónomo pode também ser designado como não-sub-classe, evitando a formação de qualquer hierarquia). Compare isso com abstratos aulas, o que implica, estimular e exigem derivação, a fim de ser usado em tudo. Uma classe não-sub-classe é implicitamente concreto .

Uma classe de sub-classe não é criado, declarando a classe como selada em C # ou como definitiva em Java ou PHP.

Por exemplo, de Java Stringclasse é designado como definitiva .

classes não-sub-classe pode permitir que um compilador (em linguagens compiladas) para realizar otimizações que não estão disponíveis para as classes de sub-classe.

Aula aberta

Uma classe aberta é aquela que pode ser alterado. Normalmente, um programa executável não pode ser alterado pelos clientes. Os desenvolvedores podem muitas vezes mudar algumas classes, mas normalmente não é possível alterar os padrões ou embutidos. Em Rubi , todas as classes estão abertas. Em Python , as aulas podem ser criados em tempo de execução, e tudo pode ser modificado depois. Categorias Objective-C permite ao programador adicionar métodos a uma classe existente, sem a necessidade de recompilar essa classe ou até mesmo ter acesso a seu código fonte.

mixins

Algumas línguas têm suporte especial para mixins , embora em qualquer idioma com herança múltipla um mixin é simplesmente uma classe que não representa um é-um-tipo de relacionamento. Mixins são normalmente utilizados para adicionar os mesmos métodos para múltiplas classes; por exemplo, uma classe UnicodeConversionMixin pode fornecer um método chamado unicode_to_ascii quando incluídos nas classes FileReader e WebPageScraper que não compartilham uma origem comum.

Parcial

Em linguagens que suportam o recurso, a classe parcial é uma classe cuja definição pode ser dividida em várias partes, dentro de um único código-fonte arquivo ou em vários arquivos. As peças são fundidas no tempo de compilação, fazendo com que a saída do compilador o mesmo que para uma classe não parcial.

A principal motivação para a introdução de classes parciais é para facilitar a aplicação de geradores de código , como designers visuais . É caso contrário, um desafio ou compromisso para desenvolver geradores de código que podem gerenciar o código gerado quando é intercalado no código escrito pelo desenvolvedor. Usando classes parciais, um gerador de código pode processar um ficheiro separado ou classe parcial de granulação grossa dentro de um ficheiro, e é, portanto, aliviada de intricada interjecting código gerado através de análise extensa, aumentando a eficiência do compilador e eliminando o risco potencial de código de programador corrompendo. Em uma implementação simples de classes parciais, o compilador pode executar uma fase de pré-compilação onde "unifica" todas as partes de uma classe parcial. Em seguida, a compilação pode prosseguir como de costume.

Outros benefícios e efeitos da característica de classe parcial incluem:

  • Permite a separação de código de interface e implementação de uma classe de uma forma única.
  • Facilita a navegação através de grandes classes dentro de um editor .
  • Permite a separação de interesses , de uma forma semelhante à programação orientada a aspectos , mas sem o uso de quaisquer ferramentas extras.
  • Permite que vários desenvolvedores para trabalhar em uma única classe ao mesmo tempo sem a necessidade de mesclar código individual em um arquivo em um momento posterior.

Classes parciais ter existido na Smalltalk sob o nome de Extensões da Classe de tempo considerável. Com a chegada do framework .NET 2 , Microsoft introduziu classes parciais, apoiados tanto em C # 2.0 e Visual Basic 2005 . WinRT também suporta classes parciais.

Exemplo em VB.NET

Este exemplo simples, escrito em Visual Basic .NET , mostra como partes da mesma classe são definidos em dois arquivos diferentes.

file1.vb
Partial Class MyClass
    Private _name As String
End Class
file2.vb
Partial Class MyClass
    Public Readonly Property Name() As String
         Get
             Return _name
         End Get
    End Property
End Class

Quando compilado, o resultado é o mesmo como se os dois arquivos foram escritas como um, como este:

Class MyClass
    Private _name As String
    Public Readonly Property Name() As String
         Get
             Return _name
         End Get
    End Property
End Class

Exemplo em Objective-C

Em Objective-C , classes parciais, também conhecidos como categorias , podem mesmo distribuídos por várias bibliotecas e executáveis, o exemplo a seguir. Mas a principal diferença é que as categorias de um Objective-C podem substituir definições em outra declaração de interface, e que as categorias não são iguais a definição de classe original (o primeiro requer a última). Em vez disso, .NET classe parcial não pode ter definições conflitantes, e todas as definições parciais são iguais aos outros.

Em Foundation, cabeçalho do arquivo NSData.h:

@interface NSData : NSObject

- (id)initWithContentsOfURL:(NSURL *)URL;
//...

@end

Na biblioteca fornecida pelo usuário, um binário separado do framework Foundation, NSData arquivo de cabeçalho + base64.h:

#import <Foundation/Foundation.h>

@interface NSData (base64)

- (NSString *)base64String;
- (id)initWithBase64String:(NSString *)base64String;

@end

E em um aplicativo, mais um arquivo binário separado, fonte main.m arquivo de código:

#import <Foundation/Foundation.h>
#import "NSData+base64.h"

int main(int argc, char *argv[])
{
    if (argc < 2)
        return EXIT_FAILURE;
    NSString *sourceURLString = [NSString stringWithCString:argv[1]];
    NSData *data = [[NSData alloc] initWithContentsOfURL:[NSURL URLWithString:sourceURLString]];
    NSLog(@"%@", [data base64String]);
    return EXIT_SUCCESS;
}

O despachante vai encontrar os dois métodos chamados sobre a instância NSData e invocar ambos corretamente.

instanciados

As classes instanciados permitem aos programadores grupo juntos por classe campos e métodos que são acessíveis em tempo de execução, sem uma instância da classe. Na verdade, instanciação é proibida para este tipo de classe.

Por exemplo, em C #, uma classe marcado "estática" não pode ser instanciada, só pode ter membros estáticos (campos, métodos, outros), podem não ter construtores exemplo , e é selada .

Sem nome

Uma classe sem nome ou classe anônima é uma classe que não está vinculado a um nome ou identificador sobre definição. Isto é análogo ao chamado contra funções não identificadas .

benefícios

Os benefícios de organizar software para classes de objetos caem em três categorias:

  • Desenvolvimento rápido
  • Facilidade de manutenção
  • Reutilização de código e projetos

classes de objetos facilitar o desenvolvimento rápido, porque eles diminuir a diferença semântica entre o código e os usuários. Os analistas de sistemas pode falar com os desenvolvedores e usuários que utilizam essencialmente o mesmo vocabulário, falando sobre contas, clientes, contas, etc. Classes de objetos muitas vezes facilitar o desenvolvimento rápido porque a maioria dos ambientes orientados a objetos vêm com poderosas ferramentas de depuração e testes. Instâncias de classes pode ser inspecionado em tempo de execução para verificar se o sistema está funcionando como esperado. Além disso, em vez de obter dumps de memória de núcleo, a maioria dos ambientes orientados a objetos têm interpretado recursos de depuração para que o desenvolvedor pode analisar exatamente onde no programa o erro ocorreu e pode ver quais métodos foram chamados para que argumentos e com que argumentos.

As classes de objeto facilitar a facilidade de manutenção através de encapsulamento. Quando os desenvolvedores precisam para mudar o comportamento de um objeto que pode localizar a mudança para apenas esse objeto e seus componentes. Isso reduz o potencial para efeitos secundários indesejados de melhorias de manutenção.

Reutilização de software é também um grande benefício do uso de Classes de objetos. Classes de facilitar a reutilização através de herança e interfaces. Quando um novo comportamento é exigido que muitas vezes pode ser alcançado através da criação de uma nova classe e ter essa classe herdar os comportamentos e os dados de sua superclasse padrão e, em seguida, adaptar alguns aspectos do comportamento ou dados em conformidade. Re-uso através de interfaces (também conhecido como métodos) ocorre quando um outro objeto quer invocar (em vez de criar um novo tipo de) alguma classe de objeto. Este método para reutilização remove muitos dos erros comuns que podem fazer o seu caminho em software quando um programa de re-usa código de outro.

Run-time representação

Como um tipo de dados, uma classe é geralmente considerado como uma construo de tempo de compilação. A linguagem pode também apoiar protótipo ou fábrica metaobjetos que representam informações de tempo de execução sobre classes, ou mesmo representar metadados que fornece acesso a reflexão instalações e capacidade de manipular formatos de estrutura de dados em tempo de execução. Muitas línguas distinguem este tipo de informações de tipo de tempo de execução sobre classes de uma classe na base de que a informação não é necessária em tempo de execução. Algumas linguagens dinâmicas não fazer distinções rígidas entre o tempo de execução e em tempo de compilação construções, e, portanto, não pode distinguir entre metaobjetos e classes.

Por exemplo, se humano é uma metaobjeto representando a classe Pessoa, em seguida, instâncias de classe Pessoa pode ser criado usando as instalações do Human metaobjeto .

Veja também

Notas

Referências

Outras leituras

links externos