OC3-父类指针指向子类对象

//
//  Cat.h
//  OC3-父类指针指向子类对象
//
//  Created by qianfeng on 15/6/17.
//  Copyright (c) 2015年 qianfeng. All rights reserved.
//

#import "Animal.h"

@interface Cat : Animal
{
    float _height;
}
@property (assign,nonatomic)float height;
@end

//
//  Cat.m
//  OC3-父类指针指向子类对象
//
//  Created by qianfeng on 15/6/17.
//  Copyright (c) 2015年 qianfeng. All rights reserved.
//

#import "Cat.h"

@implementation Cat
-(void)printAnimalFood
{
    NSLog(@"cat like to eat fish");
}
-(NSString *)description
{
    return [NSString  stringWithFormat:@"name=%@,age=%li,height=%.2f",_name,_age,_height];
}
@end
//
//  Dog.h
//  OC3-父类指针指向子类对象
//
//  Created by qianfeng on 15/6/17.
//  Copyright (c) 2015年 qianfeng. All rights reserved.
//

#import "Animal.h"

@interface Dog : Animal
{
    float _weight;
}
-(void)printAnimalHaHa;
@property (assign,nonatomic) float weight;
@end

//
//  Dog.m
//  OC3-父类指针指向子类对象
//
//  Created by qianfeng on 15/6/17.
//  Copyright (c) 2015年 qianfeng. All rights reserved.
//

#import "Dog.h"

@implementation Dog
-(void)printAnimalFood
{
    NSLog(@"dog like to eat bone");
}
//-(NSString *)description
//{
//    return [NSString stringWithFormat:@"name=%@,age=%li,weight=%.2f",_name,_age,_weight];
//}

-(void)printAnimalHaHa
{
    NSLog(@"HaHa");
}
@end
//
//  Animal.h
//  OC3-父类指针指向子类对象
//
//  Created by qianfeng on 15/6/17.
//  Copyright (c) 2015年 qianfeng. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface Animal : NSObject

{
    NSString *_name;
    NSInteger _age;
}
@property (copy,nonatomic)NSString *name;
@property(assign,nonatomic)NSInteger age;
-(void)printAnimalFood;
@end

//
//  Animal.m
//  OC3-父类指针指向子类对象
//
//  Created by qianfeng on 15/6/17.
//  Copyright (c) 2015年 qianfeng. All rights reserved.
//

#import "Animal.h"

@implementation Animal
-(void)printAnimalFood
{
    NSLog(@"-----Animal");
}
-(NSString *)description
{
    return [NSString stringWithFormat:@"name111=%@,age=%li",[self name],self.age];
}
@end
//
//  main.m
//  OC3-父类指针指向子类对象
//
//  Created by qianfeng on 15/6/17.
//  Copyright (c) 2015年 qianfeng. All rights reserved.
//

#import <Foundation/Foundation.h>
#import "Dog.h"
#import "Cat.h"
#import "Animal.h"

void showAnimalFood(Animal *ani)
{
    [ani printAnimalFood];
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {

        Dog    *xiaohei =[[Dog alloc] init];
        xiaohei.name=@"xiaogei";
        xiaohei.age=12;
        xiaohei.weight=12.6;

        //[xiaohei description];
        NSLog(@"%@",xiaohei);

        Cat *xiaomao =[[Cat alloc] init];
        xiaomao.name=@"xiaomao";
        xiaomao.age=12;
        xiaomao.height=12.6;
        //[xiaohei description];
        NSLog(@"%@",xiaomao);
        //父类的对象指针可以指向子类的对象
        //调用的方法看具体的对象类型,先从子类查找对应的方法实现,如果子类没有实现对应的方法,跳到父类查找对应的方法实现,如果父类没有实现对应的方法,再跳到父类的父类查找对应的方法实现.
        Animal *ani =xiaohei;
        [ani printAnimalFood];

        ani=xiaomao;
        [ani printAnimalFood];

        showAnimalFood(xiaomao);
        showAnimalFood(xiaohei);
        //根据传入的不同的对象,做出不同的响应.多态

    }
    return 0;
}
时间: 2024-10-26 00:13:08

