Fórum Contructor Estatico ou Método de Classe ou os Dois ???? #375478

01/10/2009

0

Delphi

Algumas biografias ´escutamos´ que o Constructor é um método Estático.
e so passa a ser virtual a partir de TComponent

Eu gostaria de discordar disso. Ou mesmo questionar .

No meu entender Constructor é um método de Classe e não um método estático

existe significativa diferença

Suponha que tenhamos definido um métodoQualquer estático na classe Pai e
também o método de mesmo nomena classe filha

TClassePai  = class
procedure MetodoQualque;
contructor Cretae;
end;

TClasseFilha = class(TClassPai)
procedure MetodoQualquer;
constructor Create;
end


Qnd se faz

Objeto:TClassePai;
Begin
Objeto:=TClasseFilha.Create;
try
Objeto.MetodoQualqer;
finally
Objeto,free;
end;


independentemente da instacia do Objeto o método que será executado será
o método da classe Pai .. Claro pois não se aplica ou não se consegue
aplicar polimorfismo , pois o método MetodoQualquer é estático

Porém qnd se faz

Objeto:=TClasseFilha.Create ;

Será sempre chamado o método da classe Filha ,<desde é clarro que o mesmo o
implemente >; Porém se o método fosse estático , por definição , o método que
seria chamado seria o da ClassePai , mas não é isto que ocoorre.

Então na minha insignificancia , penso ser melhor aplicado a definção de Método
de class para o constructor e não o termo Estático

Falo isto pq este conceito esta no Rodape da pag 39 da revista 110 e eu
sempre discordei desta definção... Mas como eu disse tudo dentro da minha
insignificancia .....


Marco Salles

Marco Salles

Responder

Posts

01/10/2009

Afarias

Opa Marco,


Na verdade o termo ´estático´ está correto. Assim como o termo ´método de classe´ tb está. Mas existe uma pequena confusão de conceitos ai..

Começando pelo simples:

Todo construtor é um método de classe, pq ele opera na classe e não na instância da mesma (o objeto)

Agora onde há uma pequena confusão:

Todo método de classe é estático. Não no sentido da herança no Delphi (static, virtual, dynamic) mas no fato que como o método não opera nos atributos do objeto (visto q não há instância) então neste contexto METODOS DE CLASSE são MÉTODOS ESTÁTICOS.

Bom, e, especificamente no Delphi, em relação a um detalhe específico de sua implementação de classe e herança, temos q o construtor do TObject é estático no sentido de que não permite ser re-escrito (override)

Enquanto que, ao criar uma classe, é possível ao programador definir um construtor com dynamic ou virtual podendo assim ser re-escrito.


T+


Responder

Gostei + 0

01/10/2009

Marco Salles

Obrigado afaria pela fedeback ...


Todo construtor é um método de classe, pq ele opera na classe e não na instância da mesma (o objeto)


Concordo em genero numero e grau. Esta é a propria razão de ser de métodos
de Classe

Todo método de classe é estático. Não no sentido da herança no Delphi (static, virtual, dynamic)


[u:2dec01952a]eu me referi no sentido de herança[/u:2dec01952a]

mas no fato que como o método não opera nos atributos do objeto (visto q não há instância) então neste contexto METODOS DE CLASSE são MÉTODOS ESTÁTICOS.


Mas ai fica dificil ... Ja é uma Outra definção de Métodos Estaticos e não
o que nos conhecemos e estudamos qnd estamos falando de Polimorfismo
Seria engraçado ate intuitivamente pensar que todo método que
opera nos atributos do Objeto , < mesmo que ele seje Estático ( no sentido de
da Herança ) > pela sua lógica seria o que ??? Dinamico ????...
então teremos um método que é Estatico por definção de Herança e
Dinamico por outra razão ... Estaremos misturando tudo

Bom, e, especificamente no Delphi, em relação a um detalhe específico de sua implementação de classe e herança, temos q o construtor do TObject é estático no sentido de que não permite ser re-escrito (override)


Mas isto é para qualquer método ... se ele não for definido como virtual ,
não pode ser reescrito.. Vale para métodos estaticos mas também vale
para métodos de classe . É Ate estranho definir um método estatico como
Virtual , mas é possivel

Então defendo que ele não permite Override , [u:2dec01952a]não porque ele é estatico ,
mas sim porque ele é METODO DE CLASSE ..[/u:2dec01952a]


Responder

Gostei + 0

01/10/2009

Afarias

|Mas ai fica dificil ... Ja é uma Outra definção de Métodos Estaticos e não
|o que nos conhecemos e estudamos qnd estamos falando de Polimorfismo
|Seria engraçado ate intuitivamente pensar que todo método que
|opera nos atributos do Objeto , < mesmo que ele seje Estático ( no sentido
|de da Herança ) > pela sua lógica seria o que ??? Dinamico ????...

