Objective-C快速入门教程-第五讲 继承性
Object-C 经典入门教程
Object-C 入门教程分类：Sip&asterisk2009-05-04 16:34 16409人阅读评论(2) 收藏举报大纲o开始吧下载这篇教学o设定环境o前言o编译 hello worldo创建 Classes@interfaceo@implementationo把它们凑在一起o详细说明...多重参数o建构子（Constructors）o访问权限o Class level accesso异常情况（Exceptions）处理o继承、多型（Inheritance, Polymorphism）以及其他面向对象功能id 型别o继承（Inheritance）o动态识别（Dynamic types）o Categorieso Posingo Protocolso内存管理Retain and Release（保留与释放）o Dealloco Autorelease Poolo Foundation Framework ClassesNSArrayo NSDictionary∙优点与缺点∙更多信息开始吧下载这篇教学▪所有这篇初学者指南的原始码都可以由objc.tar.gz下载。
这篇教学中的许多范例都是由 Steve Kochan 在Programming in Objective-C. 一书中撰写。
如果你想得到更多详细信息及范例，请直接参考该书。
这个网站上登载的所有范例皆经过他的允许，所以请勿复制转载。
设定环境▪Linux/FreeBSD: 安装GNUStep为了编译 GNUstep应用程序，必须先执行位于/usr/GNUstep/System/Makefiles/GNUstep.sh 的GNUstep.sh 这个档案。
这个路径取决于你的系统环境，有些是在 /usr, some /usr/lib，有些是/usr/local。
如果你的 shell 是以 csh/tcsh 为基础的 shell，则应该改用 GNUStep.csh。
objective c语法
objective c语法Objective-C是一种面向对象的编程语言，主要用于开发iOS和macOS平台上的应用程序。
在Objective-C中，语法结构类似于C语言，但有许多扩展和新的概念。
下面将介绍Objective-C语法的主要特点和使用方法。
1. 类的定义Objective-C中的类定义使用@interface和@end关键字。
类名通常以大写字母开头。
例如：```@interface Person : NSObject {}@end```这个类名为Person，继承自NSObjet类。
在类的大括号中，可以定义实例变量和方法。
2. 属性```@interface Person : NSObject {NSString *name;}@property (nonatomic, strong) NSString *name;@end```这里定义了一个名为name的实例变量，并使用@property定义了一个名为name的属性。
其中，strong表示对属性对象的强引用，nonatomic表示属性不是原子性的，可以提高代码的性能。
3. 方法在Objective-C中，方法名称以-（减号）开头表示实例方法，以+（加号）开头表示类方法。
例如：```- (void)printName {NSLog(@"My name is %@", name);}方法也可以有返回值，例如：```- (BOOL)isAdult {if (age >= 18) {return YES;} else {return NO;}}```4. 初始化在Objective-C中，对象的初始化方法通常被称为“构造函数”，用于为对象分配内存和初始化实例变量。
常用的初始化方法是-init，例如：5. 继承在Objective-C中，一个类可以继承自另一个类。
子类拥有父类的属性和方法，并可以添加自己的属性和方法。
组合和继承
例如有以下的类X : class X { 类名1 ob1； 类名2 ob2； … 类名n obn； };
5.1.2 对象成员的初始化
类X的构(参数表1),ob2(参数表2),…,obn(参数表n) { 类B的构造函数体 }
参数表1、参数表2 、… 、参数表n的数据，一般来自参数表 0。当类名1、类名2...类名n的构造函数不带参数或带有默认 参数时，类X的构造函数中冒号及后面的对象成员初始化列 表可省。例如：
Point::InitP; Point::GetX; … };
注意：1)在派生类中声明基类的函数时，只需给出函数的名 称，函数的参数和返回值类型不应出现。
class Rectangle: private Point{
……
public:
Point::InitP;
//正确
Point::GetX;
//正确
X∷X(参数表0) { 类B的构造函数体 }
5.1.2 对象成员的初始化
当调用构造函数X()时，首先按个对象成员在类中声明的 顺序依次调用它们的构造函数，对这些子对象初始化; 然后再执行X()的构造函数体初始化类中个其它成员。 析构函数的调用顺序与构造函数的调用顺序相反。
面向对象的继承原理是什么
面向对象的继承原理是什么面向对象的继承是一种编程概念，它允许一个对象（称为子类）继承另一个对象（称为父类）的特性和行为。
这意味着子类可以继承父类的属性和方法，并且可以在不修改父类代码的情况下添加自己的特定功能。
继承主要基于两个概念：类和对象。
类是一个抽象的概念，它描述了一个对象的特征和行为。
对象是类的一个具体实例。
在继承中，类与类之间形成了父子关系，子类可以从父类中继承属性和方法。
继承的主要目的是代码重用。
它遵循一个基本原则，即「尽量不要重复代码」，因为重复代码会导致代码的冗长、难以维护和修改。
通过继承，我们可以将通用的属性和方法定义在父类中，并让子类继承它们，从而减少重复代码的数量。
继承的原理可以通过以下几个方面来解释：1. 单继承和多继承：- 单继承：一个子类只能继承一个父类的属性和方法。
- 多继承：一个子类可以同时继承多个父类的属性和方法。
在单继承中，子类只能直接继承一个父类，但可以通过继承链间接地继承多个父类。
在多继承中，子类可以直接继承多个父类。
2. 可见性和访问控制：继承关系中，父类的属性和方法可以被子类继承和访问。
然而，有时我们希望将某些属性或方法隐藏起来，只允许在父类内部访问。
这就引出了可见性和访问控制的概念。
- 公共可见性：表示属性和方法允许在类的内部和外部访问。
- 受保护的可见性：表示属性和方法只允许在类的内部和子类中访问。
- 私有可见性：表示属性和方法只允许在类的内部访问。
可见性和访问控制允许我们灵活地控制子类对父类的继承内容的访问权限。
3. 方法重写和多态：子类有权重写继承自父类的方法，以满足自身的需求。
这被称为方法重写。
在方法重写中，子类可以实现与父类相同的方法名称、参数列表和返回类型，从而覆盖父类的方法。
多态是指同一个方法调用可以具有不同的实现方式。
通过方法重写，子类可以以不同的方式实现继承自父类的方法。
当我们通过一个父类类型的变量引用一个子类对象时，可以根据实际运行时的子类类型来决定调用哪个方法。
简述派生类的继承方式
简述派生类的继承方式派生类（子类）的继承方式是面向对象编程中的一种重要的技术。
通过继承，子类可以继承父类的属性和方法，并且还可以额外拥有自己的属性和方法。
在继承中，子类可以选择不同的继承方式，以满足不同的需求和场景。
常见的继承方式有三种：公有继承、私有继承和保护继承。
1. 公有继承：公有继承是最常用的继承方式，也是默认的继承方式。
在公有继承中，子类继承了父类的公有成员和保护成员，但是不继承父类的私有成员。
公有继承的特点是子类可以访问和调用父类的公有成员和保护成员，可以重写父类的方法，并可以添加新的成员。
这种继承方式常用于描述"is-a"关系，即子类是父类的一种特殊情况。
2. 私有继承：私有继承是一种特殊的继承方式，在私有继承中，子类继承了父类所有的成员，包括公有成员、保护成员和私有成员。
但是，子类不能访问和调用父类的任何成员，除非在子类中重新定义相应的方法。
私有继承的特点是子类可以重写父类的方法，并可以添加新的成员，但是不能访问和调用父类的成员。
这种继承方式常用于描述"has-a"关系，即子类具有父类的功能。
3. 保护继承：保护继承是介于公有继承和私有继承之间的一种继承方式。
在保护继承中，子类继承了父类的保护成员和公有成员，但是不能继承父类的私有成员。
子类可以访问和调用父类的保护成员和公有成员，可以重写父类的方法，并可以添加新的成员。
保护继承的特点是子类可以访问和调用父类的保护成员，但是不能访问和调用父类的私有成员。
这种继承方式常用于描述"is-implemented-in-terms-of"关系，即子类使用父类的实现方式。
总之，派生类的继承方式提供了灵活多样的方式来实现代码的复用和扩展。
在选择继承方式时，需要根据具体的需求和场景来选择合适的方式。
公有继承适用于描述"is-a"关系，私有继承适用于描述"has-a"关系，而保护继承适用于描述"is-implemented-in-terms-of"关系。
OBJECTIVE C知识点总结
/*1.类是一组具有相同特性和行为的某一类事和物的集合.2.对象是类的实例化.3.计算机语言的目的:模拟和解决生活中的问题.4.#include和#import的区别?答:(1)#import是oc中导入头文件的关键字,而且只需导入一次就行.(2)#include是c\c++导入头文件的关键字,include导入头文件容易引起交叉编译.5.创建对象的语法:(1)类名*对象名=[[类名alloc]init];(2)类名*对象名=[类名new];6.oc中的方法:(减号为实例方法,加号为类方法)-|+(返回类型)方法名:参数列表{//方法体}(1)器就是方法的意思;(2)void意思是无返回值;Student为类名,意思为有Student类型的返回值(3)with后面的name是属性的名称,newName 是属性name的参数名称初始化器:-|+(Student*)initWithName:(NSString*)newName{self=[super init];//继承父类NSObject 的init(初始化)方法self->name=newName;return self;}便利构造器:-|+(Student*)studentWithName:(NSString*)newName{Student*student=[[Student alloc]init];//实例化变量student=newName;return student;}7.属性#interface@property(nonatomic,retain)NSString *name;(声明)等价于:(setter方法:设置器)-(void)setAge:(int)newAge{age=newAge;}#implemention@synthesize name;(合成)等价于:(getter方法:访问器)-(int)getAge{return age;}8.点语法(1)=@"liming";等价于:[stu setName:@"liming"];(2)NSlog(@"%@",[]);等价于:NSlog(@"%@",[stu getName]);9.property有关语法(1)readwrite是可读可写特征;需要生成getter 方法和setter方法.(2)readonly是只读特性只会生成getter方法不会生成setter方法.(3)assign赋值特性,setter方法将传入参数赋值给实例变量.(4)retain表示持有特性,setter方法将传入参数先保留,再赋值,并且变量retaincount+1;(5)copy通过copy将对象复制一份,之前的对象会释放.(6)nonatomic表示单线程安全.(7)atomic表示多线程安全.10.变量作用域(1)@protected表示只有该类和其子类可以访问该类的变量.(2)@public表示无论是自身还是子类的对象,还是其它类型的对象均能访问该类的变量.(3)@private表示只有该类本身的对象可以访问该类的变量.11.面向对象三大特征:(1)封装:隐藏内部实现,稳定外部接口.(2)继承:子类继承父类的所有非私有的方法和属性.(3)多态:不同类型的对象,对同一方法名的不同响应.注意:要点一:oc中不允许多继承(一个类有多个父类),但允许多重继承(一个类的父类也拥有其自身的父类).要点二:一个类调用方法时,先从本类方法找,找不到再从父类找,一直往上直到找到NSObject类中.12.self:是指向当前对象的指针.super:调用父类的方法.id:是一个指向任何一个继承了NSObject类的对象.13.开闭原则和里氏替换原则(1)开闭原则(OCP Open Closed Principle):核心是:对扩展开放,对修改关闭.改变一个软件时,应该通过扩展的方式来改变软件,而不应该修改原有的代码来实现变化.(2)里氏替换原则(LSP Liskov Substitution Principle):(is A)原则:任何基类可以出现的地方,子类一定可以出现.a.继承必须确保超类所拥有的性质子类中仍然成立.b.子类对象总是可以替换父类对象.14.内存管理(1)黄金法则:凡是对象使用了alloc,new,copy和retain,那么必须有相对应的release和autorelease.引用计数机制：对象创建后，运行时系统通过对象维护的一个计数器来描述有多少个其他对象在使用自己，当计数器为0时，释放该对象占用的内存空间（该对象调用dealloc方法）。
c类的继承和多态例子
c类的继承和多态例子继承是面向对象编程中的重要概念之一，它允许一个类“继承”另一个类的属性和方法。
在C++中，继承分为三种类型：公有继承、私有继承和保护继承。
其中，公有继承是最常用的一种方式，也是实现多态的基础。
本文将通过一个例子来介绍C++中的公有继承和多态特性。
假设我们要设计一个动物园的系统，其中包含不同类型的动物。
首先，我们定义一个基类Animal，代表所有动物的共有属性和方法。
然后，派生出几个具体的动物类，如Lion（狮子）、Elephant （大象）和Monkey（猴子），它们都是Animal类的派生类。
1. 基类Animal的定义：```c++class Animal {public:Animal() {} // 构造函数virtual ~Animal() {} // 虚析构函数virtual void move() const = 0; // 纯虚函数，用于表示不同动物的移动方式protected:int age; // 年龄double weight; // 体重};```2. 派生类Lion的定义：```c++class Lion : public Animal {public:Lion(int a, double w) : Animal(), color("yellow") { age = a;weight = w;}void move() const {std::cout << "Lion is running." << std::endl;}private:std::string color; // 颜色};```3. 派生类Elephant的定义：```c++class Elephant : public Animal {public:Elephant(int a, double w) : Animal(), height(3.5) { age = a;weight = w;}void move() const {std::cout << "Elephant is walking." << std::endl; }private:double height; // 身高};```4. 派生类Monkey的定义：```c++class Monkey : public Animal {public:Monkey(int a, double w) : Animal(), num_bananas(5) {age = a;weight = w;}void move() const {std::cout << "Monkey is jumping." << std::endl;}private:int num_bananas; // 香蕉数目};```以上就是实现动物园系统的基本类定义。
C语言结构体的“继承”
C语⾔结构体的“继承”这⾥说的继承有点像C++⾥的⽗类和⼦类，实际上是结构体类型的强制转换，最近看Linux内核源码时经常接触到这种⽅法，在这⾥就当作是⼀个简单的学习吧。
下⾯给出⼀个Demo，很简单，分别定义了⼀个father结构体和⼀个son结构体，father结构体⾥定义了2个整形变量，son结构体⾥的第⼀个成员是father结构体类型的变量，son⾥的另外2个成员也是整形变量，这样，son结构体就好像继承了father结构体，并增加了2个成员，代码如下：1 #include <stdio.h>23 //⽗结构体4 struct father5 {6 int f1;7 int f2;8 };910 //⼦结构体11 struct son12 {13 //⼦结构体⾥定义⼀个⽗结构体变量，必须放在⼦结构体⾥的第⼀位14 struct father fn;15 //⼦结构体的扩展变量16 int s1;17 int s2;18 };1920 void test(struct son *t)21 {22 //将⼦结构体指针强制转换成⽗结构体指针23 struct father *f = (struct father *)t;24 //打印原始值25 printf("f->f1 = %d\n",f->f1);26 printf("f->f2 = %d\n",f->f2);27 //修改原始值28 f->f1 = 30;29 f->f2 = 40;30 }3132 int main(void)33 {34 struct son s;35 s.fn.f1 = 10;36 s.fn.f2 = 20;3738 test(&s);39 //打印修改后的值40 printf("s.fn.f1 = %d\n",s.fn.f1);41 printf("s.fn.f2 = %d\n",s.fn.f2);4243 return 0;44 }在这⾥，关键是把father类型的变量放在son结构体⾥的第⼀位。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第12页
Square.m文件
-(int) size { return width; } -(void) setWidth: (int) w { [self setSize: w]; } -(void) setHeight: (int) h { [self setSize: h]; } @end
第13页
调用的main函数
#import <Foundation/Foundation.h> #import "Square.h" #import "Rectangle.h" int main (int argc, const char * argv[]) { Rectangle *rec = [[Rectangle alloc] initWithWidth: 10 height: 20]; Square *sq = [[Square alloc] initWithSize: 15]; NSLog(@"Rectangle: " ); [rec print]; NSLog(@"Square: " ); [sq print]; [sq setWidth: 20]; NSLog(@"Square after change: " ); [sq print]; [rec release]; [sq release]; return 0; }
第10页
Square.h文件
#import "Rectangle.h" @interface Square: Rectangle -(Square*) initWithSize: (int) s; -(void) setSize: (int) s; -(int) size; @end
第11页
Square.m文件
方法重写
子类不能继承父类中作用域限定符为@private 的成员变量 。子类可以重写父类的方法，及命名与父类同名的成员变量 。下面通过一个矩形类和正方形类的实例说明方法重写问题。
第7页
Rectangle.h文件
#import <Foundation/NSObject.h> @interface Rectangle: NSObject { int width; int height; } -(Rectangle*) initWithWidth: (int) w height: (int) h; -(void) setWidth: (int) w; -(void) setHeight: (int) h; -(void) setWidth: (int) w height: (int) h; -(int) width; -(int) height; -(void) print; @end
第15页
运 = 10, height = 20 Square: width = 15, height = 15 Square after change: 第14页 width = 20, height = 20
作业
• 1、Objective-C是的单重继承的吗？ • 2、Objective-C中的方法重写概念？
iPhone与iPad应用开发课程 精通Objective-C语言
第五讲 继承性 主讲人：关东升 eorient@
主要知识点
• 继承概念 • 方法重写
第2页
继承概念
• 继承性是面向对象的重要概念之一，子类能够继承父类的 某些方法和成员变量。作用域限定符为private 的成员变量 是不可以被继承的。子还可以重写父类的方法。 • 为了了解继承性，我们看看这样的一个场景：一位面向对 象的程序员小赵，在编程过程中需要描述和处理个人信息， 于是他定义了类Person。
第3页
Person类
@interface Person: NSObject { NSString* name; int age; NSDate birthDate; } -(NSString*) getInfo; @end
第4页
Student类
而一周以后，小赵又遇到了新的需求，需要描述和处理学生 信息，于是他又定义了一个新的类Student。 @interface Student : NSObject { NSString* name; int age; NSDate birthDate; NSString* school; } -(NSString*) getInfo; @end
#import "Square.h" @implementation Square -(Square*) initWithSize: (int) s { self = [super init]; if ( self ) { [self setSize: s]; } return self; } -(void) setSize: (int) s { width = s; height = s; } ... ...
第9页
Rectangle.m文件
-(void) setWidth: (int) w height: (int) h { width = w; height = h; } -(int) width { return width; } -(int) height { return height; } -(void) print { printf( "width = %i, height = %i", width, height ); } @end
第8页
Rectangle.m文件
#import "Rectangle.h” @implementation Rectangle -(Rectangle*) initWithWidth: (int) w height: (int) h { self = [super init]; if ( self ) { [self setWidth: w height: h]; } return self; } -(void) setWidth: (int) w { width = w; } -(void) setHeight: (int) h { height = h; } ... ...
第5页
小结
Student和Person两个类的结构太接近了，后者只比前者多 出一个属性school，却要重复定义其它所有的内容。 Objective-C提供了解决类似问题的机制，那就是类的继承。 @interface Student : Person { NSString* school; }
第6页