Section 1
Preview this deck
@property (nullable)
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
4 years ago
Date created
Mar 1, 2020
Cards (73)
Section 1
(50 cards)
@property (nullable)
- optional - pointer may have a NULL or nil value - For Xcode 7+ (Like ? in Swift)
@property (weak)
- Create a non-owning relationship between the property and the assigned value. - Use this to prevent retain cycles. - Makes it possible to maintain a cyclical relationship (the children should store a __ reference back to the parent) - Is a possibility that the obj will be destroyed while the related obj still has a reference to it. Should this happen, the __ attribute will conveniently set the property to nil in order to avoid a dangling pointer.
SEL | data type
- Used to store selectors, which are Objective-C's internal representation of a method name. -------------- Example: __ stepOne = NSSelectorFromString(@"startEngine"); __ stepTwo = @selector(sayHello); // end with colon if the method has parameters __ stepThree = @selector(turnByAngle:quickly:);
@property (readonly)
- Don't synthesize a setter method - Prevents assignment via dot-notation - The getter is unaffected.
Closure
- Inside of a block, you have access to same data as in a normal function: local variables, parameters passed to the block, and global variables/functions. - Have access to non-local variables. - Creates a snapshot of the variables. They are frozen at whatever value they contain when the block is defined, and the block always uses that value, even if the non-local variable changes later on in the program. - An incredibly convenient way to work with the surrounding state. - Eliminates the need to pass in extra values as parameters—you simply use non-local variables as if they were defined in the block itself.
Independent automatic variables
- Default - __ declared inside of a function are reset each time the function is called. - The function behaves consistently regardless of how many times you call it. -------------- Example: NSLog(@"%d", countTwo()); // 2 NSLog(@"%d", countTwo()); // 2 NSLog(@"%d", countTwo()); // 2
id | data type
- The generic type for all Objective-C objects. - Object-oriented version of C's void pointer. - Can store a reference to any type of object. - The __ type automatically implies that the variable is a pointer, so this is not necessary to be declared with pointer notation (the asterisk *) -------------- Example: __ mysteryObject = @"An NSString object"; // String mysteryObject = @{@"model": @"Ford", @"year": @1967}; // Dictionary
Function
- They let you reuse an arbitrary block of code throughout your application. - Are code blocks that are unrelated to an object / class, just inherited from c. - Has no implicit arguments - everything it needs must be passed in. - It does not alter the state of the object. - Use if the code is used frequently within a given class, or throughout the project, that it warrants being generalized. - Use if it has no side-effects or context dependancies (none of that void *context mess). -------------- Example: RETURN_TYPE NAME(TYPE PARM-NAME, TYPE PARM-NAME...) {} int foo(int a, int b) { return a+b; } // call int ab; ab = foo(a, b);
NSNull
- empty/zero/nothing - is a Class pointer - Defines a singleton object used to represent null values in collection objects(NSArray,NSDictionary) and other situations where nil isn't allowed. -------------- Example: The [__ null] will returns the singleton instance of __.
@property (copy)
- Create a __ of the assigned value instead of referencing the existing instance. - The __ attribute is an alternative to strong. Instead of taking ownership of the existing object, it creates a __ of whatever you assign to the property, then takes ownership of that. - Create another object with duplicate values/a clone. - You do NOT share the clone/new instance with whomever passed it to you. - Has the added perk of freezing the object at whatever value it had when it was assigned. - Properties that represent values (opposed to connections or relationships) are good candidates for __ (ex NSString)
@property (atomic)
- Locks the underlying object to prevent the setter and the getter of being called at the same time - Guarantees that the get or set operation is working with a complete value. @property are __ by default
Class Implementation
- is often used to contain the implementation code for the method(s) of a class. - This file is also referred to as a source file. - You don't need to include the super class. - Private instance variables can be stored between curly braces after the class name: -------------- Example: // Car.m #import "Car.h" @___ Car { // Private instance variables double _odometer; } @synthesize model = _model; // Optional for Xcode 4.4+ - (void)drive { NSLog(@"Driving a %@. Vrooooom!", self.model); } @end
primitive C data types
int, float, char, double
Class Interface
- The header file - After the @__ directive, comes the class and the superclass name, separated by a colon. - (Protected variables can be defined inside of the curly braces, but most developers treat instance variables as implementation details and prefer to store them in the .m file instead of the __). -------------- Example: // Car.h #import <Foundation/Foundation.h> @___ Car : NSObject { // Protected instance variables (not recommended) } @property (copy) NSString *model; - (void)drive; @end
void pointer
- Can store a reference to any type of object.
Static Functions
- Private - Lets you limit the function's scope to the current file, which is useful for creating "private" functions and avoiding naming conflicts. - Note that the __ keyword should be used on both the function declaration and implementation. (By default, all functions have a global scope. This means that as soon as you define a function in one file, it's immediately available everywhere else. )
Frame
- How the view relates to the superView. - Its more about the superview knowing how big a view is, and is related to where the view lies within the superviews coordinate grid.
@property (nonnull)
- non-optional - pointer may NOT have a NULL or nil value - For Xcode 7+ (Like ! in Swift)
static
- Lets you alter the availability of a function or variable. Unfortunately, it has different effects depending on where you use it: __ Functions: By default, all functions have a global scope. The __ specifier lets you limit the function's scope to the current file. __ Local Variables: Variables retain their assigned values over repeated calls to the function.
Bounds
- The drawable area inside the view itself. - The view's coordinate system. - __ origin can be moved from (0,0) which is useful in placing scrollview's view to highlight a different area.
Class methods
- Declarations AND implementation are prefixed with a plus sign instead of a minus sign. - These are commonly called "static" __/properties in other programming languages (not to be confused with the static keyword). - Use the same square-bracket syntax as __, but they must be called directly on the class, as shown below. -------------- Example: + (void) setDefaultModel: (NSString *) aModel { _defaultModel = [aModel copy]; } --------------- // main.m [Car setDefaultModel:@"Nissan Versa"];
custom initialization method
- Own versions definition to accept configuration parameters. - Like normal instance methods, except the method name should always begin with __. - Should always return a reference to the object itself, and if it cannot be initialized, it should return nil. - We need to check if self exists before trying to use it. ( There should typically only be one initialization method that needs to do this, and the rest should forward calls to this designated initializer. ) -------------- Example: // Car.m - (id) initWithModel: (NSString *) aModel { self = [super init]; if (self) { // Any custom setup work goes here _model = [aModel copy]; _odometer = 0; } return self; }
super | keyword
The __ keyword refers to the parent class.
Parameterless Blocks
- If a __ doesn't take any parameters, you can omit the argument list in its entirety. - Specifying the return type of a block literal is always optional, so you can shorten the notation to ^ { ... }: -------------- Example: double (^randomPercent)(void) = ^ { return (double)arc4random() / 4294967295; }; NSLog(@"Gas tank is %.1f%% full", randomPercent() * 100);
Class initialization
- Allocate some memory for the object by calling the alloc method - Then you need to __ it so it's ready to use. You should never use an uninitialized object. -------------- Example: Car *toyota = [[Car alloc] init];
Function declaration
- Tells the compiler what the __'s inputs and outputs look like. - Provides the data types for the return value and the parameters - So that the __ can be used in main() without knowing what it actually does. - Notice that the __ only needs the data types of the parameters—their names can be omitted (if desired).. -------------- Example: NSString getRandomMake(NSArray );
initialize method
- The class-level equivalent of init - It gives you a chance to set up the class before anyone uses it. - Before the first time the class is used, [Car __] is called automatically! (it's good practice to use the self == [Car class] conditional to ensure that the __ code is only run once) . -------------- Example: // Car.m + (void) __ { if (self == [Car class]) { // Makes sure this isn't executed more than once _defaultModel = @"Nissan Versa"; } }
@property (nonatomic)
- Don't guarantee the integrity of accessors in a multi-threaded environment. This is more efficient than the default __ behavior. - For a NON multi-threaded environment or when you are implementing your own thread-safety - Can't guarantees that the get or set operation is working with a complete value... - Let you mix-and-match synthesized accessors with custom ones
@property (strong)
- Create an owning relationship between the property and the assigned value. - This is the default for object properties. - This ensures that it will be valid as long as another class needs it. - By convention, the parent object should maintain a __ reference with it's children.
Blocks
- Anonymous functions. - Let you pass arbitrary statements between objects as you would data, which is often more intuitive than referencing functions defined elsewhere. - Implemented as closures, making it trivial to capture the surrounding state. - Non-local variables are copied and stored with the __ as const variables, which means they are read-only. -------------- Example: // Declare double (^distanceFromRateAndTime)(double rate, double time); // Create and assign distanceFromRateAndTime = ^double (double rate, double time) { return rate * time; }; // Call double dx = distanceFromRateAndTime(35, 1.5);
@dynamic
- just tells the compiler that the getter and setter methods are implemented not by the class itself but somewhere else (like the superclass or will be provided at runtime). - tells the compiler "don't worry about it, a method is on the way." Uses for__ are e.g. with subclasses of NSManagedObject (CoreData) or when you want to create an outlet for a property defined by a superclass that was not defined as an outlet.
pointer notation
- - Recall that all Objective-C objects are referenced as pointers, so when they are statically typed, they must be declared with __. -------------- Example: NSString *mysteryObject
nil
- empty/zero/nothing - is an object value - is an id - should be used, if we are dealing with an object.
Method
- Represent the actions that an object knows how to perform. - Attached to class / instance (object) and you have to tell the class / object to perform them. -------------- Example: - (RETURN_TYPE) NAME (TYPE PARM-NAME, TYPE PARM-NAME...) {} // declaration - (int) foo { return 0; } // call int a; a = [someObjectOfThisClass foo]; [porsche initWithModel:@"Porsche" mileage:42000.0];
@property | Properties
- Represent an object's data. - An attribute of your object that can be accessed - Lets other objects inspect or change its state (with accessor methods) - Automatically generates these accessor methods - Is set in the .h file
typedef | keyword
- Used to give a type a new name. - limited to giving symbolic names to types -------------- Example: __ struct Books { NSString *title; NSString *author; NSString *subject; int book_id; } Book; __ unsigned char byte; // byte is the new name
Method Naming Conventions
- Don't abbreviate anything. - Explicitly state parameter names in the method itself. - Explicitly describe the return value of the method.
NULL
- empty/zero/nothing - is a void * (generic pointer value) - should be used, if we are not dealing with an object. (ex: check if struct is empty or not ) - Key-value observing the context should be a C pointer or an object reference. Here for the context we have to use __.
Mutable Non-Local Variables
- Like static local variables in normal functions. - Serves as a "memory" between multiple calls to a block. - You can override the const copy behavior by declaring a non-local variable with the __block storage modifier. - Capture the variable by reference, creating a direct link between the variable outside the block and the one inside the block. - You can now assign a new value to make from outside the block, and it will be reflected in the block, and vice versa. -------------- Example: __block NSString *make = @"Honda";
Static Local Variables
- The function "remembers" its value across invocations. - Uses same value / same spot in the memory every time. - __ variables retain their assigned values over repeated calls to the function. Example: NSLog(@"%d", countByTwo()); // 2 NSLog(@"%d", countByTwo()); // 4 NSLog(@"%d", countByTwo()); // 6
Instance variables | ivars
- A simple pointer to an object or C primitive (float,int) - A storage slot - Private (Only the class and subclasses can access them) - Strong by default in ARC code Declared in either the header (.h) or in the implementation file (.m). Inside the { }.
#define
- Used to define the aliases for various data types - Can be used to define alias for values as well, like you can define 1 as ONE, etc. - __ statements are processed by the pre-processor. -------------- Example: __ TRUE 1 __ FALSE 0
@synthesize
- Optional for Xcode 4.4+ - generate getter and setter methods for your property (at compile time (although as noted in the "Mixing Synthesized and Custom Accessors" section it is flexible and does not generate methods for you if either are implemented) )
self | keyword
- The __ keyword refers to the instance calling the method. - Note that in class methods, the __ keyword refers to the class itself, not an instance.
Function implementation
Attaches a code block to the declared function. -------------- Example: NSString getRandomMake(NSArray makes) { int maximum = (int)[makes count]; int randomIndex = arc4random_uniform(maximum); return makes[randomIndex]; }
class-level method
- The easiest way to get a class object. -------------- Example: // returns an object representing the Car class. [Car class]
Selectors
- Objective-C's internal representation of a method name. - Let you treat a method as an independent entity. - Enabling you to separate an action from the object that needs to perform it. - Part of Objective-C's dynamic typing system. - Can be executed on an arbitrary object via performSelector: and related methods.
Class
- Made of two files: .h (heder) | Interface | Public Properties + Method declarations .m | Implementation of Methods
Accessor methods
- Getters or Setters - Lets other objects inspect or change its state
Instance method
- Declarations AND implementation are prefixed with a minus sign instead of a plus sign.
Section 2
(23 cards)