10. 封装、继承、多态

最新推荐文章于 2024-03-08 10:00:00 发布
最新推荐文章于 2024-03-08 10:00:00 发布
阅读量884 收藏
点赞数
分类专栏： Objective-C笔记 文章标签： 继承 多态 封装 可扩展 扩展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lk972105/article/details/21949263
版权

面向对象的三大特性：封装、继承、多态

1. 封装

    将属性和方法封装在一个对象中，只给外界公开访问接口，而把具体的实现隐藏。

    主要目的是提高程序的可维护性和可扩展性，增加可读性。


    在OC中，把需要公开的属性、方法定义或者声明在interface部分，而把不需要公开的属性、方法定义在implementation部分，隐藏起来。


    OC中实例变量的处理：

      一般情况下，实例变量是不能公开的。所以实例变量应该定义在implementation部分，除非你需要在子类中直接访问实例。如果在子类中需要访问父类的实例变量，那么就定义在interface部分。

    可以用一下语法声明实例变量的访问范围：

    @public              可以在任何位置访问

    @package          可以在包内部访问，一个项目一定是在同一个包下

    @protected        可以在本类内部和子类内部访问

    @private             只可以在本类内部访问


//
//  TRStudent.h
//  day04-2
//
//  Created by tarena on 14-3-20.
//  Copyright (c) 2014年 tarena. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface TRStudent : NSObject
{
    int _age; //默认是protected
    @public
    int _height; //所有文件都可以访问
    @package
    int _weight; //只能在当前项目中访问
    @protected
    BOOL gender; //只能在本类或子类访问
    @private
    float salary; //只能在本类访问
}
@end

//
//  TRStudent.m
//  day04-2
//
//  Created by tarena on 14-3-20.
//  Copyright (c) 2014年 tarena. All rights reserved.
//

#import "TRStudent.h"

@implementation TRStudent

@end


//
//  main.m
//  day04-2
//
//  Created by tarena on 14-3-20.
//  Copyright (c) 2014年 tarena. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "TRStudent.h"

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        
        TRStudent* stu = [[TRStudent alloc]init];
        stu->_age = 10; //不能访问，报错
        stu->_height = 170;
        stu->_weight = 65;
        stu->gender = YES; //不能访问，报错
        
    }
    return 0;
}

2. 继承（Inheritance）

    2.1 概念

继承是一种代码复用技术，是类与类之间的一种关系。

类A继承了类B，类A中就直接拥有B中的所有属性和方法。我们把A类叫B类的子类（派生类），把B类叫A类的父类（基类）。

    2.2 继承的方式

单继承

    一个类只有一个父类。

    OC   java   C#

多继承

   一个类可以有多个父类。

   C++

    2.3 OC的继承语法

@interface 类 : 父类

@end

    2.4 继承是一种关系

继承是类与类之间的关系，是一种"is a"关系。

狗是动物    狗 : 动物

Computer has a CPU， has a 有一个  不能用继承描述。

    2.5 方法的重写（覆盖）  override

       子类对继承来的父类方法不满意，可以重新在子类定义一个相同的方法，进行覆盖掉从父类中继承来的方法。叫方法的重写（或覆盖）

        重写需要遵守如下原则：

        1）方法名相同

        2）参数类型相同

        3）返回值相同

    2.6 初始化方法的继承和对象创建过程

创建一个对象的过程：

    1）分配内存空间

    2）递归的创建父类对象（调用父类对象的初始化方法）

    3）初始化当前对象

dealloc方法的调用与初始化方法的顺序正好相反。

在dealloc方法的最后一行，一定要调用父类的dealloc方法，[super dealloc]方法是必须的。



练习：

    写出以下类，简单实用之。（括号里是方法或者属性）

        TRShape  形状类           (peremeter  area  show)

                |                                

----------------------------------------------

   |                                                          |

TRRectange  (width，height)          TRCircle(radius)

     |

TRSquare  (side)