São coisas diferentes. E, não é a minha lógica, apenas é um termo comum utilizado. Métodos de classe são tb chamados métodos estáticos.


|então teremos um método que é Estatico por definção de Herança e
|Dinamico por outra razão ... Estaremos misturando tudo

Não foi minha intenção misturar. Apenas citei os 2 conceitos para q ficasse claro do que se tratava seu post -- E ficou, visto que vc já deixou claro q está falando em termos de herança no Delphi (poder ou não sobrescrever o método) -- Vamos focar nisto então daqui para frente.


|Mas isto é para qualquer método ... se ele não for definido como virtual ,
|não pode ser reescrito.. Vale para métodos estaticos mas também vale
|para métodos de classe . É Ate estranho definir um método estatico como
|Virtual , mas é possivel

Separando as coisas, vamos usar apenas o termo ´Método de Classe´ e não ´Método Estático´ neste contexto (e daqui por diante).

Então. Métodos virtuais (virtual/dynamic) podem ser sobrescritos. Métodos estáticos (static/padrão) não podem. FATO! Isto (no Delphi) serve tanto para métodos do objeto ou da classe.


|Então defendo que ele não permite Override , não porque ele é estatico ,
|mas sim porque ele é METODO DE CLASSE ..

FALSO. Métodos de classe podem ser definidos com como VIRTUAL/DYNAMIC e assim podem ser sobrescritos. No Delphi a regra é a mesma para métodos de classe ou métodos do objeto.


T+


Responder

Gostei + 0

01/10/2009

Marco Salles

São coisas diferentes. E, não é a minha lógica, apenas é um termo comum utilizado. Métodos de classe são tb chamados métodos estáticos


Nunca li sobre isto e olha que leio muito......Eu sei o que é Metodo de Classe
mas não que eles são chamados de métodos estáticos .. se eu tivesse lido
isto em alguma biografia nen teria razão de levantar esta questão . Por se
tratar apenas de uma definição . Ate resolvi novamente dar uma pesquisada
no Marcu Cantu em sua definição de Métodos de Classe , mas ele tb não se
referiiu a esse métodos como Métodos Estaticos

Mas isto é para qualquer método ... se ele não for definido como virtual , não pode ser reescrito.. Vale para métodos estaticos mas também vale para métodos de classe .[b:67505607f5] É Ate estranho definir um método estatico como Virtual , mas é possivel[/b:67505607f5]


eu quiz dizer metodo de classe

Corrigindo ...

[b:67505607f5]É Ate estranho definir um [u:67505607f5]método de classe [/u:67505607f5]como Virtual , mas é possivel[/b:67505607f5]

|Então defendo que ele não permite Override , não porque ele é estatico , |mas sim porque ele é METODO DE CLASSE .. FALSO. Métodos de classe podem ser definidos com como VIRTUAL/DYNAMIC e assim podem ser sobrescritos. No Delphi a regra é a mesma para métodos de classe ou métodos do objeto.


Vc não me entendeu ... O Create não pode ser definido como Override no meu
ver pq ele não foi definido como Virtual na classe Base (TObject) , e não pelo
fato dele ser Metodo Estático. Como vc mesmo postou e ate me corrigiu
Métodos Estaticos podem ser definidos como Virtual/Dynamic e podem ser
subscritos..


Mas muito obrigado afarias , sua participação é muito bem vinda e enriquece
e muito o tópico.. Fico feliz , apenas estou ainda discordando . Mas como eu
disse , recolho a minha insignificancia ...


Responder

Gostei + 0

01/10/2009

Afarias

|Nunca li sobre isto e olha que leio muito......Eu sei o que é Metodo de Classe
|mas não que eles são chamados de métodos estáticos .. se eu tivesse lido
|isto em alguma biografia nen teria razão de levantar esta questão .

Claro.

Referências são sempre importantes. O fato é q o termo ´método estático´ (ou função estática) é mais utilizado no C++ e em Java e é equivalente ao que chamamos métodos de classe no Delphi:

http://delphi.about.com/od/objectpascalide/a/classmethods.htm
http://www.advanceis.com/delphi-cppb/articles/delphi-calling-class-methods.html
http://www.leepoint.net/notes-java/flow/methods/50static-methods.html



|Vc não me entendeu ... O Create não pode ser definido como Override
|no meu ver pq ele não foi definido como Virtual na classe Base (TObject)
|, e não pelo fato dele ser Metodo Estático.

