Bueno, no soy Lepe pero al concepto lo domino.
Mira, la herencia (en su concepto más simple) es una característica o propiedade que posee una clase de heredar el comportamiento y estructura de una clase padre. Por ejemplo si tu tienes una clase llamada Animal que cuenta con las propiedades Nombre y Tamaño (por poner un ejemplo) y un procedimiento que Mover, y tienes una clase basada en Animal (por poner un ejemplo... Gato), está segunda clase hereda todo lo común a la clase Animal y se le añade lo PROPIO o lo que le corresponde a Gato, por poner ejemplo: propiedad Color de Cola, y el procedimiento Arañar.
Un poco de código:

Código Delphi [-]
//esto es la clase Animal
Animal = class
  private
    FTamanno: integer;
    FNombre: string;
  public
    property Tamanno: string read FTamanno write SetTamanno;
    property Nombre: string read FNombre write SetNombre;
    procedure Mover(Pos: Pointer);
 end;

// esto es la clase Gato
Gato = class(Animal) // Un Gato es un animal. Por tanto Gato hereda de Animal
  private
     FColorCola: TColor;
  public
     property ColorCola: TColor read FColorCola write SetColorCola;
     procedure Arañar;
end;

¿Que se consigue con esto? que gato tenga el mismo comportamiento de un animal pero ESPECIALIZADO para algo más particular. La clase gato también tiene las propiedades tamaño y nombre y el procedimiento mover... y esto lo hereda de su padre (Animal).

Ahora... hay ocasiones en que es necesario redefinir el comportamiento de la clase padre... Por poner un ejemplo (siguiendo el anterior): Todos los animales pueden moverse, pero no todos los hacen de igual manera. Por tanto, si el procedimiento Mover de la clase Animal es único... todos los animales van a moverse igual... como se consigue esto.... con las cláusulas protected, y override (también no hay que olvidar los casos de asbtract y virtual) que señalaron Lepe y otros.

Cuando se desea que un procedimiento o función tenga una "sobrecarga", o redefinición... en la clase padre se lo introduce bajo la clausura protected (protegida).

Código Delphi [-]
Animal = class
//.... lo que venía
protected
  procedure Mover;
// ... lo que sigue
end;

Y en la clase hija (Gato) la clausura override, que indica que se va a sobreescribir el comportamiento. Esto hace que el compilador implemente el procedimiento adecuado a la clase.

Código Delphi [-]
Gato = class(Animal)
// --- lo que venía
protected
  procedure Mover; override;
// lo que sigue
end;

Este tema puede continuar... y no basta un hilo para explicar todo lo que es POO. Como dije antes... Puedes leer la Cara Oculta de Delphi 4, allí hay un capítulo entero dedicado a POO. Es muy sencillo de entender...

espero haberte ayudado en algo,
Saludos,

Si quieres una solución rápida:

Crea una nueva clase diagamos "TFormTool" del tipo TObject

Crea un método "EnableControl(aComponent:TComponent);

En el metodo EnableControl pones lo que quieras hacer con el componente que le pases.
Guarda la unidad.

Ahora puedes usar este control para manipular cualquiera de las forms que mencionas, solo tendrias que instanciar el objeto antes de abrir cualquiera de las dos forms o bien instanciarlo dentro de cada form. Da lo mismo.

Es decir nuestra clase FormTool podrá manipular forms según necesites sin necesidad de saber que contienen ni de que son.