Diferencia entre revisiones de «Prog. Aprendiendo POO»

De MediaWiki
Ir a la navegación Ir a la búsqueda
Línea 162: Línea 162:
 
: Primero, piensa dónde colocar el método que asigna los valores de los parámetros a los atributos y de inmediato se da cuenta que no puedes ubicarlo en la clase Vehiculo, ya que en esta clase no existen los atributos nombreDoc y nombreCond, por lo que decide colocarlos en las subclases.  
 
: Primero, piensa dónde colocar el método que asigna los valores de los parámetros a los atributos y de inmediato se da cuenta que no puedes ubicarlo en la clase Vehiculo, ya que en esta clase no existen los atributos nombreDoc y nombreCond, por lo que decide colocarlos en las subclases.  
 
: Entonces, en la subclase Coche, decide crear un método de cinco parámetros, en el que se asignan los valores a las cinco variables o atributos que tenemos, de la forma:
 
: Entonces, en la subclase Coche, decide crear un método de cinco parámetros, en el que se asignan los valores a las cinco variables o atributos que tenemos, de la forma:
 +
::<syntaxhighlight lang="java" enclose="div" highlight="" >
 +
coch1.asignarValores (param1, param2, param3, param4, param5)
 +
</syntaxhighlight>
 +
: donde:
 +
:* marca = param1
 +
:* matricula = param2
 +
:* ano = param3
 +
:* nombreDoc = param4
 +
:* nombreCond = param5
 +
 +
: y crear otro método en la subclase Furgoneta con otros cinco parámetros de la forma:
 +
::<syntaxhighlight lang="java" enclose="div" highlight="" >
 +
coch1.asignarValores (param1, param2, param3, param4, param5)
 +
</syntaxhighlight>
 +
: donde:
 +
:* marca = param1
 +
:* matricula = param2
 +
:* ano = param3
 +
:* dinero = param4
 +
:* numJurados = param5
 +
 +
 +
* Una vez hecho esto, podemos substituir las líneas:
 +
::<syntaxhighlight lang="java" enclose="div" highlight="" >
 +
coch1.marca = "Peugot";
 +
coch1.matricula = "C-1234-BZ";
 +
coch1.ano = 1999;
 +
coch1.nombreDoc = "Documento secreto 1";
 +
coch1.nombreCond = "Ángel";
 +
</syntaxhighlight>
 +
: por
 +
::<syntaxhighlight lang="java" enclose="div" highlight="" >
 +
coch1.asignarValores ("Peugot", "C-1234-BZ", 1999, "Documento secreto 1","ANGEL");
 +
</syntaxhighlight>
 +
 +
 +
: y las líneas:
 +
::<syntaxhighlight lang="java" enclose="div" highlight="" >
 +
fur1.marca = "Opel";
 +
fur1.matricula = "C-2342-AF";
 +
fur1.ano = 1996;
 +
fur1.dinero = 1000;
 +
fur1.numJurados = 1;
 +
</syntaxhighlight>
 +
por
 +
::<syntaxhighlight lang="java" enclose="div" highlight="" >
 +
fur1.asignarValores(“Opel”,”C-2342-AF”,1996,1000,1)
 +
</syntaxhighlight>
 +
 +
* <u>NOTA:</u> Si queréis podéis probarlo de esta manera, pero la implementación final se va a realizar de otra forma.
 +
 +
 +
 +
<br />
 +
 +
* Pero el Programador Experto vuelve a recoger una pluma que olvidó, y observa lo que el PN está a punto de hacer.
 +
: - !!!!! Pero ¿ qué haces ? ! Cómo se ve que llevas programando Java desde hace poco tiempo !
 +
 +
* En la POO para realizar la asignación inicial de variables, se puede usar un método especial, llamado '''constructor''', que se llama cada vez que se crea una nueva instancia, es decir, cada vez que se crea un objeto de una clase.
 +
: El nombre del constructor se llama igual que la clase, no lleva ningún modificador (public,private,void,...) solo su nombre, y puede o no tener parámetros.
 +
 +
 +
: Frente al asombro y la incomprensión del PN (aparte de ponerse rojo como uno tomate), el Programador Experto le comenta:
 +
: - Te daré un ejemplo para que entiendas: Supongamos que tengo una clase llamada Prueba, con dos atributos (atrib1,atrib2) y que dichos atributos tengan un valor de 10 por defecto.
 +
