I like it when I demonstrate to myself I'm a bit thick. Today was one of those days. I've been working with PHP for a coupla years now, and pretty much have ported my OO knowledge over to it. Coming from a CFML background one thing I'm not so familiar with is static variables and methods. I "get" it, that's cool, but clearly I'm still mid-way up the learning curve, and some idiosyncrasies still elude me. I found one today.
I was doing some testing, and the situation I was in was that my test classes needed some subclassing... don't ask... it was legit but I cannot go into details and it'd bore you rigid anyhow. In my base class I had a static variable which I needed to have a different value for in the subclass (it was actually a sub-sub-class. Dumb tests). So I set it to a new value in my test method, then the test method called a method from the base class, and the test went splat cos it was still using the base class value. This confused the shit out of me at first. Here's a simplified example:
class GP {
public static $test = "GP";
public function fromGP(){
return self::$test;
}
public function get(){
return self::$test;
}
}
class P extends GP {
public static $test = "P";
public function fromP(){
return self::$test;
}
}
class C extends P {
public static $test = "C";
public function fromC(){
return self::$test;
}
}
$c = new C();
echo "fromC: " . $c->fromC() . PHP_EOL;
echo "fromP: " . $c->fromP() . PHP_EOL;
echo "fromGP: " . $c->fromGP() . PHP_EOL;
echo "get: " . $c->get() . PHP_EOL;
So:
- I've got a grandparent class (GP) which sets a static variable, and has two methods to get its value.
- And a Parent class (P) that extends GP, with its own value for the static variable, and another different method to get its value.
- And a Child class (C) which does the same thing, but to the Parent.
- In my test rig I create a C instance, and call each of the methods.
fromC: C
fromP: C
fromGP: C
get: C
fromP: C
fromGP: C
get: C
Because C overrides the value for the static test variable, so the inherited methods should all use that value.
But what I did get is this:
fromC: C
fromP: P
fromGP: GP
get: GP
fromP: P
fromGP: GP
get: GP
It took me a while to click. I changed my variable to be not static, and got the results I expected. Changed it back: back to the "wrong" (where "wrong" is "not what I wanted") answer. Then it dawned on me I guess. Static variables are bound to the class. I already knew this, but the ramifications didn't hit me initially. $c might be an object that inherits from P and GP, and obviously object variables will also follow inheritance rules, but static variables relate to the class, not the object. So in the class GP, in which the method fromGP is defined... self::$test refers to the static $test variable in that class. So: the value is GP. and on from there for fromP and down to fromC too (and get).
It made sense once I engaged my brain.
When I got home from work I decided to "ask" Java what it thought about this, and knocked together an analogous solution. Please pardon my shit Java skills.
package me.adamcameron.test;
public class GP {
public static String test = "GP";
public String fromGP(){
return test;
}
public String get(){
return test;
}
}
package me.adamcameron.test;
public class P extends GP {
public static String test = "P";
public String fromP(){
return test;
}
}
package me.adamcameron.test;
public class C extends P {
public static String test = "C";
public String fromC(){
return test;
}
}
package me.adamcameron.test;
public class Test {
public static void main(String[] args){
C c = new C();
System.out.println("fromC: " + c.fromC());
System.out.println("fromP: " + c.fromP());
System.out.println("fromGP: " + c.fromGP());
System.out.println("get: " + c.get());
}
}
And that - predictably - confirmed PHP's behaviour (not that I doubted PHP. Much):
>java me.adamcameron.test.Test
fromC: C
fromP: P
fromGP: GP
get: GP
fromC: C
fromP: P
fromGP: GP
get: GP
Coolio. I'm also pleased I managed to write 20-odd lines of Java and get it right
Last but
component {
static {
test = "GP";
}
public function fromGP(){
return static.test;
}
public function get(){
return static.test;
}
}
component extends=GP {
static {
test = "P";
}
public function fromP(){
return static.test;
}
public function get(){
return static.test;
}
}
component extends=P {
static {
test = "C";
}
public function fromC(){
return static.test;
}
public function get(){
return static.test;
}
}
<cfscript>
o = new C();
writeOutput("fromC: #o.fromC()#<br>");
writeOutput("fromP: #o.fromP()#<br>");
writeOutput("fromGP: #o.fromGP()#<br>");
writeOutput("get: #o.get()#<br>");
</cfscript>
When I ran this...
fromC: C
fromP: C
fromGP: C
get: C
Hrm. So Lucee does what I originally wanted, but I now reckon this is not what it should be doing. I best go ask someone from LAS what the story is there.
Anyway that was that. Just a small lesson learned for me today.
Oh, btw... the solution was to just make the variable not static. Then me code worked fine. There really was no need for it to be static in the first place, on reflection.
Update:
It's important to read Kalle's comment (below) regarding static:: in PHP.
It's important to read Kalle's comment (below) regarding static:: in PHP.
Righto.
--
Adam
