¿Cómo se organizan los métodos y las propiedades dentro de una clase?

Digamos que está declarando una clase con todas las campanas y silbatos: constructor y destructor, métodos y propiedades públicos, privados, protegidos y estáticos, métodos mágicos, etc.

¿Cómo organizas todo esto lógicamente? Por ejemplo, ¿agrupa las cosas por visibilidad? ¿Alfabetizas los nombres de los métodos? ¿Agrupas los métodos mágicos juntos? ¿Pones el constructor al principio y el destructor al final?

Obviamente, esto es subjetivo, pero tengo curiosidad por saber qué ha funcionado para otros, o qué le resulta fácil navegar cuando lee el código de otros.

1. constantes
2. Campos por visibilidad (público, protegido, privado)
3. Constructor y destructor y otros métodos mágicos.
4. Métodos por visibilidad (público, protegido, privado)

Si tengo tiempo, trato de ponerlos en orden alfabético ;P

como esto

class Foobar 
{
      var $public;

      function __construct(....

      function public_method_1()...
      function public_method_2()...

      //

      var $_priv;

      function _private_1()...
      function _private_2()...
 }

básicamente, lo más interesante (para usuarios de clase) primero

Pongo vars estáticos primero, luego variable de clase. entonces generalmente pongo el constructor como el primer método (o si es una clase con “init” o algún otro método llamado por un marco, lo pondré en la parte superior)

Después de eso, trato de mantener los métodos relacionados agrupados para tener la menor cantidad de desplazamiento, pero puede complicarse después de un tiempo.

Tener un IDE como Eclipse + PDT o vsPHP le mostrará la vista de esquema de su clase y podrá ordenar los métodos como desee para que no tenga que buscar el código.

Sé que es una publicación antigua y olvidada, pero hoy me he encontrado ordenando a los miembros de mi clase y aquí están mis cinco centavos:

abstract class Stdclass
{
   public const CONSTANT;
   protected const CONSTANT;
   private const CONSTANT;

   use TraitA, TraitB;

   public static $property;
   protected static $property;
   private static $property;

   abstract public static function method(); 
   abstract protected static function method(); 

   public static function method() {} 
   protected static function method() {} 
   private static function method() {}

   final public static function method() {} 
   final protected static function method() {} 

   public $property;
   protected $property;
   private $property;

   abstract public function method(); 
   abstract protected function method();

   public function __construct() {} 
   public function __destruct() {}
   public function __otherMagicMethods() {}

   public function getterMethod() {}
   public function setterMethod() {}
   public function method() {}
   final public function method() {}

   protected function method() {}
   final protected function method() {}

   private function method() {}
}

Personalmente, pongo las variables de clase en la parte superior (por visibilidad), luego los métodos mágicos, luego los métodos públicos, luego los métodos protegidos/privados. Es una combinación de ordenar las cosas de las que se editan con más frecuencia a las que se editan con menos frecuencia y hacer que sea obvio lo que sucede en los métodos importantes (razón por la cual los métodos mágicos son más altos de lo que normalmente serían).

Supongo que el único tipo de organización que hago dentro de una función es poner __construct al frente, a partir de ahí la clase crece sin ningún tipo de organización de mi parte, pero generalmente empiezo con funciones no públicas y termino con funciones públicas.

Personalmente, tengo constantes de clase en la parte superior; propiedades a continuación, tratando de mantener en orden de privado, protegido, luego público. Para los métodos, busco getters y setters primero, luego otros métodos internos agrupados libremente, seguidos de __construct y otros métodos mágicos, con cualquier método estático al final… pero rara vez termino manteniendo absolutamente ese orden.