By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
435,300 Members | 1,867 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 435,300 IT Pros & Developers. It's quick & easy.

Object Oriented PHP

P: n/a
I am new to PHP, just one day new. But I am otherwise a seasoned
programmer on many other languages like C, VB 6, C#, VB.NET, Win32
platform and have some tiny bit experience in MFC, C++, Python.

All the tutorials I read so far about PHP contain procedural examples.
I haven't yet come accross a tutorial on the object oriented PHP. Could
someone point me to one?

Jun 17 '06 #1
Share this Question
Share on Google+
73 Replies


P: n/a
Not a tutorial, but an example:
http://www.w-p.dds.nl/tinyunit.htm

Water Cooler v2 wrote:
I am new to PHP, just one day new. But I am otherwise a seasoned
programmer on many other languages like C, VB 6, C#, VB.NET, Win32
platform and have some tiny bit experience in MFC, C++, Python.

All the tutorials I read so far about PHP contain procedural examples.
I haven't yet come accross a tutorial on the object oriented PHP. Could
someone point me to one?

Jun 17 '06 #2

P: n/a
I've seen the C++ scope resolution operator used in some place in PHP
code. I do not recall where I saw it.

What's that (::) for? Does it have the same use as in C++?

Jun 17 '06 #3

P: n/a
NC
Water Cooler v2 wrote:

All the tutorials I read so far about PHP contain procedural examples.
I haven't yet come accross a tutorial on the object oriented PHP. Could
someone point me to one?


Start with the Manual:

http://www.php.net/OOP
http://www.php.net/OOP5

Note that there are differences between PHP 4 and PHP 5 when it comes
to OO syntax.

Cheers,
NC

Jun 17 '06 #4

P: n/a
NC
Water Cooler v2 wrote:

What's that (::) for? Does it have the same use as in C++?


It's all in the Manual:

http://www.php.net/manual/en/keyword...ekudotayim.php
http://www.php.net/manual/en/languag...ekudotayim.php

Cheers,
NC

Jun 17 '06 #5

P: n/a
Thanks very much. :-)

Jun 17 '06 #6

P: n/a

Water Cooler v2 wrote:
Thanks very much. :-)


Here's an OO versus Procedural example of making a MySQLi connection

http://au.php.net/manual/en/function.mysqli-prepare.php

Jun 18 '06 #7

P: n/a
Water Cooler v2 wrote:
Thanks very much. :-)

You can olso read
http://www-128.ibm.com/developerwork...xw01DynamicPHP
http://www.onlamp.com/pub/a/php/2005...erloading.html
The thread "PHP Dynamic Database Code" started by jo******@gmail.com on
Fri, 9 Jun 2006 23:13:21 +0000 (UTC) (from which i have the above urls)
may also be interesting.

Once you have a reasonable understanding of the basics of OOP, you could
take a look at the examples/turorial of phpPeanuts, experiment with it
and dig into its code using the hypercode browsers to try to understand
how the framework works. It's very OO ;-)

Greetings,

Henk Verhoeven,
www.phpPeanuts.org.
Jun 23 '06 #8

P: n/a
NC
427SOHC wrote:

If I haven't worked with OOP much would PHP be a safe
starting point, or is there a better programming language
to start with?


If you haven't worked with OOP before, start by learning OOP in the
language you otherwise know well. Once you understand the basic
concepts (encapsulation, inheritance, polymorphism, etc.), you will be
able to ask intelligent questions about how those concepts are
implemented in other languages.

Also, note that PHP 4 and PHP 5 have different object models; the one
in PHP 5 is more in line with what you find in other languages, while
the one in PHP 4 is simpler, but more restrictive.

Cheers,
NC

Jun 24 '06 #9

P: n/a

"NC" <nc@iname.com> wrote in message
news:11**********************@b68g2000cwa.googlegr oups.com...
427SOHC wrote:

If I haven't worked with OOP much would PHP be a safe
starting point, or is there a better programming language
to start with?


If you haven't worked with OOP before, start by learning OOP in the
language you otherwise know well. Once you understand the basic
concepts (encapsulation, inheritance, polymorphism, etc.), you will be
able to ask intelligent questions about how those concepts are
implemented in other languages.

Also, note that PHP 4 and PHP 5 have different object models; the one
in PHP 5 is more in line with what you find in other languages, while
the one in PHP 4 is simpler, but more restrictive.


"More restrictive" is a point of view. It is possible to write OO code in
PHP 4 that also runs in PHP 5, as I have proved with my sample application
and later my full-blown framework.

AFAIAC the extra OO features in PHP 5 are nothing more than eye candy as
they do not provide any additional functionality which is worthy of merit.
They were only included to appease the OO purists.

--
Tony Marston
http://www.tonymarston.net
http://www.radicore.org
Jun 24 '06 #10

P: n/a
Tony Marston wrote:
"NC" <nc@iname.com> wrote in message
news:11**********************@b68g2000cwa.googlegr oups.com...
427SOHC wrote:
If I haven't worked with OOP much would PHP be a safe
starting point, or is there a better programming language
to start with?


If you haven't worked with OOP before, start by learning OOP in the
language you otherwise know well. Once you understand the basic
concepts (encapsulation, inheritance, polymorphism, etc.), you will be
able to ask intelligent questions about how those concepts are
implemented in other languages.

Also, note that PHP 4 and PHP 5 have different object models; the one
in PHP 5 is more in line with what you find in other languages, while
the one in PHP 4 is simpler, but more restrictive.

"More restrictive" is a point of view. It is possible to write OO code in
PHP 4 that also runs in PHP 5, as I have proved with my sample application
and later my full-blown framework.

AFAIAC the extra OO features in PHP 5 are nothing more than eye candy as
they do not provide any additional functionality which is worthy of merit.
They were only included to appease the OO purists.


Actually, things like private declarations are very important. They are
unimportant only to those who don't understand OO programming - or those who are
sloppy in their implementations.

--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 24 '06 #11

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:25******************************@comcast.com. ..
Tony Marston wrote:
"NC" <nc@iname.com> wrote in message
news:11**********************@b68g2000cwa.googlegr oups.com...
427SOHC wrote:

If I haven't worked with OOP much would PHP be a safe
starting point, or is there a better programming language
to start with?

If you haven't worked with OOP before, start by learning OOP in the
language you otherwise know well. Once you understand the basic
concepts (encapsulation, inheritance, polymorphism, etc.), you will be
able to ask intelligent questions about how those concepts are
implemented in other languages.

Also, note that PHP 4 and PHP 5 have different object models; the one
in PHP 5 is more in line with what you find in other languages, while
the one in PHP 4 is simpler, but more restrictive.

"More restrictive" is a point of view. It is possible to write OO code in
PHP 4 that also runs in PHP 5, as I have proved with my sample
application and later my full-blown framework.

AFAIAC the extra OO features in PHP 5 are nothing more than eye candy as
they do not provide any additional functionality which is worthy of
merit. They were only included to appease the OO purists.


Actually, things like private declarations are very important. They are
unimportant only to those who don't understand OO programming - or those
who are sloppy in their implementations.


