PHP 5: const vs estático

No PHP 5, qual é a diferença entre usar conste static?

Quando cada um é apropriado? E qual o papel que public, protectede privatejogar - se for o caso?

No contexto de uma classe, variáveis ​​estáticas estão no escopo da classe (não no objeto), mas, diferentemente de uma const, seus valores podem ser alterados.

class ClassName {
    static $my_var = 10;  /* defaults to public unless otherwise specified */
    const MY_CONST = 5;
}
echo ClassName::$my_var;   // returns 10
echo ClassName::MY_CONST;  // returns 5
ClassName::$my_var = 20;   // now equals 20
ClassName::MY_CONST = 20;  // error! won't work.

Público, protegido e privado são irrelevantes em termos de consts (que são sempre públicos); eles são úteis apenas para variáveis ​​de classe, incluindo variável estática.

• variáveis ​​estáticas públicas podem ser acessadas em qualquer lugar via ClassName :: $ variable.
• variáveis ​​estáticas protegidas podem ser acessadas pela classe de definição ou extensão de classes via ClassName :: $ variable.
• variáveis ​​estáticas privadas podem ser acessadas apenas pela classe de definição via ClassName :: $ variable.

Edit: É importante notar que o PHP 7.1.0 introduziu suporte para especificar a visibilidade das constantes da classe .

Um último ponto que deve ser destacado é que uma const é sempre estática e pública. Isso significa que você pode acessar o const de dentro da classe da seguinte maneira:

class MyClass
{
     const MYCONST = true;
     public function test()
     {
          echo self::MYCONST;
     }
}

De fora da classe, você o acessaria assim:

echo MyClass::MYCONST;

Constante é apenas uma constante, ou seja, você não pode alterar seu valor após a declaração.

A variável estática é acessível sem criar uma instância de uma classe e, portanto, compartilhada entre todas as instâncias de uma classe.

Além disso, pode haver uma variável local estática em uma função que é declarada apenas uma vez (na primeira execução de uma função) e pode armazenar seu valor entre chamadas de função, por exemplo:

function foo()
{
   static $numOfCalls = 0;
   $numOfCalls++;
   print("this function has been executed " . $numOfCalls . " times");
}

Ao falar sobre herança de classe, é possível diferenciar entre a constante ou a variável em diferentes escopos usando selfe staticpalavras-chave. Verifique este exemplo que ilustra como acessar o que:

class Person
{
    static $type = 'person';

    const TYPE = 'person';

    static public function getType(){
        var_dump(self::TYPE);
        var_dump(static::TYPE);

        var_dump(self::$type);
        var_dump(static::$type);
    }
}

class Pirate extends Person
{
    static $type = 'pirate';

    const TYPE = 'pirate';
}

E então faça:

$pirate = new Pirate();
$pirate::getType();

ou:

Pirate::getType();

Resultado:

string(6) "person" 
string(6) "pirate" 
string(6) "person" 
string(6) "pirate"

Em outras palavras, self::refere-se à propriedade estática e constante do mesmo escopo em que está sendo chamada (neste caso, a Personsuperclasse), enquanto static::acessará a propriedade e a constante do escopo em tempo de execução (nesse caso, na Piratesubclasse).

Leia mais sobre ligação estática tardia aqui no php.net .
Verifique também a resposta em outra pergunta aqui e aqui .

Declarar um método ou propriedade de classe como estático os torna acessíveis sem a necessidade de uma instanciação da classe.

Uma constante de classe é como uma constante normal, não pode ser alterada em tempo de execução. Este também é o único motivo pelo qual você utilizará o const.

Privado, público e protegido são modificadores de acesso que descrevem quem pode acessar qual parâmetro / método.

Público significa que todos os outros objetos obtêm acesso. Privado significa que somente a classe instanciada obtém acesso. Protegido significa que a classe instanciada e as classes derivadas obtêm acesso.

Aqui estão as coisas que aprendi até agora sobre membros estáticos, variáveis ​​constantes e modificadores de acesso (privado, público e protegido). Constante

Definição

Como o nome diz, os valores de uma variável constante não podem ser alterados. As constantes diferem das variáveis ​​normais, pois você não usa o símbolo $ para declará-las ou usá-las.

O valor deve ser uma expressão constante, não (por exemplo) uma variável, uma propriedade, o resultado de uma operação matemática ou uma chamada de função.

Nota: O valor da variável não pode ser uma palavra-chave (por exemplo, auto, pai e estática).

Declarando uma constante em php

<?php
class constantExample{

   const CONSTANT = 'constant value'; //constant

 }
?>

O escopo da Constant é global e pode ser acessado usando uma palavra-chave self

<?php
class MyClass
{
    const CONSTANT = 'constant value';

    function showConstant() {
        echo  self::CONSTANT . "\n";
    }
}

echo MyClass::CONSTANT . "\n";

$classname = "MyClass";
echo $classname::CONSTANT . "\n"; // As of PHP 5.3.0

