visibility.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<!-- EN-Revision: 70fb482c26ecfb7b95b1484ebb73a14f272c9871 Maintainer: seros Status: ready -->
<!-- Reviewed: no Maintainer: andresdzphp -->
<sect1 xml:id="language.oop5.visibility" xmlns="http://docbook.org/ns/docbook">
 <title>Visibilidad</title>
 <para>
  La visibilidad de una propiedad, un método o (a partir de PHP 7.1.0) una constante se puede definir anteponiendo
  a su declaración una de las palabras reservadas <emphasis>public</emphasis>,
  <emphasis>protected</emphasis> o
  <emphasis>private</emphasis>. A los miembros de clase declarados como 'public' se puede
  acceder desde donde sea; a los miembros declarados como 'protected',
  solo desde la misma clase, mediante clases heredadas o desde la clase padre. A los miembros
  declarados como 'private' únicamente se puede acceder desde la clase que los
  definió.
 </para>
 
 <sect2 xml:id="language.oop5.visibility-members">
  <title>Visibilidad de propiedades</title>
  <para>
   Las propiedades de clases deben ser definidas como 'public', 'private'
   o 'protected'. Si se declaran usando <emphasis>var</emphasis>,
   serán definidas como 'public'.
  </para>
  <para>
   <example>
    <title>Declaración de propiedades</title>
    <programlisting role="php">
<![CDATA[
<?php
/**
 * Definición de MyClass
 */
class MyClass
{
    public $public = 'Public';
    protected $protected = 'Protected';
    private $private = 'Private';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj = new MyClass();
echo $obj->public;    // Funciona bien
echo $obj->protected; // Error Fatal
echo $obj->private;   // Error Fatal
$obj->printHello();   // Muestra Public, Protected y Private


/**
 * Definición de MyClass2
 */
class MyClass2 extends MyClass
{
    // Se pueden redeclarar las propiedades pública y protegida, pero no la privada
    public $public = 'Public2';
    protected $protected = 'Protected2';

    function printHello()
    {
        echo $this->public;
        echo $this->protected;
        echo $this->private;
    }
}

$obj2 = new MyClass2();
echo $obj2->public;    // Funciona bien
echo $obj2->protected; // Error Fatal
echo $obj2->private;   // Undefined
$obj2->printHello();   // Muestra Public2, Protected2, Undefined

?> 
]]>
    </programlisting>
   </example>
  </para>
  <note>
   <simpara>
    La forma de declaración de una variable de PHP 4 con la
    palabra clave <emphasis>var</emphasis> todavía es soportado
    (como un sinónimo de public) por razones de compatibilidad. En PHP 5
    antes de 5.1.3, su uso genera un Warning <constant>E_STRICT</constant>.
   </simpara>
  </note>
 </sect2>
 
 <sect2 xml:id="language.oop5.visiblity-methods">
  <title>Visibilidad de Métodos</title>
  <para>
   Los métodos de clases pueden ser definidos como public, private,
   o protected. Aquellos declarados sin ninguna palabra clave de
   visibilidad explícita serán definidos como public.
  </para>
  <para>
   <example>
    <title>Declaración de métodos</title>
    <programlisting role="php">
<![CDATA[
<?php
/**
 * Definición de MyClass
 */
class MyClass
{
    // Declaración de un constructor public
    public function __construct() { }

    // Declaración de un método public
    public function MyPublic() { }

    // Declaración de un método protected
    protected function MyProtected() { }

    // Declaración de un método private
    private function MyPrivate() { }

    // Esto es public
    function Foo()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate();
    }
}

$myclass = new MyClass;
$myclass->MyPublic(); // Funciona
$myclass->MyProtected(); // Error Fatal
$myclass->MyPrivate(); // Error Fatal
$myclass->Foo(); // Public, Protected y Private funcionan


/**
 * Definición de MyClass2
 */
class MyClass2 extends MyClass
{
    // Esto es public
    function Foo2()
    {
        $this->MyPublic();
        $this->MyProtected();
        $this->MyPrivate(); // Error Fatal
    }
}

$myclass2 = new MyClass2;
$myclass2->MyPublic(); // Funciona
$myclass2->Foo2(); // Public y Protected funcionan, pero Private no

class Bar
{
    public function test() {
        $this->testPrivate();
        $this->testPublic();
    }

    public function testPublic() {
        echo "Bar::testPublic\n";
    }
    
    private function testPrivate() {
        echo "Bar::testPrivate\n";
    }
}

class Foo extends Bar
{
    public function testPublic() {
        echo "Foo::testPublic\n";
    }
    
    private function testPrivate() {
        echo "Foo::testPrivate\n";
    }
}

$myFoo = new Foo();
$myFoo->test(); // Bar::testPrivate 
                // Foo::testPublic
?>
]]>
    </programlisting>
   </example>
  </para>
 </sect2>
 
 <sect2 xml:id="language.oop5.visiblity-constants">
  <title>Visibilidad de las constantes</title>
  <para>
   A partir de PHP 7.1.0, las constantes de clase se pueden definir como públicas, privadas o
   protegidas. Las constantes declaradas sin una visibilidad explítica
   serán definidas como públicas.
  </para>
  <para>
   <example>
    <title>Declaración de constantes a partir de PHP 7.1.0</title>
    <programlisting role="php">
<![CDATA[
<?php
/**
 * Definir MiClase
 */
class MiClase
{
    // Declarar una constante pública
    public const MY_PUBLIC = 'public';

    // Declarar una constante protegida
    protected const MY_PROTECTED = 'protected';

    // Declarar una constante privada
    private const MY_PRIVATE = 'private';

    public function foo()
    {
        echo self::MY_PUBLIC;
        echo self::MY_PROTECTED;
        echo self::MY_PRIVATE;
    }
}

$myclass = new MiClase();
MiClase::MY_PUBLIC; // Funciona
MiClase::MY_PROTECTED; // Error fatal
MiClase::MY_PRIVATE; // Error fatal
$myclass->foo(); // Funcionan Public, Protected y Private


/**
 * Definir MiClase2
 */
class MiClase2 extends MiClase
{
    // Esta es pública
    function foo2()
    {
        echo self::MY_PUBLIC;
        echo self::MY_PROTECTED;
        echo self::MY_PRIVATE; // Error fatal
    }
}

$myclass2 = new MiClase2;
echo MiClase2::MY_PUBLIC; // Funciona
$myclass2->foo2(); // Funcionan Public y Protected, pero no Private
?>
]]>
     </programlisting>
    </example>
   </para>
 </sect2>
 
 <sect2 xml:id="language.oop5.visibility-other-objects">
  <title>Visibilidad desde otros objetos</title>
  <para>
   Los objetos del mismo tipo tendrán acceso a los miembros private y
   protected entre ellos aunque no sean de la misma instancia. Esto es porque
   los detalles específicos de implementación ya se conocen cuando se encuentra
   dentro de estos objetos.
  </para>
  <example>
   <title>Accediendo a miembros private del mismo tipo de objeto</title>
   <programlisting role="php">
<![CDATA[
<?php
class Test
{
    private $foo;

    public function __construct($foo)
    {
        $this->foo = $foo;
    }

    private function bar()
    {
        echo 'Método private accedido.';
    }

    public function baz(Test $other)
    {
        // Se puede cambiar la propiedad private:
        $other->foo = 'hola';
        var_dump($other->foo);

        // También se puede invocar al método private:
        $other->bar();
    }
}

$test = new Test('test');

$test->baz(new Test('other'));
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
string(5) "hola"
Método private accedido.
]]>
   </screen>
  </example>
 </sect2>
</sect1>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->