Lo primero que veo que intentas acceder a una funcion heredada directamente, para usar la funcion heredada debes usar el prefijo parent::nombredeFuncion.

Correcto.

No, no, para empezar seríar:
parent::Consulta($query);
El parent se queda como está, no se sustituye por classMySQL.

Pero en tu caso no es necesario hacer esto porque tu clase derivada no tiene ningún método llamado Consulta, entonces no hay ambiguedad y no es necesario usar parent::

Tu problema es que instanciaste classLogin pero se te olvidó usar el método conectar() y entonces no se te crea $this->conexion.

¿Solución? Usa el metodo conectar.
Cambia

$db = new classMySQL();
      $db->Conectar();
      $query = "SELECT admin, pass FROM info_admins WHERE admin = '$user' and pass = '$pass'";
      $db->Consulta($query);

      $lg = new classLogin();
      $lg->Login($user, $pass);

      $db->Desconectar();

Por:

$db = new classMySQL();
      $db->Conectar();
      $query = "SELECT admin, pass FROM info_admins WHERE admin = '$user' and pass = '$pass'";
      $db->Consulta($query);
      $db->Desconectar();

      $lg = new classLogin();
      $lg->Conectar();
      $lg->Login($user, $pass);

      $lg->Desconectar();


Y debería funcionar.

El tema de Conectar -> Hacer -> Desconectar y luego Conectar- > Hacer otra cosa -> Desconectar siempre tienes que hacerlo si lo haces entre instancias, por que tu clase esta definida así. No se si me entiendes.

Pruebalo, y si quieres saber mas sobre a lo que me refiero me dejas un mensaje y te explico ¿ok?

Saludos

Ok, ya lo he arreglado, al final queda así:

<form id="form" name="form" method="post" action="login.php">
    <input type="text" name="user" id="user" />
    <input type="text" name="pass" id="pass" />
    <input type="submit" name="send" id="send" value="Enviar" />
</form>