: Podría hacerlo en la definición del atributos, pero también puedo hacer uso del constructor, al que se llama de forma automática cuando se crea un objeto:
 +
::<syntaxhighlight lang="java" line enclose="div" highlight="5-8" >
 +
public class Prueba{
 +
 +
  int atrib1,atrib2;
 +
 +
  Prueba(){
 +
    atrib1 = 10;
 +
    atrib2 = 10;
 +
  }
 +
 +
}
 +
</syntaxhighlight>
 +
 +
: Ahora en la clase Principal:
 +
::<syntaxhighlight lang="java" enclose="div" highlight="5" >
 +
public class Principal{
 +
 +
  public static void main(String arg[]){
 +
 +
      Prueba miPrueba = new Prueba();      // En este momento llama al constructor
 +
  }
 +
 +
}
 +
</syntaxhighlight>
 +
 +
 +
* Este constructor siempre está ahí, y si el usuario no lo define, java asigna el valor 0 (numéricos), false (booleanos) y null (de referencia) para todos los atributos de la clase para ese objeto.
 +
 +
* En este momento, miPrueba.atrib1 tiene el valor 10, al igual que miPrueba.atrib2.
 +
 +
: El PN antes de esta demostración de sabiduría no puede decir nada más que:
 +
:: - Ahhhhhhhhhhhhhhhhhhh
 +
:: - Pero esto no es todo, dice el programador experto. Resulta que puedes tener definidos tantos constructores como quieras, siempre y cuando estos se diferencien en el número o tipo de argumentos (dado que el nombre es fijo, debe ser el mismo nombre que la clase).
 +
:: Entonces, podríamos tener otro constructor para asignar valores específicos a los dos atributos de la forma:
 +
::<syntaxhighlight lang="java" line enclose="div" highlight="5-8" >
 +
public class Prueba{
 +
 +
  int atrib1,atrib2;
 +
 +
  Prueba(){
 +
    atrib1 = 10;
 +
    atrib2 = 10;
 +
  }
 +
 +
  Prueba(int valor1, int valor2){    // El nombre del constructor tiene que ser el mismo que el de la clase
 +
    atrib1 = valor1;
 +
    atrib2 = valor2;
 +
  }
 +
 +
}
 +
</syntaxhighlight>
 +
 +
: De tal forma que ahora puedo asignar un valor concreto a cada atributo de la forma:
 +
::<syntaxhighlight lang="java" enclose="div" highlight="5" >
 +
public class Principal{
 +
 +
  public static void main(String arg[]){
 +
 +
      Prueba miPrueba = new Prueba(10,40);      // Llama al segundo constructor. Ahora atrib1 vale 10 y atrib2 vale 40
 +
  }
 +
 +
}
 +
</syntaxhighlight>
 +
 +
 +
* A esto se llama '''sobrecargar''' un método ('''overload''').
 +
: Es decir, tener dentro de uno clase varios métodos con el mismo nombre, pero con diferente tipo o número de argumentos le dice el programador experto con un cierto aire de superioridad ...
 +
 +
: El PN se pone risueño como un pájaro al entender lo que el Programador Experto le explica (aunque un poco mosqueado).
 +
: Ahora sabe que en el caso de la clase Coche y la clase Furgoneta, debe crear un constructor que tenga cinco parámetros, asignando a cada atributo el valor del parámetro.
 +
: A cada parámetro le asigna un nombre: param1, param2, .... y más tarde dentro del constructor, asigna los valores de estos parámetros a cada variable.
 +
: Entonces en la clase  Coche tendrá 5 parámetros que se asignarán a la marca, ano, matricula, nombreCond y nombreDoc y en el caso de Furgoneta, se asignarán a la marca, año, matricula, dinero y númJurados.
 +
Ejercicio: implementar la solución
 +
 +
  
  

Revisión del 10:55 6 nov 2017

Introducción

  • La idea de esta página es la de mostrar muchos de los conceptos de la POO siguiendo el desarrollo de un ejercicio.




Clases

  • Un programador novato (PN) decide introducirse en el mundo de POO y tratar de implementar una solución informática para la gestión de los vehículos de la empresa de transporte donde trabaja.
Decide usar como lenguaje de programación Java.
  • El problema que al que está intentando dar solución es el siguiente: Necesita almacenar información sobre los diferentes vehículos disponibles en la Compañía.
