PHP - define constante dentro de una clase

¿Cómo puedo definir una constante dentro de una clase y hacerla visible solo cuando se llama en un contexto de clase?

....algo como Foo::app()->MYCONSTANT;

(y si se llama, me gustaría MYCONSTANTser ignorado)

Ver constantes de clase :

class MyClass
{
    const MYCONSTANT = 'constant value';

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

echo MyClass::MYCONSTANT. "\n";

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

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

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

En este caso, haciendo eco MYCONSTANTpor sí mismo elevaría un aviso sobre una constante indefinida y la salida de la constante nombre convierte en una cadena: "MYCONSTANT".

EDITAR - Quizás lo que está buscando son estas propiedades / variables estáticas :

class MyClass
{
    private static $staticVariable = null;

    public static function showStaticVariable($value = null)
    {
        if ((is_null(self::$staticVariable) === true) && (isset($value) === true))
        {
            self::$staticVariable = $value;
        }

        return self::$staticVariable;
    }
}

MyClass::showStaticVariable(); // null
MyClass::showStaticVariable('constant value'); // "constant value"
MyClass::showStaticVariable('other constant value?'); // "constant value"
MyClass::showStaticVariable(); // "constant value"

Esta es una vieja pregunta, pero ahora en PHP 7.1 puede definir visibilidad constante.

EJEMPLO

<?php
class Foo {
    // As of PHP 7.1.0
    public const BAR = 'bar';
    private const BAZ = 'baz';
}
echo Foo::BAR . PHP_EOL;
echo Foo::BAZ . PHP_EOL;
?>

Salida del ejemplo anterior en PHP 7.1:

bar

Error fatal: Error no detectado: No se puede acceder a la constante privada Foo :: BAZ en…

Nota: A partir de PHP 7.1.0, se permiten modificadores de visibilidad para las constantes de clase.

Más info aquí

class Foo {
    const BAR = 'baz';
}

echo Foo::BAR;

Esta es la única forma de hacer constantes de clase . Estas constantes siempre son accesibles globalmente a través de Foo::BAR, pero no son accesibles a través de solo BAR.

Para lograr una sintaxis como Foo::baz()->BAR, necesitaría devolver un objeto de la función baz()de clase Fooque tiene una propiedad BAR . Sin embargo, eso no es una constante. Cualquier constante que defina es siempre accesible globalmente desde cualquier lugar y no puede restringirse a los resultados de llamadas a funciones.

Esta es una pregunta bastante antigua, pero quizás esta respuesta aún pueda ayudar a alguien más.

Puede emular una constante pública que está restringida dentro del ámbito de una clase aplicando la palabra clave final a un método que devuelve un valor predefinido, como este:

class Foo {

    // This is a private constant
    final public MYCONSTANT()
    {
        return 'MYCONSTANT_VALUE';
    }
}

La palabra clave final en un método evita que una clase en extensión redefina el método. También puede colocar la palabra clave final delante de la declaración de la clase, en cuyo caso la palabra clave evita la herencia de la clase.

Para obtener casi exactamente lo que Alex estaba buscando, se puede usar el siguiente código:

final class Constants {

    public MYCONSTANT()
    {
        return 'MYCONSTANT_VALUE';
    }
}

class Foo {

    static public app()
    {
        return new Constants();
    }
}

El valor constante emulado sería accesible así:

Foo::app()->MYCONSTANT();

Puede definir una constante de clase en php. Pero su constante de clase también sería accesible desde cualquier instancia de objeto. Esta es la funcionalidad de php. Sin embargo, a partir de php7.1 , puede definir sus constantes de clase con modificadores de acceso ( public, privateo protected).

Una alternativa sería definir su constante como privateo protectedy luego hacerlas legibles a través de un static function. Esta función solo debe devolver los valores constantes si se llama desde el contexto estático.

También puede crear esta función estática en su clase principal y simplemente heredar esta clase principal en todas las demás clases para convertirla en una funcionalidad predeterminada.

Créditos: http://dwellupper.io/post/48/defining-class-constants-in-php