- 新建一个Car类：
1.在Car.h中进行属性和方法的创建：
@property (nonatomic,retain) NSString *brand;
@property (nonatomic,assign) NSInteger price;
@property (nonatomic,assign) NSString *color;
//初始化方法：-开头
- (instancetype)initWithBrand:(NSString *)brand Price:(NSInteger)price Color:(NSString *)color;
//便利构造器
+(instancetype)carWithBrand:(NSString *)brand price:(NSInteger)price color:(NSString *)color;
2.涉及到的知识点：
属性的特性：
nonatomic：非原子性（线程不安全的），线程安全会影响系统性能，造成卡顿
assign：不实行OC中的内存管理机制，通常用于修饰非对象类型，如int float等
retain：实行OC的内存管理机制，通常用于修饰对象类型，如NSString等
readonly：只读的，只生成getter方法，不生成setter方法
3.在Car.m中进行初始化方法及便利构造器的实现：
- (instancetype)initWithBrand:(NSString *)brand Price:(NSInteger)price Color:(NSString *)color{
self = [super init];
if (self) {
_brand = brand;
_price = price;
_color = color;
}
return self;
}
+(instancetype)carWithBrand:(NSString *)brand price:(NSInteger)price color:(NSString *)color{
return [self carWithBrand:@"奔驰" price:230000 color:@"黑色"];
}
- 实现方法的简便操作：将.h中声明的方法复制粘贴到.m中，删除最后的分号“;”，然后空格一下左边添加一个大括号，回车，然后在大括号内进行语句添加。
- 在主函数中的实现：
1.先导入头文件：
#import "Car.h"
2.进行对象的创建并调用类方法:
Car *car = [[Car alloc]init];
car.brand = car.brand;
NSLog(@"修改后：%@",car.brand);
- 新建一个Person类：
1.先导入头文件：
#import "Person.h"
2.在.h中进行属性和方法的创建：
@interface Person : NSObject {
NSString *_name;
NSInteger _age;
NSString *_sex;
}
+(instancetype)personWithName:(NSString *)name age:(NSInteger)age;
- (instancetype)initWithName:(NSString *)name;
- (instancetype)initWithAge:(NSInteger)age;
- (instancetype)initWithName:(NSString *)name Age:(NSInteger)age;
- (void)setName:(NSString *)name;
- (NSString *)name;
- (void)setAge:(NSInteger)age;
- (NSInteger)age;
- (void)setSex:(NSString *)sex;
- (NSString *)sex;
-(void)study;
@end
3.在Person.m中进行实现：
//重写父类初始化方法
- (instancetype)init
{
self = [super init];
return [self initWithName:@"mc海杰" Age:44];
}
- (instancetype)initWithName:(NSString *)name {
return [self initWithName:name Age:0];
}
- (instancetype)initWithAge:(NSInteger)age {
return [self initWithName:@"海杰" Age:age];
}
//指派初始化方法
- (instancetype)initWithName:(NSString *)name Age:(NSInteger)age {
//调用父类的初始化方法
self = [super init];
if (self) {
_name = name;
_age = age;
}
return self;
}
- (void)setName:(NSString *)name{
_name = name;
}
- (NSString *)name{
return _name;
}
- (void)setAge:(NSInteger)age{
_age = age;
}
- (NSInteger)age{
return _age;
}
- (void)setSex:(NSString *)sex{
_sex = sex;
}
- (NSString *)sex{
return _sex;
}
-(void)study {
NSLog(@"老师学习");
}
4.在主函数中实现：
//setter getter方法
Person *person = [[Person alloc]init];
[person setName:@"小明"];
[person setAge:20];
[person name];
[person age];
person.name = @"张三";
person.age = 12;
- 新建一个Student类：
- 在.h里进行属性方法的声明：
@interface Student : Person {
NSString *_school;
NSInteger _number;
}
- (void)setSchool:(NSString *)school;
- (NSString *)school;
- (void)setNumber:(NSInteger)number;
- (NSInteger)number;
- (instancetype)initWithNumber:(NSInteger)number;
- (instancetype)initWithSchool:(NSString *)school;
- (instancetype)initWithSchool:(NSString *)school Number:(NSInteger)number;
- (void)study;
@end
2.在.m中进行方法的实现：
- (instancetype)init
{
if (self) {
return [self initWithSchool:@"集宁师范" Number:0];
}
return self;
}
- (void)setSchool:(NSString *)school{
_school = school;
}
- (NSString *)school {
return _school;
}
- (void)setNumber:(NSInteger)number {
_number = number;
}
- (NSInteger)number{
return _number;
}
- (instancetype)initWithNumber:(NSInteger)number {
return [self initWithSchool:@"" Number:235468];
}
- (instancetype)initWithSchool:(NSString *)school {
return [self initWithSchool:@"集宁师范" Number:0];
}
- (instancetype)initWithSchool:(NSString *)school Number:(NSInteger)number {
self = [super initWithName:@"" Age:45];
if (self) {
_school = school;
_number = number;
}
return self;
}
- (void)study {
//super是对父类的引用，这行代码相当于调用父类继承过来的study方法的实现
NSLog(@"学生学习");
[super study];
}
3.导入一个Student类头文件：
#import "Student.h"
4.在主函数中进行对象的创建和方法调用：
//初始化方法在生命周期内只调用一次
Student *s1 = [[Student alloc]initWithName:@"小六" Age:28];
Student *student = [[Student alloc]init];
student.name = @"小明";
student.age = 18;
student.sex = @"男";
student.school = @"XX中学";
student.number = 111110;
//study方法是在父类中实现的，student继承过来了，可以直接使用
[student study];
知识点：
1.继承
面向对象所提供的继承特性可以大大简化代码。把公共的⽅法和实例变量写在父类里，子类只需要写⾃己独有的实例变量和方法即可。
2.继承的特点
没有父类的类称为根类，OC中的根类是NSObject(祖宗)。
继承的上层：父类，继承的下层：子类。
继承的内容：所有实例变量和方法。
继承是单向的，不能相互继承。
继承具有传递性：A继承于B，B继承于C，A具有B和C的特征和⾏为。
如果子类不满意父类方法的实现，可以重写(overwrite)父类的方法。
3.super
super是编译器指令，并非对象。
作⽤:给super发消息，可以执⾏父类该⽅法的实现 。
重写从父类继承过来的方法的三种情况：
1️⃣完全以子类的实现内容为主，丢弃父类实现的内容。
2️⃣完全以父类的实现内容为主，没有子类实现的内容。
3️⃣既有父类对该方法的实现，也有子类对该方法的实现。
4.继承中方法的执行
OC中方法调用采用消息发送机制 [receiver message]
给CollegeStudent对象发送消息: study
查找本类中是否实现(重写)study方法。
如果没有，查找⽗类中study是否实现。
逐级向上查找，找到即执行。
如果NSObject也没实现，会抛出异常，引起Crash。
oc1.png
5.初始化方法
创建对象分两步:
为对象开辟空间。
进行初始化操作。
初始化⽅法的主要作用是:为某些实例变量赋初值。
初始化⽅法在对象的整个⽣命周期⾥只使⽤一次。
注：初始化方法是在对象的初始化阶段完成其实例变量的赋值操作，一个对象的初始化阶段只有一次，所以初始化方法只使用一次。
- (id)init {
//给super发送init消息：执行父类中实现的init方法
self = [super init];
//判断从父类继承过来的init方法是否初始化成功
if (self) {
//初始化设置
}
//返回初始化完成的对象
return self;
}
⼦类定义了除⽗类中公共实例变量之外的实例变量。
在⾃身的初始化⽅法中，优先向super发送init消息，初始化公共变量，初始化成功之后，再初始化⾃身特有变量，从⽽完成全部实例变量的初始化。
6.self
//self是系统关键字，在方法中指代当前方法的调用者。
//self在实例方法中，指代调用当前方法的对象。
- (void)objectMethod{
}
self在类方法中，指代当前类。
+ (void)classMethod {
}
7.初始化方法特征
初始化⽅法是 “-”方法。
id或者instancetype类型的返回值。
以init开头。
可以带0到多个参数。
内部实现:先执⾏super的初始化方法，再初始化⾃身变量，后return self
8.初始化过程
1️⃣⾃己的初始化⽅法中，优先调⽤父类的初始化方法。
2️⃣⽗类的初始化方法中再调用⽗类的初始化方法，依次往上调用。
3️⃣处于最上层的初始化完成之后，回到第二层的初始化方法中， 完成第二层的初始化。
4️⃣第二层的初始化完成之后，回到第三层的初始化方法中，依次执⾏初始化⽅法，直到本类的初始化方法完成。
9.指定初始化方法
一个类可以有多个初始化方法。
虽然可以有多个初始化方法，但是一个对象只能使用一个初始化方法。
如果要在对象初始化时，都要给实例变量赋初值，如何实现。
指定初始化方法： 无论调用哪一个初始化方法都会调用的初始化方法。
通常会把在初始化时想做的操作全部放到指定初始化方法中，这样就无需在每一个初始化方法中都要写一遍，简化代码，方便后期维护。
选取原则：一般选参数最多的初始化方法作为指定初始化方法。
10.便利构造器
封装了对象创建过程:
内部实现:封装了alloc和初始化操作，创建对象更加方便快捷。
1️⃣便利构造器是“+”方法。
2️⃣返回 本类型 的实例。
3️⃣⽅法名以类名开头。
4️⃣可以有0到多个参数。
11.便利构造器实现和使用
声明
(id)personWithName:(NSString *)name gender:(NSString *)gender;
实现
+ (id)personWithName:(NSString *)name gender:(NSString *)gender {
return [[Person alloc] initWithName:name gender:gender];
}
调用
Person *per = [Person personWithName:@"Frank" gender:@"男"];
网友评论