php oop接口或抽象类

Can anyone give me an example of the following desired OOP structure please.

I want a main class (super class) (interface or abstract class?) where all the other classes that are extending from it can have their functions called from instances of the main super class.

e.g.

class mainSupoerClass() {

}

class doWork exends mainSupoerClass(){
    public function addEntity(){
        //do stuff for entity
    }
}

I want be able to do this:

$data = new mainSupoerClass;
$data->addEntity();  (doesnt belong to this class but its fetching the function from doWork class)

Can anyone give me a start on the correct OOP structure to carry out this work?

In simple terms, you can't. You have to instantiate the extended class and you'll get all functions within the instantiated class and also the parent class/classes.

Is there any reason you need this to be done this way?

That won't work the way you describe it. PHP (nor any other language) can know which derived class you refer too. It would work if you instantiate doWork instead of mainSupoerClass.

I think you are looking for the factory pattern, but I'm not sure. With that pattern, you build an interface (either an interface or an abstract class), and let a factory instantiate any descendant of that class.

Now your code doesn't need to know which instance it is, because it can call any method declared in the interface/abstract base class.

An interface is more flexible in this regard. If you create an abstract class, you will need to derive all other classes from that class. Usually this won't be a problem, but sometimes you want a whole new implementation. In that case, an interface is better. You can implement the interface in a completely different class, and still make use of PHP's typehinting for validating that any object you pass to a function or method implements the interface.

Even it's called super-class, it does not mean that it has all classes defined elsewhere. The methodology is the following:

[super] --> [concrete]

and not

[concrete] --> [super]

So a concrete class extends the superclass. The concrete class will then have everything of the superclass plus what the concrete class has / overwrites - but not the other way round.

class Super
{
    public function a() {}
}

class Concrete extends Super
{
    public function b() {}
}

Super has ::a() and in addition Concrete has ::b(). But Super will never have ::b().

Additionally even you have multiple classes, there is always one instance regardless of how many classes it is compound of, commonly called object:

$object = new Concrete;

This makes a Concrete object.

You'll have to read. Try these:

Article: http://sourcemaking.com/design_patterns/abstract_factory

Code: http://sourcemaking.com/design_patterns/abstract_factory/php/2

It appears that the factory design pattern is what you are looking for.

I don't understand why you wanted to be able to do:

(doesnt belong to this class but its fetching the function from doWork class)

What's the reason behind it?