Differences between static properties and constants

Static properties are properties linked to the class and not a particular object, which means they can be accessed without instantiating them. 
It is possible to reference static properties with a variable:


class Parent {
public static $static_property;
}

Static methods are called using the Scope Resolution Operator (::) .

Inside of the class we would call it with self::


class Parent{
public static $static_property;
    
public function returnStaticPropertyValue() { 
    self::$static_property;        
    }
}

Outside of the class we would call it with the name of the class
class Child {
$child_inherited_static_property = Parent::$static_property;
}

Constants are an identifier for a simple value. For example, the value of number π of or the value of the garvity. They are declared starting with an underscore or letter, in capitals, without the $ sign or using the method define() as follows.

class Parent {
//Either
const GRAVITY = 9.8;
//Or
define ("GRAVITY", "9.8");
}

To call these, same as in the case of static properties, we do it using the Scope Resolution Operator (::), but without the $ sign. 


//Inside of the class
class Parent {
//define the constant
const GRAVITY = 9.8;
//call the constant
public function returnConstantValue {
    self::Gravity;
    }
}
//Outside of the class
class Child {
$child_inherited_constant = Parent::GRAVITY;
}

Apart from they different way in which they are declared and called, is there any other remarkable difference between them? Yes, indeed. Constants value cannot be changed during execution time.


Comments

Post a Comment

Popular posts from this blog

SOLID: The Single-Responsibility Principle (SRP)

 This Object Oriented Programming principle states that each module or class should be responsible for only one part of the functionality.  By saying this, we are stating that each subsystem, module, class or function should have just one reason to change.  How do we accomplish this? By developing small service classes with enclosed objectives.  What is it that we want to accomplish through this strategy?   More cohesion and less resistance to change. Allow the composition of classes (or class injection) which deserves a extended post in this blog. Avoid duplicity and copy-pasting portions of code. Now, that seems fairly simple but, as with any theoretical principle, the problem is usually visualizing with an example what the theory is suggesting and, even more than that, in which cases should we apply this theory. Of course, it's not the same developing a small online shop for a cousin who produces and sells hand made costume jewelry, than developing  an a...
Read more

Symfony HTTP client

 I am currently developing a very simple app which offers you the possibility to create question-answer flipping cards, creating thus some kind of funny Trivia to practice on any topic you want to apply it to. As a user, you create first the question-aswear entities which also include  category field, and then you can practice them in the playground area, which shows you the question on a hoverable flipping card. It also offers you a textearea which disables 60 seconds after you start typing on it, so that you can write down your answer before actually flipping the card and getting to see the correct one.  In this app, though simple, I wanted to keep a client-web service architecture from the very beginning. The web client contains the views and communicates with the API, which contains the data through Ajax calls. This was working consistently so far. An example of the creation and saving of new question-answer items is: When I press on "Create new question" button, I am...
Read more

Inheritance: Abstract classes and interfaces

What is inheritance? It's a programming principle used in the PHP object model which allows a class (child) to inherit another class' (parent) protected or public methods, properties and constants, retaining the parent's original functionality, unless these are overriden by the child class. What is an abstract class? A class that contains at least one abstract method, which means only the signature of the method is defined. For example: abstract Class Parent { abstract protected function defineMyFunction (). } Class Child extends Parent {      protected function defineMyFunction () {           return "I am an abstract function in my Parent class" ;      } } As childish as this example might seem , it quite easily represents the aforementioned definition. When a  class (or child class) extends from an abstract class (or parent class), it must define all methods declared as abstract. In fact, if you are using an IDE...
Read more