3. 继承的缺陷

    1）提高程序的复杂度，维护性和扩展性会降低

    2）破坏类的封装性


    慎用继承


4. 为什么用继承

    1）代码复用

    2）指定规则

    3）为了多态


5. 组合或聚合（Combination and Aggregation ）

    复用代码更好的方式是组合或聚合，而不是继承。

   组合和聚合描述是类与类之间"has a"的关系。

        Computer has a CPU

        在一个类中定义另一个类的属性的方式来完成组合或聚合。

//创建项目Inheritance：
//创建类TRAnimal
@interface TRAnimal : NSObject
@property (copy) NSString * name;
@property int size;
- (void)eat;
- (void)sleep;
- (id)initWithName:(NSString*)name andSize:(int)size;
@end

@implementation TRAnimal
- (void)eat
{
NSLog(@"动物%@吃", self.name);
}
- (void)sleep
{
NSLog(@"动物%@睡", self.name);
}
- (id)initWithName:(NSString*)name andSize:(int)size
{
if(self = [super init])
{
self.name = name;
self.size = size;
}
return self;
}
-(void)dealloc
{
[_name release];    //对象name是copy的
NSLog(@"狗对象被销毁"，self.name);
[super dealloc];
}
@end

//创建类TRDog
#import "TRAnimal.h"

@interface TRDog : TRAnimal
@property int age;
- (void)watchHome;
- (void)bark: (int)n;
- (id)initWithName:(NSString *)name andSize:(int)size age:(int)age;
@end


@implemantation TRDog
- (id)initWithName:(NSString *)name andsize:(int)size age:(int)age    //初始化方式
{
if(self  = [super initWithName:name andSize:size])   //调用父类初始化方法
{
self.age = age;
NSLog(@"狗对象被创建"，self.name);
}
return self;
}

- (void)watchHome
{
NSLog(@"狗狗%@在看家", self.name);
}

- (void) eat    //方法的覆盖（重写）
{
NSLog(@"狗狗%@吃骨头",self.name);
}

- (void)bark: (int)n
{
for(int i = 0; i<n; i++)
{
NSLog(@"狗狗%@在旺旺的叫",self.name);
}
}
- (void) dealloc()
{
NSLog(@"狗对象被销毁"，self.name);
[super dealloc];
}

@end

@interface TRPet : TRDog
- (id)initWithName:(NSString *)name size:(int)size age:(int)age;
@end

@implementation TRPet
- (id)initWithName:(NSString *)name size:(int)size age:(int)age
{
if(self = [super initWithName:name size:size age:age])
{
NSLog(@"宠物狗对象被创建"，self.name);
}
}
- (void)bark:(int)n
{
for(int i = 0; i<n; i++)
{
NSLog(@"小狗狗%@很好听地叫",self.name);
}
}

- (void)dealloc
{
NSLog(@"宠物狗对象被销毁"，self.name);
[super dealloc];
}

@end

//main.m中：
#import "TRDog.h"
void test()
{
TRDog *dog = [[TRDog alloc]init];
dog.name = @"旺财";
dog.size = 30;
[dog eat];
[dog sleep];
[dog watchHome];
NSString* desc = [dog description];    //任何类都有此方法，继承Object
NSLog(@"desc:%@", desc);    //NSLog(@"%@", dog);
[dog release];
}

void test2()
{
TRDog *dog = [[TRDog alloc]initWithName:@"阿黄" andSize:100];
[dog catchMouse];
[dog release];
}

void test3()
{
TRPet *pet = [[TRPet alloc]initWithName:@"小黄" size:30 age:3]
NSLog(@"pet:%@,%d,%d", pet.name, pet.size, pet.age);
[pet release]
}

int main(int argc, const char * argv[])
{
@autoreleasepool{
//test();
test2();
}
return 0;
}

3. 多态（Polymorphism）

    3.1 概念

多种形态，变量的多种形态。

对于一个引用（指针）变量，可以指向任何子类的对象。也可以指向本类型的对象。

