OOP extension method cross-referencing

Anon

Is it just me, or is there a screaming need for an "Advanced OOP Techniques" article? 🙂

Like many programmers who are moving to OOP, I'm finding myself repeating a lot of coding, so I'm trying to sew together a nice "base" class with a few good extensions that cover most of my needs, which you all are familiar with:

base (error handling, timing, etc.)
adodb (or some database abstraction layer)
FastTemplate (or some template scheme)

BUT, I'm having a problem when I try to access method from one extended class in another extended class. For example:

class base {}
class template extends base {}
class news extends base {}

And now a method in the "news" class needs to use a method in "template", say, $this->parse(). Well, this doesn't work. PHP complains that this is an undefined function...

Ok, so one work-around is to instantiate the class ( $tpl = new template; ) within the calling file (the file that is calling this classes), then globalizing $tpl in the news class, thus making $tpl->parse(); available to news.

This, however, seems to be defeating the purpose of the whole "oop-saves-you-lots-of-time" thing.

Enter work-around #2: put ALL the methods you will need in the "base" class! That way, all the methods you know you'll need a LOT are accessible via $this->whatever.

Ok, this is a little bit better, but it does make for a VERY large base class (couple thousand lines), but then, for large complicated sites, this is a good thing, right?

So the question is, am I doing something wrong here? Is there really a way for an extended class to access methods that are in another extended class WITHOUT going through the steps of declaring each extended class individually, globalizing each object, then calling the methods.

Oh, and before anyone posts anything along the lines of "it's obvious you don't know anything about class design..." let me be preemptive: I DON'T know anything about class design, and I AM a brand new programmer, so an explanation (however brief) of WHY my design stinks would be greatly appreciated 🙂.

Thanks in advance!

-DLST

Anon

What you are trying to is called "multiple inheritance" (having a class inherit properties of two classes).

Some languages do support this (C++ does) - some don't (PHP or Delphi for example). Some programmers swear they can't work without it - some say it is the greatest evil of all times.

My take is that it is the greatest evil of all times 🙂. Multiple inheritance is most of the time used to fix a badly designed OO architecture... it generates lots of problems as parent classes can have contradicting definitions - hence leading to an horrible situation where some functions and properties are supposed to work together yet come from different parent classes with contradicting behavior. Sometimes multiple inheritance makes sense from a logical standpoint : a boat and a car inherit from vehicule, and an amphibian car inherit both from boat and car. But most of the time you are better of without it.

Anon

Thanks, Pierre, for your thoughts. "Multiple Inheritance" as you call it can in fact be emulated (it's not really supported) in PHP.

It also presents another possible answer to the problem:

Using the "::" scope operator.

This way, if you had:

class base {}
class template extends base {}
class news extends base {}

and a method in news needed to access a method in template, you could call it like this:

template::parse();

This is a way of telling the process where to find the method you are referencing, and it works!

Pierre: point taken about bad OO design. Is your recommendation then to put ALL "basic" methods (that is, methods on whom most of the rest of the application will rely) in one big class, so that all extensions have access to them without messing with scope problems? Please elaborate on your thoughts.

-DLST

vsego

I'm not Pierre, but here is what I feel about one-big-class thing.

Unless all your projects are very much alike, common class/include file will produce huge overhead. Now, with today's hardware this is not a problem, but consider debuging such class. Most of the time you won't be sure what are you using in the "current" project and what's been used in others.

As always, I believe a hybrid solution to be the best: make basic class with stuff you use in (almost) all of your projects (i.e. I use functions to produce links, headers and footers). Specific classes should inherit that one.