Objective-C (Português)

Objective-C deriva sua sintaxe de objeto do Smalltalk. Toda a sintaxe para operações não orientadas a objetos (incluindo variáveis primitivas, pré-processamento, expressões, declarações de funções e chamadas de funções) são idênticas às de C, enquanto a sintaxe para recursos orientados a objetos é uma implementação de mensagens de estilo Smalltalk.

MessagesEdit

o modelo Objective-C de programação orientada a objetos é baseado na passagem de mensagens para instâncias de objetos. No Objetivo-C não se chama um método; envia-se uma mensagem., This is unlike the Simula-style programming model used by C++. A diferença entre estes dois conceitos está em como o código referenciado pelo método ou nome da mensagem é executado. Em uma linguagem de estilo Simula, o nome do método é, na maioria dos casos, ligado a uma seção de código na classe alvo pelo compilador. Em Smalltalk e Objective-C, o alvo de uma mensagem é resolvido em tempo de execução, com o próprio objeto receptor interpretando a mensagem., Um método é identificado por um seletor ou SEL — um identificador único para cada nome de mensagem, muitas vezes apenas uma string nul-terminada representando seu nome — e resolvido para um ponteiro de método C implementando-o: um IMP. Uma consequência disso é que o sistema de passagem de mensagens não tem verificação de tipo. O objeto para o qual a mensagem é direcionada — o receptor — não está garantido para responder a uma mensagem, e se não responder, ele levanta uma exceção.,

a Enviar a mensagem método para o objeto apontado pelo ponteiro obj exigiria o seguinte código em C++:

obj->method(argument);

Em objective-C, este é escrito da seguinte maneira:

;

O “método” chamada é traduzido pelo compilador para a objc_msgSend(id auto, SEL-operatório …) family of runtime functions. Diferentes implementações lidam com adições modernas como super. Em famílias GNU esta função é chamada objc_msg_sendv, mas tem sido depreciada em favor de um sistema de busca moderno sob objc_msg_lookup.,ambos os estilos de programação têm os seus pontos fortes e fracos. Programação orientada a objetos no estilo Simula (C++) permite uma herança múltipla e uma execução mais rápida usando a binding compile-time sempre que possível, mas não suporta a binding dinâmica por padrão. Ele também obriga todos os métodos a ter uma implementação correspondente, a menos que eles sejam abstratos. A programação de estilo Smalltalk, como usada no Objective-C, permite que as mensagens não sejam implementadas, com o método resolvido para sua implementação em tempo de execução., Por exemplo, uma mensagem pode ser enviada para uma coleção de objetos, aos quais apenas alguns serão esperados para responder, sem medo de produzir erros de tempo de execução. A passagem de mensagens também não requer que um objeto seja definido no tempo de compilação. Uma implementação ainda é necessária para que o método seja chamado no objeto derivado. (Ver a secção de dactilografia dinâmica abaixo para mais vantagens da ligação dinâmica (tardia).)

Interfaces e implementaçõesedit

Objective-C requer que a interface e a implementação de uma classe sejam em blocos de código declarados separadamente., Por convenção, os desenvolvedores colocam a interface em um arquivo de cabeçalho e a implementação em um arquivo de código. Os ficheiros de cabeçalho, normalmente com sufixo .h, são semelhantes aos arquivos de cabeçalho C enquanto os arquivos de implementação (método), normalmente sufixos .m, pode ser muito semelhante a arquivos de código C.

InterfaceEdit

isto é análogo às declarações de classes usadas em outras linguagens orientadas a objetos, como C++ ou Python.

a interface de uma classe é normalmente definida num ficheiro de cabeçalho. Uma convenção comum é nomear o arquivo de cabeçalho após o nome da classe, por exemplo, bola.,h conteria a interface para a bola de classe.

uma declaração de interface toma a forma:

no acima, mais sinais denotam métodos de classe, ou métodos que podem ser chamados na própria classe (não em uma instância), e menos sinais denotam métodos de instância, que só podem ser chamados em uma instância particular da classe. Métodos de classe também não têm acesso a variáveis de instância.,

o código acima é aproximadamente equivalente à seguinte interface C++:

Note que instancemethod2w2parameters: param2_callName: demonstra a intercepção de segmentos de selector com expressões de argumento, para os quais não há equivalente direto em C/C++.

Return types can be any standard C type, a pointer to a generic Objective-C object, a pointer to a specific type of object such as NSArray *, NSImage*, or NSString*, or a pointer to the class to which the method belongs (instancetype). O tipo de retorno padrão é o ID genérico do tipo Objective-C.,os argumentos do método

começam com um nome rotulando o argumento que faz parte do nome do método, seguido por um ponto seguido pelo tipo de argumento esperado entre parênteses e o nome do argumento. O rótulo pode ser omitido.

