1
00:00:00,750 --> 00:00:02,400
Hola y bienvenidos a esta elección.

2
00:00:02,400 --> 00:00:07,450
A continuación vamos a ver el tema de auto Boxing y un Boxing en Llada están listos.

3
00:00:07,450 --> 00:00:15,440
Vamos bien vamos a ver nuestro IDEP si tenemos algún proyecto abierto vamos a cerrarlo damos clic derecho

4
00:00:15,440 --> 00:00:23,020
Clowes posteriormente damos clic en File seleccionamos mi proyecto ya va web Maiden y Java Application

5
00:00:23,430 --> 00:00:28,550
damos sigue Next y el nombre del proyecto se va a llamar atu Boxing

6
00:00:31,700 --> 00:00:38,980
un Boxing y lo depositamos en la carpeta de cursos Llavona aullaba el nombre de drupa y 10 cm MX con

7
00:00:38,980 --> 00:00:40,250
G.M. de Global mentoring.

8
00:00:40,540 --> 00:00:48,920
La versión 1.0 y dejamos el nombre del paquete vacío damos clic en Finalizar bien vamos a crear una

9
00:00:48,920 --> 00:00:55,050
nueva clase damos trigueño ya va Clas y la clase se llama auto Boxing

10
00:00:59,620 --> 00:01:09,390
Boxing y lo depositamos en el paquete de test damos surgió en finalizar quitamos estos comentarios y

11
00:01:09,390 --> 00:01:15,950
agregamos un método main Public estatico y Main tabulador bien con eso ya tenemos nuestra clase para

12
00:01:15,950 --> 00:01:16,940
comenzar a trabajar.

13
00:01:17,450 --> 00:01:24,320
Básicamente el concepto de auto Boxing y Boxing quiero decir que podemos asignar tipos primitivos hacia

14
00:01:24,320 --> 00:01:30,770
su clase envolvente así que también otro nombre que recibe este tipo de concepto se conoce como clases

15
00:01:30,830 --> 00:01:37,010
envolventes y vamos a ver algunos ejemplos de cómo podemos envolver tipos primitivos en clases sóviet

16
00:01:37,460 --> 00:01:43,820
pero también el proceso inverso de extraer un valor de una clase envolvente hacia un tipo primitivo.

17
00:01:43,820 --> 00:01:50,360
Se conoce como Boxing así que vamos a ver lo siguiente Primero vamos a ver el concepto de auto Boxing

18
00:01:51,590 --> 00:01:55,910
donde envolvemos tipos primitivos

19
00:01:59,530 --> 00:02:08,720
en clases de tipo rapero es decir envolventes vamos a probar con el tipo primitivo más básico si definimos

20
00:02:08,720 --> 00:02:15,320
una literal 10 normalmente esta literal la hemos tenido que asignar a una variable de tipo entero

21
00:02:18,100 --> 00:02:25,450
pero hasta aquí tenemos únicamente un tipo primitivo la clase envolvente del tipo int es la clase integrar

22
00:02:27,030 --> 00:02:32,620
y podemos observar que el compilador no tiene ningún problema para asignar una literal de tipo primitivo

23
00:02:32,740 --> 00:02:41,560
de tipo entero y asignarlo a la clase de tipo integrar vamos a imprimir el valor ese Addy tabulador

24
00:02:42,730 --> 00:02:44,530
guardamos cambios y ejecutamos

25
00:02:48,340 --> 00:02:54,220
y podemos observar que el valor que contiene esta clase integral es el valor de 10 que es la literal

26
00:02:54,220 --> 00:02:59,470
de tipo entero que le hemos asignado al inicio así que podemos recuperar sin ningún problema el valor

27
00:02:59,470 --> 00:03:04,420
de tipo primitivo y también de manera explícita si lo quisiéramos recuperar.

28
00:03:04,420 --> 00:03:12,690
Podemos solicitar el valor entero utilizando el método in valio es otra forma de recuperar y asegurarnos

29
00:03:12,900 --> 00:03:19,690
que está regresando el tipo entero primitivo ejecutamos y observamos el mismo resultado.

30
00:03:21,400 --> 00:03:26,210
Sin embargo para qué hacemos esto de convertir tipos primitivos a tipos horiek.

31
00:03:26,470 --> 00:03:28,010
Tenemos varias ventajas.

32
00:03:28,210 --> 00:03:34,960
Por ejemplo una de ellas es que a través de la variable que ya es de tipo objeto podemos ejecutar varios