Entre esta información está el año de compra del vehículo, su matrícula y su marca.
  • El PN decide implementar en una clase la información necesaria.
Recuerda que las clases no son más que abstracciones de las propiedades de los objetos sin dar ningún valor concreto.
Por convención, las clases tienen que estar definidas en singular y la la primera letra en mayúscula así como las primeras letras de las siguientes palabras si el nombre está formado por varias.
Más tarde utiliza la clase creada previamente en otra clase llamada 'Principal', una que se va a ejecutar (dispone del método main)
Dentro de esta clase, el PN creará los cuatro vehículos que tiene la empresa en este momento y le asignará los siguientes valores:
Prog ej novato 1.jpg
  • Una vez hecho esto, el PN compila sus clases (Vehiculo y Principal) y ejecuta la clase Principal, creando 4 instancias de la clase Coche.


Ejercicio 1: Implementar la solución.

Solución Ejercicio 1



Métodos sin parámetros

  • Comprueba que no le haya dado errores, pero permanece con la duda de que si habrá guardado los valores de forma correcta, por lo que es necesario que se muestren estos valores.
Para imprimir los valores, necesita un procedimiento (método) que los saque a la pantalla.
Entonces decide crear dentro de la clase Vehiculo, un método que imprima la información Puede hacer un único método que imprima el año, matrícula y marca a la vez, pero decide crear tres métodos, uno para cada tipo de información a imprimir, de nombre imprimirAno, imprimirMatricula, imprimirMarca, porque necesita mostrar la información en forma individualizada.
  • Una vez escritos, decide probarlos, para ver si muestran la información correcta,
Para esto modifica la clase Principal, haciendo que cada objeto de la clase Vehículo llame a cada uno métodos.


Ejercicio 2: Implementar la solución.

Solución Ejercicio 2



Herencia

  • El PN está bastante satisfecho con lo que se ha logrado hasta ahora, pero esto fue solo una pequeña parte de lo que tienes que hacer.
Digamos que su empresa se dedica al transporte de 'dinero', y dos de sus vehículos son furgonetas. Cada una de ellas es capaz de transportar una cantidad de dinero.
Además, cada furgonete lleva consigo un número de vigilantes jurados
  • Esta información es necesaria almacenarla.
Ante esta situación, el PN decide crear una nueva clase, Furgoneta, con los procedimientos de la clase Vehículo y los nuevos atributos (cantidad de dinero y número de vigilantes jurados).
Pero cuando iba a comenzar a implementar esta solución, aparece el Programador Experto, alguien que ha trabajado en Java durante muchos años, y viendo lo que iba a hacer, le explica que en Java, al ser un lenguaje de POO se puede implementar algo que se denomina Herencia.
  • La herencia se da entre dos clases y es un tipo de relación jerárquica de tipo es un y se denomina generalización o especialización.
En la herencia, hacemos que una clase (subclase) pueda hacer uso de todos los métodos y atributos definidos en la clase de la que va a heredar (superclase).
El otro tipo de relación 'jerárquica' es el de tipo es parte de denominada de agregación o inclusión. Es un tipo de relación que heredó de la asociación.


  • Con esta gran ventaja, el PN decide crear una subclase Furgoneta de la superclase Vehiculo.
Dentro de la nueva clase implementa los nuevos atributos (cantidad de dinero y número de vigilantes jurados), ya que son atributos de la clase Furgoneta, que no tiene la clase Vehículo.
  • Por otro lado, como el PN querrá mostrar la información de estos dos nuevos atributos, también crea, dentro de la clase Furgoneta, dos métodos para mostrar estos atributos del nombre 'imprimirDinero()', 'imprimirJurados()'.
  • Para probar esta nueva clase, tendrá que cambiar su clase Principal, ya que tenía cuatro objetos de la clase Vehículo, pero ahora sabe que dos de ellos son furgonetas, por lo que tendrá que cambiar su código, y si antes tenía cuatro vehículos de forma:
Vehiculo vehiculo1 = new Vehiculo();
Vehiculo vehiculo2 = new Vehiculo();
Vehiculo vehiculo3 = new Vehiculo();
Vehiculo vehiculo4 = new Vehiculo();
Ahora tendrá dos furgonetas y dos vehículos de la forma:
Vehiculo vehiculo1 = new Vehiculo();
Vehiculo vehiculo2 = new Vehiculo();
Furgoneta furgoneta1 = new Furgoneta();
Furgoneta furgoneta2 = new Furgoneta();
  • A cada uno de sus vehículos (furgonetas y vehículos) les asignará los valores a sus atributos y llamará a los métodos que imprimen estos valores.