É o create do TObject -- pra ficar claro -- não pode ser sobrescrito. Um construtor declarado VIRTUAL é um método de classe e PODE ser sobrescrito.

Ele é estático pq não foi definido como virtual. Estamos andando em círculos aqui. Não entendo qual o seu ponto.


|Como vc mesmo postou e ate me corrigiu Métodos Estaticos podem ser
|definidos como Virtual/Dynamic e podem ser subscritos..

Sim. E como o Create do TObject não pode ser sobrescrito, ele é dito estático.


|Mas muito obrigado afarias , sua participação é muito bem vinda e
|enriquece e muito o tópico.. Fico feliz , apenas estou ainda discordando .

Discordando em que?

Não é possível separar as coisas. Os métodos podem ser de classe ou do objeto. E, independente disso, podem ser definidos como virtual (podem ser sobrescritos) ou static (não podem ser sobrescritos)

É assim q é implementado no Delphi :D


Agora... lendo seu exemplo no post inicial acho q ficou claro a sua dúvida... mas é pq vc está trabalhando com herança/polimorfismo de classes como se fossem objetos. Veja este exemplo para ficar claro:


TBaseObject = class
public
  class function GetMyName1: string; // estático
  class function GetMyName2: string; virtual; 
end;

TChildObject = class (TBaseObject)
public
  class function GetMyName1: string; // re-definido
  class function GetMyName2: string; override; // sobrescrito
end;

TBaseObjectClass = class of TBaseObject;

{...}


function TBaseObject.GetMyName1: string;
begin
  Result := ´Base Class´;
end;

function TBaseObject.GetMyName2: string;
begin
  Result := ´Base Class´;
end;

function TChildObject.GetMyName1: string;
begin
  Result := inherited GetMyName1+´:Child Class´;
end;

function TChildObject.GetMyName2: string;
begin
  Result := inherited GetMyName2+´:Child Class´;
end;


{ ... }


var
  MyClass: TBaseObjectClass;
begin

  MyClass := TBaseClass;
  Memo1.Lines.Add(MyClass.GetMyName1);
  Memo1.Lines.Add(MyClass.GetMyName2);

  MyClass := TChildClass;
  Memo1.Lines.Add(MyClass.GetMyName1);
  Memo1.Lines.Add(MyClass.GetMyName2);

end;


verá q o resultado de GetMyName1 e GetMyName2 para a classe TChildClass é diferente. Pq GetMyName2 usou polimorfismo (por ter sido sobrescrito) e GetMyName1 apenas executa o método definido na classe base. Seria necessário um TypeCast para executar o método re-definido.

O mesmo vale para os construtores. Espero q o exemplo jogue luz no assunto =)


Abração, T+


Responder

Gostei + 0

01/10/2009

Afarias

Quanto ao lance do ´método estático = métodos de classe´ (em OO), queria deixar uma outra referência mais genérica (e objetiva):

http://en.wikipedia.org/wiki/Method_(computer_science)


´In object-oriented programming, a method is a subroutine that is exclusively associated either with a class (in which case it [b:94a86508ac]is called a class method or a static method[/b:94a86508ac]) or with an object (in which case it is an instance method).´


T+


Responder

Gostei + 0

01/10/2009

Marco Salles

|
Como vc mesmo postou e ate me corrigiu Métodos Estaticos podem ser |definidos como Virtual/Dynamic e podem ser subscritos.. Sim. E como o Create do TObject não pode ser sobrescrito, ele é dito estático.


Seria , se

Var
Obj:TClassePai;
begin
Obj:=TClasseFilha.Create;

Deveria ser Chamado o método da classe pai pois o método é Estatico , mas não é isto que ocorre .. Este é o meu ponto de Vista. E ai que estou pegando ... Não tem nada de Estatico no sentido de Herança (Polomorfismo)
mas sim métodos de Classe que são Aplicados a uma classe e não a uma
istancia

Vc postou um link aonde se lé :

ele é chamado um método de classe ou um método estático) ou com um objeto (caso em que é um método de instância) ou um método de Dado

Tudo bem , uma definição ... Podemos pensar assim

Mas qnd nas biografias se refere a métodos estaticos ele estão se referindo a
método estaticos no sentido de Herança . Esta definção eu não concordo

Veja bem : ABRE ASPAS

Observe que Destroy é declarado como Virtual em TOBJECT . Logo devemos dar um override para sobescrever .. Ao contrário , o constructor é estático e so passa a ser Virtual a partir de TComponete


Veja Aspas

Se Constructor fosse Estatico TClasseFilha.Create >> seria executado o
método estatico da classe PAI , mas não é isto que ocorre...
Este estatico no contexto da definição se refere a Estico de Herança
e ai eu não concordo , ou no mínimo é contraditório