对于同一个指针，指向的对象类型不同，当通过该指向发送消息时，调用的方法会不同，此时，方法的调用是多态的。

    NSObject *obj = @"abc";

    NSString *desc = [obj description];

    obj = [[TRPoint alloc]init];

    desc = [obj description];

    3.2 编译期类型和运行期类型

          在多态下，父类的引用可以指向子类的对象。但当编译器编译程序时，编译器无法确定引用指向的对象时什么类型，所以编译会将引用当做父类型做编译检查，如果调用的方法父类中没有，则编译警告。但程序运行期间，通过父类的引用向子类对象发消息时，调用的方法却是子类的方法。

            TRAnimal *a = [[TRDog alloc]init];

            编译将a当做TRAnimal类型来看，叫编译器类型

            运行时，系统将a当做TRDog类型来看，叫运行期间类型。

    3.3 多态的好处

          可以让我们设计出更加合理的架构，写出更加通用的程序，更加提高程序的可维护性和扩展性。

    3.4 多态的表现

1）多态在方法的参数的表现

2）方法的返回值

3）数组或集合体现多态

//创建项目Ploymorphism
@interface TRAninal : NSObject
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int size;
- (void)eat;
-(void)sleep;
- (id)initWithName:(NSString*)name andSize:(int)size;
@end

@implemenatation TRAnimal
- (void)eat
{
    NSLog(@"动物吃");
}
-(void)sleep
{
    NSLog(@"动物吃");
}

- (id)initWithName:(NSString*)name andSize:(int)size
{
    if(self = [super init])
    {
        self.name = name;
        self.size = size;
    }
    return self;
}
@end


//创建子类TRDog
@interface TRDog : NSAnimal
- (void)watchHome;
@end

@implementation
- (void)watchHome
{
    NSLog(@"狗看家");
}

- (void)eat
{
    NSLog(@"狗吃骨头");
}

@end

//main.m中：

void testPoly()
{
    TRAnimal *a = [[TRDog alloc]initWith:@"阿黄" andSize:50];    //父类型指针指向子类型对象
    [a eat];    //调用子类的方法  打印了"狗吃骨头"
    [a sleep];    //调用父类的方法   打印了"动物睡"
    //[a watchHome];
    [a release];
}
//参数具有多态特征
void show(TRAnimal* a)
{
    [a eat];
    [a sleep];
}

void testParameter()
{
    TRDog *dog = [[TRDog alloc]init];
    show(dog);    //a = dog;
    TRCat *cat = [[TRCat alloc]init];
    show(cat);
    [dog release];
    [cat release];
}

typedef enum Animals{
    ANIMAL,
    DOG,
    CAT,
}Animals;

//返回值上的多态
TRAnimal* get(Animals type)
{
    if(type == ANIMAL)
    {
        return [[[TRAnimal alloc]init]autorelease];
    }
    if(type == DOG)
    {
        return [[[TRDog alloc]init]autorelease];
    }
    if(type == CAT)
    {
        return [[[TRCat alloc]init]autorelease];
    }
}

//数组或集合体现多态
void testArrayPoly()
{
    TRAnimal* as[5];
    as[0] = [[TRDog alloc]init];
    as[1] = [[TRCat alloc]init];
    as[2] = [[TRAnimal alloc]init];
    as[3] = [[TRDog alloc]init];
    as[4] = [[TRCat alloc]init];
    for (int i = 0; i<5; i++)
    {
        [as[i] eat];
    }
}

int main(int argc, const char * argv[])
{
    @autoreleasepool{
        testPoly();
    }
    return 0;
}


