1
00:00:09,930 --> 00:00:13,400
Hola te saluda nuevamente Ubaldo Acosta.

2
00:00:13,560 --> 00:00:16,730
Espero que estén listos para comenzar con esta elección.

3
00:00:16,740 --> 00:00:23,020
A continuación vamos a estudiar el tema de auto Boxing y un Boxing enviaba están listos.

4
00:00:23,020 --> 00:00:28,420
Vamos atu Boxing y un Boxing en IAVA.

5
00:00:28,720 --> 00:00:35,740
El concepto de auto Boxing y boxing es simple pero poderoso auto boxing es el proceso en el cual el

6
00:00:35,740 --> 00:00:42,160
compilador hace de manera automática una conversión de un tipo primitivo a un tipo hobbie.

7
00:00:42,430 --> 00:00:49,570
Por ejemplo en el código mostrado podemos observar que la literal 10 se asigna directamente a una variable

8
00:00:49,660 --> 00:00:59,740
de tipo integer llamada entero Object o entero o BJ así que este valor es un primitivo y se asigna directamente

9
00:00:59,800 --> 00:01:04,440
a una variable de tipo integer la cual es un tipo obvie.

10
00:01:04,510 --> 00:01:11,860
Esta clase integral se conoce como una clase envolvente o rapper del tipo primitivo int y es la que

11
00:01:11,860 --> 00:01:20,290
permite el proceso de conversión de manera automática entre tipos primitivos y objetos de tipo entero.

12
00:01:20,290 --> 00:01:26,380
Existe un tipo de clase envolvente por cada uno de los tipos primitivos existentes los cuales veremos

13
00:01:26,380 --> 00:01:27,710
más adelante.

14
00:01:28,060 --> 00:01:34,750
El proceso de auto Boxing no requiere de hacer ningún tipo de conversión entre tipos primitivos y objetos

15
00:01:34,990 --> 00:01:41,470
siempre y cuando utilicemos el tipo envolvente equivalente al tipo primitivo que se está intentando

16
00:01:41,470 --> 00:01:49,170
convertir de manera automática y así en cada uno de estos ejemplos podemos observar que el tipo primitivo

17
00:01:49,170 --> 00:01:57,170
correspondiente se asigna a un tipo obvie en este caso el tipo primitivo flotante en la litera flotante

18
00:01:57,170 --> 00:01:58,520
15.2.

19
00:01:58,520 --> 00:02:04,490
Para ello estamos indicando que es flotante se asigna a una variable de tipo float y esto es un objeto

20
00:02:05,450 --> 00:02:11,090
y por lo tanto a partir de este momento se le puede dar tratamiento de un objeto y no únicamente de

21
00:02:11,090 --> 00:02:12,670
un tipo primitivo.

22
00:02:12,830 --> 00:02:20,000
Y finalmente tenemos la literal 40 punto 1 la cual en automático es de tipo dual y se asigna a una variable

23
00:02:20,000 --> 00:02:27,020
de tipo obvie llamada Doble o BJ y podemos observar que no hay necesidad de hacer ninguna conversión

24
00:02:27,380 --> 00:02:28,310
en automático.

25
00:02:28,310 --> 00:02:35,410
El compilador hace esta conversión por nosotros por otro lado tenemos el proceso inverso el cual es

26
00:02:35,410 --> 00:02:42,400
el proceso de Unboxing es decir un objeto de tipo envolvente se puede convertir de manera automática

27
00:02:42,490 --> 00:02:49,750
a un tipo primitivo sin necesidad de aplicar ninguna conversión entre objetos y tipos primitivos tal

28
00:02:49,750 --> 00:02:52,480
como podemos observar en el código mostrado.

29
00:02:52,660 --> 00:02:58,600
De esta manera es muy sencillo trabajar con tipos primitivos pero cuando necesitamos utilizar las ventajas

30
00:02:58,600 --> 00:03:05,200
de un objeto IAVA podemos utilizar la clase envolvente respectiva así que también tenemos el proceso

31
00:03:05,200 --> 00:03:09,880
inverso en el cual podemos tomar un objeto de una clase rapper.

32
00:03:09,910 --> 00:03:16,840
En este caso de la clase integer y de manera automática podemos asignar el valor de esta variable la

