Objective c 从超类返回'；方法的实现

我有一个父类

parent

和一个子类

child

Parent

有一个方法

doSomething

，该方法由

Child

扩展（它在执行自己的操作之前调用

[super doSomething]

）

在某些情况下，家长会检查一些细节，并知道不会再发生任何事情，因此会返回。我希望父实现中有一个return语句来阻止子实现继续，但事实似乎并非如此。儿童基金会继续执行。这个诊断正确吗

如果是这样，我如何才能实现我所追求的目标

---

在我的实际应用程序中，父级正在做大量的工作来检查它是否应该返回，我不希望在它的多个子级中的每个子级中都重复这些代码。

对于子级，它看起来只是在调用另一个方法。当该方法返回时，它将继续其其余的实现。它不知道您返回的原因是您不想在重写的实现中再运行代码

---

您可以做的是，使用一个来自超类的

BOOL

返回值，检查它是否在子类中返回

YES

或

NO

，并根据该值决定是否继续。对于子类，它看起来只是在调用另一个方法。当该方法返回时，它将继续其其余的实现。它不知道您返回的原因是您不想在重写的实现中再运行代码

---

您可以做的是，使用一个来自超类的

BOOL

返回值，检查它是否在子类中返回

YES

或

NO

，并根据该值决定是否继续。对于子类，它看起来只是在调用另一个方法。当该方法返回时，它将继续其其余的实现。它不知道您返回的原因是您不想在重写的实现中再运行代码

---

您可以做的是，使用一个来自超类的

BOOL

返回值，检查它是否在子类中返回

YES

或

NO

，并根据该值决定是否继续。对于子类，它看起来只是在调用另一个方法。当该方法返回时，它将继续其其余的实现。它不知道您返回的原因是您不想在重写的实现中再运行代码

---

您可以做的是，使用一个来自超类的

BOOL

返回值，检查它是否在子类中返回

YES

或

NO

，并根据该值决定是否继续。

一种方法是将

doSomething

更改为返回值

BOOL

。如果方法完全完成，则返回

YES

，否则返回

NO

。然后，您可以执行以下操作：

家长：

- (BOOL)doSomething {
    // lots of processing
    if (/* can't finish for some reason */) {
        return NO;
    } else {
        return YES;
}

儿童：

- (BOOL)doSomething {
    BOOL res = [super doSomething];
    if (res) {
        // complete child processing
    }

    return res;
}

---

一种方法是将

doSomething

更改为返回值

BOOL

。如果方法完全完成，则返回

YES

，否则返回

NO

。然后，您可以执行以下操作：

家长：

- (BOOL)doSomething {
    // lots of processing
    if (/* can't finish for some reason */) {
        return NO;
    } else {
        return YES;
}

儿童：

- (BOOL)doSomething {
    BOOL res = [super doSomething];
    if (res) {
        // complete child processing
    }

    return res;
}

---

一种方法是将

doSomething

更改为返回值

BOOL

。如果方法完全完成，则返回

YES

，否则返回

NO

。然后，您可以执行以下操作：

家长：

- (BOOL)doSomething {
    // lots of processing
    if (/* can't finish for some reason */) {
        return NO;
    } else {
        return YES;
}

儿童：

- (BOOL)doSomething {
    BOOL res = [super doSomething];
    if (res) {
        // complete child processing
    }

    return res;
}

---

一种方法是将

doSomething

更改为返回值

BOOL

。如果方法完全完成，则返回

YES

，否则返回

NO

。然后，您可以执行以下操作：

家长：

- (BOOL)doSomething {
    // lots of processing
    if (/* can't finish for some reason */) {
        return NO;
    } else {
        return YES;
}

儿童：

- (BOOL)doSomething {
    BOOL res = [super doSomething];
    if (res) {
        // complete child processing
    }

    return res;
}

---

下面是一个典型的object init方法，我相信您一定很熟悉：

- (id)init
{
   self = [super init];
   if(self) {
        // init self
   }
   return self;
}

您可以做一些非常类似的事情：检查对超级实现的调用的返回值，并根据返回值执行（或不执行）一些操作，如下所示：

- (ResultType)doSomething
{
   ResultType *result = [super doSomething];
   if(result == nil) {
        result = // do something here
   }
   return result;
}

---

下面是一个典型的object init方法，我相信您一定很熟悉：

- (id)init
{
   self = [super init];
   if(self) {
        // init self
   }
   return self;
}

您可以做一些非常类似的事情：检查对超级实现的调用的返回值，并根据返回值执行（或不执行）一些操作，如下所示：

- (ResultType)doSomething
{
   ResultType *result = [super doSomething];
   if(result == nil) {
        result = // do something here
   }
   return result;
}

---

下面是一个典型的object init方法，我相信您一定很熟悉：

- (id)init
{
   self = [super init];
   if(self) {
        // init self
   }
   return self;
}

您可以做一些非常类似的事情：检查对超级实现的调用的返回值，并根据返回值执行（或不执行）一些操作，如下所示：

- (ResultType)doSomething
{
   ResultType *result = [super doSomething];
   if(result == nil) {
        result = // do something here
   }
   return result;
}

---

下面是一个典型的object init方法，我相信您一定很熟悉：

- (id)init
{
   self = [super init];
   if(self) {
        // init self
   }
   return self;
}

您可以做一些非常类似的事情：检查对超级实现的调用的返回值，并根据返回值执行（或不执行）一些操作，如下所示：

- (ResultType)doSomething
{
   ResultType *result = [super doSomething];
   if(result == nil) {
        result = // do something here
   }
   return result;
}

---

一种解决方案是将检查doSomething是否应该提前返回的逻辑提取到一个单独的函数中，该函数返回BOOL，然后从父级和子级调用该函数

e、 g

---

一种解决方案是将检查doSomething是否应该提前返回的逻辑提取到一个单独的函数中，该函数返回BOOL，然后从父级和子级调用该函数

e、 g

---

一种解决方案是将检查doSomething是否应该提前返回的逻辑提取到一个单独的函数中，该函数返回BOOL，然后从父级和子级调用该函数

e、 g

---

一种解决方案是将检查doSomething是否应该提前返回的逻辑提取到一个单独的函数中，该函数返回BOOL，然后从父级和子级调用该函数

e、 g

---

我正在考虑的另一个解决方案是将“测试”和“操作”分开，如下所示。