OrigHeart
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java封装继承多态实验总结_java封装继承多态理解3000字论文
weixin_36302331的博客
03-09 1201
一、怎么理解JAVA中封装、继承、多态他是一个“司机”，他的平时行为还有“开车”，我们再次划分出了“哺乳动物”这个类，一个类只能继承另一个类(或抽象类)但可以实现多个接口。打个比方封装，“鱼”等等)，接着，最后有“马”。 多态，正如上面朋友所说一重写，二重载。用汉字来打个比方，很显然，比如“开”这个字，在不同的时候各有的意思，比如“开门”、继承、多态 继承，先说说我对类的理解，类起到的作用有：分类...
Java封装继承多态练习题
qq_44918461的博客
08-09 3273
题目描述 某公司的雇员分为以下若干类： Employee：这是所有员工总的父类， 属性：员工的姓名，员工的生日月份。 方法：getSalary(intmonth) 根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励100 元。 SalariedEmployee：Employee 的子类，拿固定工资的员工。 属性：月薪 HourlyEmployee： Employee 的子类， 按小时拿工资的员工，每月工作超出160 小时的部分按照1.5 倍工资发放。 属性：每小时的工资、每月工作的小时数 Sale
Java 封装 继承 多态（深入理解）
2302_79806056的博客
03-08 3688
详细解析了面向对象编程（java）的三大特性：封装继承和多态（超详细）收藏精品，帮助加深理解
C++ 封装、继承和多态
SimpleForest的博客
07-08 1234
多态指的是同一个函数名可以调用不同类型的函数，从而实现不同对象之间的差异性行为。静态多态是通过函数重载和运算符重载来实现的，而动态多态则是通过虚函数来实现的。多态的目的是实现代码的灵活性和可扩展性，使得程序可以更好地适应不同的应用场景。封装是指的是将数据和操作数据的方法封装在类中，使得数据和方法不能被外部直接访问，只能通过类的公共接口进行访问和修改。封装的目的是实现代码模块化和信息隐藏，提高代码的可维护性和可重用性。继承是指的是一个类（子类）通过继承另一个类（父类）的属性和方法，从而实现代码的扩展。
C++封装继承多态理解
奋斗Andy的博客
12-29 2792
面向对象的三个基本特征: 封装 、继承 、多态 简单概括三大特性作用： 封装是为了代码模块化和增加安全性 继承是为了重用和扩展现有的代码模块 多态是为了接口复用 封装： 保护数据成员，不让类以外的程序直接访问或者修改类的成员，只能通过其成员对应方法访问(即数据封装) 隐藏方法实现的具体细节，仅仅提供接口， 内容修改不影响外部调用(即方法封装) 继承： 三种继承方式：public、protected、private。 继承的...
封装继承多态（详解）
weixin_45847110的博客
08-15 1324
封装继承多态
C++ 类的封装继承多态
恋恋风辰的技术博客
04-28 2266
C++ 特性 C++ 三大特性，封装继承多态。我们先实现一个Quote作为基类 class Quote { public: Quote() = default; Quote(const std::string &book, double sales_price) { price = sales_price; bookNo = book; } std::string isbn() const { retu
C++中的封装继承多态
m0_46663240的博客
07-31 764
之后当我学习了面向对象的分析设计编程思想，开始考虑通过封装、继承、多态把程序的耦合度降低，传统印刷术的问题就在于所有的字都刻在同一版面上造成耦合度太高所致，开始用设计模式使得程序更加的灵活，容易修改，并且易于复用。多态不同对象收到相同的的消息时（即调用相同的函数），产生不同的动作。继承就是派生类会获得父类所有公开权限的成员函数和成员变量，这样少去了重新定义的麻烦，另外派生类还可以增加其他的函数，扩展父类，以及重写父类函数，增加这个可拓展性，因为会遇到很多不同的情况，如果没有这种应变能力，就太死板了。...
Java面向对象三大特性(封装继承多态)解释及案例
coderge's CSDN Blog.
11-12 1665
继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过。测试类中添加一个方法showEmpAnnual(Employee e),实现获取任何员工对象的年工资，并在main方法中调用该方法[e.getAnnual()]简单的说:方法覆盖(重写)就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样那么我们就说子类的这个方法覆盖了父类的那个方法。
java封装继承多态实验总结_java实验报告2继承多态封装.docx
weixin_39778447的博客
03-09 811
?鬲昌大承实验报告学生姓名： 学 号：专业班级：实验类型：口验证 □综合 □设计 □创新 实验日期： 实验成绩：一、实验项目名称抽象、封装与类(一)二、实验目的掌握抽象、封装、继承和多态熟练掌握如何白定义一个类。掌握类的访问权限掌握类成员的访问控制三、实验基本原理四、主要仪器设备及耗材Myclipse五、实验步骤1、调试程序例3-42、编写如下程序。定义一个表示学生的类Student,包括属性“...
TWDH#Leetcode-From-Zero#28.封装 继承 多态1
07-25
多态所谓多态就是指程序中定义的 引用变量所指向的具体类型 和 通过该引用变量发出的方法调用在编程时 ==并不确定==，而是在程序运行期间才确定，即一个引用变量到
详解java封装继承多态
08-26
Java 封装继承多态详解 Java 中的封装、继承和多态是面向对象编程（Object Oriented Programming）三大特性。下面，我们将详细介绍这三者之间的关系和应用。 封装是指将数据和方法放入类中，并控制对数据的访问...
C#封装继承多态
11-05
这是关于C#封装继承多态的一个简单的例子，对于深入学习C#中封装继承多态将很有帮助！
da06抽象继承封装多态接口.zip
05-25
在编程领域，面向对象编程（OOP）是设计和实现软件的一种重要方法，它强调了类、对象、继承、封装、多态等核心概念。在Flutter框架中，这些概念同样得到了广泛的应用。Flutter是一个用于构建高性能、高保真度的移动...
11. 分类、扩展、协议、ARC
lk972105的专栏
03-24 1694
增强一个类的能力 在面向对象编程中，有两种方式可以增强一个类的功能，一种是继承，另一种是遵守一个协议。 继承：子类可以拥有父类所有的属性和                方法，子类可以重写父类的方法。                                          老盖茨说这种“勤奋”与生俱来，从祖父             辈到他，再到比尔.盖茨，最大的共同点  
07. self指针
lk972105的专栏
03-24 848
self是什么     self在一个方法中代表当前对象。给一个对象发消息，对象调用相应的方法，方法中的self就指向这个对象。     self是指针变量。指向自己（当前对象）。     当给一个对象发消息时，对象会调用相应的方法，对象在调用方法时，一定会讲对象本身的地址传给方法，方法会用self指针
08. 内存管理
lk972105的专栏
03-24 695
1. 内存管理     1.1 进程空间 代码区：只读 全局区：进程启动时分配，进程结束时释放 栈区：局部变量，自动分配和释放内存 堆区：所有的对象，是自由区，分配和释放都要程序主动进行 内存管理主要是对堆区进行管理。所谓的管理，其实就是分配和释放空间。     1.2 iOS的内存管理方式 Reference Counting（引用计数器） 1) MRC   M
Java 封装继承多态
最新发布
06-20
Java 是一种广泛使用的面向对象编程语言，其核心特性包括封装、继承和多态。以下是这三个概念的简介： 1. **封装**：封装是将数据和操作数据的方法（函数或方法）捆绑在一起形成一个独立的单元，即类。这样，外部只能通过类提供的接口（公共方法）访问数据，隐藏了内部实现细节，提高了代码的安全性和可维护性。 2. **继承**：继承是一种机制，允许一个类（子类）从另一个类（父类）继承属性和行为。子类可以重写（覆盖）父类的方法，也可以添加新的属性和方法，从而扩展或修改父类的功能。这促进了代码的复用和模块化。 3. **多态**：多态是指同一种行为具有多种形态的能力。在Java中，通过方法重载（不同参数列表）和方法覆盖（子类提供自己的实现）实现多态。调用的对象可以根据上下文自动匹配合适的方法，即使对象是子类实例，也能调用父类的方法，这就是动态绑定的体现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值