1
00:00:01,050 --> 00:00:02,680
Hola y bienvenidos esta elección.

2
00:00:02,700 --> 00:00:06,760
A continuación vamos estudiar el tema de constructores en Java están listos.

3
00:00:06,840 --> 00:00:11,560
Vamos bien vamos a continuar con nuestro ejercicio de aritmética.

4
00:00:11,880 --> 00:00:17,910
Pero ahora vamos a modificarlo para manejar el concepto de constructores un constructor básicamente

5
00:00:17,910 --> 00:00:24,180
nos permite inicializar los valores de nuestra clase y además reservar espacio en memoria para que se

6
00:00:24,180 --> 00:00:29,940
pueda crear un objeto de nuestra clase existen varios tipos de constructores que podemos tener en nuestras

7
00:00:29,940 --> 00:00:30,870
clases.

8
00:00:30,870 --> 00:00:35,480
El primer tipo de constructor es el constructor vació a su vez también un constructor.

9
00:00:35,520 --> 00:00:40,530
Es un método especial en Java ya que únicamente se puede mandar a llamar este método cuando se está

10
00:00:40,530 --> 00:00:43,350
creando el objeto no se puede mandar a llamar.

11
00:00:43,350 --> 00:00:49,740
Un método de Tipo Constructor posterior a la creación del objeto y si no definimos un constructor en

12
00:00:49,740 --> 00:00:52,050
nuestra clase de manera explícita.

13
00:00:52,260 --> 00:00:57,860
Entonces el compilador de java va a agregar por default lo que se conoce como el constructor vacio.

14
00:00:57,900 --> 00:01:03,750
Por ello es que podemos observar que nuestra clase aritmética no hemos definido un método de tipo constructor

15
00:01:04,200 --> 00:01:11,170
el cual vamos a ver a continuación pero en automático el compilador de java agregó este método por nosotros.

16
00:01:11,310 --> 00:01:17,740
De lo contrario no podríamos crear el objeto aritmética que hemos utilizado dentro del método main bien

17
00:01:17,920 --> 00:01:23,830
así que vamos a definir nuestro constructor vació el constructor como hemos comentado es un método especial

18
00:01:23,920 --> 00:01:24,600
en Java.

19
00:01:24,730 --> 00:01:30,670
únicamente se puede mandar a llamar la primera vez que se crea este objeto y se debe de llamar exactamente

20
00:01:30,670 --> 00:01:36,730
igual que la clase así que para identificar un constructor dentro de nuestra clase debemos de buscar

21
00:01:36,820 --> 00:01:43,030
un método que se llame exactamente igual que nuestra clase así que vamos a definir el siguiente constructor

22
00:01:43,570 --> 00:01:49,030
vamos a utilizar el modificador de acceso público para que se pueda mandar a llamar desde otra clase

23
00:01:49,660 --> 00:01:54,840
y posteriormente la diferencia también con un método y un constructor es que un constructor no regresa

24
00:01:54,850 --> 00:01:56,380
ningún tipo de dato.

25
00:01:56,380 --> 00:02:03,550
Por lo tanto no vamos a encontrar aquí un Void o un Hint o un Streeck etc. ya que no se va a definir

26
00:02:03,580 --> 00:02:10,090
un tipo de regreso así que inmediatamente después del modificador de acceso vamos a encontrar el nombre

27
00:02:10,090 --> 00:02:17,040
de nuestra clase y de esta manera es que vamos a poder identificar el método que corresponde a un constructor

28
00:02:17,040 --> 00:02:23,190
de nuestra clase en este caso el constructor vació no recibe ningún argumento y abrimos el cuerpo de

29
00:02:23,190 --> 00:02:28,100
nuestro constructor así que podemos observar que es muy similar a la definición de un método.

30
00:02:28,260 --> 00:02:32,730
Sin embargo se debe de llamar exactamente igual que en nuestra clase.

31
00:02:32,730 --> 00:02:39,060
Por ejemplo si nos llegamos a equivocar y utilizamos la letra minúscula podemos observar que ya tenemos