El PN realiza todo lo anterior, compila las clases y ejecuta la clase principal, comprobando que todo sea correcto.


Ejercicio 3: Implementar la solución.

Solución Ejercicio 3




  • El PN ahora piensa que sus otros dos vehículos (que son coches) no llevan dinero, pero llevan documentos secretos. Cada coche lleva un documento secreto, por lo que es necesario para guardar su nombre, así como el nombre del conductor que conduce el coche
Pensando de la misma manera que el caso de las furgonetas, ahora sabe que puede crea una subclase (llamada Coche, por ejemplo) de la superclase Vehiculo.
En esa subclase estarán los atributos nombreCond y nombreDoc. Por lo tanto, implementa esta subclase y los dos atributos, así como los métodos necesarios para mostrarlos (imprimirNombreDoc, imprimirNombreCond)


  • Una vez hecho esto, el PN modifica la clase Principal, tal como lo hizo en el caso de Furgonetas para probar todo de nuevo.


Ejercicio 4: Implementar la solución.

Solución Ejercicio 4



Constructores

  • Repasemos lo que hemos hecho hasta este momento.
  • Creamos 3 clases (Vehiculos, Coche y Furgoneta), para almacenar la información que necesito, así como los métodos necesarios para imprimir (mostrar) esa información.
  • Por otro lado, creamos otra clase Principal, que hará uso de las clases anteriores, mediante la creación de 4 vehículos, dos de tipo Coche y dos de tipo Furgoneta.
  • Cada uno de estos vehículos es una instancia de la clase correspondiente y tendrá almacenados algunos valores específicos. Si quisiera tener más información almacenada de otros vehículos, solo tendría que crear un nuevo objeto (instanciar) de la clase correspondiente.


  • El PN todavía está rompiéndose el 'coco' para implementar completamente todo el proceso de su empresa
Lo siguiente que piensa es en 'refinar' un poco más lo hecho hasta ahora.
Primero, sería conveniente tener un método que dé valores a las variables o atributos que tenemos en cada clase.
Es decir, en lugar de poner:
coch1.marca = "Peugot";
coch1.matricula = "C-1234-BZ";
coch1.ano = 1999;
coch1.nombreDoc = "Documento secreto 1";
coch1.nombreCond = "Ángel";
se podría llamar un método con 5 parámetros, tal que cada uno de estos parámetros asignará un valor a cada atributo, de la siguiente manera:
coch1.asignarValores (param1, param2, param3, param4, param5)
donde:
  • marca = param1
  • matricula = param2
  • ano = param3
  • nombreDoc = param4
  • nombreCond = param5
para que pudiéramos poner en una sola línea lo que teníamos antes en cinco:
coch1.asignarValores ("Peugot", "C-1234-BZ", 1999, "Documento secreto 1","ANGEL");
  • A la luz de esta brillante idea, el PN está listo para implementarla.
Primero, piensa dónde colocar el método que asigna los valores de los parámetros a los atributos y de inmediato se da cuenta que no puedes ubicarlo en la clase Vehiculo, ya que en esta clase no existen los atributos nombreDoc y nombreCond, por lo que decide colocarlos en las subclases.
Entonces, en la subclase Coche, decide crear un método de cinco parámetros, en el que se asignan los valores a las cinco variables o atributos que tenemos, de la forma:
coch1.asignarValores (param1, param2, param3, param4, param5)
donde:
  • marca = param1
  • matricula = param2
  • ano = param3
  • nombreDoc = param4
  • nombreCond = param5
y crear otro método en la subclase Furgoneta con otros cinco parámetros de la forma:
coch1.asignarValores (param1, param2, param3, param4, param5)
donde:
  • marca = param1
  • matricula = param2
  • ano = param3
  • dinero = param4
  • numJurados = param5


  • Una vez hecho esto, podemos substituir las líneas:
coch1.marca = "Peugot";
coch1.matricula = "C-1234-BZ";
coch1.ano = 1999;
coch1.nombreDoc = "Documento secreto 1";
coch1.nombreCond = "Ángel";
por
coch1.asignarValores ("Peugot", "C-1234-BZ", 1999, "Documento secreto 1","ANGEL");


