Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 8 years ago.
Improve this question
It's possible to do this if the class B NOT extended the class A but the class A call a new class B
class A{
public $lang;
public function __construct($lang) {
$this->lang=$lang;
}
public function new_B(){
return new B();
}
}
class B{
public function __construct() {
echo 'lang='.A::$lang;
}
}
$root=new A('eng');
$root->new_B();
You seem to have a mixup of concepts here. The $lang property of A is an instance level variable (since it is not defined as static), therefore you cannot access it statically as you are trying to. If you were to declare the variable as static then you would have access to it, but if you have multiple instances of class A that change it, it will change on the class level, rather than instance level.
Is A::$lang common to all A objects you will create? Then make this variable static. If not you can pass A::$lang as parameter to the B constructor. That is
class A{
public $lang;
public function __construct($lang) {
$this->lang=$lang;
}
public function new_B(){
return new B($this->lang);
}
}
class B{
public function __construct($lang) {
echo 'lang='.$lang;
}
}
Following is making A::$lang static:
class A{
public static $lang;
public function __construct($lang) {
self::$lang=$lang;
}
public function new_B(){
return new B();
}
}
class B{
public function __construct() {
echo 'lang='.A::$lang;
}
}
change the class B like this:
class B extends A{
public function __construct() {
echo 'lang='.$this->$lang; // you can use parent variables like this
}
}
Related
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 20 days ago.
Improve this question
During some workaround with some architecture I faced a question and I am wondering if this implementation follows best practice or not.
Here we have a base abstract class:
abstract class A {
protected mixed $object;
public function __construct() {
$this->loadObject()
->fuc1();
}
abstract protected function loadObject(): self;
abstract public function fuc1(): bool;
abstract public function fuc3(): iterable;
}
In this case, I want to implement Class B and C. if I create each class separately everything is fine but as far as these 2 classes have the same functions I decided to create a base class for them (BC) so codes are now like this:
class BC extends A {
protected string x;
protected string y;
protected function loadObject(): self {
throw new \Exception('Child must implement loeadObject');
}
public function fuc1(): bool {
//Some Codes
}
public function fuc3(): iterable {
//Some Codes
}
}
And Class B and Class C are like this:
class B extends BC {
protected function loadObject(): self {
$this->object = new SomeObject();
return $this;
}
}
class C extends BC {
protected function loadObject(): self {
$this->object = new SomeObject2();
return $this;
}
}
We also can not move loadObject function to class BC cuz maybe class D wants to inherit directly from class A.
We can also rely on interfaces but I was wondering if some one forget to make class B/C implement an Interface then we will have problem in class A.
So is it a good practice that we throw exceptions in the class BC and force other developers to don't forget to overwrite the loadObject function?
This is not a good practice, if you doesn't need to implement the loadObject method in the BC class, you should keep it abstract.
abstract class BC extends A {
protected string $x;
protected string $y;
public function fuc1(): bool {
}
public function fuc3(): iterable {
}
}
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 2 years ago.
Improve this question
In file A,
Class A {
__construct() {
...
lots of code
...
}
public function P() {
code here
}
}
New A();
In file B,
Class B {
__construct() {
...
lots of code
...
}
public function E() {
I need to call function P in Class A
}
}
New B();
I would like to call the function P() in function E().
Is there any way to call a function in another class?
I found several ways such as dependency injection using __construct( A $aobj ) or "extends"
However, the class A was already instantiated in file A and there're a lot of things in __counstruct so I would like to know
1) the way of refractory technique
2) fancy way to call function E() in function P().
It really depends on how class B is related to A :
no link : the function in A should be static (it doesn't interact with a specific instance of A and its properties), and you can call A::P()
the class B is a child of A :
In B class definition, you have a class B extends A and in the constructor of B, you will have a parent::__construct() to call the constructor of A.
Then you can simply call $this->P() : as B is a subclass of A, and P is public (or protected), B inherits of all methods from A
The class B uses a object of type A`
Then, you must have a $a attribute in the class B, and a $this->a = new A(); in the constructor of B. You can call P with $this->a->P();
Or if you need only temporarily A in E(), you can construct a new object $a = new A(); and call $a->P(); in the code of E
Let's say that we have file a.php which contains class A:
class A {
public function __construct()
{
}
public function P()
{
echo "It is function P";
}
}
And file b.php which contains class B, in file b.php we first include a.php
include('a.php');
class B {
private $aobj;
public function __construct(){
$this->aobj = new A();
}
public function E(){
$this->aobj->P();
}
}
$b = new B();
$b->E();
Now open the browser and http://localhost/your-project/b.php and see the result.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 6 years ago.
Improve this question
So, I have this class that gets used over and over again throughout my app. This is just an example, not what's actually needed to be done:
File A:
class Names {
public function first() {
echo 'Bob';
}
}
That file is autoloaded into my app using spl_autoload_register and used all throughout in other pages/classes:
File B:
class LastNames {
public function __construct() {
$this->first = new Names();
}
public function last() {
echo $this->first->first().' Smith';
}
}
$names = new LastNames();
echo $names->last(); // Bob Smith
I have many files that instantiate the class Names inside the constructor.
Does this cause much of a hit on performance?
Should I be using static function instead of public function?
Is there a better way to reuse the functions inside Names over and over again inside different classes?
You have several options, using static function is one of them :
class LastNames {
public static function foo(){
// do stuff
}
}
Or you can use a singleton :
class LastNames {
private static $instance = null;
private function __construct(){
// do stuff
}
public function foo(){
// do stuff
}
public static function getInstance(){
if ( !self::$instance ){
self::$instance = new LastNames();
}
return self::$instance;
}
}
And then you can call it with :
$lastnames = LastNames::getInstance();
$lastnames->foo();
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 8 years ago.
Improve this question
Why is the following code returning NULL? I am trying to get the parent method to return a value of a property inside the parent class but for some reason it is returning null.
class A {
public $greeting;
public function __construct($message){
$this->greeting = $message;
}
public function getGreeting(){
print 1;
return $this->greeting;
}
}
class B extends A{
public function __construct(){
}
public function getGreetingMessage(){
parent::getGreeting();
}
}
$classA = new A('Hello world');
$classB = new B();
var_dump($classB->getGreetingMessage());
In the parent method "1" is being printed so I know the method is being called
Because the greeting message is not set in class b. so greeting message returns null.
1) return parent::getGreeting();
2) $classA and $classB are different instances. Whatever you set in $classA is not accessible in $classB
3) constuctor of the parent is not called from classB and, moreover, you do not provide any arguments in initialization of classB (look at 2) above)
class A {
public $greeting;
public function __construct($message){
$this->greeting = $message;
}
public function getGreeting(){
print 1;
return $this->greeting;
}
}
class B extends A{
public function __construct($message){
parent::__construct($message);
// or $this->greeting = $message;
}
public function getGreetingMessage(){
return parent::getGreeting();
}
}
$classA = new A('Hello world');
$classB = new B('Hello world 2');
var_dump($classB->getGreetingMessage());
You have to call the parent's constructor in the child class, otherwise the parent constructor is not run and the class isn't properly initialized:
class B extends A{
public function __construct($message){
parent::__construct($message);
}
So you most likely want this
$classB=new B('Hello World');
Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 9 years ago.
Improve this question
How to create public php class object inside a another class?.
I have a class called
page.php
and also
Main.php
and
Content.php
I want to call Main.php and Content.php class inside the page.php class. What is the correct way to do this.
I tried this, but not working :( . Please help.
<?php
class Page
{
public $main;
public $content;
function __construct()
{
$main=new Main_Model();
$content=new Content_Model();
}
public function Menu()
{
$load_menu=$content->Load_Menu();
...
...
}
}
?>
I can only assume you are new to OOP.
But the issue resides within you needing to access the variables from the global scope.
I am also making the assumption that you are using a framework that provides auto-loading and that these classes are actually accessible.
class Page
{
private $main;
private $content;
function __construct()
{
$this->main=new Main_Model();
$This->content=new Content_Model();
}
public function Menu()
{
$load_menu=$this->content->Load_Menu();
...
...
}
}
That should solve everything for you. Also you should define your variables as private unless you plan on exposing them for use in other places as a public interface. And even then there is discussion on using methods to access private variables.
This should fix you're issue and I've changed/fixed a few other bits like public/private variables etc. As others have said you're missing the $this-> in your construct()
<?php
class Main_Model {
public function Load_Menu() {
return "This is the menu function";
}
}
class Content_Model {
public function Load_Content() {
return "This is the main content function";
}
}
class Page {
private $mainmenu;
private $content;
function __construct() {
$this->mainmenu = new Main_Model();
$this->content = new Content_Model();
}
function Menu() {
return $this->mainmenu->Load_Menu();
}
function Content() {
return $this->content->Load_Content();
}
}
$page = new Page();
echo $page->Menu();
echo "<br />";
echo $page->Content();
?>