1
00:00:01,190 --> 00:00:04,730
Vamos a continuar con este ejercicio de conversiones de objetos.

2
00:00:04,730 --> 00:00:12,220
Vamos a crear ahora una clase de prueba sobre estos packages damos el derecho nio a la clase y la clase

3
00:00:12,220 --> 00:00:25,560
se llama prueba conversión objetos y la depositamos en el paquete de test damos clic en Finalizar quitamos

4
00:00:25,560 --> 00:00:29,680
estos comentarios con controlé y agregamos un método.

5
00:00:29,940 --> 00:00:35,490
Ahora vamos a empezar a crear un objeto primero de la más alta jerarquía es decir un tipo de la clase

6
00:00:35,490 --> 00:00:36,180
padre.

7
00:00:36,270 --> 00:00:38,820
Declaramos la variable de tipo padre

8
00:00:42,350 --> 00:00:50,300
importamos esta clase y con esta variable vamos a ver que podemos apuntar a diferentes tipos siempre

9
00:00:50,300 --> 00:00:53,110
y cuando sean parte de la relación de las clases.

10
00:00:53,210 --> 00:00:58,220
En este caso pueden ser del mismo tipo es decir un objeto de tipo empleado o un tipo de las clases hijas

11
00:00:58,460 --> 00:01:04,400
como puede ser un objeto de tipo gerente o un objeto de tipo escritor así que esta variable puede apuntar

12
00:01:04,460 --> 00:01:09,620
a diferentes objetos en tiempo de ejecución así que lo que vamos a hacer es que vamos a asignar una

13
00:01:09,620 --> 00:01:16,070
referencia de un objeto de menor jerarquía así que utilizando la misma variable de empleado vamos a

14
00:01:16,070 --> 00:01:19,650
crear un nuevo objeto de la clase escritor.

15
00:01:20,090 --> 00:01:22,360
Le asignamos el nombre de rey.

16
00:01:22,370 --> 00:01:28,070
Posteriormente el sueldo de 5 000 y también proporcionamos el tipo de escritura

17
00:01:31,470 --> 00:01:37,050
en este caso vamos a proporcionar el valor de clásico pueden seleccionar cualquier opción de la numeración

18
00:01:38,250 --> 00:01:45,740
importamos esta clase y podemos ver que ya tenemos nuestra línea de código en la cual una variable de

19
00:01:45,740 --> 00:01:49,720
tipo empleado está apuntando a un objeto de menor jerarquía.

20
00:01:49,940 --> 00:01:53,300
Así que sin problemas el compilador nos deja hacer esta asignación.

21
00:01:53,300 --> 00:01:59,720
Sin embargo si quisiéramos mandar a llamar por ejemplo el método de la clase escritor tipo de escritura

22
00:01:59,720 --> 00:02:07,510
en texto vamos a intentar hacerlo si escribimos empleado punto y solicitamos los métodos G.T disponibles

23
00:02:07,750 --> 00:02:11,160
podemos observar que no podemos acceder al tipo de escritura.

24
00:02:11,590 --> 00:02:16,960
Incluso si escribimos todo el nombre de este método qué tipo de escritura en texto

25
00:02:20,660 --> 00:02:26,750
vamos a poner todo el nombre del método podemos observar que la variable empleado no puede acceder a

26
00:02:26,750 --> 00:02:32,750
este método debido a que el tipo que estamos utilizando únicamente puede acceder a los métodos que tenemos

27
00:02:32,750 --> 00:02:41,060
en común entre estas clases es decir entre la clase empleado y entre la clase gerente o escritor en

28
00:02:41,060 --> 00:02:43,930
este caso con la clase escritor y la clase empleado.

29
00:02:44,000 --> 00:02:50,990
El único método que tenemos en común es el método obtener detalles así que este método tipo de escritura

30
00:02:50,990 --> 00:02:53,900
no lo podríamos mandar a llamar directamente.

31
00:02:53,900 --> 00:02:59,720
Para ello precisamente es que vamos a hacer una conversión pero eso lo vamos a ver posteriormente.

32
00:02:59,720 --> 00:03:06,450
De momento vamos a mandar a llamar el método obtener detalles y esto ya lo vimos elecciones anteriores

33
00:03:06,630 --> 00:03:12,420
donde se aplica el polimorfismo y el método que se va a ejecutar va a ser el método del objeto al cual