y las líneas:
fur1.marca = "Opel";
fur1.matricula = "C-2342-AF";
fur1.ano = 1996;
fur1.dinero = 1000;
fur1.numJurados = 1;

por

fur1.asignarValores(Opel,C-2342-AF,1996,1000,1)
  • NOTA: Si queréis podéis probarlo de esta manera, pero la implementación final se va a realizar de otra forma.



  • Pero el Programador Experto vuelve a recoger una pluma que olvidó, y observa lo que el PN está a punto de hacer.
- !!!!! Pero ¿ qué haces ? ! Cómo se ve que llevas programando Java desde hace poco tiempo !
  • En la POO para realizar la asignación inicial de variables, se puede usar un método especial, llamado constructor, que se llama cada vez que se crea una nueva instancia, es decir, cada vez que se crea un objeto de una clase.
El nombre del constructor se llama igual que la clase, no lleva ningún modificador (public,private,void,...) solo su nombre, y puede o no tener parámetros.


Frente al asombro y la incomprensión del PN (aparte de ponerse rojo como uno tomate), el Programador Experto le comenta:
- Te daré un ejemplo para que entiendas: Supongamos que tengo una clase llamada Prueba, con dos atributos (atrib1,atrib2) y que dichos atributos tengan un valor de 10 por defecto.
Podría hacerlo en la definición del atributos, pero también puedo hacer uso del constructor, al que se llama de forma automática cuando se crea un objeto:
 1 public class Prueba{
 2 
 3   int atrib1,atrib2;
 4 
 5   Prueba(){
 6      atrib1 = 10;
 7      atrib2 = 10;
 8   }
 9 
10 }
Ahora en la clase Principal:
public class Principal{

   public static void main(String arg[]){

      Prueba miPrueba = new Prueba();      // En este momento llama al constructor
   }

}


  • Este constructor siempre está ahí, y si el usuario no lo define, java asigna el valor 0 (numéricos), false (booleanos) y null (de referencia) para todos los atributos de la clase para ese objeto.
  • En este momento, miPrueba.atrib1 tiene el valor 10, al igual que miPrueba.atrib2.
El PN antes de esta demostración de sabiduría no puede decir nada más que:
- Ahhhhhhhhhhhhhhhhhhh
- Pero esto no es todo, dice el programador experto. Resulta que puedes tener definidos tantos constructores como quieras, siempre y cuando estos se diferencien en el número o tipo de argumentos (dado que el nombre es fijo, debe ser el mismo nombre que la clase).
Entonces, podríamos tener otro constructor para asignar valores específicos a los dos atributos de la forma:
 1 public class Prueba{
 2 
 3   int atrib1,atrib2;
 4 
 5   Prueba(){
 6      atrib1 = 10;
 7      atrib2 = 10;
 8   }
 9 
10   Prueba(int valor1, int valor2){    // El nombre del constructor tiene que ser el mismo que el de la clase
11      atrib1 = valor1;
12      atrib2 = valor2;
13   }
14 
15 }
De tal forma que ahora puedo asignar un valor concreto a cada atributo de la forma:
public class Principal{

   public static void main(String arg[]){

      Prueba miPrueba = new Prueba(10,40);      // Llama al segundo constructor. Ahora atrib1 vale 10 y atrib2 vale 40
   }

}


  • A esto se llama sobrecargar un método (overload).
Es decir, tener dentro de uno clase varios métodos con el mismo nombre, pero con diferente tipo o número de argumentos le dice el programador experto con un cierto aire de superioridad ...
El PN se pone risueño como un pájaro al entender lo que el Programador Experto le explica (aunque un poco mosqueado).
Ahora sabe que en el caso de la clase Coche y la clase Furgoneta, debe crear un constructor que tenga cinco parámetros, asignando a cada atributo el valor del parámetro.
A cada parámetro le asigna un nombre: param1, param2, .... y más tarde dentro del constructor, asigna los valores de estos parámetros a cada variable.
Entonces en la clase Coche tendrá 5 parámetros que se asignarán a la marca, ano, matricula, nombreCond y nombreDoc y en el caso de Furgoneta, se asignarán a la marca, año, matricula, dinero y númJurados.

Ejercicio: implementar la solución





-- Ángel D. Fernández González -- (2017).