<?php
  $user = $_POST[&#39;user&#39;];
  $pass = $_POST[&#39;pass&#39;];
  $send = $_POST[&#39;send&#39;];

  if (isset($user) && isset($pass)) {
    if (file_exists("login.class.php")) {
      require("login.class.php");

      $lg = new classLogin();
      $lg->Conectar();
      $lg->Login($user, $pass);
      $lg->Desconectar();
    }
  }
?>
PD: Sí, tengo que hacer el destructor de la clase, debería hacer tambien el constructor no? y asi elimino el conectar...

Su clase heredada solo tiene un método llamado Login, por eso no es necesario usar parent::.
Y si, usó conectar, pero lo usó en la variable $db, no en la variable $lg, y por eso no funciona. Son instancias separadas. Que lo haya usado en $db no significa que vaya a funcionar en $lg, por eso dije que es necesario que vuelva a usar el método conectar.
Y no, no es lo correcto (en este caso) sustituir el método desconectar por un destructor. Por la sencilla razón de que necesitas usar el método desconectar antes de terminar la ejecución de código, como por ejemplo en este caso. Lo correcto sería que en el destructor se llamara al metodo Desconectar, pero sin sustituirlo.

Ese código que tu has puesto es la otra opción si ya no quieres usar el objeto $db.
El caso es que usando POO tiene que quedarte claro que si tienes dos instancias, debes conectar en las dos, y lo mas correcto es desconectar primero la primera, y luego conectar con la segunda. En el caso de que solo tengas un objeto entonces no hay problema.

Para lo del destructor, mira mi primer parrafo de este mensaje. Con que hagas:
__destruct() {
   $this->Desconectar();
}
(Con la sintaxis corregida)
Es suficiente

Saludos

Tu estas hablando de la clase que la heredo, pero la clase que fue heredada lo tiene, asi que es obvio que tiene que usar parent. El destructor se ejecuta cuando se termina de ejecutar la clase, es decir que si el todavia sigue consultando no se va a destruir, lo digo por experiencia.

En realidad solo estoy llamando de la clase Login y utilizando métodos de la clase MySQL, por lo que no necesito llamar a Conectar/Desconectar desde $db no? Si conecto de $lg, pues desconecto de $lg y ya está.

Gracias por lo del destructor!

En realidad solo estoy llamando de la clase Login y utilizando métodos de la clase MySQL, por lo que no necesito llamar a Conectar/Desconectar desde $db no? Si conecto de $lg, pues desconecto de $lg y ya está.

Gracias por lo del destructor!

A ver, el número de clases que uses es indiferente. Lo importante es el número de objetos que uses.

// Si usas solo un objeto (como en tu solución el objeto $lg). Entonces solo necesitas usar
$lg->Conectar();
// Aqui lo que sea que trabaje con la BD y el objeto $lg
// Y luego por ultimo
$lg->Desconectar();

Esto en el caso de un único objeto.

@Focux: En este caso (con un único objeto) lo correcto si es usar un destructor, pero ahora vas a ver por qué con varios objetos es mejor usar tambien el metodo Desconectar.

Cuando usas varios objetos (como la solucion que te dí yo) tienes que tener en cuenta que cada objeto abre una conexión con el servidor SQL, y realiza sus propias querys.
Es decir, si tienes:
$lg = new classMysql();
$bd = new classMysql();

Si aquí haces:
$lg->Conectar();

Esto significa que has conectado el objeto $lg a la BD, pero no significa que el objeto $bd esté conectado, es más, no lo está. Si quieres hacer querys en los dos entonces tendrás que conectar los dos.

$lg->Conectar();
$bd->Conectar();

// Aqui hacemos cosas con estos objetos como
$lg->Query("SELECT TAL");
$bd->Query("TALTAL");

// Desconectamos
$lg->Desconectar(); // Ahora esta desconectado el objeto lg
$bd->Desconectar(); // Ahora esta desconectado el objeto bd y el objeto lg

@Focux, este ultimo codigo sería equivalente a escribir en el destructor el metodo desconectar.

El problema es que con esta forma mantienes activas 2 conexiones al servidor al mismo tiempo, lo que consume recursos del servidor.
Alomejor con 2 conexiones no importa tanto, pero imagina que en lugar de 2 objetos tienes 50. La cosa cambia un poco.
La forma de corregir esto: Conectas -> Usas -> Desconectar, y cuando lo necesites con otro objeto pues Conectar -> Usas -> Desconectar.
De esta forma ya siempre tienes abierta una única conexión al servidor.

Así que sería:

$lg = new classMysql();
$bd = new classMysql();

// Vamos a hacer algo con $lg, conectemos
$lg->Conectar();
// Hacemos algo con $lg
$lg->Query("TALTALTAL");
// Hemos terminado así que cerramos
$lg->Desconectar();

// Ahora con el otro objeto, con $db
$db->Conectar();
$db->Query("SELECT ...");
$db->Desconectar();


¿Veis por que se hace así? De esta forma solo mantenemos una conexión al servidor cada vez que la necesitemos.

@Focux, en este ultimo caso tu opción de los destructores no nos vale, porque no nos permitiría realizar una única conexión, sino que mantiene todas abiertas hasta que se eliminan los objetos, que normalmente es al finalizar el código, con lo que tienes varias conexiones abiertas.

¿Entiendes lo que quiero decirte C-Chack?
No hay problema si es solo un objeto. Las cosas "curiosas" como ves vienen cuando hay mas de uno.

¿Sabes cual es el problema del último método a pesar de ser el mas avanzado de los tres?
Su problema es que tienes que estar conectado y desconectando cada vez que quieres utilizar la BD, con lo que estas constantemente: que si conecto esto, que si desconecto lo otro y demás.

Hay una cuarta opción que se podría implementar variando un poco tu código que consistiría en esto:


<?php
$conexion = mysql_connect("localhost", "root", "123456");
mysql_select_db("sistemaphp", $this->conexion) or die(mysql_error());
// Creamos la conexion en la variable $conexion

// Ahora se la pasamos a nuestro objeto en cuanto lo creamos
$lg = new classMysql($conexion);
// Ahora podemos usarlo siempre que queramos, no necesitamos conectarlo porque ya lo hicimos en la primera linea, y tampoco necesitamos
// cerrarlo porque dejar de usar el objeto no implica que dejemos de usar la conexion, de esta forma podemos usar la misma conexion para
// varios objetos.
$lg->Query("SELECT... ");

// Lo podemos usar con cuantos objetos queramos
$db = new classMysql($conexion);
$db->Query("TALTAL");

// Por último, cuando terminemos todo el código, cerramos la conexion que creamos al principio y listo
mysql_close($conexion);

Esta es la opción mas avanzada, pero habría que modificar un poco tu código.
Con esto consigues tener una única conexión a la BD y además no necesitas estar conectando y desconectando sin parar, sino que se mantiene abierta durante todo el código y se cierra cuando termina. Una única conexión y una única desconexión.

@Focux, en este caso no es cuestión de formas, si no cuestión de funcionalidad. Es cierto que a veces lo que yo programo de una forma es diferente a como otra persona lo hace, y las dos sirven. Pero en este caso es mejor hacerlo así para evitarte tener varias conexiones abiertas.

Saludos!!