Eu tenho um monte de funções que eu quero mudar para uma aula. Eles estão atualmente divididos em alguns arquivos bastante longos. Eu prefiro não ter um arquivo de linha de 2500, mas tanto quanto eu posso dizer, você não pode usar incluir para dividir uma classe em vários arquivos. Em teoria, eu poderia agrupar as funções em diferentes classes, mas elas estão intimamente relacionadas o suficiente para que eu me sinta como se elas pertencessem, e dividi-las irá reduzir um pouco da utilidade que espero obter ao me afastar de uma abordagem processual. (com propriedades compartilhadas, em vez de um monte de parâmetros que estão em quase todas as funções).

Eu sei que isso é um pouco vago, mas alguma sugestão / ponteiros? Se for importante, isso é para um protótipo, portanto a facilidade de gerenciamento de código tem precedência sobre segurança e desempenho.

ATUALIZAR: Deixe-me ver se consigo remover um pouco da imprecisão:

Esta classe / conjunto de funções gera o html para um formulário complexo. Existem muitas seções e variações diferentes dentro de cada seção, dependendo de cerca de 5 ou 6 parâmetros, que atualmente são passados ​​para as funções. Eu estava esperando para definir os parâmetros uma vez como propriedades da classe e, em seguida, ter acesso a eles de dentro de todos os métodos de criação de seção. Se eu usar subclasses, os valores dessas propriedades não serão inicializados corretamente, daí o desejo de uma classe. (Hmm ... a menos que eu os defina como estáticos. Eu posso ter apenas respondido a minha própria pergunta. Vou ter que olhar para ver se há alguma razão que não funcionaria.)

Eu atualmente tenho uma confusão de funções como:

get_section_A ($type='foo', $mode='bar', $read_only=false, $values_array=array()) {
    if ($this->type == 'foo') { }
    else ($this->type == 'foo') { }
}    

Então eu estava inicialmente imaginando algo como:

class MyForm {
    public $type;          // or maybe they'd be private or 
    public $mode;          // I'd use getters and setters 
    public $read_only;     // let's not get distracted by that :)
    public $values_array;
    // etc.

    function __constructor ($type='foo', $mode='bar', $read_only=false, $values_array=array()) {
        $this->type = $type;
        // etc.
    }

    function get_sections () {
        $result = $this->get_section_A();
        $result .= $this->get_section_B();
        $result .= $this->get_section_C();        
    }      

    function get_section_A() { 
        if ($this->type == 'foo') { }
        else { }
    }
    function get_section_B() {}
    function get_section_C() {}
    // etc. for 2500 lines
}

Agora estou pensando em algo como:

// container class file
class MyForm {
    static $type 
    static $mode
    static $read_only
    static $values_array
    // etc.

    function __constructor ($type='foo', $mode='bar', $read_only=false, $values_array=array()) {
        MyForm::$type = $type;
        // etc.
    }

    function get_sections () {
        $result = new SectionA();
        $result .= new SectionB();
        $result .= new SectionC();
    }      
}

// section A file
class SectionA extends MyForm {
    function __constructor() { 
        if (MyForm::$type == 'foo') { }
        else { }
    }

    function __toString() {
        // return string representation of section
    }
}

// etc.

Ou provavelmente eu preciso de uma classe abstrata de FormSection onde as propriedades vivem.

Alguma outra ideia / abordagem?