class A
{
public function child1()
{
$var1 = 'abc';
}
}
class B extends A
{
public function child1()
{
echo parent::$var1; // Return error undefined class constant 'var1'
}
}
How can i access $var1 in this situation ?
Expected result: 'abc'
First you cannot do class B extends class A. The correct syntax would be class B extends A:
class A
{
public function child1()
{
$var1 = 'abc';
return $var1;
}
}
class B extends A
{
public function child1()
{
echo parent::child1();
}
}
$temp = new B;
$temp->child1();
Now what I've done is return the $var1 in your class A.
You cannot call echo parent::$var1; because it is inside a function, so you call the parent function echo parent::child1();.
working example here
You need to make $var1 a class property. See following code:
<?php
class A
{
protected $var1;
public function child1()
{
$this->var1 = 'abc';
}
}
class B extends A
{
public function child1()
{
parent::child1();
echo $this->var1;
}
}
$b = new B();
$b->child1();
?>
Related
I have 3 classes:
Class A - Parent Class
Class B - Child Class
Class C - Class to be used in Class A
I want to use functions from class C using variables from my Child class.
<?php
class A
{
public function __construct()
{
$this->load();
}
public function load()
{
$class = new C();
$class->test = $this->test;
$this->c = $class;
}
}
class B extends A
{
public function __construct()
{
parent::__construct();
}
}
class C
{
public function display()
{
echo $this->test;
}
}
$b = new B();
$b->test = 1;
$b->c->display();
Your problem is here:
$class->test = $this->test;
You are attempting to use a property that is not yet defined, because when you do this:
$b->test = 1;
the constructor has already been called, and there's nothing in your classes to update C with the value of B's test property.
You can solve this in a couple of different ways.
1) Send the value in B's constructor, and pass it down the entire chain:
class A
{
public function __construct($test)
{
$this->load($test);
}
public function load($test)
{
$class = new C();
$class->test = $test;
$this->c = $class;
}
}
class B extends A
{
public function __construct($test)
{
parent::__construct($test);
}
}
class C
{
public function display()
{
echo $this->test;
}
}
$b = new B(123);
$b->c->display();
2) Add a method to B that will update C's property:
<?php
class A
{
public function __construct()
{
$this->load();
}
public function load()
{
$class = new C();
$this->c = $class;
}
}
class B extends A
{
public function __construct()
{
parent::__construct();
}
public function setTest($test)
{
$this->c->test = $test;
}
}
class C
{
public function display()
{
echo $this->test;
}
}
$b = new B();
$b->setTest(123);
$b->c->display();
Or perhaps a combination of both.
<?php
class A {
private function foo() {
echo "baf!<br/>";
}
public function test() {
$this->foo();
}
}
class C extends A {
private function foo() {
echo "bar!<br/>";
}
}
$c = new C();
$c->test(); //Prints baf!
?>
How to make c->test() to print bar! ? I was expecting that foo() will be overridden in C and would print bar! can someone explain it to me?
By making both methods protected you will achieve the desired result; the reason being that within A::test() it can only resolve $this->foo() to A::foo() because of the private visibility. See Visibility.
class A {
protected function foo() {
echo "baf!<br/>";
}
public function test() {
$this->foo();
}
}
class C extends A {
protected function foo() {
echo "bar!<br/>";
}
}
$c = new C();
$c->test(); //Prints bar!
class A {
protected function foo() {
echo "baf!<br/>";
}
public function test() {
$this->foo();
}
}
class C extends A {
protected function foo() {
echo "bar!<br/>";
}
}
$c = new C();
$c->test(); //Prints baf!
just make both the foo function as public or protected access level.
consider this code:
class C
{
public function get()
{
echo 'C';
static::get();
}
public function save()
{
self::get();
}
}
class B extends C
{
public function get()
{
echo 'B';
static::get();
}
}
class A extends B
{
public function get()
{
echo 'A';
}
}
$x = new A();
$x->save();
it echoes CA while I was expected CBA
To get this to work the way you want, reverse the logic - get your save to call the static::get() so it will start at the top of the inheritence tree; and use calls to parent::get() in each inherited class in the tree (except the base level) before echoing its own output
class C
{
public function get()
{
echo 'C';
}
public function save()
{
static::get();
}
}
class B extends C
{
public function get()
{
parent::get();
echo 'B';
}
}
class A extends B
{
public function get()
{
parent::get();
echo 'A';
}
}
$x = new A();
$x->save();
Demo
I need to know what kind invokes a static method, without sending as parameter
class foo
{
public static function test($clase)
{
echo "Class invoke:" . FUNCTION();
}
}
class A { public function x { foo::test(); } }
class B { public function y { foo::test(); } }
class C { public function z { foo::test(); } }
You can use late static bindings and get_called_class() (PHP >= 5.3) if you make all of your classes extend foo, like this:
class foo
{
public static function test($clase)
{
echo "Class invoke:" . get_called_class();
}
}
class A extends foo { public function x() { self::test(''); } }
class B extends foo { public function y() { self::test(''); } }
class C extends foo { public function z() { self::test(''); } }
With these objects:
$a = new A; $a->x();
$b = new B; $b->y();
$c = new C; $c->z();
You'll get as output:
Class invoke:A
Class invoke:B
Class invoke:C
we have two class A & B:
class A{
var $settings;
function getinfo(){
$settings['domain']="mydomain";
$settings['pass']="1234";
return $settings;
}
}
class B extends A{
$ads = A::getinfo();
function makeurl(){
return "template/".$ads['domain'];
}
}
now i have an instance of B in my page, but i need "pass" , maybe some code like this:
$theme=new B();
$mypass = $theme->A->getinfo;
echo $mypass[$pass];
I know this code is full of faults , but i could not write a better one. is there any solution to access to password without making an instance of A?
Yes. It is as simple as this:
$theme = new B();
$mypass = $theme->getinfo();
echo $mypass['pass'];
You can also improve your classes a bit:
class A
{
var $settings;
function getinfo()
{
$this->settings['domain'] = "mydomain";
$this->settings['pass'] = "1234";
return $this->settings;
}
}
class B extends A
{
function makeurl()
{
$this->getinfo();
return 'template/' . $this->settings['domain'];
}
}
Why not call the settings variable in A from the B instance since B is a subclass of A?
Try this code:
<?php
class A
{
var $settings;
function getinfo()
{
$settings['domain'] = "mydomain";
$settings['pass'] = "1234";
return $settings;
}
}
class B extends A
{
function makeurl()
{
$ads = $this->getinfo();
return "template/" . $ads['domain'];
}
}
$theme=new B();
$mypass = $theme->getinfo();
echo $mypass['pass'];
What about making settings a public static variable in A? By making it a class variable you won't need an instance of A.
class A {
public static $settings;
// getter and setter methods here
}
// code elsewhere
echo A::$settings['pass'];
Also because your class B extends A it inherits the methods and properties, so you could call
$theme = new B();
$mySettings = $theme->GetInfo();
if B extends A, all protected and public members of A are inherited into B, so you can access them directly.
class A {
protected $foo;
public function __construct() { $this->foo = 1; }
}
class B extends A {
public function bar() {
echo $this->foo;
}
}
$b = B();
$b->bar();
If I understand you correctly, you're pretty close:
$theme=new B();
$settings = $theme->getinfo();
$mypass = $settings['pass'];
echo $mypass;