32
00:02:39,060 --> 00:02:44,670
un error ya que entonces el compilador de Java en este caso infiere que queremos declarar un método

33
00:02:44,880 --> 00:02:46,120
y no un constructor.

34
00:02:46,200 --> 00:02:51,720
Por lo tanto nos está indicando que debemos agregar el tipo de retorno y como este método no tiene un

35
00:02:51,720 --> 00:02:57,810
tipo de retorno entonces no es una definición válida de un método para que sea una definición válida.

36
00:02:57,930 --> 00:03:03,150
En este caso de un constructor entonces debe de llamarse igual que la clase y no debe de regresar ningún

37
00:03:03,150 --> 00:03:04,530
tipo de dato.

38
00:03:04,690 --> 00:03:09,630
En este caso los constructores por default o vacíos son los que se agregan de manera automática por

39
00:03:09,630 --> 00:03:14,840
el compilador siempre y cuando no tengamos otro tipo de constructores que reciban argumentos.

40
00:03:14,970 --> 00:03:20,350
Si definimos un constructor con argumentos entonces ya no se va a agregar de manera automática.

41
00:03:20,400 --> 00:03:26,790
Este constructor y nosotros somos responsables de agregarlo a nuestra clase bien vamos a mandar a imprimir

42
00:03:26,790 --> 00:03:29,580
un mensaje ejecutando

43
00:03:32,450 --> 00:03:37,340
constructor vacío para que sepamos en qué momento se manda llamar este constructor.

44
00:03:37,340 --> 00:03:42,980
Así que podemos observar que ya estamos definiendo de manera explícita nuestro constructor vacío y cuando

45
00:03:42,980 --> 00:03:48,620
se cree en nuestro objeto aritmética se va a mandar a consola el mensaje ejecutando constructor vacío

46
00:03:49,520 --> 00:03:51,620
bien por otro lado en nuestra clase de prueba.

47
00:03:51,680 --> 00:03:58,580
Podemos observar que tenemos la llamada de Niu a nuestra clase aritmética y ahora ya podemos entender

48
00:03:58,910 --> 00:04:04,910
que la llamada a estos paréntesis realmente estamos mañana llamar el constructor vació o con argumentos

49
00:04:05,180 --> 00:04:10,370
si pasamos argumentos entonces necesitamos definir un constructor que reciban los diferentes argumentos

50
00:04:10,370 --> 00:04:16,240
que estamos proporcionando y como en este caso no estamos definiendo ningún argumento no estamos pasando

51
00:04:16,250 --> 00:04:22,750
ningún argumento entonces está mandando llamar el constructor vacío si no se ha definido en nuestra

52
00:04:22,750 --> 00:04:28,270
clase en automático el compilador lo va a agregar pero en este caso como ya lo hemos definido entonces

53
00:04:28,270 --> 00:04:33,820
se va a ejecutar esta línea de código de nuestro constructor que hemos definido vamos a comprobarlo

54
00:04:34,840 --> 00:04:36,880
vamos a poner un punto de ruptura.

55
00:04:36,880 --> 00:04:44,350
En esta línea guardamos cambios y ejecutamos damos clic derecho de Buffy y presionamos F7 para entrar

56
00:04:44,440 --> 00:04:51,790
al detalle de la llamada del constructor así que presionamos F7 o step into y podemos llevar que ya

57
00:04:51,790 --> 00:04:58,420
estamos posicionados dentro de la llamada del constructor vacío ya estamos dentro de la clase aritmética.

58
00:04:58,630 --> 00:05:08,660
Ahora presionamos F8 vamos a consola de nueva cuenta F8 y podemos observar el mensaje ejecutando constructor

59
00:05:08,660 --> 00:05:17,560
vacío presionamos de nueva cuenta f 8 y presionamos otra vez f 8 y en este momento ya se ha creado el

60
00:05:17,560 --> 00:05:19,000
objeto aritmética.

61
00:05:19,120 --> 00:05:25,030
Así que una de las labores de haber mandado a llamar este constructor vació es por un lado inicializar

62
00:05:25,210 --> 00:05:30,710
las variables de nuestra clase en este caso no hemos declarado ningún atributo de esta clase.