You don't *need* private declarations. Code will work just as well without
them.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 24 '06 #12

P: n/a
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
Actually, things like private declarations are very important. They are
unimportant only to those who don't understand OO programming - or those
who are sloppy in their implementations.


You don't *need* private declarations. Code will work just as well without
them.


What the heck! Let's just throw away multiply and divide. We don't
*need* them. We can just use add and subtract.

Heck! Why do we need subtract? We can just add negative values.

Hey! Assembler works well without private declarations. Let's just pitch
PHP all together.

The point is that constructs are added to language to assist in the
functionality and maintainability of programs written in that language.
The introduction of private and protected adds to the maintainability
both through its inherent protection capabilities and its clarity of
intent for the maintainer.

Now if PHP could just get polymorphism...

-david-

Jun 25 '06 #13

P: n/a
David Haynes wrote:
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
Actually, things like private declarations are very important. They
are unimportant only to those who don't understand OO programming -
or those who are sloppy in their implementations.


You don't *need* private declarations. Code will work just as well
without them.


What the heck! Let's just throw away multiply and divide. We don't
*need* them. We can just use add and subtract.

Heck! Why do we need subtract? We can just add negative values.

Hey! Assembler works well without private declarations. Let's just pitch
PHP all together.

The point is that constructs are added to language to assist in the
functionality and maintainability of programs written in that language.
The introduction of private and protected adds to the maintainability
both through its inherent protection capabilities and its clarity of
intent for the maintainer.

Now if PHP could just get polymorphism...

-david-


Sorry I am new to PHP but use Java. My question is how can you have a
OOP Language and not have polymorphic features. Sorry, I have not gotten
up to par on PHP yet.

Thanks in Advance...
IchBin, Pocono Lake, Pa, USA http://weconsultants.awardspace.com
__________________________________________________ ________________________

'If there is one, Knowledge is the "Fountain of Youth"'
-William E. Taylor, Regular Guy (1952-)
Jun 25 '06 #14

P: n/a
IchBin wrote:
David Haynes wrote:
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message

Actually, things like private declarations are very important. They
are unimportant only to those who don't understand OO programming -
or those who are sloppy in their implementations.
You don't *need* private declarations. Code will work just as well
without them.


What the heck! Let's just throw away multiply and divide. We don't
*need* them. We can just use add and subtract.

Heck! Why do we need subtract? We can just add negative values.

Hey! Assembler works well without private declarations. Let's just
pitch PHP all together.

The point is that constructs are added to language to assist in the
functionality and maintainability of programs written in that
language. The introduction of private and protected adds to the
maintainability both through its inherent protection capabilities and
its clarity of intent for the maintainer.

Now if PHP could just get polymorphism...

-david-


Sorry I am new to PHP but use Java. My question is how can you have a
OOP Language and not have polymorphic features. Sorry, I have not gotten
up to par on PHP yet.

Thanks in Advance...
IchBin, Pocono Lake, Pa, USA http://weconsultants.awardspace.com
__________________________________________________ ________________________

'If there is one, Knowledge is the "Fountain of Youth"'
-William E. Taylor, Regular Guy (1952-)


PHP does have some polymorphic-like abilities, but that's because of the untyped
nature of the variables.

PHP is getting better in it's OO aspects, but I doubt it will ever be quite like
Java. There's just a basic difference between languages with typed and untyped
variables.
--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 25 '06 #15

P: n/a
Jerry Stuckle wrote:
IchBin wrote:
David Haynes wrote:
Tony Marston wrote:

"Jerry Stuckle" <js*******@attglobal.net> wrote in message

> Actually, things like private declarations are very important.
> They are unimportant only to those who don't understand OO
> programming - or those who are sloppy in their implementations.
You don't *need* private declarations. Code will work just as well
without them.
What the heck! Let's just throw away multiply and divide. We don't
*need* them. We can just use add and subtract.

Heck! Why do we need subtract? We can just add negative values.

Hey! Assembler works well without private declarations. Let's just
pitch PHP all together.

The point is that constructs are added to language to assist in the
functionality and maintainability of programs written in that
language. The introduction of private and protected adds to the
maintainability both through its inherent protection capabilities and
its clarity of intent for the maintainer.

Now if PHP could just get polymorphism...

-david-


Sorry I am new to PHP but use Java. My question is how can you have a
OOP Language and not have polymorphic features. Sorry, I have not
gotten up to par on PHP yet.

Thanks in Advance...
IchBin, Pocono Lake, Pa, USA http://weconsultants.awardspace.com
__________________________________________________ ________________________
'If there is one, Knowledge is the "Fountain of Youth"'
-William E. Taylor, Regular Guy (1952-)


PHP does have some polymorphic-like abilities, but that's because of the
untyped nature of the variables.

PHP is getting better in it's OO aspects, but I doubt it will ever be
quite like Java. There's just a basic difference between languages with
typed and untyped variables.

Thanks for the info..

I read something about PHP version 5, OOP\OOD and typed Objects. So I
guess there are really not fully typed object. I have to read more and
not take OOP references as used by say smalltalk and Java and others.

--

Thanks in Advance...
IchBin, Pocono Lake, Pa, USA http://weconsultants.awardspace.com
__________________________________________________ ________________________

'If there is one, Knowledge is the "Fountain of Youth"'
-William E. Taylor, Regular Guy (1952-)
Jun 25 '06 #16

P: n/a
Jerry Stuckle wrote:
PHP does have some polymorphic-like abilities, but that's because of the
untyped nature of the variables.

PHP is getting better in it's OO aspects, but I doubt it will ever be
quite like Java. There's just a basic difference between languages with
typed and untyped variables.


I was thinking about this the other day and it may not be all that
difficult to add it.

Consider that you can already type the arguments to the constructor.
Given this, it would not be all that hard to derive a typed signature
which could then be applied.

-david-

Jun 25 '06 #17

P: n/a
David Haynes wrote:
Jerry Stuckle wrote:
PHP does have some polymorphic-like abilities, but that's because of
the untyped nature of the variables.

PHP is getting better in it's OO aspects, but I doubt it will ever be
quite like Java. There's just a basic difference between languages
with typed and untyped variables.

I was thinking about this the other day and it may not be all that
difficult to add it.

Consider that you can already type the arguments to the constructor.
Given this, it would not be all that hard to derive a typed signature
which could then be applied.

-david-


I really don't know how hard it would be to add - but I would like to see it
added. One thing I don't like all that much is the untyped variables. It makes
things "easy" - but leads to some sloppy programming.

It also means you can't overload functions - at least not with the same number
of parms. Typing the constructor arguments is a good start. But expanding that
to other functions without breaking existing code might be more difficult.

--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 25 '06 #18

P: n/a

"David Haynes" <da***********@sympatico.ca> wrote in message
news:Tv*******************@fe26.usenetserver.com.. .
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
Actually, things like private declarations are very important. They are
unimportant only to those who don't understand OO programming - or those
who are sloppy in their implementations.


You don't *need* private declarations. Code will work just as well
without them.


