(Continuação do primeiro artigo)
Mantendo o pensamento orientado a objetos, este tópico parece um pouco extenso. O que acabei de dizer e mencionar aqui são, na verdade, apenas alguns pequenos problemas aos quais devemos prestar atenção durante a codificação. Portanto, pode ser mais apropriado alterar o termo “totalmente” para “ter em mente”.
Alguns comentários sobre alguns recursos do Delphi:
Gostaria de saber se você notou que todos os componentes (incluindo controles) colocados em um Formulário Delphi são visíveis para outros Formulários. Para ser mais preciso, esses componentes são o conteúdo da parte Pública do Formulário. Por um lado, este resultado é bom, devido à sua flexibilidade, outras classes podem facilmente referenciar estes componentes no Form, definir as suas propriedades, executar os seus métodos, eventos, etc., mas por outro lado, as suas falhas também são óbvias; . Sim, isso leva à perda do encapsulamento do Form. Na minha opinião, esses componentes colocados no Form, no que diz respeito à intenção do usuário, deveriam existir como propriedades privadas do Form e não deveriam ser visíveis para outras classes ou outros Forms. Mesmo que você precise acessá-los, você deverá acessá-los indiretamente através de uma série de métodos de propriedade fornecidos pelo Form.
Dê um exemplo para dar a todos alguma compreensão perceptiva:
Procedimento TForm1.Button1Click(Remetente: TObject);
começar
Form2.Edit1.Text := 'abc'; // <-- Não concordo com a forma como esta frase está escrita.
fim;
Muitas pessoas podem não ter o conceito de encapsulamento em mente ao escrever esse código, mas depois de ler este artigo, você nunca mais fará tal coisa (mude seus métodos!). Na minha opinião, TForm1 é TForm1 e TForm2 é TForm2. Todos eles existem para realizar certas funções específicas, portanto, fornecem algumas interfaces para o mundo exterior (alguns atributos, métodos e eventos. Estritamente falando, eventos também são atributos.) cumprir as funções prometidas. Quanto à implementação específica destas interfaces, elas devem ser mantidas por si mesmas. Não há necessidade ou forma de intervenção do mundo exterior. Essa ideia corresponde a aplicações práticas, ou seja, à questão de saber se Form2.Edit1 precisa ser acessado diretamente por From1. Eu pessoalmente prefiro a seguinte implementação:
//O seguinte faz parte do conteúdo do TForm1 na Unidade1
procedimento TForm1.Button1Click(Remetente: TObject);
começar
TForm2(FAnotherForm).EditText := 'abc'; // <-- Esta implementação incorpora a ideia de encapsulamento
fim;
//A seguir está a definição de TForm2 na Unidade2
tipo
TForm2 = classe(TForm)
Editar1: TEdit;
privado
função GetEditText: string;
procedimento SetEditText(const Valor: string);
público
propriedade EditText: string lida GetEditText escreve SetEditText;
// <-- Meu uso recomendado;
fim;
…
função TForm2.GetEditText: string;
começar
resultado := Edit1.Text;
fim;
procedimento TForm2.SetEditText (valor const: string);
começar
if Valor <> EditText então
Edit1.Text := Valor;
fim;
FAnotherForm aqui é uma propriedade privada de TForm1, que é um ponteiro para uma instância de TForm2 (esse uso foi enfatizado no primeiro artigo). Acessar a propriedade EditText do TForm2 em vez de acessar diretamente o Edit1.Text de forma imprudente do TForm2 incorpora uma ideia, ou seja, a ideia de divisão de trabalho e colaboração, ou seja, a ideia de independência, ou seja, a ideia de encapsulamento.
(Inacabado, continua)
Mais artigos