三大特性
//
// main.m
// 三大特性
//
// Created by 彭利民 on 14-4-5.
// Copyright (c) 2014年 彭利民. All rights reserved.
//
//面向对象的三大特性
//成员变量的封装. 继承.多态
//今天讲封装,封装非常重要,是一个编程代码规范,能保证数据的安全性
//Set方法
//#import <Foundation/Foundation.h>
//
//@interface Student : NSObject
//{
// //成员变量尽量不要用@public
// @public
// int _age;
//
//
//}
//- (void)study;
////提供一个方法给外界2规范
////设置age属性值
//////set方法
//////set方法
////1.作用:提供一个方法给外界设置成员变量值
////2.命名规范
////1>方法名必须以set开头
////2>set后面跟成员变量的名称,成员变量的首字母必须用大写
////3>set方法返回值一定是void
////4>一定要接受一个参数,而且参数类型跟成员变量类型一致
////5>形参的名称不能跟成员变量名一致
//- (void)setAge:(int)age; //方法名一定要记得加冒号.
//
//@end
//@implementation Student
//
//- (void)study
//{
//
// NSLog(@"%d岁的学生在学习",_age);
//}
//
//
//- (void)setAge:(int)age;
//{
// if(age <= 0)
// {
//
// age = 1; //注意,自己在这里犯错了,啊啊啊啊啊
//
// }
// _age = age;
//
//}
//
//@end
//
//int main()
//{
//
// Student *stu = [Student new];//简化思想,指针可以这样理解,直接理解为把变量赋值给对象,这个变量就代表着对象.
//
// stu->_age = -1;//假如是0岁的学生在学习呢,这样不合理,不合逻辑,那怎么办呢,只有对传进来的值进行过滤,把public去掉,不允许改变成员变量,想提供一种手段,写一个方法,让别人用这一个方法,用来改变我们成员变量的值
// [stu study];
// [stu setAge:-1];
// [stu study];
//
//
// return 0;
//}
////以后在开发中不能再写public,不然别人会看到内部结构,成员变量会暴露,会被扣分的.
////成员变量封装,set也是一个方法,行为,功能.是用创建的对象来调的,通过调用set方法,改变成员变量的值,达到预期目的.
// 现在只是提供一个接口,设置成员变量,但是有时候人会想查看成员变量的年龄等信息,为了让别人查看,又想不让直接访问成员变量又想让他能拿到成员变量的值, 提供一个手段,给别人去访问成员变量,要提供一种方法 就是get方法 get方法
////get方法
//1.作用:返回对象内部的成员变量
//2.命名规范
//1>肯定有返回值,返回值类型肯定与成员变量类型一致
//2>方法名跟成员变量名一样
//3>不需要接受任何参数
//
//面向对象的三大特性
//成员变量的封装.继承.多态
//封装非常重要,是一个编程代码规范,能保证数据的安全性
//Set方法
//#import <Foundation/Foundation.h>
//
//@interface Student : NSObject
//{
// //成员变量尽量不要用@public
//@public
// int _age;
//
//
//}
//- (void)study;
////提供一个方法给外界2规范
////设置age属性值
//////set方法
//////set方法
////1.作用:提供一个方法给外界设置成员变量值
////2.命名规范
////1>方法名必须以set开头
////2>set后面跟成员变量的名称,成员变量的首字母必须用大写
////3>set方法返回值一定是void
////4>一定要接受一个参数,而且参数类型跟成员变量类型一致
////5>形参的名称不能跟成员变量名一致
//- (void)setAge:(int)age;
//- (int)age;
//
//@end
//@implementation Student
//
//- (void)study
//{
//
// NSLog(@"%d岁的学生在学习",_age);
//}
//
//
//- (void)setAge:(int)age;
//{
// if(age <= 0)
// {
//
// age = 1; //注意,自己在这里犯错了,啊啊啊啊啊//这里是过滤传进来的值,不是成员变量值,所以修改时用了age=1;
//
// }
// _age = age;
//
//}
//- (int)age //注意age首字母不用大写.
//{
//
// return _age ;
//}
//@end
//
//int main()
//{
//
// Student *stu = [Student new];//简化思想,指针可以这样理解,直接理解为把变量赋值给对象,这个变量就代表着对象.
//
// stu->_age = -1;//假如是0岁的学生在学习吗,这样不合理,不合逻辑,那怎么办呢,只有对传进来的值进行过滤,把public去掉,不允许改变成员变量,想提供一种手段,让别人这一个方法,用来改变我们成员变量的值
// [stu study];
// [stu setAge:-1];
// [stu study];
// int s = [stu age];
// NSLog(@"学生年龄是%d",s);//两种写法
//
//
// NSLog(@"学生年龄是%d",[stu age]); //两种写法
//
//
// return 0;
//}
////以后在开发中不能再写public,不然别人会看到内部结构,成员变量会暴露,会被扣分的.
////成员变量封装,set也是一个方法,行为,功能.是用创建的对象来调的,通过调用set方法,改变成员变量的值,达到预期目的.
//
//
//
//
//封装的好处
//把我们的细节隐藏在里面.编程思想,意义在于那里?搞清每一行的作用.学习方法.代码写再多也没用.重点是关键思想,成为架构师没有思想是不行的.写任何代码想清楚是干什么的,
//如果有一些属性值对外界来说是只读(readonly)的不可写 只允许外界访问我的number,不允许外界修改我的number,不能用public,只需要提供get方法.
//也有只写的,比较少.只修改不允许访问.用set方法.
//
//
////成员变量的命名规范
//
////封装的细节
//
//#import <Foundation/Foundation.h>
//typedef enum
//{
// kSexMan,
// kSexWoman
//} Sex;
//
//
//@interface Student : NSObject
//{
// int _no;
// Sex _sex; //枚举也算一种数据类型.
//}
////age的 set 和 get 方法
//- (void)setSex:(Sex)sex;
//- (Sex)sex;
//- (void)setNo:(int)no;
//- (int)no;
//@end
//@implementation Student
//- (void)setNo:(int)no
//{
// _no = no;
//
//}
//- (int)no
//{
// return _no;
//}
//
//- (void)setSex:(Sex)sex
//{
//
// _sex = sex;
// }
//- (Sex)sex
//{
// return _sex;
//}
//@end
//
//int main()
//{
// Student *stu = [Student new];
// [stu setSex:kSexMan];
// int s = [stu sex];
// [stu setNo:10];
// NSLog(@"数字是%d",[stu no]);
//
// NSLog(@"性别是%d",s);
//
//
// NSLog(@"性别是%d",[stu sex]);
//
//
//
//}
//封装练习
//设计一个成绩类
//1>属性
//*C语言成绩(可读可写)
//*OC成绩(可读可写)
//*总分(只读)
//*平均分(只读)
//#import <Foundation/Foundation.h>
//@interface ChengJi : NSObject
//{
// int _scoreC;//C语言成绩
// int _scoreOc;//OC语言成绩
//}
//- (void)setScoreC:(int)scoreC;
//- (int)scoreC;
//- (void)setScoreOc:(int)scoreOc;
//- (int)scoreOc;
//- (int)total;
//- (int)average;
//@end
//@implementation ChengJi
//
//- (void)setScoreC:(int)scoreC
//{
// _scoreC = scoreC;
//}
//- (int)scoreC
//{
// return _scoreC;
//}
//- (void)setScoreOc:(int)scoreOc
//{
// _scoreOc = scoreOc;
//}
//- (int)scoreOc
//{
// return _scoreOc;
//
//}
//- (int)total
//{
// return _scoreOc + _scoreC;
//}
//- (int)average;
//{
// return (_scoreC + _scoreOc)/2;
//}
//
//@end
//
//int main()
//{
// ChengJi *c = [ChengJi new];
// [c setScoreC:80];
// [c setScoreOc:90];
// NSLog(@"c语言成绩%d",[c scoreC]);
//
// NSLog(@"oc语言成绩%d",[c scoreOc]);
//
// NSLog(@"总成绩%d",[c total]);
//
// NSLog(@"oc语言成绩%d",[c average]);
//
//
//
//}
//
//
//
//
//
//
//
//封装练习
//设计一个成绩类
//1>属性
//*C语言成绩(可读可写)
//*OC成绩(可读可写)
//*总分(只读)
//*平均分(只读)
//#import <Foundation/Foundation.h>
//@interface ChengJi : NSObject
//{
// int _scoreC;//C语言成绩
// int _scoreOc;//OC语言成绩
// int _sum;
// int _average;
//}
//- (void)setScoreC:(int)scoreC;
//- (int)scoreC;
//- (void)setScoreOc:(int)scoreOc;
//- (int)scoreOc;
//- (int)total;
//- (int)average;
//@end
//@implementation ChengJi
//
//- (void)setScoreC:(int)scoreC
//{
// _scoreC = scoreC;
// _sum = _scoreOc + _scoreC; //注意此处犯错,注意要把_scoreOc = scoreOc;放在加法和求平均之前
// _average = _sum/2;
//
//}
//- (int)scoreC
//{
// return _scoreC;
//}
//- (void)setScoreOc:(int)scoreOc
//{
// _scoreOc = scoreOc;
// _sum = _scoreOc + _scoreC; //注意此处犯错,注意要把_scoreOc = scoreOc;放在加法和求平均之前
// //监听成员变量改变.起到监听功能.
// _average = _sum/2; //设置成绩时,计算总分.设置成绩时,计算平均分.
//
//}
//- (int)scoreOc
//{
// return _scoreOc;
//
//}
//- (int)total
//{
// return _sum;
//}
//- (int)average;
//{
// return _sum/2;
//}
//
//@end
//
//int main()
//{
// ChengJi *c = [ChengJi new];
// [c setScoreC:80];
// [c setScoreOc:90];
// [c setScoreC:100];
//
// NSLog(@"c语言成绩%d",[c scoreC]);
//
// NSLog(@"oc语言成绩%d",[c scoreOc]);
//
// NSLog(@"总成绩%d",[c total]);
//
// NSLog(@"oc语言成绩%d",[c average]);
//
//
//
//}
//
//
//
//
//get set 方法是不是应该放在一起写
//如
//- (void)setScoreC:(int)scoreC
//{
//
//
//}
//- (int)scoreC
//{
//
//
//}
//OC弱语法 本质还是C语言.只不过是苹果公司给其包装了一件外衣而已
//#import <Foundation/Foundation.h>
//
//
//@interface Person : NSObject
//
//
//@end
//
//@implementation Person
//
//
//@end
//
//int main()
//{
// Person *p = [Person new];
// [p test]; //在xcode 5.0.2之前是不会抱错的吗???
// return 0;
//}
//
//[p test] 消息机制,给person对象发送了一个test消息.
//声明方法,而没有实现会报警告,能链接通过,运行时系统崩溃.OC是在运行中才会检测有没有实现相应的方法.
//没有声明只写实现,编译没有警告,链接没有警告,能运行成功.开发中还是要有声明实现的. 严格来说没有函数声明也能运行
//开发中一般会有类的声明,和实现,该写的东西还是要写,虽然编译器容错性很强.
//只有方法声明没有方法实现,系统崩溃,如果在手机上运行,会出现闪退,黑屏.最好不要出现闪退,经常闪退说明有Bug,一旦程序运行中出错,就会出现闪退.一定要注意.
//类方法 使用类名调用
//很多情况下用类方法提高性能
//#import <Foundation/Foundation.h>
//@interface Person : NSObject
////类方法都是以+开头
//+ (void)printClassName;
//
//
//@end
//@implementation Person
//
//+ (void)printClassName
//{
// NSLog(@"这个类叫person");
//
//}
//
//@end
//
//
//
//int main()
//{
// [Person printClassName]; //类方法
//// Person *p = [Person new]; //对象方法
// return 0;
//}
//
//person 类 中放有方法
//类方法与对象方法的区别
#import <Foundation/Foundation.h>
/*
对象方法
1>减号开头
2>只能由对象来调用
类方法
1>加号开头
2>只能由类名来调用;
3>类方法中不能访问成员变量(实例变量)
类方法的好处和使用场合
1>不依赖于对象,执行效率高
2>能用类方法,尽量用类方法
3>场合:当方法内部不需要使用到成员变量时,就可以改为类方法
可以允许类方法和对象方法同名.
*/
//@interface Person : NSObject
////类方法都是以+开头
//+ (void)printClassName;
//
//- (void)test;
//@end
//@implementation Person
//
//+ (void)printClassName
//{
// NSLog(@"这个类叫person");
//
//}
//- (void)test
//{
// NSLog(@"调用类test方法");
//}
//
//@end
//
//
//
//int main()
//{
// [Person printClassName]; //类方法
// Person *p = [Person new]; //对象方法
// //[p printClassName];//能编译链接通过,运行时会出现错误//unrecognized selecter sent to instance ~~~~
// //系统会认为现在调用的是类方法.
// [Person test];//编译有警告,但运行会报错,会认为test是类方法,会去person里找+号开头的类方法.
//
//
// return 0;
//}
//
//
////类方法名称可以和对象方法名称一样.
////- (void)test;
////+ (void)test;
//
//
//
//
//
//
////实例变量不能在类方法中访问,只有对象实例化后,才有实例变量,成员变量,没有进行对象创建,类中就不能对实例变量进行访问.
//
//
//
//
//
//类方法练习
/*
设计一个类
*求和
*求平均值
*/
//@interface JiSuanQi : NSObject
//
//- (int)sumOfNum1:(int)num1 andNum2:(int)num2;
//- (int)averageOfNum1:(int)num1 andNum2:(int)num2;
//
//@end
//
//@implementation JiSuanQi
//- (int)sumOfNum1:(int)num1 andNum2:(int)num2
//{
//
// return num1 +num2;
//}
//- (int)averageOfNum1:(int)num1 andNum2:(int)num2
//{
// return (num1 + num2)/2;
//
//}
//
//@end
//int main()
//{
//
// JiSuanQi *jsq = [JiSuanQi new];
// int a = [jsq sumOfNum1:10 andNum2:20];
// NSLog(@"和是%d",[jsq averageOfNum1:20 andNum2:30]);
// NSLog(@"和是%d",a);
//}
//
//类方法练习
/*
设计一个类
*求和
*求平均值
*/
//#import <Foundation/Foundation.h>
//@interface JiSuanQi : NSObject
//
//+ (int)sumOfNum1:(int)num1 andNum2:(int)num2;
//+ (int)averageOfNum1:(int)num1 andNum2:(int)num2;
//
//@end
//
//@implementation JiSuanQi
//+ (int)sumOfNum1:(int)num1 andNum2:(int)num2
//{
//
// return num1 +num2;
//}
//+ (int)averageOfNum1:(int)num1 andNum2:(int)num2
//{
// return (num1 + num2)/2;
//
//}
//
//@end
//int main()
//{
//
//// JiSuanQi *jsq = [JiSuanQi new];
// int a = [JiSuanQi sumOfNum1:10 andNum2:20];
//// NSLog(@"和是%d",[jsq averageOfNum1:20 andNum2:30]);
// NSLog(@"和是%d",a);
// NSLog(@"和是%d",[JiSuanQi averageOfNum1:20 andNum2:30]);
//}
//
//
/*
设计一个类
*求和
*求平均值
// */
//#import <Foundation/Foundation.h>
//@interface JiSuanQi : NSObject
//
//+ (int)sumOfNum1:(int)num1 andNum2:(int)num2;
//+ (int)averageOfNum1:(int)num1 andNum2:(int)num2;
//
//@end
//
//@implementation JiSuanQi
//+ (int)sumOfNum1:(int)num1 andNum2:(int)num2
//{
//
// return num1 +num2;
//}
//+ (int)averageOfNum1:(int)num1 andNum2:(int)num2
//{
// int sum = [JiSuanQi sumOfNum1:num1 andNum2:num2];//调用类的类方法;
// return sum / 2;
//
//}
//
//@end
//int main()
//{
//
// // JiSuanQi *jsq = [JiSuanQi new];
// int a = [JiSuanQi sumOfNum1:2 andNum2:20];
// // NSLog(@"和是%d",[jsq averageOfNum1:20 andNum2:30]);
// NSLog(@"和是%d",a);
// NSLog(@"和是%d",[JiSuanQi averageOfNum1:22 andNum2:30]);
//}
//
//调用类方法,然后类方法实现中又调用类方法.
//类方法使用注意
//#import <Foundation/Foundation.h>
//
//@interface Person : NSObject
//
//{
// int _age;
//}
//- (void)test;
//+ (void)test;
//+ (void)test1;
//- (void)setAge:(int)age; //注意刚才自己写错了方法名,忘记了加:号(冒号)
//@end
//@implementation Person
//
//- (void)test
//{
// NSLog(@"1111-%d",_age);
// [Person test];
//
//}
//+ (void)test
//{
// NSLog(@"333");
//
//}
//+ (void)test1
//{
// NSLog(@"333");
// [Person test1];
//}
//
//- (void)setAge:(int)age
//{
// _age = age;
//}
//@end
//
//
//int main()
//{
// Person *p = [Person new];
//// p->_age = 20;
// [p setAge:20];
// [p test];
//
// [Person test1];//会引发死循环,注意注意注意
//
//}
//对象方法一样可以调用类方法
//如何 退出死循环??????
//self 用法
//这个关键字不是以@开头,其作用很大很大.
//
//@interface Person : NSObject
//{
// int _age;
//
//}
//
//- (void)setAge:(int)age;
//- (int)age;
//- (void)test;
//@end
//@implementation Person
//- (void)setAge:(int)age
//{
// _age = age;
//}
//- (int)age;
//{
// return _age;
//
//}
//- (void)test
//{
//// self :指针 指向了方法调用者.谁调用了self,就指向谁.
// int _age = 20;
// NSLog(@"person的年龄是%d",_age);
//
// NSLog(@"person的年龄是%d",self->_age);//会输出10,因为调用self的是p,当前self就是p.
// //代表当前对象
//
//
//}
//
//
//@end
//
//int main()
//{
// Person *p = [Person new];
// [p setAge:10];
// [p test];
//
//
//}
//
//
//
//
//
//
//#import <Foundation/Foundation.h>
////self的用途:
////1>谁调用了当前方法,self就代表谁 self出现在对象方法中,self就代表对象
// self 出现在类方法中,self就代表类 .
////2>可以利用"self->成员变量名"访问当前对象内部的成员变量
////3>[self 方法名];可以调用其他对象方法\类方法.
////
//@interface Dog : NSObject
//
// - (void)bark;
// - (void)run;
//
//
//
//@end
//@implementation Dog
//- (void)bark
//{
//
// NSLog(@"汪汪汪");
//}
//- (void)run
//{
// [self bark];
// NSLog(@"跑跑跑");
//}
//@end
//
//
//
//@end
//
//int main()
//{
//
//
//}
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
/*
设计一个类
*求和
*求平均值
// */
//#import <Foundation/Foundation.h>
//@interface JiSuanQi : NSObject
//
//+ (int)sumOfNum1:(int)num1 andNum2:(int)num2;
//+ (int)averageOfNum1:(int)num1 andNum2:(int)num2;
//
//@end
//
//@implementation JiSuanQi
//+ (int)sumOfNum1:(int)num1 andNum2:(int)num2
//{
//
// return num1 +num2;
//}
//+ (int)averageOfNum1:(int)num1 andNum2:(int)num2
//{
// int sum = [self sumOfNum1:num1 andNum2:num2];//调用类的类方法;
// return sum / 2; //self 代表当前JiSuanQi类.在这种情况下self代表类.
//
//}
//
//@end
//int main()
//{
//
// // JiSuanQi *jsq = [JiSuanQi new];
// int a = [JiSuanQi sumOfNum1:2 andNum2:20];
// // NSLog(@"和是%d",[jsq averageOfNum1:20 andNum2:30]);
// NSLog(@"和是%d",a);
// NSLog(@"和是%d",[JiSuanQi averageOfNum1:22 andNum2:30]);
//}
//
//#import <Foundation/Foundation.h>
//@interface Person : NSObject
//
// - (void)test;
//- (void)test1;
//- (void)test2;
//- (void)haha1;
//+ (void)haha2;
//@end
//@implementation Person
//- (void)test
//{
// NSLog(@"调用了-test方法");
// //会造成死循环
// //[self test];
//}
//+ (void)test
//{
//
// NSLog(@"调用了+test方法");
// //会造成死循环
// //[self test];
//}
//- (void)test1
//{
// [self test];// 调用到-test方法
//}
//+ (void)test2
//{
// [self test]; // 调用到 +test方法
//}
//- (void)haha1
//{
// NSLog(@"hahah____");
//}
//void haha3()
//{
//
//}
//+ (void)haha2
//{
//// [self haha1]; //报错,找不到+haha1;
//// [self haha3];//haha3() 会报错.不可能调用函数.
//}
//
//@end
//
//
//
//int main()
//{
//
// Person *p = [Person new];
//// [p test2];//不合理.
// [p test1];//合理.调用对象方法.
//
// [Person test2];
// return 0;
//
//
//}
//
//
//
//继承是最重要的,继承是一种语法,也是一种动作,类与类之间的关系,两个类之间的关系,
//如果说类B继承了类A 说明类B中有类A的所有东西
//
/*
#import <Foundation/Foundation.h>
@interface Animal : NSObject
{
int _age;
double _weight;
}
- (void)setAge:(int)age;
- (int)age;
- (void)setWight:(double)weight;
- (double)weight;
@end
@implementation Animal
- (void)setAge:(int)age
{
_age = age;
}
- (int)age
{
return _age;
}
- (void)setWight:(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;
//}
//
//
//这种情况下用继承.创建一个动物类,把狗和猫相同的属性和实现方法抽提到一个动物类中
//继承的好处
//1.可以抽取重复的代码
//2.建立了类之间的关系
//3.子类可以拥有父类中的所有成员变量和方法
//2.注意点
//1>基本上所有类的根类是NSObject
//不继承nsobject 就不能创建新对象. new方法在NSObject里面,是类方法. NSObject是基类,最根本的类
//NXProxy也是个类,基类????
//NSObject
//+new
//Animal(继承NSObject)
//_age
//_weight
//get 和 set 方法
/////Dog继承自Animal, Cat继承自Animal
//OC中使用的注意
//1.重写:子类重新实现父类中的某个方法,覆盖父类以前的做法 //重写后会留下父类中的东西吗..
//2.注意
//1>父类必须声明在子类的前面
//2>子类不能拥有和父类相同的成员变量
//3>调用某个对象的方法时,优先去当前对象中找,如果找不到,就去父类中找
//#include <Foundation/Foundation.h>
//
//
////person
//
//@interface Person : NSObject
//{
// int _age;
//
//}
//- (void)setAge:(int)age;
//- (int)age;
//- (void)run;
//+ (void)test;
//@end
//@implementation Person
//- (void)setAge:(int)age
//{
// _age = age;
//
//}
//- (int)age
//
//{
// return _age;
//}
//- (void)run
//{
//
// NSLog(@"person---run");
//}
//+ (void)test
//{
// NSLog(@"person---+test");
//}
//@end
//
////不允许子类和父类拥有相同的名称的成员变量
//
////student
//@interface Student : Person
//{
// int _no;
//// int _age;//会报错,成员变量重复
//
//}
//- (void)run;
//+ (void)test2;
//
//@end
//@implementation Student
////重写:子类重新实现父类中的某个方法,覆盖父类以前的做法
//- (void)run
//{
// NSLog(@"student---run");
//
//
//}
//+ (void)test
//{
// NSLog(@"student---+test");
//}
//+ (void)test2
//{
// [self test];
//
//}
//
//
//@end
//
//int main()
//{
// Student *s = [Student new];
// [s run]; //优先去student找run方法,如果student找不到run方法,会到person中找run方法
// [Person test];
// [Student test];
// [Student test2];
//
// return 0;
//}
//
//
//
////每个对象中有一个isa指针,每个类中有个superclass指针,指向父类.父类中也有superclass指针,指向NSObject,NSObject中有+new方法.
////isa 指向CLASS(类),所以isa指向对象所对应的类.
//
//
////重写很重要
////2.继承的坏处:耦合性太强
//
//
//
////继承与组合
////
//
///*
// 1.继承:当两个类拥有相同属性和方法时候,就可以将相同的东西抽取到一个父类中
// 2.当A类拥有B类中的部分属性和方法时,可以考虑让B类继承A类
// A
// {
// int _age;
// int _no;
// }
// B
// {
// int _age;
// int _no;
// int _weight;
//
// }
//
// */
////
//
//@interface Score : NSObject
//{
//
// int _cScore;
// int _ocScore;
//}
//@end
//@implementation Score
//
//@end
//@interface Student : NSObject
//{
// //组合
// int _cScore;
// int _ocScore;
// int _age;
//}
//@end
//@implementation Student
//
//@end
////不能继承.
//
//@interface Score : NSObject
//{
//
// int _cScore;
// int _ocScore;
//}
//@end
//@implementation Score
//
//@end
//继承:...是.....
//组合:...拥有......
//@interface Student : NSObject(这叫组合)(score//这叫继承)
//{
// //组合
// Score *_score;
//// int _cScore;
//// int _ocScore;
// int _age;
//}
//@end
//@implementation Student
//
//
//@end
//成绩类和学生类,没办法继承吧,学生是个成绩???????看起来成绩里的成员变量都在学生的成员变量里面,但不能继承.只能叫组合.
//有时候利用继承和组合都能实现我们的需求,但是是有本质去别的,如果是:score说明student是score,如果是:NSObject,代表student拥有score.
//super关键字
//非常好用和self差不多,但使用不一样.
/*
跳跃僵尸
舞王僵尸
铁桶僵尸
super 的作用 //重点是思想
1.直接调用父类中的某个方法
2.super处在对象方法中,那么就会调用父类的对象方法
super处在类方法中,那么就会调用父类的类方法
3.使用场合:子类重写父类的方法时想保留父类的一些行为.
*/
//@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 //重写了对象方法 ,用super关键字,调用父类的方法,保留了父类的一些行为.
//{
// //跳两下 重写了work方法.
// NSLog(@"跳两下");
//// NSLog(@"往前挪两步---");
// [super walk];//super 用来访问父类,调用父类的walk方法.
// //重写方法时, 保留父类的一些行为.
//}
//@end
//int main()
//{
//// JumpZoombie *jz = [JumpZoombie new];
//// [jz walk];
////
// [JumpZoombie haha];
// JumpZoombie *jz = [JumpZoombie new];
// [jz haha2];
// return 0;
//}
//
//
//
//
// 多态 挺常见的,多种形态,那么在代码中如何体现多态呢
//没有继承就没有多态
//#import <Foundation/Foundation.h>
//@interface Animal : NSObject
//- (void)eat;
//@end
//
//@implementation Animal
//
//- (void)eat
//{
//
// NSLog(@"吃东西");
//
//}
//@end
//@interface Dog : Animal
//
//@end
//@implementation Dog
//- (void)eat
//{
// NSLog(@"Dog吃东西---");
//}
//
//
//@end
//
//int main()
//{
// NSObject *n = [Dog new];
// NSObject *n2 = [Animal new];
// //多种形态
//// Dog *d = [Dog new];//Dog类型
//
// //另一种形态
// Animal *a = [Dog new];
// //多态:父类指针指向子类对象
// [a eat]; //如果你使用多态指针时,去调用方法时,会动态绑定真实类型,虽然[a eat]是animal方法,但是他会动态调用dog方法
// //调用方法时会检测对象的真实方法.
// //如果真是
// return 0;
//}
//多态注意点
//#import <Foundation/Foundation.h>
////动物
//@interface Animal : NSObject
//- (void)eat;
//@end
//
//@implementation Animal
//
//- (void)eat
//{
//
// NSLog(@"Animal-吃东西");
//
//}
//@end
////狗
//@interface Dog : Animal
//
//@end
//@implementation Dog
//- (void)eat
//{
// NSLog(@"Dog吃东西---");
//}
//
//
//@end
//
////猫
//@interface Cat : Animal
//
//@end
//@implementation Cat
//- (void)eat
//{
// NSLog(@"Cat吃东西---");
//}
//
//
//@end
//
//int main()
//{
//// NSString *s = [Cat new];//NSString 是一个类(字符串),你能说猫是个字符串吗?但Oc是弱语法,不会报错,只是一个警告.
//// Cat *c = [Dog new]; 不合理 ,OC是弱语法,但左边写任何东西编译器都不会报错.
//// Cat *c = [Animal new]; 不合理
// Animal *a = [Dog new];
//
//
//
// //多种形态
// // Dog *d = [Dog new];//Dog类型
//
//
/////////////多态的好处
//
//
//
//#import <Foundation/Foundation.h>
// //动物
// @interface Animal : NSObject
// - (void)eat;
// @end
//
// @implementation Animal
//
// - (void)eat
// {
//
// NSLog(@"Animal-吃东西");
//
// }
// @end
// //狗
// @interface Dog : Animal
//
// @end
// @implementation Dog
// - (void)eat
// {
// NSLog(@"Dog吃东西---");
// }
//
//
// @end
//
// //猫
// @interface Cat : Animal
//
// @end
// @implementation Cat
// - (void)eat
// {
// NSLog(@"Cat吃东西---");
// }
//
//
// @end
////void feed(Dog *d)
////{
//// [d eat];
////}
////void feed2(Cat *c)
////{
//// [c eat];
////}
//void feed(Animal *a)//多态好处,节省代码.
//{
// [a eat];
//}
//
// int main()
// {
// // NSString *s = [Cat new];//NSString 是一个类(字符串),你能说猫是个字符串吗?但Oc是弱语法,不会报错,只是一个警告.
// // Cat *c = [Dog new]; 不合理 ,OC是弱语法,但左边写任何东西编译器都不会报错.
// // Cat *c = [Animal new]; 不合理
// Animal *a = [Dog new];
// Dog *dd = [Dog new];
// feed(dd);
// Cat *cc = [Cat new];//不能这样写
// feed(cc);//不能这样写,猫对象传给了狗指针.
//
// //多种形态
// // Dog *d = [Dog new];//Dog类型
//
//}
//多态的局限性
//
//1.没有继承就没有多态,
//2.代码的体现:父类类型的指针指向子类对象
//3.好处:如果函数/方法参数中使用的是父类类型,可以传入父类,子类对象.
//4.局限性:父类类型的变量,不能,直接调用子类特有的方法
//狗继承自动物,狗可以在动物的基础上,再增加一个方法
//#import <Foundation/Foundation.h>
////动物
//@interface Animal : NSObject
//- (void)eat;
//@end
//
//@implementation Animal
//
//- (void)eat
//{
//
// NSLog(@"Animal-吃东西");
//
//}
//@end
////狗
//@interface Dog : Animal
//- (void)run;
//@end
//@implementation Dog
//- (void)eat
//{
// NSLog(@"Dog吃东西---");
//}
//- (void)run
//{
// {
// NSLog(@"Dog跑起来---");
// }
//
//}
//
//@end
//
////猫
//@interface Cat : Animal
//
//@end
//@implementation Cat
//- (void)eat
//{
// NSLog(@"Cat吃东西---");
//}
//
//
//@end
////void feed(Dog *d)
////{
//// [d eat];
////}
////void feed2(Cat *c)
////{
//// [c eat];
////}
//void feed(Animal *a)//多态好处,节省代码.
//{
// [a eat];
//}
//
//int main()
//{
// // NSString *s = [Cat new];//NSString 是一个类(字符串),你能说猫是个字符串吗?但Oc是弱语法,不会报错,只是一个警告.
// // Cat *c = [Dog new]; 不合理 ,OC是弱语法,但左边写任何东西编译器都不会报错.
// // Cat *c = [Animal new]; 不合理
//// Animal *a = [Dog new];
//// Dog *dd = [Dog new];
//// feed(dd);
//// Cat *cc = [Cat new];//不能这样写
//// feed(cc);//不能这样写,猫对象传给了狗指针.
//
// //多种形态
// // Dog *d = [Dog new];//Dog类型
// Dog *d = [Dog new];
// [d run];
// Animal *aa = [Dog new];//多态的局限性:父类类型的变量,不能,用来调用子类的方法.
// [[aa run];//从语法上不建议这样写,编译器会先去animal中去找,会报个警告;但是为什么xcode5.1里报错了呢?
//// 强制转换可以用父类调
// //将aa转换为Dog *类型的变量
// Dog *dd = (Dog *)aa;//类型转换是做给编译器看的.这样写不合理Dog *dd = aa;
//// int a = (int)1.2;
//
//}
//