33
00:03:16,840 --> 00:03:21,240
cual es de tipo objeto a una variable de tipo primitivo.

34
00:03:21,250 --> 00:03:26,560
Más adelante veremos el proceso de conversión de objetos en el cual veremos que es necesario indicar

35
00:03:26,590 --> 00:03:28,330
un cast o conversión.

36
00:03:28,420 --> 00:03:30,820
Cuando vamos a hacer conversión entre objetos.

37
00:03:30,940 --> 00:03:36,550
Sin embargo debido a que estamos utilizando en este momento el concepto de auto Boxing y unboxing que

38
00:03:36,550 --> 00:03:43,780
básicamente consiste en utilizar la clase equivalente de un tipo primitivo a un tipo obvie no hay necesidad

39
00:03:43,840 --> 00:03:45,330
de hacer esta conversión.

40
00:03:45,520 --> 00:03:52,280
Por lo tanto podemos asignar directamente el valor del objeto integer a un tipo primitivo equivalente

41
00:03:52,290 --> 00:03:57,820
de tipo entero y así en cada uno de los objetos que estamos trabajando en este caso de tipo flotante

42
00:03:58,180 --> 00:04:06,220
lo podemos asignar a una variable de tipo primitivo float y finalmente un objeto de tipo doble lo podemos

43
00:04:06,220 --> 00:04:13,010
asignar a una variable de tipo doble y esta variable es de tipo primitivo recuerden que el estudio de

44
00:04:13,010 --> 00:04:17,420
los tipos primitivos lo vimos a detalle en el curso de Fundamentos de IAVA

45
00:04:20,230 --> 00:04:26,830
continuando con lo anterior podemos observar ahora en la tabla el tipo primitivo y su clase envolvente

46
00:04:26,890 --> 00:04:28,160
equivalente.

47
00:04:28,240 --> 00:04:34,360
Podemos observar que según las convenciones de IAVA la clase envolvente está escrita con mayúscula y

48
00:04:34,360 --> 00:04:41,000
así podemos identificar rápidamente si estamos tratando con un tipo primitivo o con un tipo obvie.

49
00:04:41,110 --> 00:04:47,410
Varias de estas clases envolventes descienden de una clase llamada nombre y esta clase a su vez es la

50
00:04:47,410 --> 00:04:53,650
que define muchos de los métodos que las clases que sean de tipo numérico pueden utilizar esta clase

51
00:04:53,650 --> 00:04:59,740
contiene los métodos para realizar la conversión a distintos tipos de datos según se necesite.

52
00:04:59,740 --> 00:05:06,220
Por ejemplo sin importar de qué tipo numérico se trate podemos solicitar que nos regrese el valor correspondiente

53
00:05:06,550 --> 00:05:12,650
a un primitivo de tipo Veidt sort int long float o doble.

54
00:05:12,670 --> 00:05:18,880
De esta manera podremos convertir el dato contenido por la clase envolvente a cualquiera de los tipos

55
00:05:18,880 --> 00:05:26,320
mencionados así que esta es una de las ventajas de utilizar una clase envolvente una clase y no un tipo

56
00:05:26,320 --> 00:05:32,950
primitivo ya que si hemos asignado el valor primitivo a una clase de tipo envolvente podremos solicitar

57
00:05:32,950 --> 00:05:38,380
la conversión por medio de los métodos de la clase envolvente sin necesidad de hacer una conversión

58
00:05:38,380 --> 00:05:45,280
manual sino que en automático solicitando el método respectivo al método de la clase envolvente podremos

59
00:05:45,340 --> 00:05:53,260
obtener la conversión al tipo primitivo que deseemos en resumen el concepto de Boxing y unboxing permite

60
00:05:53,260 --> 00:05:58,930
escribir código más simple y más sencillo de leer cuando estamos hablando de conversiones entre tipos

61
00:05:58,930 --> 00:06:06,130
primitivos y tipos obvie esto sin necesidad de realizar tantas conversiones entre objetos y tipos primitivos

62
00:06:06,400 --> 00:06:10,260
como se tenía que realizar antes de la versión 5 de IAVA.

63
00:06:10,390 --> 00:06:13,800
Vamos a desarrollar un ejercicio para aplicar este concepto.