$class = new MyClass();
$class->showConstant();

echo $class::CONSTANT."\n"; // As of PHP 5.3.0

?>

Estático

Definição

A palavra-chave estática pode ser usada para declarar uma classe, função-membro ou variável. Os membros estáticos de uma classe são globais também podem ser acessados ​​usando uma palavra-chave própria. Declarar propriedades ou métodos de classe como estáticos os torna acessíveis sem a necessidade de uma instanciação da classe . Uma propriedade declarada como estática não pode ser acessada com um objeto de classe instanciado (embora um método estático possa). Se nenhuma declaração de visibilidade (pública, privada, protegida) for usada, a propriedade ou o método será tratado como se fosse declarado como público.Porque os métodos estáticos podem ser chamados sem uma instância do objeto criado.

Nota: a pseudo-variável $ this não está disponível dentro do método declarado como static. As propriedades estáticas não podem ser acessadas através do objeto usando o operador de seta ->

A partir do PHP 5.3.0, é possível referenciar a classe usando uma variável. O valor da variável> não pode ser uma palavra-chave (por exemplo, auto, pai e estática).

Exemplo de propriedade estática

<?php
class Foo
{
    public static $my_static = 'foo'; //static variable 

    public static function staticValue() { //static function example
        return self::$my_static;  //return the static variable declared globally
    }
}

?>

Acessando propriedades estáticas e exemplo de funções

 <?php
     print Foo::$my_static . "\n";

    $foo = new Foo();
    print $foo->staticValue() . "\n";
    print $foo->my_static . "\n";      // Undefined "Property" my_static 

    print $foo::$my_static . "\n";
    $classname = 'Foo';
    print $classname::$my_static . "\n"; // As of PHP 5.3.0

    print Bar::$my_static . "\n";
    $bar = new Bar();
    print $bar->fooStatic() . "\n";

 ?>

Público, privado, protegido (modificadores de acesso AKA)

Antes de ler a definição abaixo, leia este artigo sobre Encapsulamento. Isso ajudará você a entender o conceito mais profundamente

Link 1 wikipedia

Tutoriais apontam link sobre encapsulamento

Definição

Usando palavras-chave privadas, públicas e protegidas, você pode controlar o acesso aos membros de uma classe. Os membros da classe declarados públicos podem ser acessados ​​em qualquer lugar. Os membros declarados protegidos podem ser acessados ​​apenas dentro da própria classe e pelas classes herdada e pai. Os membros declarados como privados podem ser acessados ​​apenas pela classe que define o membro.

Exemplo

 <?php 
class Example{
 public $variable = 'value'; // variable declared as public 
 protected $variable = 'value' //variable declared as protected
 private $variable = 'value'  //variable declared as private

 public function functionName() {  //public function
 //statements
 }

 protected function functionName() {  //protected function
 //statements
 }
  private function functionName() {  //private function
   //statements
   }

} 
 ?> 

Acessando o exemplo de membros públicos, privados e protegidos

As variáveis ​​públicas podem ser acessadas e modificadas de fora da classe ou dentro da classe. Mas você pode acessar as variáveis ​​e funções privadas e protegidas apenas de dentro da classe. Você não pode modificar o valor de membros protegidos ou públicos fora da classe.

  <?php 
  class Example{
    public $pbVariable = 'value'; 
    protected $protVariable = 'value'; 
    private $privVariable = 'value';
    public function publicFun(){

     echo $this->$pbVariable;  //public variable 
     echo $this->$protVariable;  //protected variable
     echo $this->privVariable; //private variable
    }

   private function PrivateFun(){

 //some statements
  }
  protected function ProtectedFun(){

 //some statements
  }

  }


 $inst = new Example();
 $inst->pbVariable = 'AnotherVariable'; //public variable modifed from outside
 echo $inst->pbVariable;   //print the value of the public variable

 $inst->protVariable = 'var'; //you can't do this with protected variable
 echo $inst->privVariable; // This statement won't work , because variable is limited to private

 $inst->publicFun(); // this will print the values inside the function, Because the function is declared as a public function

 $inst->PrivateFun();   //this one won't work (private)
 $inst->ProtectedFun();  //this one won't work as well (protected)

  ?>

Para obter mais informações, leia esta documentação php sobre visibilidade Visibility Php Doc.

Referências: php.net

Espero que você tenha entendido o conceito. Obrigado pela leitura :) :) Tenha uma boa

Então, para recapitular a ótima resposta do @Matt:

• se a propriedade que você precisa não deve ser alterada, uma constante é a escolha certa

• se a propriedade necessária for alterada, use static em vez disso

Exemplo:

class User{
    private static $PASSWORD_SALT = "ASD!@~#asd1";
    ...
}

class Product{
    const INTEREST = 0.10;
    ...
}

Edit: É importante notar que o PHP 7.1.0 introduziu suporte para especificar a visibilidade das constantes da classe .