Programación en Pascal/Visibilidad

Introducción

Las directivas de visibilidad permiten restringir el acceso a los atributos y métodos de un objeto, la directiva más restrictiva es private, que únicamente deja acceder a los atributos y métodos desde la unidad en la que esta la clase, en contrapartida, tenemos la public y permite acceder desde cualquier método a los atributos especificados como tales. También existe la directiva protected, de la que se hablara en el tema de herencia que es como private, pero los atributos bajo esta directiva también esta disponible en las clases hijas (ATENCIÓN: las directivas explicadas aquí pueden tener una funcionalidad diferente en otros lenguajes. Por ejemplo los atributos y métodos bajo private en C++, también, lo hereda la clase hija y los atributos y métodos bajo protected en C++ pueden ser llamados bajo funciones amigas, etc.).

Estas directivas explicadas anteriormente se ponen en la definición de la clase::

Type NombreClase = class
  private
    ...
  public
    ...
end;

Por defecto si no se especifica la directiva se tomara toda la definición de la clase como public.

Reglas de estilo en la definición de las clases

Dentro de cada clase se definirán dos constructores Create, uno de ellos sin parametros, es el que viene por defecto heredado de TObject, que inicializara los atributos del objeto con los valores por defecto.

El 2º constructor inicializara los atributos con los datos que se pasen como parámetros, existirá por lo tanto, un parámetro por cada atributo definido en la clase.

Al denominarse de la misma forma los dos constructores, es lo que se denomina sobrecarga que permite definir en un mismo sitio objetos con un mismo nombre pero distinta lista de parámetros, en Object Pascal, la sobrecarga se especifica mediante la palabra reservada overload.

Los atributos de la clase, se declararan como privados, mediante la directiva private y los métodos serán públicos, al declarar atributos como privados, se impide que el programa pueda usarlo directamente, para poder hacer uso de atributos, se hará un método consultor que devuelva el valor de un método y un método modificador que modifique el contenido de un atributo, existirá un consultor y un modificador por cada atributo.

Consultor -> GetNombreAtributo Modificador -> SetNombreAtributo

Los métodos consultores Get, se implementaran como funciones del tipo correspondiente a cada uno de los atributos

Los métodos modificadores Set, se implementaran como procedimientos (procedures), con un parámetro por cada valor correspondiente al nuevo dato a asignar al atributo.

Debido al hecho de declarar los atributos como privados con el fin de evitar utilizaciones inapropiadas por parte del programa, a dichos atributos se podrá acceder únicamente mediante sus métodos consultor y modificador, que sean públicos. A esta propiedad de acceder a los atributos a través de los métodos, se conoce en POO (Programación Orientada a Objetos) como encapsulamiento.

Ejemplos

Siguiendo los ejemplos del capitulo anterior, vamos a modificar el archivo UEsfera.pas:

Unit UEsfera;

{$mode delphi}

inteface

  type TEsfera = class
    public
      constructor Create;
      constructor Create(r, cx, cy, cz : real); overload;
      function GetRadio : real;
      procedure SetRadio(x : real);
      function GetCentrox : real;
      procedure SetCentrox(x : real);
      function GetCentroy : real;
      procedure SetCentroy(x : real);
      function GetCentroz : real;
      procedure SetCentroz(x : real);
      procedure Visualizar;
      function Superficie : real;
      function Volumen : real;
    private
      radio, centrox, centroy, centroz : real;
  end;

implementation

  Constructor TEsfera.Create;
  begin
    radio := 0;
    centrox := 0;
    centroy := 0;
    centroz := 0;
  end;

  Constructor TEsfera.Create(r, cx, cy, cz : real);
  begin
    radio := r;
    centrox := cx;
    centroy := cy;
    centroz := cz;
  end;

  function TEsfera.GetRadio : real;
  begin
    result := radio;
  end;

  procedure TEsfera.SetRadio(x : real);
  begin
    radio := x;
  end;
  function TEsfera.GetCentrox : real;
  begin
    result := centrox;
  end;

  procedure TEsfera.SetCentrox(x : real);
  begin
    centrox := x;
  end;

  function TEsfera.GetCentroy : real;
  begin
    result := centroy;
  end;

  procedure TEsfera.SetCentroy(x : real);
  begin
    centroy := x;
  end;

  function TEsfera.GetCentroz : real;
  begin
    result := centroz;
  end;

  procedure TEsfera.SetCentroz(x : real);
  begin
    centroz := x;
  end;

  Function TEsfera.Superficie : real;
  begin
    result := 4*3.1416*Radio*Radio;
  end;

  Function TEsfera.Volumen : real;
  begin
    result := 4*3.1416*Radio*Radio*Radio/3;
  end;

  Procedure TEsfera.Visualizar;
  begin
    writeln('Radio=', radio:0:2, ' Centro X=', centrox:0:2, ' Centro Y=', centroy:0:2, ' Centro Z=', centroz:0:2);
  end;

end.

Programa.pp:

Program Esfera;
 
{$mode delphi}
 
uses UEsfera;
 
var
  Esfera1 : TEsfera;
  r, cx, cy, cz : real;
 
begin
  repeat
    write('Introducir radio mayor o igual que 0: ');
    readln(r);
  until(r>=0);
  write('Introducir coordenadas x, y, z desde el centro: ');
  readln(cx, cy, cz);
  Esfera1 := TEsfera.Create;
  Esfera1.SetRadio(r);
  Esfera1.SetCentrox(cx);
  Esfera1.SetCentroy(cy);
  Esfera1.SetCentroz(cz);
  Esfera1.Visualizar;
  writeln('Superficie=', Esfera1.Superficie:0:2);
  writeln('Volumen=', Esfera1.Volumen:0:2);
end.