OC3-父类指针指向子类对象的相关文章

用父类指针指向子类对象

class A {public:A() { printf("A \n"); }~A() { printf(" ~A \n"); } // 这里不管写不写virtual,删除B对象的时候,都会被执行.因为这个例子是B*指针指向B对象,不是A*指针指向B对象.}; class B : public A{public:B() { printf("B \n"); }~B() { printf("~B \n"); }}; int mai

当父类指针指向子类对象时的函数调用

class A { public: void FuncA() { printf( "FuncA called\n" ); } virtual void FuncB() { printf( "FuncB called\n" ); } }; class B : public A { public: void FuncA() { A::FuncA(); printf( "FuncAB called\n" ); } virtual void FuncB(

基类与派生类,父类指针指向子类对象

先看一段代码: 1 #include<iostream> 2 3 using namespace std; 4 5 class Base{ 6 public: 7 Base() { cout<<"Base Creted"<<endl; } 8 ~Base() { cout<<"Base Destroyed"<<endl; } 9 }; 10 11 class Derived: public Base { 1

关于父类引用指向子类对象

例如: 有以下2个类 public class Father { public int age = 70; public static string name = "父亲"; } public class Son : Father { public int age = 30; public static string name = "儿子"; } Father f=new Son(); 这种用法叫做“父类引用指向子类对象,或者叫“父类指针指向子类对象”,指的是定义一

java父类引用指向子类对象

父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog.其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类. Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象. 那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态.动态链接,向上转型 也有人说这是面向接口编程,可以降低程序的耦合性,即调用者不必关心调用的是哪个对象,只需要针对接口编程就可以了,被调用者对于调用者是完全透明的.让你更关

【转】父类引用指向子类对象

父类引用指向子类对象指的是: 例如父类Animal,子类Cat,Dog.其中Animal可以是类也可以是接口,Cat和Dog是继承或实现Animal的子类. Animal animal = new Cat(); 即声明的是父类,实际指向的是子类的一个对象. 那这么使用的优点是什么,为什么要这么用?可以用这几个关键词来概括:多态.动态链接,向上转型 也有人说这是面向接口编程,可以降低程序的耦合性,即调用者不必关心调用的是哪个对象,只需要针对接口编程就可以了,被调用者对于调用者是完全透明的.让你更关

父类引用指向子类对象

1 public class Test { 2 /** 3 * 对于多态,可以总结它为: 4 5 一.使用父类类型的引用指向子类的对象: 6 7 二.该引用只能调用父类中定义的方法和变量: 8 9 三.如果子类中重写了父类中的一个方法,那么在调用这个方法的时候,将会调用子类中的这个方法:(动态连接.动态调用) 10 11 四.变量不能被重写(覆盖),”重写“的概念只针对方法,如果在子类中”重写“了父类中的变量,那么在编译时会报错. 12 13 多态的3个必要条件: 14 15 1.继承 2.重写

理解父类引用指向子类对象

java多态,如何理解父类引用指向子类对象 要理解多态性,首先要知道什么是“向上转型”. 我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类.我可以通过   Cat c = new Cat(); 实例化一个Cat的对象,这个不难理解. 但当我这样定义时:   Animal a = new Cat(); 这代表什么意思呢? 很简单,它表示我定义了一个Animal类型的引用,指向新建的Cat类型的对象.由于Cat是继承自它的父类Animal,所以Animal类型的引用是可以指向C

java多态,如何理解父类引用指向子类对象

摘录 要理解多态性,首先要知道什么是“向上转型”. 我定义了一个子类Cat,它继承了Animal类,那么后者就是前者是父类.我可以通过   Cat c = new Cat(); 实例化一个Cat的对象,这个不难理解. 但当我这样定义时:   Animal a = new Cat(); 表示定义了一个Animal类型的引用,指向新建的Cat类型的对象.由于Cat是继承自它的父类Animal,所以Animal类型的引用是可以指向Cat类型的对象的. 那么这样做有什么意义呢?因为子类是对父类的一个改进