34
00:03:12,420 --> 00:03:14,010
esté apuntando en memoria.

35
00:03:14,010 --> 00:03:18,440
Es decir que en este caso la variable empleado está apuntando a un objeto de tipo escritor.

36
00:03:18,540 --> 00:03:23,460
Por lo tanto el método a obtener detalles que se va a ejecutar va a ser el de la clase escritor aunque

37
00:03:23,460 --> 00:03:28,800
la variable sea de tipo empleado el método que se ejecuta es el del objeto al cual está apuntando en

38
00:03:28,800 --> 00:03:31,520
memoria y este método nos regresa un estreno.

39
00:03:31,590 --> 00:03:33,420
Por lo tanto lo podemos mandar a imprimir

40
00:03:38,880 --> 00:03:44,880
con el método LN guardamos cambios ejecutamos simplemente para comprobar que todo está funcionando correctamente

41
00:03:45,550 --> 00:03:51,400
y podemos observar el nombre de rey el sueldo de 5000 y el tipo de escritura escritura a mano.

42
00:03:51,450 --> 00:03:56,940
Así que con esto estamos observando que se está ejecutando el método de la clase hija obtener detalles

43
00:03:57,180 --> 00:04:03,240
ya que estamos observando el tipo de escritura ya que el método de la clase empleado obtener detalles

44
00:04:03,420 --> 00:04:09,250
no incluye el tipo de escritura así que hasta aquí está funcionando correctamente el polimorfismo.

45
00:04:09,360 --> 00:04:15,090
Pero ahora si quisiéramos ejecutar el método qué tipo de escritura en texto lo que tenemos que hacer

46
00:04:15,150 --> 00:04:20,790
es una conversión hacia abajo es decir que la variable empleado la podemos convertir a un tipo escritor

47
00:04:20,910 --> 00:04:24,020
para que podamos acceder a este método.

48
00:04:24,090 --> 00:04:31,700
Esto lo podemos hacer de dos maneras podemos declarar una variable de tipo escritor puede ser cualquier

49
00:04:31,700 --> 00:04:35,450
nombre le ponemos escritor y le asignamos la variable de empleado

50
00:04:38,230 --> 00:04:43,520
y podemos observar que el compilador nos está indicando que debemos hacer un cast es decir una conversión

51
00:04:45,530 --> 00:04:50,000
y la conversión básicamente la hacemos poniendo del lado izquierdo el tipo al cual queremos convertir

52
00:04:50,030 --> 00:04:51,140
esta variable.

53
00:04:51,140 --> 00:04:56,270
Esto es muy similar a los tipos primitivos pero en este caso estamos trabajando con objetos así que

54
00:04:56,270 --> 00:05:02,120
la variable de tipo empleado la estamos convirtiendo a tipo escritor y lo estamos asignando a una variable

55
00:05:02,120 --> 00:05:03,680
de tipo escritor.

56
00:05:03,710 --> 00:05:09,980
De esta manera ahora si la variable escritor como es de tipo escritor puede acceder a los métodos que

57
00:05:09,980 --> 00:05:16,070
se han definido en esta clase y sin ningún problema podemos acceder a este método Goeth tipo de escritura

58
00:05:16,100 --> 00:05:16,700
en texto

59
00:05:20,710 --> 00:05:23,620
imprimimos este mensaje que nos regresa este método

60
00:05:26,770 --> 00:05:28,980
podemos ver que no hay ningún problema de compilación.

61
00:05:29,020 --> 00:05:36,220
Guardamos cambios y ejecutamos y podemos llevar el mensaje escritura a mano que fue precisamente el

62
00:05:36,220 --> 00:05:42,060
tipo de escritura que asignamos al momento de crear este objeto.

63
00:05:42,140 --> 00:05:44,170
Esta es una forma de hacer la conversión.

64
00:05:44,270 --> 00:05:50,120
Esta es la primer forma pero también tenemos una segunda forma que es al vuelo así que con la misma

65
00:05:50,120 --> 00:05:51,380
variable de empleado

66
00:05:55,490 --> 00:06:02,030
el lugar en lugar de asignarle a una variable podemos simplemente hacer la conversión al vuelo es decir

67
00:06:02,030 --> 00:06:08,870
del lado izquierdo especificamos el tipo de dato al cual queremos convertir y ponemos todo entre paréntesis

68
00:06:09,900 --> 00:06:14,810
y básicamente con esto le estamos diciendo al compilador que la variable empleado la vamos a convertir

