封装、继承

2023-10-14 21:38:28

封装：就是包装。

1.接口可以说是只涉及声明方法(没去实现方法)的抽象基类。

2.封装隐藏类内部的实现，稳定类外部接口。

属性封装了实例变量。

方法封装了具体实现代码。

类封装了属性和方法。

3.封装好处

使用更简单，开发速度更快。不再象面向过程编写零散。

变量更安全。类里的参数隐藏了。

可以隐藏实现细节。

继承：是一个类拥有另一个类的某些特征和行为的特性。

1.好处:代码可复用。用处：提取类间共同信息。

2.抽象：现实提取信息到模型的过程

3.越往上(基类)越简单、抽象，越往下越具体。现实中的分析过程从下往上着手。金字塔模式。

4.被继承的类称父类（超类），继承的类称子类，子类可直接“拥有”父类中所有非私有成员变量、成员方法。

5.super编译指示符可以调用父类方法。

6.OC中属性是特殊的方法，属性就等于设置器同访问器。

7.OC中的方法都是公有方法，因此子类都能继承父类的方法。

8.问题：当子类继承父类的方法时，父类不能满足子类的需求，那么写类就可以根据子类实际需求选择修改or放弃。

9.方法重写（覆盖）overRide：即子类重写父类方法，发生在子类与父类之间。

需求：

a.父类方法部分能用（局部覆盖）。

b.父类方法完全不能用（完全覆盖）。

10.（目前在OC中还没重载这个概念）方法重载overLoad：一般发生在本类里面。

作用：丰富该类功能，使其支持多种数据类型等。

重载的定义：当类中方法名字一样，但方法的形参类型或形参个数不一样时，这个方法就是方法的重载。

返回值不作重载的标记，方法重载与返回值无关。（如void add(int a);int add(int a);不叫重载）

注意：-eat与-eat:是不一样的方法名

11.OC中哪个初始化就是那个类。

子类初始化可以赋值给父类对象，转回子类类型的时候要记得强转。父类初始化不建议赋值给子类对象（面向接口编程原则）。

12.继承特性

单根性：（OC中只支持单继承）一个子类只能有一个父类。

传递性：属性、方法能多代传递。

里氏替换原则：子类重写父类方法问题。

13.

精确判断对象是否指定类型(BOOL)isMemberOfClass:

判断对象是否指定类型或其子类(BOOL)isKindOfClass:

Animal.h

@interface Animal : NSObject
{
    /*@private修饰私有变量,只能在本类中使用
    @protected修饰保护变量，能在本类与其子类使用.(他是默认值)
    @public修饰公共变量，所以类都能访问，它打破了面向对象的特性，所以不常用，也不建议用它修饰类的成员变量 */
    @private
    NSString *_name;
    BOOL _hasTail;
}

@property(nonatomic,retain)NSString *name;
@property(nonatomic,assign)BOOL hasTail;
-(Animal *)initWithName:(NSString *)aName
                HasTail:(BOOL)aHasTail;

-(void)eat;
-(void)wagTail;
-(void)sleep;
@end

Animal.m

#import "Animal.h"

@implementation Animal
@synthesize name = _name,
            hasTail = _hasTail;

-(Animal *)initWithName:(NSString *)aName
                HasTail:(BOOL)aHasTail
{
    self = [super init];
    if (self)
    {
        self.name = aName;
        self.hasTail = aHasTail;
    }
    return self;
}


-(void)eat
{
    NSLog(@"%@ is eatting",self.name);
}

//目前OC中没有重载概念
//-(void)eat:(NSString *)aMeatName
//{
//    
//}
//-(void)eat:(int *)aGrassName
//{
//    
//}

-(void)wagTail
{
    NSLog(@"%@ is waging tail",self.name);
}
//OC中所有方法都公开的@public，因此子类都可以继承
-(void)sleep;
{
    NSLog(@"%@ is sleeping",self.name);
}

@end

Pet.h

#import "Animal.h"

@interface Pet : Animal
{
    NSString *_color;
    int _legs;
}