33
00:03:34,960 --> 00:03:35,800
métodos.

34
00:03:35,800 --> 00:03:41,620
A diferencia de los tipos primitivos que no tienen acceso a métodos en el caso de tener un tipo integral

35
00:03:41,620 --> 00:03:47,530
que ya es de tipo Object tenemos acceso a los métodos como por ejemplo para recuperar el valor de tipo

36
00:03:47,530 --> 00:03:55,690
Bayt recuperar el valor pero utilizando un tipo float como ya hemos visto el valor entero.

37
00:03:55,800 --> 00:04:02,120
También un tipo long y por ejemplo también convertirlo a un tipo string hace que una vez que ya tenemos

38
00:04:02,240 --> 00:04:07,460
una clase envolvente entonces podemos acceder a los métodos de dicha clase.

39
00:04:07,460 --> 00:04:14,150
Esa es la ventaja de envolver tipos primitivos a tipos obvie y esta clase si damos control y nos posicionamos

40
00:04:14,150 --> 00:04:20,060
sobre la clase integral podemos observar que extiende la clase nombre y como comenta la clase integrar

41
00:04:20,360 --> 00:04:27,530
esta clase envuelve un tipo primitivo de tipo entero y lo convierte a un objeto bien así que esa es

42
00:04:27,540 --> 00:04:32,010
la manera de convertir un tipo primitivo int a una clase de tipo integral.

43
00:04:32,220 --> 00:04:38,790
Y ahora el proceso inverso se conoce como unboxing en el cual extraemos

44
00:04:42,090 --> 00:04:51,090
el tipo primitivo del objeto envolvente vamos a cambiar el nombre de esta variable ya que éste es la

45
00:04:51,090 --> 00:05:00,330
variable entero pero de tipo obvie y ahora vamos a declarar la variable entero pero que es de tipo primitivo

46
00:05:00,920 --> 00:05:04,160
y para recuperar el valor de la clase entero bien

47
00:05:07,150 --> 00:05:14,950
basta con asignar el valor que contiene esta clase de tipo integer y asignarlo al tipo primitivo y podemos

48
00:05:14,950 --> 00:05:20,830
ver que esta asignación ocurre sin ningún problema es decir que de manera automática el compilador va

49
00:05:20,830 --> 00:05:27,820
a extraer el valor entero que contiene este objeto y lo va a asignar a esta variable primitiva.

50
00:05:27,820 --> 00:05:30,310
Vamos a imprimir el valor para observar el resultado

51
00:05:35,790 --> 00:05:43,720
guardamos cambios y ejecutamos y podemos observar que el entero Object que imprime el valor de 10 como

52
00:05:43,720 --> 00:05:48,760
ya lo habíamos revisado pero ahora la variable primitiva también imprime el mismo valor

53
00:05:52,520 --> 00:05:58,580
así que lo que hicimos básicamente fue recuperar el valor que contenía la clase envolvente y lo asignamos

54
00:05:58,580 --> 00:05:59,840
a un tipo primitivo.

55
00:05:59,840 --> 00:06:05,150
Podemos observar que no tenemos necesidad de hacer ningún tipo de casting tanto al asignar el valor

56
00:06:05,150 --> 00:06:11,530
primitivo hacia la clase envolvente pero tampoco al recuperar el valor de la clase envolvente y asignarlo

57
00:06:11,540 --> 00:06:15,680
al tipo primitivo en ninguno de los casos tenemos que hacer ningún tipo de conversión.

58
00:06:15,770 --> 00:06:22,740
Esto lo va a hacer en automático el compilador y así podemos probar con cualquier otro tipo de objetos

59
00:06:23,580 --> 00:06:33,430
por ejemplo para el tipo float declaramos una variable flou o BJ y asignamos una literal flotante y

60
00:06:33,430 --> 00:06:39,960
mandamos a imprimir esta variable y posteriormente hacemos el proceso de unboxing.

61
00:06:40,860 --> 00:06:42,390
Declaramos una variable

62
00:06:45,050 --> 00:06:54,910
llamada flotante y le asignamos el valor de la clase envolvente Flock o DJ y mandamos a imprimir esta

63
00:06:54,910 --> 00:06:58,240
variable guardamos cambios y ejecutamos

64
00:07:04,850 --> 00:07:08,300
y podemos observar que para este caso es exactamente lo mismo.