What the heck! Let's just throw away multiply and divide. We don't *need*
them. We can just use add and subtract.

Heck! Why do we need subtract? We can just add negative values.

Hey! Assembler works well without private declarations. Let's just pitch
PHP all together.

The point is that constructs are added to language to assist in the
functionality and maintainability of programs written in that language.
The introduction of private and protected adds to the maintainability both
through its inherent protection capabilities and its clarity of intent for
the maintainer.

Now if PHP could just get polymorphism...


OOP with PHP already has polymorphism. You obviously don't know what
polymorphism means.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #19

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:4K******************************@comcast.com. ..
David Haynes wrote:
Jerry Stuckle wrote:
< snip >
I really don't know how hard it would be to add - but I would like to see
it added. One thing I don't like all that much is the untyped variables.
It makes things "easy" - but leads to some sloppy programming.

It also means you can't overload functions - at least not with the same
number of parms. Typing the constructor arguments is a good start. But
expanding that to other functions without breaking existing code might be
more difficult.


You don't need function overloading in PHP. Why? First you need to look at
why other languages need it:
(a) To accept arguments of different types.
(b) To make some arguments optional.

With PHP you can accept an argument of any type and then cast it to the one
you want, so item (a) is irrelevant.

With PHP you can define a default value for an argument if it is not
supplied, so item (b) is irrelevant.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #20

P: n/a
Tony Marston wrote:
"David Haynes" <da***********@sympatico.ca> wrote in message
news:Tv*******************@fe26.usenetserver.com.. .
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
Actually, things like private declarations are very important. They are
unimportant only to those who don't understand OO programming - or those
who are sloppy in their implementations.
You don't *need* private declarations. Code will work just as well
without them.

What the heck! Let's just throw away multiply and divide. We don't *need*
them. We can just use add and subtract.

Heck! Why do we need subtract? We can just add negative values.

Hey! Assembler works well without private declarations. Let's just pitch
PHP all together.

The point is that constructs are added to language to assist in the
functionality and maintainability of programs written in that language.
The introduction of private and protected adds to the maintainability both
through its inherent protection capabilities and its clarity of intent for
the maintainer.

Now if PHP could just get polymorphism...


OOP with PHP already has polymorphism. You obviously don't know what
polymorphism means.

Tony:

PHP5 has weak polymorphism but not true polymorphism in the sense that
it is used in OOP.

You cannot, for instance, have multiple constructors for an object where
the number of the arguments to the constructor are variable. Yes, you
may supply default values to 'optional' arguments but consider this example:

class Foo {
function __construct($one, $two="two", $three="three") {

I cannot instantiate this object as new Foo($one, $three) since there is
no typing on the arguments and, therefore, no signature for a 'one,
three' contructor. Nor could I define multiple __constructor() methods
to allow for the new Foo($one, $three) case.

This type of action is common in other OOP languages such as Java and C++.

To add to the confusion from an OOP programmer's viewpoint, in order to
invoke the 'default' value for $three, I *must* supply a value for $two.
That is, new Foo($one, , $three) is syntactically illegal and there is
AFAIK no way to specify that we want $two to take its default value
while supplying a value for $three.

So, maybe its not me who is unclear on the concept of polymorphism...

-david-

Jun 25 '06 #21

P: n/a
On 2006-06-25, David Haynes <da***********@sympatico.ca> wrote:
PHP5 has weak polymorphism but not true polymorphism in the sense that
it is used in OOP.
So how would you define polymorphism? And what exactly are the
differences between 'weak' and 'true' polymorphism?

If i look at http://en.wikipedia.org/wiki/Polymor...ter_science%29

"The concept of polymorphism applies to data types in addition to
functions. A function that can evaluate to and be applied to values of
different types is known as a polymorphic function. A data type that
contains elements of different types is known as a polymorphic data
type."
function __construct($one, $two="two", $three="three") {

I cannot instantiate this object as new Foo($one, $three) since there is
no typing on the arguments and, therefore, no signature for a 'one,
three' contructor.


Imho that's the same as saying: I'm standing with my back against a wall,
and now i'm wondering why i can't step backwards anymore...

Define your constructor as __constructor($args) and handle with
func_num_args and func_get_args(s) any number of parameters...

(I do agree that the language/compiler can, probably should, make this
easier... But that's a different discussion.)

--
Met vriendelijke groeten,
Tim Van Wassenhove <http://timvw.madoka.be>
Jun 25 '06 #22

P: n/a
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:4K******************************@comcast.com. ..
David Haynes wrote:
Jerry Stuckle wrote:


< snip >
I really don't know how hard it would be to add - but I would like to see
it added. One thing I don't like all that much is the untyped variables.
It makes things "easy" - but leads to some sloppy programming.

It also means you can't overload functions - at least not with the same
number of parms. Typing the constructor arguments is a good start. But
expanding that to other functions without breaking existing code might be
more difficult.

You don't need function overloading in PHP. Why? First you need to look at
why other languages need it:
(a) To accept arguments of different types.
(b) To make some arguments optional.

With PHP you can accept an argument of any type and then cast it to the one
you want, so item (a) is irrelevant.

With PHP you can define a default value for an argument if it is not
supplied, so item (b) is irrelevant.


Sure. I would love to be able to have a function which does different things
based on the type of parameter passed. It would save a lot of work trying to
sort out parameters and potentially having to change existing code when adding
new parameter types.

But we already know you don't understand or appreciate real OO programming,
Tony. So quite frankly, I don't give a damn what you think.
--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 25 '06 #23

P: n/a
Tony Marston wrote:
"David Haynes" <da***********@sympatico.ca> wrote in message
news:Tv*******************@fe26.usenetserver.com.. .
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message

Actually, things like private declarations are very important. They are
unimportant only to those who don't understand OO programming - or those
who are sloppy in their implementations.

You don't *need* private declarations. Code will work just as well
without them.


What the heck! Let's just throw away multiply and divide. We don't *need*
them. We can just use add and subtract.

Heck! Why do we need subtract? We can just add negative values.

Hey! Assembler works well without private declarations. Let's just pitch
PHP all together.

The point is that constructs are added to language to assist in the
functionality and maintainability of programs written in that language.
The introduction of private and protected adds to the maintainability both
through its inherent protection capabilities and its clarity of intent for
the maintainer.

Now if PHP could just get polymorphism...

OOP with PHP already has polymorphism. You obviously don't know what
polymorphism means.


No, Tony, you really don't know what polymorphism is, do you?

--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 25 '06 #24

P: n/a
Tim Van Wassenhove wrote:
On 2006-06-25, David Haynes <da***********@sympatico.ca> wrote:
PHP5 has weak polymorphism but not true polymorphism in the sense that
it is used in OOP.


So how would you define polymorphism? And what exactly are the
differences between 'weak' and 'true' polymorphism?

If i look at http://en.wikipedia.org/wiki/Polymor...ter_science%29

"The concept of polymorphism applies to data types in addition to
functions. A function that can evaluate to and be applied to values of
different types is known as a polymorphic function. A data type that
contains elements of different types is known as a polymorphic data
type."


Keep reading the article you referenced.

"This type of polymorphism [overloading] is common in object-oriented
programming languages, many of which allow operators to be overloaded in
a manner similar to functions (see operator overloading). It is also
used extensively in the purely functional programming language Haskell
in the form of type classes. Many languages lacking ad-hoc polymorphism
suffer from long-winded names such as print_int, print_string, etc. (see
C, Objective Caml)."
function __construct($one, $two="two", $three="three") {

I cannot instantiate this object as new Foo($one, $three) since there is
no typing on the arguments and, therefore, no signature for a 'one,
three' contructor.


Imho that's the same as saying: I'm standing with my back against a wall,
and now i'm wondering why i can't step backwards anymore...

Define your constructor as __constructor($args) and handle with
func_num_args and func_get_args(s) any number of parameters...

(I do agree that the language/compiler can, probably should, make this
easier... But that's a different discussion.)


What you have specified is a non-overloaded generic constructor. I view
this as a work-around due to the inability of the PHP interpreter to
handle overloading polymorphism.

I'm not saying that this is a bad thing - in fact if you rewind your
news feed about a week - you will see that I recommended such an
approach to another coder, but I am saying that most strongly-typed OO
languages do support overloading as part of the their OOP environment.

-david-
Jun 25 '06 #25

P: n/a
Tim Van Wassenhove wrote:
On 2006-06-25, David Haynes <da***********@sympatico.ca> wrote:
PHP5 has weak polymorphism but not true polymorphism in the sense that
it is used in OOP.

So how would you define polymorphism? And what exactly are the
differences between 'weak' and 'true' polymorphism?

If i look at http://en.wikipedia.org/wiki/Polymor...ter_science%29

"The concept of polymorphism applies to data types in addition to
functions. A function that can evaluate to and be applied to values of
different types is known as a polymorphic function. A data type that
contains elements of different types is known as a polymorphic data
type."

function __construct($one, $two="two", $three="three") {

I cannot instantiate this object as new Foo($one, $three) since there is
no typing on the arguments and, therefore, no signature for a 'one,
three' contructor.

Imho that's the same as saying: I'm standing with my back against a wall,
and now i'm wondering why i can't step backwards anymore...

Define your constructor as __constructor($args) and handle with
func_num_args and func_get_args(s) any number of parameters...

(I do agree that the language/compiler can, probably should, make this
easier... But that's a different discussion.)


The constructor overloading example isn't really polymorphism. It's just
function overloading.

Polymorphism is the ability to operate on objects of derived classes, without
knowing what the derived classes are (or potentially even the existence of the
derived classes).

For instance - let's say we have class "mammal" with function "eats". Now all
mammals eat something, but what the class of mammals eats is not defines.

So, derive from mammal the class "ape" and have eats return "bananas". Also
derive the class "horse" and have eats return "oats".

Now - when you create an object of the class "ape" you can pass it to a function
which takes a "mammal". And you can print out what *this* mammal eats. The
same with a horse.

Polymorphism is closely tied to inheritance. But while inheritance allows the
programmer to take advantage of the commonalities between classes, polymorphism
allows the program to take advantage of the differences.
--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 25 '06 #26

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:l7******************************@comcast.com. ..
Tony Marston wrote:
"David Haynes" <da***********@sympatico.ca> wrote in message
news:Tv*******************@fe26.usenetserver.com.. .
Tony Marston wrote:

"Jerry Stuckle" <js*******@attglobal.net> wrote in message

>Actually, things like private declarations are very important. They
>are unimportant only to those who don't understand OO programming - or
>those who are sloppy in their implementations.

You don't *need* private declarations. Code will work just as well
without them.
What the heck! Let's just throw away multiply and divide. We don't *need*
them. We can just use add and subtract.

Heck! Why do we need subtract? We can just add negative values.

Hey! Assembler works well without private declarations. Let's just pitch
PHP all together.

The point is that constructs are added to language to assist in the
functionality and maintainability of programs written in that language.
The introduction of private and protected adds to the maintainability
both through its inherent protection capabilities and its clarity of
intent for the maintainer.

Now if PHP could just get polymorphism...

OOP with PHP already has polymorphism. You obviously don't know what
polymorphism means.


No, Tony, you really don't know what polymorphism is, do you?


The simplest definition of polymorphism is "same interface, different
implementation". This means that different objects can share the same
interface but which do different things. What do you think it means?

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #27

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:l7******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:4K******************************@comcast.com. ..
David Haynes wrote:

Jerry Stuckle wrote:


< snip >
I really don't know how hard it would be to add - but I would like to see
it added. One thing I don't like all that much is the untyped variables.
It makes things "easy" - but leads to some sloppy programming.

It also means you can't overload functions - at least not with the same
number of parms. Typing the constructor arguments is a good start. But
expanding that to other functions without breaking existing code might be
more difficult.

You don't need function overloading in PHP. Why? First you need to look
at why other languages need it:
(a) To accept arguments of different types.
(b) To make some arguments optional.

With PHP you can accept an argument of any type and then cast it to the
one you want, so item (a) is irrelevant.

With PHP you can define a default value for an argument if it is not
supplied, so item (b) is irrelevant.


Sure. I would love to be able to have a function which does different
things based on the type of parameter passed. It would save a lot of work
trying to sort out parameters and potentially having to change existing
code when adding new parameter types.

But we already know you don't understand or appreciate real OO
programming, Tony. So quite frankly, I don't give a damn what you think.


Just because my understanding and implementation of OOP is different from
yours does not make you right and me wrong.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #28

P: n/a

"Tim Van Wassenhove" <ti***@users.sourceforge.net> wrote in message
news:e7**********@ikaria.belnet.be...
On 2006-06-25, David Haynes <da***********@sympatico.ca> wrote:
PHP5 has weak polymorphism but not true polymorphism in the sense that
it is used in OOP.


So how would you define polymorphism? And what exactly are the
differences between 'weak' and 'true' polymorphism?

If i look at
http://en.wikipedia.org/wiki/Polymor...ter_science%29

"The concept of polymorphism applies to data types in addition to
functions. A function that can evaluate to and be applied to values of
different types is known as a polymorphic function.


Exactly! Same interface, different implementation.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #29

P: n/a

"David Haynes" <da***********@sympatico.ca> wrote in message
news:pR******************@fe43.usenetserver.com...
Tony Marston wrote:
"David Haynes" <da***********@sympatico.ca> wrote in message
news:Tv*******************@fe26.usenetserver.com.. .
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
> Actually, things like private declarations are very important. They
> are unimportant only to those who don't understand OO programming - or
> those who are sloppy in their implementations.
You don't *need* private declarations. Code will work just as well
without them.

What the heck! Let's just throw away multiply and divide. We don't
*need* them. We can just use add and subtract.

Heck! Why do we need subtract? We can just add negative values.

Hey! Assembler works well without private declarations. Let's just pitch
PHP all together.

The point is that constructs are added to language to assist in the
functionality and maintainability of programs written in that language.
The introduction of private and protected adds to the maintainability
both through its inherent protection capabilities and its clarity of
intent for the maintainer.

Now if PHP could just get polymorphism...
OOP with PHP already has polymorphism. You obviously don't know what
polymorphism means.

Tony:

PHP5 has weak polymorphism but not true polymorphism in the sense that it
is used in OOP.

You cannot, for instance, have multiple constructors for an object where
the number of the arguments to the constructor are variable. Yes, you may
supply default values to 'optional' arguments but consider this example:

class Foo {
function __construct($one, $two="two", $three="three") {

I cannot instantiate this object as new Foo($one, $three) since there is
no typing on the arguments and, therefore, no signature for a 'one, three'
contructor. Nor could I define multiple __constructor() methods to allow
for the new Foo($one, $three) case.


Polymorphism means "same interface, different implementation". It has
nothing to do with overloading.
This type of action is common in other OOP languages such as Java and C++.
Just because those languages have to employ a certain mechanism to achieve a
certain result does not mean that EVERY language has to employ the same
mechanism to achieve the same result. Different languages work differently,
so you should expect different languages to achieve similar results with
different techniques. If everything was the same there would be no need for
different languages, would there?
To add to the confusion from an OOP programmer's viewpoint, in order to
invoke the 'default' value for $three, I *must* supply a value for $two.
That is, new Foo($one, , $three) is syntactically illegal and there is
AFAIK no way to specify that we want $two to take its default value while
supplying a value for $three.

So, maybe its not me who is unclear on the concept of polymorphism...


I repeat, overloading has nothing to do with polymorphism.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #30

P: n/a

"David Haynes" <da***********@sympatico.ca> wrote in message
news:wa*******************@fe03.usenetserver.com.. .
Tim Van Wassenhove wrote:
On 2006-06-25, David Haynes <da***********@sympatico.ca> wrote:
PHP5 has weak polymorphism but not true polymorphism in the sense that
it is used in OOP.


So how would you define polymorphism? And what exactly are the
differences between 'weak' and 'true' polymorphism?

If i look at
http://en.wikipedia.org/wiki/Polymor...ter_science%29

"The concept of polymorphism applies to data types in addition to
functions. A function that can evaluate to and be applied to values of
different types is known as a polymorphic function. A data type that
contains elements of different types is known as a polymorphic data
type."


Keep reading the article you referenced.

"This type of polymorphism [overloading] is common in object-oriented
programming languages, many of which allow operators to be overloaded in a
manner similar to functions (see operator overloading). It is also used
extensively in the purely functional programming language Haskell in the
form of type classes. Many languages lacking ad-hoc polymorphism suffer
from long-winded names such as print_int, print_string, etc. (see C,
Objective Caml)."
function __construct($one, $two="two", $three="three") {

I cannot instantiate this object as new Foo($one, $three) since there is
no typing on the arguments and, therefore, no signature for a 'one,
three' contructor.


Imho that's the same as saying: I'm standing with my back against a wall,
and now i'm wondering why i can't step backwards anymore...

Define your constructor as __constructor($args) and handle with
func_num_args and func_get_args(s) any number of parameters...

(I do agree that the language/compiler can, probably should, make this
easier... But that's a different discussion.)


What you have specified is a non-overloaded generic constructor. I view
this as a work-around due to the inability of the PHP interpreter to
handle overloading polymorphism.


Just because PHP does not handle overloading in the way that other languages
do does not mean that it does not support polymorphism. Overloading is not
the same as polymorphism. They are different concepts that may or may not be
employed at the same time.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #31

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:SY******************************@comcast.com. ..
Tim Van Wassenhove wrote:
On 2006-06-25, David Haynes <da***********@sympatico.ca> wrote:
PHP5 has weak polymorphism but not true polymorphism in the sense that it
is used in OOP.

So how would you define polymorphism? And what exactly are the
differences between 'weak' and 'true' polymorphism?

If i look at
http://en.wikipedia.org/wiki/Polymor...ter_science%29

"The concept of polymorphism applies to data types in addition to
functions. A function that can evaluate to and be applied to values of
different types is known as a polymorphic function. A data type that
contains elements of different types is known as a polymorphic data
type."

function __construct($one, $two="two", $three="three") {

I cannot instantiate this object as new Foo($one, $three) since there is
no typing on the arguments and, therefore, no signature for a 'one,
three' contructor.

Imho that's the same as saying: I'm standing with my back against a wall,
and now i'm wondering why i can't step backwards anymore...

Define your constructor as __constructor($args) and handle with
func_num_args and func_get_args(s) any number of parameters...

(I do agree that the language/compiler can, probably should, make this
easier... But that's a different discussion.)


The constructor overloading example isn't really polymorphism. It's just
function overloading.


Absolutely correct. Polymorphism means "same interface, different
implememtation". You do not need overloading to make polymorphism work.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org
Polymorphism is the ability to operate on objects of derived classes,
without knowing what the derived classes are (or potentially even the
existence of the derived classes).

For instance - let's say we have class "mammal" with function "eats". Now
all mammals eat something, but what the class of mammals eats is not
defines.

So, derive from mammal the class "ape" and have eats return "bananas".
Also derive the class "horse" and have eats return "oats".

Now - when you create an object of the class "ape" you can pass it to a
function which takes a "mammal". And you can print out what *this* mammal
eats. The same with a horse.

Polymorphism is closely tied to inheritance. But while inheritance allows
the programmer to take advantage of the commonalities between classes,
polymorphism allows the program to take advantage of the differences.
--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================

Jun 25 '06 #32

P: n/a
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:l7******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:4K******************************@comcast.c om...
David Haynes wrote:
>Jerry Stuckle wrote:
>

< snip >

I really don't know how hard it would be to add - but I would like to see
it added. One thing I don't like all that much is the untyped variables.
It makes things "easy" - but leads to some sloppy programming.

It also means you can't overload functions - at least not with the same
number of parms. Typing the constructor arguments is a good start. But
expanding that to other functions without breaking existing code might be
more difficult.
You don't need function overloading in PHP. Why? First you need to look
at why other languages need it:
(a) To accept arguments of different types.
(b) To make some arguments optional.

With PHP you can accept an argument of any type and then cast it to the
one you want, so item (a) is irrelevant.

With PHP you can define a default value for an argument if it is not
supplied, so item (b) is irrelevant.


Sure. I would love to be able to have a function which does different
things based on the type of parameter passed. It would save a lot of work
trying to sort out parameters and potentially having to change existing
code when adding new parameter types.

But we already know you don't understand or appreciate real OO
programming, Tony. So quite frankly, I don't give a damn what you think.

Just because my understanding and implementation of OOP is different from
yours does not make you right and me wrong.


Other than the fact your understanding and implementation is different from
every expert in the field.

You *think* you understand OO. But you have no idea what *real* OO is about.
Otherwise you wouldn't be making some of your comments.
--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 25 '06 #33

P: n/a
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message

No, Tony, you really don't know what polymorphism is, do you?

The simplest definition of polymorphism is "same interface, different
implementation". This means that different objects can share the same
interface but which do different things. What do you think it means?


I rest my case.

--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 25 '06 #34

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:cY******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
<snip>
Just because my understanding and implementation of OOP is different from
yours does not make you right and me wrong.

Other than the fact your understanding and implementation is different
from every expert in the field.


What you mean is that people who think like you are the so-called *experts*
while those who choose to think differently are *idiots*. What an arrogant
pratt you are to think that YOUR brand of OO is the only true brand.
You *think* you understand OO. But you have no idea what *real* OO is
about. Otherwise you wouldn't be making some of your comments.


OO is about encapsulation, polymorphism and inheritance. Nothing more,
nothing less. What you choose to call *real* OO I call *bastardised* OO
because some people of low intelligence are trying to make it more difficult
than it really is.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #35

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ms******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message

No, Tony, you really don't know what polymorphism is, do you?

The simplest definition of polymorphism is "same interface, different
implementation". This means that different objects can share the same
interface but which do different things. What do you think it means?


I rest my case.


Without answering the question, I notice. Is it too difficult for you? I
take my definition from http://c2.com/cgi/wiki?PolyMorphism and
http://en.wikipedia.org/wiki/Polymor...mputer_science) Where did you
get yours? The toilet?

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #36

P: n/a
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:cY******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message

<snip>
Just because my understanding and implementation of OOP is different from
yours does not make you right and me wrong.

Other than the fact your understanding and implementation is different
from every expert in the field.

What you mean is that people who think like you are the so-called *experts*
while those who choose to think differently are *idiots*. What an arrogant
pratt you are to think that YOUR brand of OO is the only true brand.


My understanding comes from people like Grady Booch, James Rumbaugh and Ivar
Jacobson - and is in complete agreement with these people. But of course, they
disagree with you, so you'll call them idiots, also.
You *think* you understand OO. But you have no idea what *real* OO is
about. Otherwise you wouldn't be making some of your comments.

OO is about encapsulation, polymorphism and inheritance. Nothing more,
nothing less. What you choose to call *real* OO I call *bastardised* OO
because some people of low intelligence are trying to make it more difficult
than it really is.


Also message passing - which you seem to conveniently forget. And YOU are the
one "bastardizing" OO. Your sloppy approach to programming is just what *real*
OO is designed to eliminate. And it makes the coding much more maintainable,
expandable and modifiable.

--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 25 '06 #37

P: n/a
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ms******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message

No, Tony, you really don't know what polymorphism is, do you?
The simplest definition of polymorphism is "same interface, different
implementation". This means that different objects can share the same
interface but which do different things. What do you think it means?


I rest my case.

Without answering the question, I notice. Is it too difficult for you? I
take my definition from http://c2.com/cgi/wiki?PolyMorphism and
http://en.wikipedia.org/wiki/Polymor...mputer_science) Where did you
get yours? The toilet?


No need to answer your question. You're "definition" speaks for itself.

--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 25 '06 #38

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ce******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ms******************************@comcast.com. ..
Tony Marston wrote:

"Jerry Stuckle" <js*******@attglobal.net> wrote in message

>No, Tony, you really don't know what polymorphism is, do you?
The simplest definition of polymorphism is "same interface, different
implementation". This means that different objects can share the same
interface but which do different things. What do you think it means?
I rest my case.

Without answering the question, I notice. Is it too difficult for you? I
take my definition from http://c2.com/cgi/wiki?PolyMorphism and
http://en.wikipedia.org/wiki/Polymor...mputer_science) Where did
you get yours? The toilet?


No need to answer your question. You're "definition" speaks for itself.


You mean that the definition I use is correct while yours is a pile a poo?

My definition is shared by experts. Your definition is shared by people who
think they're experts.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #39

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ce******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:cY******************************@comcast.com. ..
Tony Marston wrote:

"Jerry Stuckle" <js*******@attglobal.net> wrote in message

<snip>
Just because my understanding and implementation of OOP is different
from yours does not make you right and me wrong.
Other than the fact your understanding and implementation is different
from every expert in the field.

What you mean is that people who think like you are the so-called
*experts* while those who choose to think differently are *idiots*. What
an arrogant pratt you are to think that YOUR brand of OO is the only true
brand.


My understanding comes from people like Grady Booch, James Rumbaugh and
Ivar Jacobson - and is in complete agreement with these people. But of
course, they disagree with you, so you'll call them idiots, also.
You *think* you understand OO. But you have no idea what *real* OO is
about. Otherwise you wouldn't be making some of your comments.

OO is about encapsulation, polymorphism and inheritance. Nothing more,
nothing less. What you choose to call *real* OO I call *bastardised* OO
because some people of low intelligence are trying to make it more
difficult than it really is.


Also message passing - which you seem to conveniently forget.


OO is about encapsulation, polymorphism and inheritance. Message passing is
incidental.
And YOU are the one "bastardizing" OO. Your sloppy approach to
programming is just what *real* OO is designed to eliminate. And it makes
the coding much more maintainable, expandable and modifiable.


Not the way some people use OO. They deliberately make it more complicated
than it need be, while I keep it as simple as possible.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 25 '06 #40

P: n/a
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ce******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:cY******************************@comcast.c om...
Tony Marston wrote:
>"Jerry Stuckle" <js*******@attglobal.net> wrote in message
<snip>

>Just because my understanding and implementation of OOP is different

>from yours does not make you right and me wrong.

Other than the fact your understanding and implementation is different

from every expert in the field.
What you mean is that people who think like you are the so-called
*experts* while those who choose to think differently are *idiots*. What
an arrogant pratt you are to think that YOUR brand of OO is the only true
brand.


My understanding comes from people like Grady Booch, James Rumbaugh and
Ivar Jacobson - and is in complete agreement with these people. But of
course, they disagree with you, so you'll call them idiots, also.
You *think* you understand OO. But you have no idea what *real* OO is
about. Otherwise you wouldn't be making some of your comments.
OO is about encapsulation, polymorphism and inheritance. Nothing more,
nothing less. What you choose to call *real* OO I call *bastardised* OO
because some people of low intelligence are trying to make it more
difficult than it really is.


Also message passing - which you seem to conveniently forget.

OO is about encapsulation, polymorphism and inheritance. Message passing is
incidental.

And YOU are the one "bastardizing" OO. Your sloppy approach to
programming is just what *real* OO is designed to eliminate. And it makes
the coding much more maintainable, expandable and modifiable.

Not the way some people use OO. They deliberately make it more complicated
than it need be, while I keep it as simple as possible.


And that is where you are 100% wrong. Message passing is an integral part of
both object-based and object-oriented languages.

One bit of wisdom, Tony. Tis better to remain silent and have everyone thing
you might be a fool than to open your mouth and remove all doubt.

In the OO world you have removed all doubt.
--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 26 '06 #41

P: n/a
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ce******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:cY******************************@comcast.c om...
Tony Marston wrote:
>"Jerry Stuckle" <js*******@attglobal.net> wrote in message
<snip>

>Just because my understanding and implementation of OOP is different

>from yours does not make you right and me wrong.

Other than the fact your understanding and implementation is different

from every expert in the field.
What you mean is that people who think like you are the so-called
*experts* while those who choose to think differently are *idiots*. What
an arrogant pratt you are to think that YOUR brand of OO is the only true
brand.


My understanding comes from people like Grady Booch, James Rumbaugh and
Ivar Jacobson - and is in complete agreement with these people. But of
course, they disagree with you, so you'll call them idiots, also.
You *think* you understand OO. But you have no idea what *real* OO is
about. Otherwise you wouldn't be making some of your comments.
OO is about encapsulation, polymorphism and inheritance. Nothing more,
nothing less. What you choose to call *real* OO I call *bastardised* OO
because some people of low intelligence are trying to make it more
difficult than it really is.


Also message passing - which you seem to conveniently forget.

OO is about encapsulation, polymorphism and inheritance. Message passing is
incidental.

And YOU are the one "bastardizing" OO. Your sloppy approach to
programming is just what *real* OO is designed to eliminate. And it makes
the coding much more maintainable, expandable and modifiable.

Not the way some people use OO. They deliberately make it more complicated
than it need be, while I keep it as simple as possible.


And the way you use OO is a bastardization of OO techniques.
--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 26 '06 #42

P: n/a
Tim Van Wassenhove wrote:
On 2006-06-25, David Haynes <da***********@sympatico.ca> wrote:
PHP5 has weak polymorphism but not true polymorphism in the sense that
it is used in OOP.


So how would you define polymorphism? And what exactly are the
differences between 'weak' and 'true' polymorphism?

If i look at http://en.wikipedia.org/wiki/Polymor...ter_science%29

"The concept of polymorphism applies to data types in addition to
functions. A function that can evaluate to and be applied to values of
different types is known as a polymorphic function. A data type that
contains elements of different types is known as a polymorphic data
type."
function __construct($one, $two="two", $three="three") {

I cannot instantiate this object as new Foo($one, $three) since there is
no typing on the arguments and, therefore, no signature for a 'one,
three' contructor. .


Imho that's the same as saying: I'm standing with my back against a wall,
and now i'm wondering why i can't step backwards anymore...

Define your constructor as __constructor($args) and handle with
func_num_args and func_get_args(s) any number of parameters...

(I do agree that the language/compiler can, probably should, make this
easier... But that's a different discussion.)

--
Met vriendelijke groeten,
Tim Van Wassenhove <http://timvw.madoka.be>

There are two annoying problems with this, which is why its such a nice
feature to have:

1) It is a pain in the but to have to order out and determine the types
of the passed variables. Whenever I make classes i always end up
having to spend 100+ lines trying to figure out the types of variables
passed to sort out what goes where. Why? One object returns an
indexed array, another an associative array, other return other objects
of various types. The reason for being able to call the function with
any of these types is so that I don't have to pre-process the data and
can operate more efficently on the passed value. What ends up
happening is converting everything to an array, or string, or object,
or what not. A lot of extra work on my part and the program's part
that would otherwise be handled by a compiler.

They have type hints in PHP5, but they are more like type requirements,
as it causes a fatal error and is largely useless unless you
pre-process things to match that definition. I'd much rather be able
to create multiple methods with different signatures that could be
called if the parameters match, but thats not really feasible in a
typeless language.

2) It makes overriding methods harder in derived classes. Why?
Because the overridden method is completely hidden and you must convert
parameters to what it expects to be able to use its functionality.
This happened to me while extending HTML_Table from pear. Its addRow
method accepts 2 types of arrays, and invokes different completely code
paths depending on the array type, which is determined by a private
method thats not (well, shouldn't be) accesible from the derived class.
Ideally, all i would have to do is override addRow, modify the incoming
data to match what the original addRow expects, then pass it up.
Extension with minimum effort. However, because the addRow method uses
several private methods and a bunch of code and logic to determine what
to do, I either have to:
- Duplicate all that logic and code (including the private methods,
default values, etc), then pass it up to addRow to have it done again,
which is a lot of redunant work, or
- Pass it up to addRow then modify the object accordingly, which
performs several of the same operations addRow did originally (as well
as introducing a caveat of overwriting instead of updating certain
attributes, which limits the functionality in a few cases).

If i could just override the method to accept the single object i
wanted to pass it, while the original method existed and could be
called directly, all of that could have been avoided.

Then there is the lack of multiple inheritence in PHP. Considering the
wide breadth of small operations a single object should be able to do,
its completely insane to have to rewrite the exact same interface code
again and again for the smallest of operations (a problem that rears
its head in java gui programing, when you have to implement an
interface then manually delegate all methods to an instance of a class
that has a handle back to the container, more needless complication
that could have been handled by MI). I'm getting off topic though.
Please, continue the flame war.

Jun 26 '06 #43

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:Gc******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ce******************************@comcast.com. ..
<snip>
OO is about encapsulation, polymorphism and inheritance. Nothing more,
nothing less. What you choose to call *real* OO I call *bastardised* OO
because some people of low intelligence are trying to make it more
difficult than it really is.
Also message passing - which you seem to conveniently forget.

OO is about encapsulation, polymorphism and inheritance. Message passing
is incidental.

And YOU are the one "bastardizing" OO. Your sloppy approach to
programming is just what *real* OO is designed to eliminate. And it
makes the coding much more maintainable, expandable and modifiable.

Not the way some people use OO. They deliberately make it more
complicated than it need be, while I keep it as simple as possible.


And the way you use OO is a bastardization of OO techniques.


That's just your opinion. Just because my implementation of OO is different
from yours does not make it wrong, merely different. If you believe that
YOUR way is the ONLY way then you are just being arrogant.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 26 '06 #44

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:tM******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ce******************************@comcast.com. ..
<snip>
OO is about encapsulation, polymorphism and inheritance. Message passing
is incidental.

And YOU are the one "bastardizing" OO. Your sloppy approach to
programming is just what *real* OO is designed to eliminate. And it
makes the coding much more maintainable, expandable and modifiable.

Not the way some people use OO. They deliberately make it more
complicated than it need be, while I keep it as simple as possible.


And that is where you are 100% wrong. Message passing is an integral part
of both object-based and object-oriented languages.

One bit of wisdom, Tony. Tis better to remain silent and have everyone
thing you might be a fool than to open your mouth and remove all doubt.

In the OO world you have removed all doubt.


The three principles of OO are encapsulation, polymorphism and inheritance.
Message passing does not appear in that list, so it is a minor detail.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 26 '06 #45

P: n/a
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:tM******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ce******************************@comcast.c om...

<snip>
OO is about encapsulation, polymorphism and inheritance. Message passing
is incidental.

And YOU are the one "bastardizing" OO. Your sloppy approach to
programming is just what *real* OO is designed to eliminate. And it
makes the coding much more maintainable, expandable and modifiable.
Not the way some people use OO. They deliberately make it more
complicated than it need be, while I keep it as simple as possible.


And that is where you are 100% wrong. Message passing is an integral part
of both object-based and object-oriented languages.

One bit of wisdom, Tony. Tis better to remain silent and have everyone
thing you might be a fool than to open your mouth and remove all doubt.

In the OO world you have removed all doubt.

The three principles of OO are encapsulation, polymorphism and inheritance.
Message passing does not appear in that list, so it is a minor detail.


And that's where you are totally wrong.

--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 26 '06 #46

P: n/a
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:Gc******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ce******************************@comcast.c om...

<snip>
OO is about encapsulation, polymorphism and inheritance. Nothing more,
>nothing less. What you choose to call *real* OO I call *bastardised* OO
>because some people of low intelligence are trying to make it more
>difficult than it really is.
>

Also message passing - which you seem to conveniently forget.
OO is about encapsulation, polymorphism and inheritance. Message passing
is incidental.

And YOU are the one "bastardizing" OO. Your sloppy approach to
programming is just what *real* OO is designed to eliminate. And it
makes the coding much more maintainable, expandable and modifiable.
Not the way some people use OO. They deliberately make it more
complicated than it need be, while I keep it as simple as possible.


And the way you use OO is a bastardization of OO techniques.

That's just your opinion. Just because my implementation of OO is different
from yours does not make it wrong, merely different. If you believe that
YOUR way is the ONLY way then you are just being arrogant.


And the opinion of other experts in the field - such as the ones I mentioned before.

Your implementation violates some of the basic reasons for even having OO! And
no, I don't believe MY way is the only way. But I believe the experts in the
field know a hell of a lot more about it than you do.

I suspect you've had no real-world OO experience. Large, complex projects OO is
designed to make easier. All of your experience is probably simple PHP pages
you do yourself with no collaboration.

Your attitude would never survive in a the large scale projects I've been
involved in (100+ programmers, 2 years+ time). But then it wouldn't survive the
smaller projects I've been involved in, either - (i.e. three programmers for two
months).

--
==================
Remove the "x" from my email address
Jerry Stuckle
JDS Computer Training Corp.
js*******@attglobal.net
==================
Jun 26 '06 #47

P: n/a
Jerry Stuckle wrote:
Actually, things like private declarations are very important.


IMHO private declarations are too rigid and therfore decrease
reusability. I agree that it can be very usefull to know the intentions
of the developer of some code one is evaluating to call or some member
variable one is avaluating to access. But every now and then there are
good reasons to do it anyway, even if it was intended to be private. For
example lazy initialization and default reasoning both are often
implemented using direct access to member variables. Another example is
using a visitor to implement persistency.

Now maybe you would say that i should change these member variables to
protected or public. There are two problems with this:
1. It may not be my own code. Then if i get an upgrade of this code,
these member variables will once again be private, unless i re-apply my
changes. This is uneccessary overhead.
2. By changing the private declaration the intension of the other
developer gets lost. Now i could put a comment in that it was intended
to be private, but in that case: why not put the @private marker in the
comment in the first place?

The fundamental point is: With these private and protected declarations
you get stuck with the uneccessarily limitations introduced by the
author. Object-orientation can lead to more reusability then
conventional parameterized code exactly because the code can be
overridden and extended in ways the original author did not provide for.
private and protected declarations are a step backwards that is only
reasonable if you assume that future developers that will maintain or
reuse your code will ignore your intentions becuase they are fools. If
this is the case, i think you should tell your boss that you are
limiting the reusability of your code because you are aniticipating him
to hire fools and let them work on/with your code ;-)

Greetings,

Henk Verhoeven,
www.phpPeanuts.org.
Jun 26 '06 #48

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:7f******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:tM******************************@comcast.com. ..
Tony Marston wrote:

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ce******************************@comcast. com...


<snip>
OO is about encapsulation, polymorphism and inheritance. Message passing
is incidental.

>And YOU are the one "bastardizing" OO. Your sloppy approach to
>programming is just what *real* OO is designed to eliminate. And it
>makes the coding much more maintainable, expandable and modifiable.
Not the way some people use OO. They deliberately make it more
complicated than it need be, while I keep it as simple as possible.
And that is where you are 100% wrong. Message passing is an integral
part of both object-based and object-oriented languages.

One bit of wisdom, Tony. Tis better to remain silent and have everyone
thing you might be a fool than to open your mouth and remove all doubt.

In the OO world you have removed all doubt.

The three principles of OO are encapsulation, polymorphism and
inheritance. Message passing does not appear in that list, so it is a
minor detail.


And that's where you are totally wrong.


Excuse me? After performing a google search on OOP all I see quoted time
after time are the three basic principles - encapsulation, inheritance and
polymorphism - so how could I possibly be wrong?

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 26 '06 #49

P: n/a

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:qe******************************@comcast.com. ..
Tony Marston wrote:
"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:Gc******************************@comcast.com. ..
Tony Marston wrote:

"Jerry Stuckle" <js*******@attglobal.net> wrote in message
news:ce******************************@comcast. com...

<snip>
>>OO is about encapsulation, polymorphism and inheritance. Nothing more,
>>nothing less. What you choose to call *real* OO I call *bastardised*
>>OO because some people of low intelligence are trying to make it more
>>difficult than it really is.
>>
>
>Also message passing - which you seem to conveniently forget.
OO is about encapsulation, polymorphism and inheritance. Message passing
is incidental.

>And YOU are the one "bastardizing" OO. Your sloppy approach to
>programming is just what *real* OO is designed to eliminate. And it
>makes the coding much more maintainable, expandable and modifiable.
Not the way some people use OO. They deliberately make it more
complicated than it need be, while I keep it as simple as possible.
And the way you use OO is a bastardization of OO techniques.

That's just your opinion. Just because my implementation of OO is
different from yours does not make it wrong, merely different. If you
believe that YOUR way is the ONLY way then you are just being arrogant.


And the opinion of other experts in the field - such as the ones I
mentioned before.


Even experts disagree on what is or is not the *right* way in OO, so all I
am doing is agreeing with those experts who disagree with your your
favourite experts.
Your implementation violates some of the basic reasons for even having OO!
And no, I don't believe MY way is the only way. But I believe the experts
in the field know a hell of a lot more about it than you do.
I disagree. I am using the three basic principles of OO, as documented, to
achieve a higher level of reuse than I could by using non-OO techniques.
I suspect you've had no real-world OO experience. Large, complex projects
OO is designed to make easier. All of your experience is probably simple
PHP pages you do yourself with no collaboration.
At least I have not been taught by people who don't know what they're
talking about.
Your attitude would never survive in a the large scale projects I've been
involved in (100+ programmers, 2 years+ time). But then it wouldn't
survive the smaller projects I've been involved in, either - (i.e. three
programmers for two months).


The size of project is irrelevant. The OOP principles are the same
regardless of the size of project. The only project I have ever been
associated with which failed disastrously was one where the system
architects got carried away with their fancy ideas of how OOP should be
implemented and produced something that was so inefficient and unproductive
that the client cancelled the entire project as soon as the first live
programs were produced. It was THEIR attitude that was wrong, not mine.

--
Tony Marston

http://www.tonymarston.net
http://www.radicore.org

Jun 26 '06 #50

73 Replies

This discussion thread is closed

Replies have been disabled for this discussion.