Responder

Gostei + 0

01/10/2009

Afarias

[quote:3d50fbf4e3=´Marco Salles´]Seria , se

Var
Obj:TClassePai;
begin
Obj:=TClasseFilha.Create;

Deveria ser Chamado o método da classe pai pois o método é Estatico , mas não é isto que ocorre .. Este é o meu ponto de Vista. E ai que estou pegando ... Não tem nada de Estatico no sentido de Herança (Polomorfismo)
mas sim métodos de Classe que são Aplicados a uma classe e não a uma
istancia [/quote:3d50fbf4e3]

Isto não é uma questão de ponto de vista. É como a coisa funciona. É como é implementado no Delphi. Acho q vc não prestou atenção no exemplo que passei. Seu exemplo acima não demonstra nada pois vc está definindo a classe q está trabalhando, assim não tem como demonstrar polimorfismo em um método de classe. Classes<>Objetos!


Mas qnd nas biografias se refere a métodos estaticos ele estão se referindo a método estaticos no sentido de Herança.


Toda palavra tem q estar dentro de um contexto para ter significado. Se toda biografia q vc leu é sobre Delphi e a implementação OO no Delphi então é normal q, neste contexto particular, estático (static) esteja relacionado apenas à métodos (de classe ou instância) que não podem ser sobrescritos.


Observe que Destroy é declarado como Virtual em TOBJECT . Logo devemos dar um override para sobescrever .. Ao contrário , o constructor é estático e so passa a ser Virtual a partir de TComponete


Nesta citação o único erro é dizer que o construtor passa a ser virtual a partir de TComponent. Um construtor pode ser declarado virtual em qualquer classe, sem ter qualquer ligação com TComponent.


[quote:3d50fbf4e3=´Marco Salles´]Se Constructor fosse Estatico TClasseFilha.Create >> seria executado o método estatico da classe PAI , mas não é isto que ocorre... Este estatico no contexto da definição se refere a Estico de Herança e ai eu não concordo , ou no mínimo é contraditório
[/quote:3d50fbf4e3]

Não é nada contraditório e o q vc está dizendo q ´não acontece´, na realidade ACONTECE sim. O problema é q o exemplo q vc está se baseando não diz NADA pq vc está definindo a classe! Oras, se eu defino a classe, então é claro q será executado o método da classe definida -- é assim q funciona polimorfismo!

O exemplo q mostrei deixa a diferença entre um método (de classe) virtual sobrescrito e um método (de classe) estático q foi re-escrito (ou redefinido) na ´classe filha´.

Tente o mesmo exemplo com um construtor e verá q o efeito é o mesmo.

Aliais, vou postar aqui outro exemplo simples com um construtor:

TPai = class (TObject)
public
  fTexto: string;
  constructor Create; virtual;
end;

TFilho = class (TObject)
public
  constructor Create; override;
end;

TPaiClass = class of TPai;

{...}

constructor TPai.Create;
begin
  inherited Create;
  fTexto := ´Eu Sou Pai´;
end;

constructor TFilho.Create;
begin
  inherited Create;
  fTexto := ´Eu Sou Filho´;
end;

{...}

procedure TForm1.Button1Click(Sender: TObject);
var
  c: TPaiClass;
begin

  c := TPai;
  with c.Create do
    try
      Memo1.Lines.Add(fTexto);
    finally
      Free;
    end;


  c := TFilho;
  with c.Create do
    try
      Memo1.Lines.Add(fTexto);
    finally
      Free;
    end;

end;


Teste esse código e verá q no Memo serão escrito as linhas ´Eu sou pai´ e em seguida ´Eu sou filho´.

Agora, teste o mesmo exemplo mas apagando a declaração ´virtual´ o ´override´ dos construtores (TPai e TFilho respectivamente) tornando o construtor de TPai estático.

Verá q desta vez, no memo aparece apenas ´Eu sou pai´ 2 vezez!! Ou seja, lá se foi o polimorfismo, o método da classe base foi executado e não o método ´redefinido´ na classe filha!!!

Execute e veja acontecendo. Vale mais q mil palavras (ou biografias) :D


T+


Responder

Gostei + 0

02/10/2009

Afarias

Uma correção no texto do exemplo acima (com o construtor)

onde tem :

TFilho = class (TObject)

o correto (claro) é:

TFilho = class ([b:4ca705cd5e]TPai[/b:4ca705cd5e])




T+


Responder

Gostei + 0

Utilizamos cookies para fornecer uma melhor experiência para nossos usuários, consulte nossa política de privacidade.

Aceitar