OC is a minimal object-oriented grammar based on the C language
//
// main.m
// LearnOC1
//
// Created by apple on 2020/9/11.
// Copyright © 2020 tu. All rights reserved.
//
#import <Foundation/Foundation.h>
//#import 引入的头文件可以防止重复包含
/*
//Foundation/Foundation.h 包含了其他大量的头文件，把OC的库文件都引过来了
//头文件的位置，在应用程序里面找到Xcode，右键显示包内容
找到路径
Applications/Xcode.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS.sdk/System/Library/Frameworks/Foundation.framework/Headers
下有一个Foundation.h 文件
*/
void testc()
{
printf("testc ---- \n") ;
}
int main(int argc, const char * argv[]) {
//@autoreleasepool 自动释放池
@autoreleasepool {
// insert code here...
//NSLog 一个函数，向控制台输出字符串
//NSLog 是cocoa框架提供的一个方法，定义在NSObjCRuntime.h中
//按Command+鼠标左键，跳转到函数的声明文件中
//NSLog会自动换行，会自动输出时间等项目信息
//NSLog的函数参数是一个 NSString对象
NSLog(@"Hello world");
//NSLog 格式化输出
int a=5;
float f1=2.3f;
double d1=3.14;
char ch='X';
NSLog(@"%d,%.2f,%.2f,%c",a,f1,d1,ch);
//OC字符串表示方法
//用%@ 输出字符串
NSString *str1=@"hhhzhan张";
NSLog(@"%@",str1);
//@"" 这个符号表示将一个C的字符串转化为OC中的字符串对象NSString
//@符号 OC的大部分关键字都是以@开头的，比如 @interface,@implementation,@end 等
//
testc();
//.m文件 ， Objective-C的源文件
//.mm文件 ， Objective-C++的源文件
//.m文件 ，类的实现文件，参与文件的编译，用来实现类中声明的方法
//OC 新增的for循环
NSArray *arr=@[@"one",@"two",@"three"];
for(NSString *str in arr)
{
NSLog(@"%@",str);
}
//OC 新增的数据类型
//（1） Boolean 存放逻辑值， 存储的值 true(1) false(0)
//（2） BOOL 存放逻辑值， 存储的值 YES(1) NO(0)
//异常捕获
@try
{
}
@catch (NSException* exception){ //捕获最具体的异常类型
}
@catch(NSException *ne) //捕获一个比较重要的异常类型
{
} @catch(id ue) //再次抛出捕获的异常
{
}@finally{ //不管有没有异常 都执行
}
}
return 0;
}
class:
//
// main.m
// LearnOC2
//
// Created by apple on 2020/9/11.
// Copyright © 2020 tu. All rights reserved.
//
//类 ，一类事物共同特征和行为的抽象 ，对象 ：类的具体个体
//.h 类的声明文件，声明成员变量和方法。
//类的声明使用关键字 @interface和@end
//.m 类的实现文件，用于实现.h中声明的方法。
//类的实现使用关键字@implementation 和 @end
//方法
//方法的声明和实现，都必须以+或者-开头
// + 表示类方法（静态方法）
// - 表示对象放方法（动态方法）
//在.h中声明的所有方法作用域都是public类型，不能更改
//方法类型标识符 (返回类型) 方法名字:(参数类型)参数名 方法名字2:(参数类型)参数名
//冒号是方法名的一部分
//OC里面没有方法重载，不允许方法重名
//成员变量的常用作用域 @public @protected @private
//成员变量不允许使用static声明为静态
//可以在函数内定义用static定义静态变量，是个局部静态变量
//self 和super 用于在方法定义中引用执行该方法的对象
//OC语言中的self，相当于c++中的this指针
//super 发送消息可以将方法实现分发其父类，可以重写一个已有的方法来修改或将它添加到现有的方法中，
// 仍然可以将原始的方法纳入到修改后到方法中
//self 谁调用当前方法，self就代表谁
//self 在对象方法中，self代表当前对象
//self 在类方法中，self代表类
/*
//---类的声明
@interface 类名:父类名
{
//定义类的属性
}
//类的行为
@end
//--- 类的实现
@implementation 类名
//行为的具体实现
@end
//OC对象创建
类名* obj= [类名 new];
//做了3件事情， 申请内存空间，给类中的每个成员初始化值，返回新申请空间的首地址
*/
#import <Foundation/Foundation.h>
//#pragma mark指令 ， 对代码有分组的作用
#pragma mark Car类声明
//类的声明
@interface Car : NSObject
{
//类的属性， 类的行为不能在大括号这里写
@public;
int lunz;
NSString* color;
int speed;
}
//类的行为
//无参无返回值
-(void) run;
-(void) stop;
-(void) callPhone:(NSString*) telNum;
-(int) sendMessage:(NSString*) telNum andContent:(NSString*) content;
//类方法
+(int) sum:(int) x andsum:(int) y;
+(void) printself;
@end
#pragma mark -
#pragma mark Car类实现
//类的实现
@implementation Car
-(void) run{
NSLog(@"Car is running! %d",self->lunz);
}
-(void) stop{
NSLog(@"Car stop!");
// [self run]; //当前对象调用方法
}
-(void) callPhone:(NSString*) telNum
{
NSLog(@"Car callPhone %@ !",telNum);
}
-(int) sendMessage:(NSString*) telNum andContent:(NSString*) content
{
NSLog(@"Car callPhone %@,%@!",telNum,content);
return 1;
}
+(int) sum:(int) x andsum:(int) y
{
return x+y;
}
+(void) printself
{
NSLog(@"self= %p",self); //self 指代当前的类
//可以调用类方法，不能调用对象方法
NSLog(@"sum=%d" , [self sum:10 andsum:20] );
}
@end
#pragma mark -
#pragma mark main函数入口
//
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
NSLog(@"Hello, World!");
//创建一个对象 实质还是指针（用指针间接访问实力变量值）
Car* car1 =[Car new];
car1->lunz=3;
car1->speed=130;
car1->color=@"blue";
NSLog(@"%d,%d,%@",car1->lunz,car1->speed,car1->color);
//[类名 方法名]
[car1 run];
//向car1对象发送stop消息
[car1 stop];
//调用有参的方法
int res=[car1 sendMessage:@"hahh" andContent:@"参数2" ];
NSLog(@"res= %d",res);
//调用静态方法
NSLog(@"sum= %d",[Car sum:2 andsum:3]);
//匿名类
// [[Car alloc] init] 等价于 [Car new]
[[[Car alloc] init] stop];
[[Car new] stop];
//打印出类的地址
//[Car class] 返回的实质就是当前类（类对象）
NSLog(@"Car = %p",[Car class]);
[Car printself] ;
}
return 0;
}
NSString：
//
// main.m
// LearnOC3
//
// Created by apple on 2020/9/11.
// Copyright © 2020 tu. All rights reserved.
//
//NSString 处理字符串的类
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
NSLog(@"Hello, World!");
//创建常量字符串，注意使用“@”符号
NSString* astring=@"this is a string"; //特殊用法
//创建空字符串，给予赋值
//NSString是一个类
NSString* s1=[NSString new];
s1=@"sjfljs";
//格式化创建字符串
for(int i=0;i<5;++i)
{
NSString* imgName=[NSString stringWithFormat:@"xxxxx%02d.jpg",i];
NSLog(@"%@",imgName);
}
//用一个已经存在的字符串创建一个新的字符串
NSString* s2=[[NSString alloc] initWithString:s1];
NSLog(@"%@",s2);
//计算NSString 字符串长度计算
NSLog(@"字符串长度= %d", [s2 length]);
//在OC中 字符串中英文都是一个字符
//在C语言UTF-8编码中一个汉字占用3个字节
}
return 0;
}
Class inheritance
//
// main.m
// LearnOC4
//
// Created by apple on 2020/9/11.
// Copyright © 2020 tu. All rights reserved.
//
//派生类的方法属性=基类方法属性+派生类自己新增的方法和属性
//基类私有属性 能被继承，不能被使用
//OC 是单继承的，一个类只能继承一个父类
//子类不能定义和父类同名的变量，但是可以继承父类的变量
//在@interface @end之间的权限默认是protected
//在.m文件中定义的变量（不是写在@implementation @end之间的变量），是私有的
//在.h中没有声明的方法，但在.m中实现了，此时该方法被称为私有方法
//多态：一类事物的多种形态
//不同的对象以自己的方式响应相同名称方法的能力称为多态
//代码体现，用父类类型的指针指向子类对象，这就是多态
//动态绑定， 动态类型是程序直到执行才确定对象所属类型。
//类类型的变量 就是实例对象
//类的本质 其实也是一个对象（类对象）
//类对象在程序运行时一直存在
//类对象的所保存的信息在程序编译时确定，在第一次使用该类的时候被加载到内存
#import <Foundation/Foundation.h>
//Animal
@interface Animal : NSObject
{
@public
int _age;
}
-(void) eat:(NSString*)foodName;
-(void) run;
-(void) bark;
@end
@implementation Animal
-(void) eat:(NSString*)foodName
{
NSLog(@"正在吃 %@ ",foodName);
}
-(void) run{
NSLog(@"Animal is running.");
}
-(void) bark
{
NSLog(@"Animal is barking.");
}
@end
//----Dog
@interface Dog : Animal
-(void)lookHome;
+(void) testClass;
@end
@implementation Dog
-(void)lookHome{
NSLog(@"Dog lookHome.");
}
//重写父类的方法
-(void) bark
{
NSLog(@"Dog is barking.");
}
//重写方法
-(NSString*) description
{
return [NSString stringWithFormat:@"_age:%d",_age];
}
+(void) testClass{
NSLog(@"Dog +testClass.");
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
NSLog(@"Hello, World!");
Animal* animal=[Animal new];
animal->_age=11;
[animal eat:@"yumi"];
[animal run];
Dog *d1=[Dog new];
d1->_age=10;
[d1 eat:@"gutou"];
[d1 run];
[d1 lookHome];
[d1 bark];
//先查找当前类有没有bark，
//如果有，就先调用自己的
//如果没有，查看父类有没有bark方法
//如果父类没有，就往父类的父类查找
//查找到就执行
//当我们以%@的格式，打印对象，此时调用了对象的description方法
//对象如果没有重新description方法，就会调用父类的方法，
//可以重写description方法，来打印类的信息
NSLog(@"d1=%p ",d1);//d1=0x100404200
NSLog(@"d1=%@ ",d1); //d1=<Dog: 0x100404200>
//多态
Animal* d2=[Dog new];
[d2 bark];
//类对象的获取方法
Class c1=[d1 class]; //通过实例对象获取
Class c2=[Dog class]; //通过类名来获取
NSLog(@"c1=%p",c1); //c1=0x1000022d8
NSLog(@"c2=%p ",c2); //c2=0x1000022d8
//使用类对象创建实例对象
Dog* d3=[c1 new];
//使用类对象调用类方法
[c1 testClass];
//SEL 类型 ，全称selector，表示方法的存储位置
//SEL其实就是对方法的一种包装，将方法包装成一个SEL类型的数据，去寻找对应的方法地址，找到方法地址后
//就可以调用方法，这些都是运行时特性，发消息就是发送SEL，然后根据SEL找到地址，调用方法。
Dog* d4=[c1 new];
//手动把lookHome方法包装成SEL类型
SEL s1=@selector(lookHome);
//响应方法
[d4 performSelector:s1 ];
}
return 0;
}
//
// main.m
// LearnOC5
//
// Created by apple on 2020/9/14.
// Copyright © 2020 tu. All rights reserved.
//
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
// NSLog(@"Hello, World!");
//点语法,xcode编译器的特性，编译帮我们左了替换
//对象.属性名
//出现在等号左侧，p.age=18
//注意，此时（p.age） 并不是直接访问实例变量，
//而是xcode 看到点语法（p.age）后会帮我们自动替换成
//p.age -----替换--> [p setAge:18]
//出现在等号右侧， int a=p.age;
//实际上，当xcode 看到p.age出现在等号右侧后，会帮我们自动替换成
//把 p.age ----替换成---------------->[p age]
//
//@property 是编译器的指令
//是编译器的指令就是用来告诉编译器要做什么
//@property 告诉编译器声明属性的访问器（getter/setter）方法和实现
//用法： @property 类型名 方法名
//如 @property int age; 相党于进行了age的set和get方法的声明
// -(void)setAge:(int)age;
// -(int)age;
// xcode4.4后， 可以只使用@property来实现属性的get和set方法的声明和实现，不用@synthesize，
//@property 操作的是带有下划线的实例变量，如果当前类没有下划线的实例变量，系统会帮我们生成
// @synthesize 是在.m文件中定义set和get方法实现
//id类型是一种通用的对象类型，它可以用来存储属于任何类的对象
//也可以理解外万能指针
//id不需要强制类型转换
//编译器看到id以后，认为是动态类型，不再检查类型
/*
Animal *animal=[Animal new]; //动物类
Dog* dog=[Dog new]; //Dog类，继承Animal
//定义id类型,(id是个关键字)
id obj=dog;
[dog run];
*/
// instancetype类型（ios5.0后才有的），和id一样也是一个万能指针
//instancetype可以返回和方法所在类相同类型的对象，id只能返回未知类型的对象，
//instancetype 只能作为返回值，不能像id那样作为参数
//判断某个对象是某时类的实例对象，或者子类的的实例对象
//isKindOfClass
/*
Animal *ani=[Animal new];
BOOL isInstance=[ani isKindOfClass:[Animal class] ];
NSLog(@"%d",isInstance);//返回1 ，就表示ani时Animal类的实例
*/
// isMemberOfClass 判断对象是否时指定类的实例对象
//格式： [对象 isMemberOfClass:类对象 ]
// 判断类是是否时指定类的子类 （类和类之间的关系）
/*
//Dog Animal
BOOL isSub=[Dog isSubclassOfClass:[Animal clas]];
*/
//判断对象是否响应指定的方法
//-(BOOL) respondsToSelector:selector 判断实例是否有这样的方法
/*
SEL s1=@selector(run)
BOOL b=(dog)respondsToSelector(s1);
*/
//响应方法 -(id) performSelector:selector
//SEL s1=@selector(run);
//[dog performSelector:s1];//无参
// 有参
//SEL s2=@selector(eat:);
//[dog performSelector:s2 withObject:@"ssa"];
//performSelector:s2 withObject: withObject: 响应2个
//SEL s3=@selector(eat:andFoodName);
//[dog performSelector:s3 withObject:@"ssa" withObject:@"22a"];
//构造方法：用来初始化对象的方法 ， - 开头
// init就是构造方法
//重写构造方法 ，要记得调用 self=[super init]; 和 return self;
/*
-(instancetype)init{
self=[super init];
if(self)
{
//初始化
//_age=10;
}
return self;
}
*/
//自定义构造方法
//定义构造方法的规范
//（1）一般时对象方法
//（2）返回值一般时id类型
//（3）方法名一般以 initWith开头
/*
//Person类的实现
@implementation Person
-(id) initWithName:(NSString*) name
{
if(self=[super init])
{
_name=name;
}
return self;
}
//2个参数的构造方法
-(id) initWithName:(NSString*) name andNo:(int) no
{
if(self=[super init])
{
_name=name;
_no=no;
}
return self;
}
@
*/
}
return 0;
}