@property(nonatomic,retain)NSString *color;
@property(nonatomic,assign)int legs;

-(Pet *)initWithName:(NSString *)aName
             HasTail:(BOOL)aHasTail
               Color:(NSString *)aColor
                Legs:(int)aLegs;

-(void)walk;
-(void)bark;

@end

Pet.m

#import "Pet.h"

@implementation Pet

@synthesize color = _color,legs = _legs;

-(Pet *)initWithName:(NSString *)aName
             HasTail:(BOOL)aHasTail
               Color:(NSString *)aColor
                Legs:(int)aLegs
{
    //self = [self initWithName:aName HasTail:aHasTail];//这里不能这样用，因为self的对象不存在，只是指向对象的指针
    self = [super initWithName:aName HasTail:aHasTail];//比[super init]好
    if (self)
    {
        self.color = aColor;
        self.legs = aLegs;
        //_name = aName;出错
        self.name =aName;
    }
    return self;
}


-(void)walk
{
    NSLog(@"%@ walk",self.name);
}
-(void)bark
{
    NSLog(@"%@ bark",self.name);
}

//重写父类的方法，根据子类自身的特征实现更适合自己的方法
-(void)sleep
{
    //NSLog(@"%@ is sleeping",self.name);完全覆盖
    //局部覆盖
    [super sleep];//调用父类的方法实现部分功能，里氏替换原则
    NSLog(@"%@ is close the eyes",self.name);//子类添加额外的内容实现额外的功能（一般是更强大，更具体的功能）
}
@end

Dog.h

#import "Pet.h"

@interface Dog : Pet

-(void)watchDoor;

@end

Dog.m

#import "Dog.h"

@implementation Dog

-(void)watchDoor
{
    NSLog(@"%@ watchDoor",self.name);
}

@end

Cat.h

#import "Pet.h"

@interface Cat : Pet

-(void)catchMouse;

@end

Cat.m

#import "Cat.h"

@implementation Cat

-(void)catchMouse
{
    NSLog(@"%@ is catching mouse",self.name);
}

@end

Flsh.h

#import "Animal.h"

@interface Flsh : Animal
-(void)swimming;
@end

Flsh.m

#import "Flsh.h"

@implementation Flsh

-(void)swimming
{
    NSLog(@"%@ swimming",self.name);
}

-(void)sleep
{
    [super sleep];
    NSLog(@"%@ open eyes when sleeping",self.name);
}
@end

AppDelegate.m

#import "AppDelegate.h"
#import "Animal.h"
#import "Dog.h"
#import "Cat.h"
#import "Pet.h"
#import "Flsh.h"
@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
    // Override point for customization after application launch.
    self.window.backgroundColor = [UIColor whiteColor];
    
    Dog *d = [[Dog alloc]initWithName:@"旺财"
                              HasTail:YES
                                Color:@"black"
                                 Legs:4];
    [d sleep];
    
    Flsh *f = [[Flsh alloc]initWithName:@"NiMo"
                                HasTail:NO];
    [f sleep];
    //
    Animal *ani =nil;
    ani = [[Dog alloc]initWithName:@"来福"
                           HasTail:YES
                             Color:@"黄色"
                              Legs:4];
    
    [ani sleep];//执行的是子类的方法
    //
    Dog *d1 = [[Dog alloc]initWithName:@"大黄"
                               HasTail:YES
                                 Color:@"黄色"
                                  Legs:4];
    
    Animal *a1 = (Animal *)d1;
    [a1 sleep];
    
//    Dog *d2 = [[Animal alloc] initWithName:@"小白"
//                                   HasTail:YES];
//    [d2 sleep];
    
    Dog *d3 = (Dog *)[[Animal alloc] initWithName:@"小黑"
                                   HasTail:YES];
    [d3 sleep];
    //
    BOOL m = [d3 isMemberOfClass:[Dog class]];
    BOOL k = [d3 isKindOfClass:[Animal class]];
    
    NSLog(@"m = %d , j = %d",m,k);
    //.......................................................
    [self.window makeKeyAndVisible];
    return YES;
}

封装、继承

码农公寓

相关文章