69
00:06:14,960 --> 00:06:21,710
a un tipo de escritor y si ponemos punto podemos observar que podemos acceder al método qué tipo de

70
00:06:21,710 --> 00:06:30,220
escritura en texto lo podemos mandar a imprimir simplemente para comprobar que esto funciona sin ningún

71
00:06:30,220 --> 00:06:30,660
problema

72
00:06:37,900 --> 00:06:39,460
guardamos cambios y ejecutamos

73
00:06:42,210 --> 00:06:44,360
y podemos observar que tenemos el mismo resultado.

74
00:06:44,530 --> 00:06:50,980
Escritura a mano y escritura a mano así que cualquiera de las dos conversiones que hagamos ya sea asignándole

75
00:06:50,980 --> 00:06:55,630
a una variable o haciendo la conversión al vuelo simplemente poniéndolo entre paréntesis.

76
00:06:55,680 --> 00:07:01,830
Podemos convertir este tipo de dato en el tipo de dato deseado y de esta forma acceder a los métodos

77
00:07:01,830 --> 00:07:04,950
disponibles en la clase a la cual estamos convirtiendo.

78
00:07:05,010 --> 00:07:10,700
En este caso a una clase e hija y como siguiente paso vamos a utilizar la misma variable de empleado

79
00:07:11,270 --> 00:07:14,300
simplemente para comprobar que funciona correctamente nuestro código.

80
00:07:14,600 --> 00:07:20,240
Pero ahora le vamos a asignar un objeto de tipo gerente es decir la otra clase hija

81
00:07:23,090 --> 00:07:26,210
le asignamos el nombre de Laura el sueldo de 6000

82
00:07:30,330 --> 00:07:38,200
y el área de sistemas importamos la clase gerente y podemos sustituir estas líneas simplemente poniendo

83
00:07:38,200 --> 00:07:42,050
asterisco para no importar cada una de las clases por separado.

84
00:07:44,120 --> 00:07:46,650
Y podemos ver que esta línea funciona sin ningún problema.

85
00:07:46,780 --> 00:07:53,020
Es decir que la variable de tipo padre de tipo empleado puede apuntar a objetos del mismo tipo o de

86
00:07:53,020 --> 00:08:01,790
tipos hijo pero si quisiéramos acceder al método o departamento de la clase gerente sucede exactamente

87
00:08:01,790 --> 00:08:08,560
lo mismo que revisamos anteriormente directamente la clase empleado no puede acceder al método departamento.

88
00:08:08,810 --> 00:08:11,750
Si quisiéramos hacer esto tenemos que hacer una conversión

89
00:08:14,370 --> 00:08:22,250
hacemos la conversión hacia la clase gerente ponemos todo entre paréntesis y si ponemos punto podemos

90
00:08:22,250 --> 00:08:29,630
observar que ya podemos acceder al método departamento mandamos a imprimir esto simplemente para comprobar

91
00:08:29,630 --> 00:08:30,290
que funciona

92
00:08:36,240 --> 00:08:37,860
guardamos cambios ejecutamos

93
00:08:40,420 --> 00:08:46,780
y podemos observar que podemos acceder al departamento en este caso el departamento de sistemas así

94
00:08:46,780 --> 00:08:49,440
que básicamente en esto consiste la conversión de objetos.

95
00:08:49,570 --> 00:08:55,270
Podemos tener una variable que apunta a objetos de tipo hijo en tiempo de ejecución pero el momento

96
00:08:55,270 --> 00:09:00,220
de tratar de acceder a los métodos de la clase fija en muchos casos no vamos a poder acceder directamente

97
00:09:00,220 --> 00:09:05,290
a estos métodos con la variable de tipo padre así que por ello es que necesitamos hacer una conversión

98
00:09:05,680 --> 00:09:11,140
a la clase de tipo hijo para que podamos acceder nuevamente a los métodos definidos en las clases hijas

99
00:09:11,820 --> 00:09:14,230
y dependiendo del tipo al cual queramos convertir.

100
00:09:14,230 --> 00:09:19,720
Tenemos que hacer la conversión ya sea por ejemplo en este caso a la clase escritor o en este caso a

101
00:09:19,720 --> 00:09:25,340
la clase hija de tipo gerente bien eso es todo por esta elección y nos vemos en el siguiente vídeo.

102
00:09:25,420 --> 00:09:26,050
Saludos.