63
00:05:30,820 --> 00:05:36,970
Por lo tanto la siguiente labor que realiza este constructor es reservar espacio en memoria para que

64
00:05:36,970 --> 00:05:42,820
se pueda crear una instancia de la clase aritmética y por ello es que se crea el objeto aritmética en

65
00:05:42,820 --> 00:05:49,480
memoria podemos observar que la variable aritmética ya está apuntando al objeto que se creó en este

66
00:05:49,480 --> 00:05:51,160
espacio de memoria.

67
00:05:51,370 --> 00:05:56,800
Este es un valor hexadecimal así que esta es la ubicación de memoria donde se encuentra el objeto que

68
00:05:56,800 --> 00:05:58,870
se ha creado el objeto aritmética.

69
00:05:58,990 --> 00:06:02,920
Así que en resumen tenemos nuestra clase aritmética que es la plantilla

70
00:06:07,250 --> 00:06:12,500
y por otro lado en esta línea de código lo que estamos haciendo es mandar a llamar el constructor que

71
00:06:12,500 --> 00:06:19,640
está definido dentro de esta plantilla y lo que va a hacer este constructor es crear un objeto solicitando

72
00:06:19,670 --> 00:06:25,550
espacio de memoria para crear este objeto y ese objeto se creó en el espacio de memoria que nos ha indicado

73
00:06:25,900 --> 00:06:33,140
y posteriormente la variable aritmética apunta al objeto que se ha creado en el espacio de memoria que

74
00:06:33,140 --> 00:06:35,800
nos ha proporcionado el constructor vacío.

75
00:06:35,900 --> 00:06:40,730
Pero también podríamos mandar a llamar un constructor con argumentos esto lo vamos a ver a continuación

76
00:06:42,060 --> 00:06:47,160
pero con esa sintaxis ya podemos entender que esta línea de código realmente lo que está haciendo es

77
00:06:47,160 --> 00:06:52,830
mandar a llamar el constructor vació para inicializar los argumentos de nuestra clase por un lado si

78
00:06:52,830 --> 00:06:56,970
es que fuera necesario y por otro lado reservar espacio en memoria.

79
00:06:56,970 --> 00:07:02,790
Así que cada vez que veamos la palabra reservada Niu realmente lo que estamos haciendo es mandar llamar

80
00:07:02,820 --> 00:07:08,160
el constructor de nuestra clase y esta es la única forma en que podemos mandar a llamar un constructor

81
00:07:08,160 --> 00:07:11,780
de la clase en conjunto con la palabra reservada Nio.

82
00:07:11,970 --> 00:07:17,490
No es posible por ejemplo escribir nuestra variable aritmética punto

83
00:07:21,070 --> 00:07:25,500
aritmética como si mandáramos a llamar el constructor vacío.

84
00:07:25,630 --> 00:07:31,270
Esto no sería posible ya que el constructor únicamente se puede mandar a llamar para crear el objeto.

85
00:07:31,300 --> 00:07:35,180
Esto quiere decir que debe ir en conjunto con la palabra reservada.

86
00:07:35,470 --> 00:07:41,940
Una vez que ya se ha creado el objeto ya no podemos mandar a llamar los constructores quitamos esta

87
00:07:41,940 --> 00:07:42,330
línea

88
00:07:45,970 --> 00:07:50,920
vamos a detener la ejecución paso a paso ya que las demás líneas de código ya tienen que ver con la

89
00:07:50,920 --> 00:07:54,380
llamada al método ya no tienen que ver con el constructor.

90
00:07:54,670 --> 00:08:00,100
Así que presionamos este botón para detener la ejecución paso a paso y podemos quitar nuestro punto

91
00:08:00,100 --> 00:08:01,480
de ruptura.

92
00:08:01,540 --> 00:08:06,400
Bien vamos a detener hasta aquí este vídeo y en el siguiente vídeo vamos a ver los constructores que

93
00:08:06,400 --> 00:08:09,550
reciben argumentos nos vemos en el siguiente vídeo.

94
00:08:09,590 --> 00:08:10,150
Saludos.
