关闭

黑马程序员——OC基础---面向对象(思想,类,对象,三大特性)

329人阅读 评论(0) 收藏 举报

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------

面向对象和面向过程思想

OC是面向对象的,C是面向过程的。面向对象和面向过程只是解决问题的两种不同思想

面向对象和面向过程的区别

以用电脑听歌为例子

面向过程

打开电脑 

播放电脑中的歌曲 

关闭电脑


面向对象

电脑   

开机   

播放歌曲   

关机


区别分析

面向过程关注的是解决问题需要哪些步骤;面向对象关注的是解决问题需要哪些对象

没有开发经验很难感受到它们的区别,两种思想都能达到解决问题的目的,但是解决思路不一样


现实生活中面向对象的例子

想打电话\发短信 找手机,不用分析电话要怎样才能拨通

去饭店吃饭 找服务员,不用分析怎么到厨房炒菜

汽车坏了 找汽车维修工,不用分析修车的步骤

境界:万物皆对象


常用术语

面向过程 Procedure Oriented

面向对象 Object Oriented,简称OO

面向对象编程 Object Oriented Programming,简称OOP


类和对象的关系

面向对象中有2个非常重要的概念:类和对象

如何创建对象

面向对象解决问题的时候必须有对象,那如何创建对象呢?


现实生活的例子:如何创造汽车对象?

需要先有汽车的建造图纸,图纸上描述清楚汽车应该具备的属性和功能(行为)

属性:轮子数、时速

功能(行为):跑

然后再根据图纸上的描述生成汽车

每一辆汽车都是对象,都有自己具体的属性值,都是图纸的实例

图纸是抽象的,房子是具体的。图纸是对房子对象的高度概括


OC中的面相对象

OC中的相当于图纸,用来描述一类事物。也就是说,要想创建对象,必须先有类

OC利用类来创建对象,对象是类的具体存在

因此,面向对象解决问题应该是先考虑需要设计哪些类,再利用类创建多少个对象


需要设计哪些类,如何设计类

类的设计,只关心3样东西:

