Question: Novice here attempting to understand inheritance. If I initialize a new object with several properties and I want other classes to help assign values to those properties, do I need to create instances of those other classes? Visualized:

```
-(ObjA *)init{
    self = [super init];
    self.property1 = [method from Class A];
    self.property2 = [method from Class B];
    self.property3 = [method from Class C]; etc...
    return self;
 }

```

In other words, assuming Class A, B, and C need to know what Object A is, would I need to make those class methods instance methods and initialize each object? Is there another way to go about this? Thank you in advance for your help.

Answer: 
> 
> In other words, assuming Class A, B, and C need to know what Object A
>  is
> 
> 
> 

**NO**.

---

You can simply call a method from ClassA/B/C etc. But the return type must match with respective `property`.

Let, the `property1` is for kind `NSString` then your `ClassA` method must be 

```
-(NSString *)methodClassA{
   ...
   return someStringValue;
}

```

Then you need to use:

```
ClassA *objClassA=[ClassA new];
self.property1=[objClassA methodClassA];

```

---

Or you can go with class method by this:

```
+(NSString *)methodClassA{
   ...
   return someStringValue;
}

```

And using it as:

```
self.property1=[ClassA methodClassA];

```
```
assuming Class A, B, and C need to know what Object A is

```

The initialization code of an object should be self contained, unless it is using functionality owned by a different object, in which case the object acts as a client of that functionality. That is, objectA acts as client of A,B,C (as seen in your code).

But this doesn't imply that A,B,C need to know (have a dependency on) objectA. By doing that, you are saying that they don't have a reason to exist on their own.

In general, 

* Every class or method should have one encapsulated purpose. This makes it easy to understand, change, and test in isolation. It's a common pattern to create classes whose sole purpose is to encapsulate information to create a different class, but to split that in three different classes is beyond weird (as in, I can't imagine an example of that).
* An object shouldn't be allowed to exist in an unusable state, nor should it require non essential information when it is created. Does objectA require those properties to function? if it does, your code is right, if it doesn't, the initializer is providing too much information and making it less reusable.

Try to rethink your doubt with a real (instead abstract) example. You may end up making sense of it yourself.