65
00:07:08,300 --> 00:07:16,040
Primero asignamos el valor de 15.4 pero indicamos que es un tipo flotante y lo asignamos a nuestro objeto

66
00:07:16,040 --> 00:07:21,830
de tipo float sin necesidad de hacer ningún tipo de conversión y posteriormente el valor de nuestro

67
00:07:21,830 --> 00:07:28,150
objeto flotante lo asignamos a la variable primitiva llamada flotante la mandamos a imprimir y podemos

68
00:07:28,210 --> 00:07:35,550
ver que recuperamos exactamente el mismo valor pero tenemos la ventaja de la clase envolvente.

69
00:07:35,670 --> 00:07:46,680
Por ejemplo si quisiéramos recuperar un entero a partir del float entonces tendríamos que hacer lo siguiente

70
00:07:47,430 --> 00:07:57,750
usamos el objeto flotante float Object punto y podemos recuperar el valor entero solicitamos el método

71
00:07:57,810 --> 00:07:58,800
invalido.

72
00:07:58,800 --> 00:08:00,690
Vamos a ver qué es lo que imprime.

73
00:08:00,930 --> 00:08:02,670
Guardamos cambios y ejecutamos

74
00:08:07,660 --> 00:08:14,180
y podemos ver que realiza la conversión de un tipo flotante de 15.4 y lo convierte a un tipo entero

75
00:08:14,480 --> 00:08:16,310
es decir sin la parte flotante.

76
00:08:16,310 --> 00:08:22,070
Por lo tanto tenemos el valor de 15 así que también estas clases envolventes nos van a permitir hacer

77
00:08:22,070 --> 00:08:25,430
conversiones más fácilmente entre los tipos primitivos.

78
00:08:25,520 --> 00:08:30,020
Ya no vamos a tener que estar haciendo directamente las conversiones sino que si envolvemos nuestros

79
00:08:30,020 --> 00:08:32,640
tipos primitivos en esas clases envolventes.

80
00:08:32,750 --> 00:08:40,180
Después podemos utilizar los métodos para realizar las conversiones que necesitemos y se les vea como

81
00:08:40,180 --> 00:08:43,360
ejercicio probar cada una de las clases envolventes.

82
00:08:43,360 --> 00:08:45,370
Este es el listado de las clases envolventes

83
00:08:47,850 --> 00:08:52,410
listado de clases envolventes

84
00:08:55,180 --> 00:09:06,210
el tipo primitivo bullían tiene su clase envolvente llamada bullían la clase Bayt tiene su clase envolvente

85
00:09:06,360 --> 00:09:17,660
Bayt y así con los demás elementos el tipo primitivo Char tiene su clase asociada cáracter.

86
00:09:17,940 --> 00:09:23,370
En algunos casos el nombre de la clase envolvente cambia como es el caso de Char y también el caso de

87
00:09:23,430 --> 00:09:31,930
integrar las demás clases envolvente se llama igual que el tipo primitivo el tipo primitivo short tiene

88
00:09:31,930 --> 00:09:39,970
su clase envolvente llamada Llort el tipo hinque ya revisamos su clase envolvente es la clase integral

89
00:09:42,110 --> 00:09:49,650
el tipo primitivo longe tiene su clase envolvente llamada Long el tipo flop también que ya revisamos

90
00:09:50,280 --> 00:09:55,250
su clase envolventes float y finalmente doblé su clase envolvente.

91
00:09:55,410 --> 00:10:01,320
También se llama así que se les da como ejercicio probar cada una de estas clases envolventes pero básicamente

92
00:10:01,380 --> 00:10:07,790
es exactamente lo mismo que ya hemos revisado por ejemplo para el tipo int o para el tipo float.

93
00:10:08,010 --> 00:10:13,530
Así que con ese ejercicio hemos puesto en práctica el concepto de auto Boxing y un Boxing en IAVA el

94
00:10:13,530 --> 00:10:18,720
cual va a ser muy útil cuando estamos trabajando con otros tipos primitivos y en lugar de trabajar directamente

95
00:10:18,720 --> 00:10:24,900
con tipos primitivos podemos asignar estos valores a clases envolventes y así poder trabajar con objetos

96
00:10:25,080 --> 00:10:28,230
y no directamente con los tipos primitivos.

97
00:10:28,360 --> 00:10:30,840
Todo por esta elección y nos vemos en el siguiente video.

98
00:10:30,900 --> 00:10:31,500
Saludos.