uma derivada da definição da interface é a categoria, que permite adicionar métodos às classes existentes.

ImplementationEdit

a interface apenas declara a interface de classe e não os próprios métodos: o código real é escrito no arquivo de implementação., Implementation (method) files normally have the file extension .m, which originally signified “messages”.

@implementation classname+ (return_type)classMethod { // implementation}- (return_type)instanceMethod { // implementation}@end

os métodos são escritos usando as suas declarações de interface.Comparando objective-C e C:

- (int)method:(int)i { return ;}

int function(int i) { return square_root(i);}

A sintaxe permite pseudo-nomeação de argumentos.representações internas de um método variam entre diferentes implementações do Objective-C., Se o myColor for da cor da classe, o método da instância-alterado: Verde: Azul: poderá ser identificado internamente como _i_color_changecolortored_ green_ blue. O i é referir-se a um método de instância, com a classe e, em seguida, nomes de método anexados e colões alterados para underscores. Como a ordem dos parâmetros é parte do nome do método, ele não pode ser alterado para se adequar ao estilo de codificação ou expressão como com parâmetros verdadeiros nomeados.

no entanto, os nomes internos da função raramente são usados diretamente. Geralmente, as mensagens são convertidas para chamadas de funções definidas na biblioteca de tempo de execução Objective-C., Não é necessariamente conhecido no momento do link qual método será chamado porque a classe do receptor (o objeto que está sendo enviado a mensagem) não precisa ser conhecida até o tempo de execução.

InstantiationEdit

Uma vez que uma classe objetiva-C é escrita, ela pode ser instanciada. Isto é feito primeiramente alocando uma instância não inicializada da classe (um objeto) e, em seguida, inicializando-A. Um objeto não está totalmente funcional até que ambos os passos tenham sido completados., Estes passos devem ser realizados com uma linha de código, de modo que não é nunca um objeto alocado que não tenha sofrido de inicialização (e porque não é sensato manter o resultado intermediário desde -init pode retornar um objeto diferente do que aquele em que ele é chamado).,

Instanciação com o padrão, não-parâmetro inicializador:

MyObject *foo = init];

Instanciação com um personalizado inicializador:

MyObject *foo = initWithString:myString];

Em caso de inicialização personalizada está sendo executada, o “novo” método muitas vezes pode ser usado no lugar do alloc-init mensagens:

MyObject *foo = ;

além disso, algumas classes de implementar método de classe inicializadores., Como +new, eles combinam +alloc e -init, mas ao contrário de +new, eles retornam um autoreleased instância. Algumas método de classe de inicializadores de tomar parâmetros:

MyObject *foo = ;MyObject *bar = ;

A alocação mensagem aloca memória suficiente para conter todas as variáveis de instância de um objeto, define todas as variáveis de instância para valores zero, e transforma a memória em uma instância da classe; em nenhum momento durante a inicialização é a memória de uma instância da superclasse.,

a mensagem init executa a configuração da instância após a criação. O método init, muitas vezes, é escrito da seguinte forma:

- (id)init { self = ; if (self) { // perform initialization of object here } return self;}

No exemplo acima, observe o id tipo de retorno. Este tipo significa “ponteiro para qualquer objecto” no Objective-C (ver a secção de tipagem dinâmica).

O padrão de inicialização é usado para garantir que o objeto é inicializado corretamente por sua superclasse antes que o método init realize sua inicialização., Ele executa as seguintes ações:

1. self = envia a instância de superclasse uma mensagem init e atribui o resultado ao self (ponteiro para o objeto atual).
2. if (self)Checks if the returned object pointer is valid before performing any initialization.
3. return selfReturns the value of self to the caller.

Um ponteiro de objecto não válido tem o valor nula; declarações condicionais como “se” tratam nula como um ponteiro nulo, de modo que o código de inicialização não será executado se devolvido nula., Se houver um erro na inicialização, o método init deve realizar qualquer limpeza necessária, incluindo o envio de uma mensagem “release” para o self, e retornar nada para indicar que a inicialização falhou. Qualquer verificação para tais erros só deve ser realizada depois de ter chamado a inicialização da superclasse para garantir que a destruição do objeto será feita corretamente.

Se uma classe tem mais do que um método de inicialização, apenas um deles (o “inicializador designado”) precisa seguir este padrão; outros devem chamar o inicializador designado em vez do inicializador de superclass.,

ProtocolsEdit

em outras linguagens de programação, estas são chamadas de “interfaces”.O Objetivo-C foi estendido ao lado para introduzir o conceito de herança múltipla da especificação, mas não implementação, através da introdução de protocolos. Este é um padrão alcançável tanto como uma classe base abstrata de múltiplos herdados em C++, ou como uma “interface” (como em Java e c#). Objective-C faz uso de protocolos ad hoc chamados de protocolos informais e protocolos forçados pelo compilador chamados protocolos formais.,um protocolo informal é uma lista de métodos que uma classe pode optar por implementar. É especificado na documentação, uma vez que não tem presença na língua. Protocolos informais são implementados como uma categoria (veja abaixo) no NSObject e muitas vezes incluem métodos opcionais, que, se implementados, podem mudar o comportamento de uma classe. Por exemplo, uma classe de campo de texto pode ter um delegado que implementa um protocolo informal com um método opcional para executar a completação automática do texto digitado pelo Usuário., O campo de texto descobre se o delegado implementa esse método (através de reflexão) e, em caso afirmativo, chama o método do delegado para suportar o recurso Auto-completo.

um protocolo formal é semelhante a uma interface em Java, C#, e Ada 2005. É uma lista de métodos que qualquer classe pode se declarar implementar. Versões do Objective-C antes do 2.0 exigiram que uma classe deve implementar todos os métodos em um protocolo que se declara adotando; o compilador emitirá um erro se a classe não implementar todos os métodos de seus protocolos declarados. Objectivo – C 2.,0 suporte adicional para marcar certos métodos em um protocolo opcional, e o compilador não vai impor a implementação de métodos opcionais.deve declarar-se que uma classe aplica o protocolo em conformidade com o mesmo. Isto é detectável no tempo de execução. Protocolos formais não podem fornecer quaisquer implementações; eles simplesmente asseguram aos chamadores que classes que estejam em conformidade com o protocolo irão fornecer implementações. Na biblioteca NeXT/Apple, protocolos são frequentemente usados pelo sistema de objetos distribuídos para representar as habilidades de um objeto executando em um sistema remoto.,

a sintaxe

@protocol NSLocking- (void)lock;- (void)unlock;@end

denota que existe a ideia abstracta de bloqueio. Ao afirmar na definição da classe que o protocolo é implementado,

@interface NSLock : NSObject <NSLocking>// ...@end

instâncias do NSLock afirmam que eles fornecerão uma implementação para os dois métodos de instância.

dynamic typingEdit

Objective-C, like Smalltalk, can use dynamic typing: an object can be sent a message that is not specified in its interface., Isso pode permitir uma maior flexibilidade, pois permite que um objeto “capture” uma mensagem e envie a mensagem para um objeto diferente que possa responder à mensagem apropriadamente, ou também enviar a mensagem para outro objeto. Este comportamento é conhecido como encaminhamento de mensagens ou delegação (ver abaixo). Alternativamente, um manipulador de erros pode ser usado no caso da mensagem não poder ser encaminhada. Se um objeto não encaminhar uma mensagem, responder a ela, ou lidar com um erro, então o sistema irá gerar uma exceção de tempo de execução., Se as mensagens forem enviadas para zero (o ponteiro do objeto nulo), elas serão silenciosamente ignoradas ou levantarão uma exceção genérica, dependendo das opções do compilador.a informação de dactilografia estática pode também, opcionalmente, ser adicionada às variáveis. Esta informação é então verificada na hora de compilação. Nas quatro declarações que se seguem, são fornecidas informações de tipo cada vez mais específicas. As declarações são equivalentes no tempo de execução, mas a informação extra permite ao compilador avisar o programador se o argumento passado não corresponde ao tipo especificado.,

- (void)setMyValue:(id)foo;

na declaração acima, foo pode ser de qualquer classe.

- (void)setMyValue:(id<NSCopying>)foo;

Na instrução acima, foo pode ser uma instância de qualquer classe que está de acordo com o NSCopying protocolo.

- (void)setMyValue:(NSNumber *)foo;

na declaração acima, foo deve ser uma instância da classe NSNumber.

- (void)setMyValue:(NSNumber<NSCopying> *)foo;

#import <objc/Object.h>// A simple Recipient object.@interface Recipient : Object- (id)hello;@end

#import "Recipient.h"@implementation Recipient- (id)hello { printf("Recipient says hello!\n"); return self;}@end

$ ./a.outRecipient says hello!

#import <objc/Object.h>@interface Integer : Object { int integer;}- (int)integer;- (id)integer:(int)_integer;@end

#import "Integer.h"@interface Integer (Arithmetic)- (id) add: (Integer *) addend;- (id) sub: (Integer *) subtrahend;@end

#import "Integer.h"@interface Integer (Display)- (id) showstars;- (id) showint;@end

gcc -x objective-c main.m Integer.m Integer+Arithmetic.m Integer+Display.m -lobjc