iOS Tips

gistfile1.txt

iOS Tips
========

- métodos que possuem o prefixo "-" são métodos de instância, enquanto métodos com prefixo "+" são métodos de classe;
 
- variaveis de instancia e properties sao a "mesma coisa". através de properties, entretanto, é possível usar "dot notation"

- @synthesize gera o getter/setter da propertie automagicamente (entretanto, é possível sobescrever tais métodos, caso necessário)

- int x = eye; (chama a variável de instância diretamente)

- int x = self.eye; (chama o método getter da variável eye)

- designated initializers são os initializers default, que chamam o init de "super" e retornam self. caso seja retornado nil, o objeto nao foi instanciado

    @implementation MyObject
    - (id)init {
        if ([super init]) {
            // initialize our subclass here
            return self;
        } else {
            return nil; 
        }
    } 
    @end

- convenience initializers são initializers personalizados, eles chamam o init de self por ser boa prática (já que o init de self chamara o init de super) por exemplo:

    @implementation CalculatorBrain
    
    - (id)initWithValidOperations:(NSArray *)anArray {
        self = [self init];
        self.validOperations = anArray; // will do nothing if self == nil
        return self;
    }
    
    @end

- TODOS os objetos que são criados através de **new**, **alloc** ou **copy**, **são** de responsabilidade do developer.

- Qualquer outro objeto que não foi criado através dos métodos acima, **NÃO é** de responsabilidade do developer, entretanto, essa responsabilidade pode ser conquistada através do método **retain**

- Para liberar um objeto de sua responsabilidade, é necessário passar a mensagem **release**, mas apenas para objetos de sua responsabilidade;

- Objetos que podem ter sua responsabilidade passada a diante através da mensagem **autorelease** no momento de sua instanciação, antes do retorno. O caller pode, então, "conquistar" a responsabilidade deste objeto através do método **retain**:

  - (Money *)showMeTheMoney:(double)amount {
    Money *theMoney = [[Money alloc] init:amount];
    [theMoney autorelease]; // isso permite que o objeto theMoney pode ser "retain" pelo caller
    return theMoney;
  }

  //caller
  Money *myMoney = [bank showMeTheMoney:4500.00];
  [myMoney retain]; //myMoney é responsabilidade do caller...

- Algumas classes implementam métodos que fazem o "autorelease", dos objetos criados, automaticamente. Evitando que seja passada a mensagem "autorelease" para o objeto criado;

- Deve-se usar o "release" (parar de usar, abrir mão da responsabilidade deste objeto) assim que possível, quando o objeto em questão não for mais utilizado;

- Quando o método "release" é chamado em cima de um objeto (e você é o último responsável por este objeto), um outro método especial, chamado **dealloc** é chamado. Este método retorna a memória do "ex objeto" para a heap;

- É possível sobescrever o método "dealloc" nas suas classes, mas **não** se deve usá-lo explicitamente. Deixe que o "release" faça essa tarefa. A única exceção é que deve ser chamado "[super dealloc]" na sua implementação do "dealloc":

  - (void)dealloc {
    [brain release];
    [otherObjectInstanceVariable release];
    [super dealloc];
  }

- Variáveis de instância que são setadas através de @properties, também **devem** ter uma chamada do método "retain" dentro dos setters. Entretanto, setters gerados através do @synthesize **não** possuem o "retain" embutido. Para resolver isso (não precisar reescrever o setter) pode-se fazer o seguinte:

  @property (retain) NSString *name;
  //@synthesize irá gerar o seguinte setter para *name
  - (void)setName:(NSString *)aString {
    [name release];
    name = [aString retain];
  }
  
  @property (copy) NSString *name;
  //@synthesize irá gerar o seguinte setter para *name
  - (void)setName:(NSString *)aString {
    [name release];
    name = [aString copy];
  }

- Ainda há uma terceira opção para uma @property: "@property (assign) id delegate;". O "assign" é usado em casos onde o objeto passado para o setter é **dono** do objeto com a @property. Exemplo: Um Controller e suas Views (porque uma View nunca pode "viver" mais que seu Controller). A View pode ter uma @property (delegate é bem comum) que então é "assign"ed para o Controller.

  @property (assign) NSString *name;
  //@synthesize irá gerar o seguinte setter para *name
  - (void)setName:(NSString *)aString {
    name = aString;
  }

Kick ass!!!