事物名称(类名):人(Person

属性:身高(height)、年龄(age

行为(功能):跑(run)、打架(fight


一般名词都是类

坦克发射3颗炮弹轰掉了2架飞机

小明在公车上牵着一条叼着热狗的狗


拥有相同(或者类似)属性和行为的对象都可以抽像出一个类

愤怒的小鸟游戏界面



植物大战僵尸



新浪微博



类名、属性、行为练习

僵尸、炮弹、车、学生、书本


哪个对象最清楚这个行为,就把这个行为写到哪个对象中去。打开电脑(开机)这个行为应该是属于电脑的。





定义OC的类和创建OC的对象

接下来就在OC中模拟现实生活中的情况,创建一辆车出来。首先要有一个车子类,然后再利用车子类创建车子对象

要描述OC中的类稍微麻烦一点,分2大步骤:类的声明类的实现(定义)。跟函数类似,函数有分声明和定义

类的声明


示例:

定义一个Car类,拥有2个属性:轮子数、时速,1个行为:跑

类名\属性的命名规则:标示符的规则

类名的命名规范:有意义、驼峰标识、首字母大写

/*
 类名:Car
 属性:轮胎个数、时速(速度)
 行为:跑
 */

// 因为使用了NSObject
#import <Foundation/Foundation.h>

// 完整地写一个函数:函数的声明和定义(实现)
// 完整地写一个类:类的声明和实现

// 1.类的声明
// 声明对象的属性、行为
// : NSObject 目的是:让Car这个类具备创建对象的能力
@interface Car : NSObject
{// 用来声明对象属性(实例变量\成员变量,默认会初始化为0)
    // @public可以让外部的指针间接访问对象内部的成员变量
    @public
    int wheels; // 轮胎个数
    int speed; // 时速(xxkm/h)
}

// 方法(行为):方法名、参数、返回值(声明、实现)
// 只要是OC对象的方法,必须以减号 - 开头
// OC方法中任何数据类型都必须用小括号()扩住
// OC方法中的小括号():括住数据类型
- (void)run;

@end

// 2.类的实现
// 用来实现@inteface中声明的方法
@implementation Car
// 方法的实现(说清楚方法里面有什么代码)

- (void)run
{
    NSLog(@"车子跑起来了");
}

@end

int main()
{
    // 在OC中,想执行一些行为,就写上一个中括号[行为执行者 行为名称]
    // 利用类来创建对象
    // 执行了Car这个类的new行为来创建新对象
    
    // 定义了一个指针变量p,p将来指向的是Car类型的对象
    // [Car new]每次都会创建出一个新对象,并且会返回新对象本身(新对象的地址)
    Car *p = [Car new];
    
    
    Car *p2 = [Car new];
    p2->wheels = 5;
    p2->speed = 300;
    [p2 run];
    
    // 给p所指向对象的wheels属性赋值
    p->wheels = 4;
    p->speed = 250;
    
    // 给p所指向对象发送一条run消息
    [p run];
    
    NSLog(@"车子有%d个轮子,时速位:%dkm/h", p->wheels, p2->speed);
    
    return 0;
}

运行结果:



面向对象封装的好处

更加接近人类的思考方式

只需要关注对象,不需要关注步骤


对象与函数参数

对象成员变量作为函数参数

指向对象的指针作为函数参数

修改指向指向对象的成员

修改指针的指向


类的声明和实现

@interface@implementation的分工


@interface就好像暴露在外面的时钟表面

@implementation就好像隐藏在时钟内部的构造实现


声明和定义多个类


常见错误

只有类的声明,没有类的实现

漏了@end

@interface@implementation嵌套

两个类的声明嵌套

成员变量没有写在括号里面

方法的声明写在了大括号里面


语法细节

成员变量不能在{}中进行初始化、不能被直接拿出去访问

方法不能当做函数一样调用

成员变量\方法不能用static等关键字修饰,别跟C语言混在一起(暂时忽略)

类的实现可用写在main函数的后面,主要在声明后面就行了


OC方法和函数的区别

OC方法只能声明在@interface@end之间,只能实现在@implementation@end之间。也就是说OC方法不能独立于类存在

C函数不属于类,跟类没有联系,C函数只归定义函数的文件所有

C函数不能访问OC对象的成员

低级错误:方法有声明,但是实现的时候写成了函数


OC的方法注意

方法只有声明,没有实现(经典错误)

方法没有声明,只有实现(编译器警告,但是能调用,OC的弱语法)

编译的时候:访问没有的成员变量直接报错,访问没有的方法,只是警告


@implementation

没有@interface,只有@implementation,也是能成功定义一个类的

@implementation Car : NSObject

{

    @public

    int wheels; // 多少个轮子

    int speed; // 时速

}

- (void) run

{

    NSLog(@"%i个轮子,%i时速的车子跑起来了", wheels, speed);

}

@end

@implementation中不能声明和@interface一样的成员变量


方法

设计一个Caculator计算器类,它拥有计算的功能(行为)

不带参数的方法

设计一个返回PI的方法

// 方法声明

- (double)pi;

// 方法实现

- (double)pi

{

    return 3.14;

}


方法调用


带一个参数的方法

设计一个计算平方的方法

// 方法声明

- (double)square:(double)number;

// 方法实现

- (double)square:(double)number

{

    return number * number;

}


方法调用



带多个参数的方法

设计一个计算和的方法

// 方法声明

- (double)sumOfNum1:(double)num1 andNum2:(double)num2;

// 方法实现

- (double)sumOfNum1:(double)num1 andNum2:(double)num2

{

    return num1 + num2;

}


方法调用


方法名注意

冒号也是方法名的一部分

同一个类中不允许两个对象方法同名






set方法和get方法

set方法和get方法的使用场合

@public的成员可以被随意赋值,应该使用set方法和get方法来管理成员的访问(类似机场的安检、水龙头过滤,过滤掉不合理的东西),比如僵尸的生命值不能为负数

set方法

作用:用来设置成员变量,可以在方法里面过滤掉一些不合理的值

命名规范:

方法都是以set开头,而且后面跟上成员变量名,成员变量名的首字母必须大写

形参名称不要跟成员变量同名

get方法

作用:返回对象内部的成员变量

命名规范:get方法的名称一般就跟成员变量同名

成员变量的命名规范

成员变量都以下划线 _ 开头

可以跟get方法的名称区分开

可以跟其他局部变量区分开,一看到下划线开头的变量,肯定是成员变量

代码示例

#import <Foundation/Foundation.h>

// 声明

@interface Car : NSObject

{

    int _wheels; // 轮子个数

}

/*set方法*/

- (void) setWheels:(int)wheels;

/*get方法*/

- (int) wheels;

@end


@implementation Car

// set方法的实现

- (void) setWheels:(int)wheels

{

    //对外面传进来的轮子数进行过滤

    if (wheels<=0)

    {

        wheels = 1;

    }

    

    _wheels = wheels;

}


// get方法的实现

- (int) wheels

{

    return _wheels;

}

@end

封装的好处

过滤不合理的值

屏蔽内部的赋值过程

让外界不必关注内部的细节


示例:

/*
 人
 类名:Person
 属性(成员变量\实例变量):体重、年龄
 行为(方法):走路、吃
 */
#import <Foundation/Foundation.h>
/*
 1.类的声明
    * 成员变量
    * 方法的声明
 */
@interface Person : NSObject
{
    @public
    int age;
    double weight;
}

- (void)walk;
- (void)eat;

@end


// 2.类的实现
@implementation Person

// 实现@interface中声明的方法
- (void)walk
{
    NSLog(@"%d岁、%f公斤的人走了一段路", age, weight);
}

- (void)eat
{
    NSLog(@"%d岁、%f公斤的人在吃东西", age, weight);
}

@end

int main()
{
    // 在使用类创建对象之前,会将类加载进内存
    Person *p = [Person new];
    p->age = 20;
    p->weight = 40;
    
    [p eat];
    [p walk];
    
    Person *p2 = [Person new];
    p2->age = 30;
    p2->weight = 60;
    [p2 eat];
    [p2 walk];
    
    /*
    Person *p2 = [Person new];
    p2->age = 30;
    p2->weight = 50;
    
    p = p2;
    
    p->age = 40;
    
    [p2 walk];
    */
    
    /*
    Person *p = [Person new];
    p->age = 20;
    
    Person *p2 = [Person new];
    p2->weight = 50.0;
    
    [p walk];
     */
     
    /*
    Person *p = [Person new];
    p->age = 20;
    p->weight = 50.0;
    [p walk];
    
    Person *p2 = [Person new];
    p2->age = 30;
    p2->weight = 60.0;
    [p2 walk];
    */
    return 0;
}




类方法

基本概念

直接可以用类名来执行的方法(类本身会在内存中占据存储空间,里面有类\对象方法列表)

类方法和对象方法对比

对象方法

以减号-开头

只能让对象调用,没有对象,这个方法根本不可能被执行

对象方法能访问实例变量(成员变量)


类方法

以加号+开头

只能用类名调用,对象不能调用

类方法中不能访问实例变量(成员变量)

使用场合:当不需要访问成员变量的时候,尽量用类方法

类方法和对象方法可以同名


示例:


/*
 设计一个计算器类
 * 求和
 * 求平均值
 */

#import <Foundation/Foundation.h>

// 工具类:基本没有任何成员变量,里面的方法基本都是类方法
@interface JiSusnQi : NSObject
+ (int)sumOfNum1:(int)num1 andNum2:(int)num2;

+ (int)averageOfNum1:(int)num1 andNum2:(int)num2;
@end

@implementation JiSusnQi
+ (int)sumOfNum1:(int)num1 andNum2:(int)num2
{
    return num1 + num2;
}

+ (int)averageOfNum1:(int)num1 andNum2:(int)num2
{
    int sum = [JiSusnQi sumOfNum1:num1 andNum2:num2];
    return sum / 2;
}
@end

int main()
{
    int a = [JiSusnQi averageOfNum1:10 andNum2:12];
    
    NSLog(@"a=%d", a);
    
//    JiSusnQi *jsq = [JiSusnQi new];
//    
//    
//    [jsq sumOfNum1:10 andNum2:13];
    
    return 0;
}

运行结果:



self关键字

成员变量和局部变量同名

当成员变量和局部变量同名时,采取就近原则,访问的是局部变量

self访问成员变量,区分同名的局部变量

使用细节

出现的地方:所有的OC方法中(对象方法\类方法),不能出现在函数

作用

使用 "self->成员变量名"访问当前方法调用的成员变量

使用 "[self 方法名];"来调用方法(对象方法\类方法)

常见错误

低级错误:self去调用函数

类方法中用self调用对象方法,对象方法中用self调用类方法

self死循环


示例:


计算器类,计算平均值的调用求和方法

/*
 设计一个计算器类
 * 求和
 * 求平均值
 */

#import <Foundation/Foundation.h>

// 工具类:基本没有任何成员变量,里面的方法基本都是类方法
@interface JiSusnQi : NSObject
+ (int)sumOfNum1:(int)num1 andNum2:(int)num2;

+ (int)averageOfNum1:(int)num1 andNum2:(int)num2;
@end

@implementation JiSusnQi
+ (int)sumOfNum1:(int)num1 andNum2:(int)num2
{
    return num1 + num2;
}

+ (int)averageOfNum1:(int)num1 andNum2:(int)num2
{
    // 在这种情况下,self代表类
    int sum = [self sumOfNum1:num1 andNum2:num2];
    return sum / 2;
}
@end

int main()
{
    int a = [JiSusnQi averageOfNum1:10 andNum2:12];
    
    NSLog(@"a=%d", a);
    
//    JiSusnQi *jsq = [JiSusnQi new];
//    
//    
//    [jsq sumOfNum1:10 andNum2:13];
    
    return 0;
}

运行结果:



示例:

设计一个方法,用来和其他车比较车速,返回车速的差距

#import <Foundation/Foundation.h>

@interface Car : NSObject
{
    @public
    int speed;
}

- (int)compareSpeedWithOther:(Car *)other;

@end

@implementation Car

- (int)compareSpeedWithOther:(Car *)other
{
    // speed
    // other->speed
    // 返回当前这辆车和other这辆车的速度差距
    return speed - other->speed;
}

@end

int main()
{
    Car *c1 = [Car new];
    c1->speed = 300;
    
    Car *c2 = [Car new];
    c2->speed = 250;
    
    int a = [c1 compareSpeedWithOther:c2];
    
    NSLog(@"a=%d", a);
    
    return 0;
}

运行结果:






继承

继承的基本用法

设计两个类BirdDog

// Bird的声明

@interface Bird : NSObject

{

    @public

    int weight;

}

- (void)eat;

@end

// Bird的定义

@implementation Bird

- (void)eat {

    NSLog(@"吃吃吃-体重:%d", weight);

}

@end

// Dog的声明

@interface Dog : NSObject

{

    @public

    int weight;

}

- (void)eat;

@end

// Dog的定义

@implementation Dog

- (void)eat {

    NSLog(@"吃吃吃-体重:%d", weight);

}

@end

有相同的属性和行为,抽出一个父类Animal(先抽取weight属性,再抽取eat方法)

// Animal的声明

@interface Animal : NSObject

{

    @public

        int weight;

}

- (void)eat;

@end

// Animal的定义

@implementation Animal

- (void)eat {

    NSLog(@"吃吃吃-体重:%d", weight);

}

@end

子类在父类的基础上拓充属性和方法

// Bird的声明

@interface Bird : Animal

{

    @public

        int height;

}

- (void)fly;

@end


// Bird的定义

@implementation Bird

- (void)fly {

    NSLog(@"飞飞飞-高度:%d", height);

}

@end


// Dog的声明

@interface Dog : Animal

{

    @public

        int speed;

}

- (void)run;

@end

// Dog的定义

@implementation Dog

- (void)run {

    NSLog(@"跑跑跑-高度:%d", speed);

}

@end

子类方法和属性的访问过程:如果子类没有,就去访问父类的

父类被继承了还是能照常使用的

父类的静态方法

画继承结构图,从子类抽取到父类

NSObject的引出:全部OC类的最终父类,包含了一些常用方法,比如+new


继承的专业术语

父类\超类  superclass

子类  subclass\subclasses


继承的细节

单继承

子类和父类不能有相同的成员变量

方法的重写


示例:

/*
 1.重写:子类重新实现父类中的某个方法,覆盖父类以前的做法
 2.注意
 1> 父类必须声明在子类的前面
 2> 子类不能拥有和父类相同的成员变量
 3> 调用某个方法时,优先去当前类中找,如果找不到,去父类中找
 
 2.坏处:耦合性太强
 */

#import <Foundation/Foundation.h>
// Person
@interface Person : NSObject
{
    int _age;
}

- (void)setAge:(int)age;
- (int)age;

- (void)run;

+ (void)test;

@end

@implementation Person

+ (void)test
{
    NSLog(@"Person+test");
}

- (void)run
{
    NSLog(@"person---跑");
}

- (void)setAge:(int)age
{
    _age = age;
}
- (int)age
{
    return _age;
}
@end

// 不允许子类和父类拥有相同名称的成员变量
// Student
@interface Student : Person
{
    int _no;
    // int _age;
}

+ (void)test2;

@end

@implementation Student
// 重写:子类重新实现父类中的某个方法,覆盖父类以前的做法
- (void)run
{
    NSLog(@"student---跑");
}

+ (void)test2
{
    [self test];
}
@end


int main()
{
    [Student test2];
    
//    Student *s = [Student new];
//    
//    [s run];
    
    return 0;
}

运行结果:



示例:

#import <Foundation/Foundation.h>
/*
 1.继承的好处:
 1> 抽取重复代码
 2> 建立了类之间的关系
 3> 子类可以拥有父类中的所有成员变量和方法
 
 2.注意点
 1> 基本上所有类的根类是NSObject
 */


/********Animal的声明*******/
@interface Animal : NSObject
{
    int _age;
    double _weight;
}

- (void)setAge:(int)age;
- (int)age;

- (void)setWeight:(double)weight;
- (double)weight;
@end

/********Animal的实现*******/
@implementation Animal
- (void)setAge:(int)age
{
    _age = age;
}
- (int)age
{
    return _age;
}

- (void)setWeight:(double)weight
{
    _weight = weight;
}
- (double)weight
{
    return _weight;
}
@end

/********Dog*******/
// : Animal 继承了Animal,相当于拥有了Animal里面的所有成员变量和方法
// Animal称为Dog的父类
// Dog称为Animal的子类
@interface Dog : Animal
@end

@implementation Dog
@end

/********Cat*******/
@interface Cat : Animal
@end

@implementation Cat
@end

int main()
{
    Dog *d = [Dog new];
    
    [d setAge:10];
    
    NSLog(@"age=%d", [d age]);
    return 0;
}



super关键字

分别调用父类的对象方法和类方法

super的作用

 1.直接调用父类中的某个方法

 2.super处在对象方法中,那么就会调用父类的对象方法

   super处在类方法中,那么就会调用父类的类方法

 3.使用场合:子类重写父类的方法时想保留父类的一些行为


示例:

/*
 僵尸
 
 跳跃僵尸、舞王僵尸、铁桶僵尸
 */
#import <Foundation/Foundation.h>


// 僵尸
@interface Zoombie : NSObject
- (void)walk;

+ (void)test;
- (void)test;

@end

@implementation Zoombie
- (void)walk
{
    NSLog(@"往前挪两步******");
}

+ (void)test
{
    NSLog(@"Zoombie+test");
}

- (void)test
{
    NSLog(@"Zoombie-test");
}
@end

// 跳跃僵尸
@interface JumpZoombie : Zoombie
+ (void)haha;
- (void)haha2;
@end


@implementation JumpZoombie

+ (void)haha
{
    [super test];
}

- (void)haha2
{
    [super test];
}

- (void)walk
{
    // 跳两下
    NSLog(@"跳两下");
    
    // 走两下(直接调用父类的walk方法)
    [super walk];
    //NSLog(@"往前挪两步----");

}
@end

int main()
{
    //[JumpZoombie haha];
    JumpZoombie *jz = [JumpZoombie new];
    
    [jz haha2];
    
    return 0;
}

运行结果:


继承的好处

不改变原来模型的基础上,拓充方法

建立了类与类之间的联系

抽取了公共代码

坏处:耦合性强


继承的使用场合

它的所有属性都是你想要的,一般就继承

它的部分属性是你想要的,可以抽取出另一个父类


示例:

/*
1.继承的使用场合
 1> 当两个类拥有相同属性和方法的时候,就可以将相同的东西抽取到一个父类中
 2> 当A类完全拥有B类中的部分属性和方法时,可以考虑让B类继承A类
 A
 {
    int _age;
    int _no;
 }
 
 B : A
 {
    int _weight;
 }
 
 // 继承:xx 是 xxx
 // 组合:xxx 拥有 xxx
 
 2.组合
 A
 {
     int _age;
     int _no;
 }
 
 B
 {
     A *_a;
     int _weight;
 }
*/

@interface Score : NSObject
{
    int _cScore;
    int _ocScore;
}
@end

@implementation Score
@end

@interface Student : NSObject
{
    // 组合
    Score *_score;
//    int _cScore;
//    int _ocScore;
    int _age;
}
@end

@implementation Student

@end



多态

多态的基本概念

某一类事物的多种形态

OC对象具有多态性


多态的体现

Person *p = [Student new];

p->age = 100;

[p walk];

子类对象赋值给父类指针

父类指针访问对应的属性和方法


多态的好处

用父类接收参数,节省代码


多态的局限性

不能访问子类的属性(可以考虑强制转换)


多态的细节

动态绑定:在运行时根据对象的类型确定动态调用的方法


示例:

#import <Foundation/Foundation.h>

/*
 多态
 1.没有继承就没有多态
 2.代码体现:父类类型的指针指向子类对象
 3.好处:如果函数\方法参数中使用的是父类类型,可以传入父类、
    子类对象
 4.局限性:
 1》父类类型的变量 不能 直接调用子类特有的方法。必须强转为子类类型变量后,
    才能直接调用子类特有的方法
 2》
 */

@interface Animal : NSObject
- (void)eat;
@end

@implementation Animal
- (void)eat
{
    NSLog(@"Animal吃东西----");
}

@end

//狗
@interface Dog : Animal
- (void)run;

@end

@implementation Dog
- (void)run
{
    NSLog(@"Dog----跑起来");
}

- (void)eat
{
   NSLog(@"Dog吃东西----");
}

@end

//猫
@interface Cat : Animal

@end

@implementation Cat
- (void)eat
{
    NSLog(@"Cat吃东西----");
}


@end
//如果参数中使用的是父类类型,可以传入父类、子类对象
// 这个函数是专门用来喂动物的
void feed(Animal *a)
{
    [a eat];
}

int main()
{
    NSString *d = [Cat new];
    
    [d eat];
    //Animal *aa = [Dog new];
    // 多态的局限性:父类类型的变量 不能 用来调用子类的方法
    //[aa run];
    
    //将aa转为Dog *类型的方法
    //Dog *dd = (Dog *)aa;
    
    //[dd run];
    /*
     Animal *aa = [Animal new];
    
    feed(aa);
    
    Dog *dd = [Dog new];
    
    feed(dd);
    
    Cat *cc = [Cat new];
    
    feed(cc);
    */
    
    //NSString *s = [Cat new];
    //Cat *c = [Animal new];
    
    // 多种形态
    //Dog *d = [Dog new];
    
    // 多态:父类指针指向子类对象
    //Animal *a = [Dog new];
    
    // 调用方法时会检测对象的真实形象
    //[a eat];
    
    return 0;
}


运行结果:


NSString的简单使用

字符串的快速创建

NSStirng *str = @“Hello”;

使用静态方法创建

使用%@输出字符串

NSString *name = @”mj”;

NSLog(@“我的名字是%@”,  name);


示例:

#import <Foundation/Foundation.h>

int main()
{
    /*
     最简单的创建字符串的方式
    NSString *str = @"itcast";
    
    char *name = "itcast";
    
    NSLog(@"我在%@上课", str);
    //NSLog(@"%s", name);
    */
    
    int age = 10;
    int no = 5;
    NSString *name = @"jack";
    
    int size = [name length];
    
    NSLog(@"%d", size);
    // 创建OC字符串的另一种方式
    NSString *newStr = [NSString stringWithFormat:@"My age is %d and no is %d and name is %@", age, no, name];
    
    
    
    NSLog(@"----%ld", [newStr length]);
    
    return 0;
}

运行结果:





0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:3686次
    • 积分:216
    • 等级:
    • 排名:千里之外
    • 原创:19篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章存档