1
00:00:07,059 --> 00:00:14,419
Bien, antes de meterme en los conceptos un poco más abstractos de la programación orientada a objetos,

2
00:00:14,539 --> 00:00:19,019
voy a poner un ejemplo práctico en función de lo que hemos visto para que veamos cómo eso se traduce en código.

3
00:00:19,480 --> 00:00:22,920
Concretamente en código en C-Sharp y concretamente en C-Sharp para Unity,

4
00:00:23,079 --> 00:00:28,359
que tiene sus peculiaridades, pero como es el que vamos a usar, pues directamente parto de un script creado para Unity.

5
00:00:28,920 --> 00:00:33,840
Mi entorno de desarrollo ya me está avisando de aquí de un error, y es lo que he comentado antes,

6
00:00:33,840 --> 00:00:38,700
que hay que seguir ciertas ciertas convenciones y él me está avisando como

7
00:00:38,700 --> 00:00:41,280
podemos ver es un error no grave por eso no me lo indica ni en rojo ni en

8
00:00:41,280 --> 00:00:46,920
amarillo ni nada pero me está diciendo que al ser eso una clase debería empezar

9
00:00:46,920 --> 00:00:50,659
con mayúscula porque empieza con minúscula porque yo cuando cree este

10
00:00:50,659 --> 00:00:55,899
script en unity pues lo cree con minúscula y él automáticamente creó una

11
00:00:55,899 --> 00:01:00,200
clase con el nombre del archivo vale de hecho ahí está el archivo

12
00:01:00,200 --> 00:01:08,640
En fin, pero bueno, a partir de ahora vamos a intentar crear los archivos y por tanto las clases que están contenidas dentro de esos archivos con mayúscula.

13
00:01:09,120 --> 00:01:19,140
He borrado el método update porque ahora solo me interesa el método start para tenerlo todo dentro de una estructura lógica de C Sharp.

14
00:01:19,439 --> 00:01:25,540
No me voy a detener ahora en cómo se estructura un archivo de C Sharp porque es un poco complejo el que quiera investigar lo que lo investigue,

15
00:01:25,540 --> 00:01:29,219
pero digamos que no era tan fácil como cuando programábamos en javascript

16
00:01:29,219 --> 00:01:31,519
que podíamos empezar a escribir código y ya está

17
00:01:31,519 --> 00:01:36,680
no, hay que seguir cierta estructura en cuanto a dónde están disponibles mis variables

18
00:01:36,680 --> 00:01:39,819
mis métodos, mis clases, toda una historia que incluso a mí se me escapa

19
00:01:39,819 --> 00:01:42,120
pero vamos a crear nuestra propia clase

20
00:01:42,120 --> 00:01:46,700
por ejemplo, ya que estamos aquí voy a crear una clase mía

21
00:01:46,700 --> 00:01:49,620
la voy a crear pública, ¿para qué? para que esté disponible fuera

22
00:01:49,620 --> 00:01:55,260
y así otros pueden llamar a esta clase y crear objetos aunque estén fuera de este script

23
00:01:55,260 --> 00:02:01,299
Y aquí definimos que es una clase, no es una variable ni nada, es una clase.

24
00:02:01,719 --> 00:02:07,400
Aquí le damos el nombre que queremos, como he comentado antes, en mayúscula,

25
00:02:07,859 --> 00:02:14,139
y directamente creamos las llaves que indican todo lo que contiene mi clase.

26
00:02:14,500 --> 00:02:17,719
¿Y qué va a contener mi clase? Pues, por ejemplo, sus atributos.

27
00:02:18,219 --> 00:02:22,740
Muy importante. Y aquí es donde empezamos a entender el ámbito de las variables de las clases.

28
00:02:22,740 --> 00:02:25,599
ya comenté en un vídeo anterior

29
00:02:25,599 --> 00:02:27,539
cuando hablaba del ámbito del scope

30
00:02:27,539 --> 00:02:29,960
de las variables, es que en programación orientada

31
00:02:29,960 --> 00:02:32,460
a objetos es un poco más complejo en el sentido de que

32
00:02:32,460 --> 00:02:33,819
aparte de

33
00:02:33,819 --> 00:02:36,120
declarar variables globales o locales

34
00:02:36,120 --> 00:02:38,139
en este tipo de programación

35
00:02:38,139 --> 00:02:40,280
también las declaramos públicas

36
00:02:40,280 --> 00:02:42,080
es decir, están disponibles

37
00:02:42,080 --> 00:02:44,020
fuera de la clase los atributos

38
00:02:44,020 --> 00:02:44,979
de los que hemos hablado antes

39
00:02:44,979 --> 00:02:47,020
mi coche tiene el atributo color

40
00:02:47,020 --> 00:02:49,419
si yo ese atributo no lo hago público

41
00:02:49,419 --> 00:02:51,539
luego no lo puedo declarar en mi objeto

42
00:02:51,539 --> 00:02:54,659
No le puedo decir, este objeto de esa clase tiene este color rojo.

43
00:02:55,039 --> 00:02:57,020
No, porque no es público.

44
00:02:57,139 --> 00:03:00,819
Así que si es un atributo que va a estar disponible fuera de la clase, tiene que ser público.

45
00:03:01,580 --> 00:03:06,580
Si va a ser un atributo que lo vamos a utilizar para las operaciones que hacemos dentro de la clase,

46
00:03:07,139 --> 00:03:09,080
pues tiene que ser privado, no accesible desde fuera.

47
00:03:09,159 --> 00:03:14,460
Así evitamos que alguien por error nos cambie una variable que en principio no debería tener acceso a él.

48
00:03:14,879 --> 00:03:19,680
Y existe otro tipo de variable un poco más delicada de la que nunca he hablado hasta ahora,

49
00:03:19,680 --> 00:03:24,120
que son las variables estáticas de las que hablaré luego,

50
00:03:24,400 --> 00:03:26,620
pero que sepamos que existen, que son unas variables

51
00:03:26,620 --> 00:03:29,400
cuyo valor se va repitiendo en todos los objetos.

52
00:03:29,759 --> 00:03:32,360
Antes he dicho que, por ejemplo, la variable o el atributo color

53
00:03:32,360 --> 00:03:36,639
luego en el objeto podría decirle, pues este objeto de coche es rojo,

54
00:03:36,800 --> 00:03:38,520
este objeto es azul, este objeto es verde.

55
00:03:39,340 --> 00:03:41,039
Pero en el caso, por ejemplo, de la cuenta bancaria

56
00:03:41,039 --> 00:03:43,699
a lo mejor hay un atributo que es el interés.

57
00:03:44,360 --> 00:03:47,000
Entonces a mí me interesa que el interés que se aplica

58
00:03:47,000 --> 00:03:48,939
a las cuentas bancarias siempre sea el mismo.

59
00:03:49,680 --> 00:03:57,900
Así que creo un atributo que se llama estático, que significa que todos los objetos comparten el valor de esa variable.

60
00:03:58,300 --> 00:04:03,919
Es más, si yo lo cambio en un objeto, por ejemplo, digo, ahora el interés no es del 85%, es del 80%,

61
00:04:03,919 --> 00:04:08,580
si lo cambio automáticamente todos los objetos que han instanciado esa clase actualizan el interés.

62
00:04:09,520 --> 00:04:13,580
Es también un poco complejo, pero luego también me pararé un momentito a hablar de las clases estáticas.

63
00:04:13,580 --> 00:04:22,060
Quedémonos con que yo ahora mismo voy a crear variables que sean públicas para poder acceder fuera de la clase

64
00:04:22,060 --> 00:04:25,699
Acordémonos que siempre tenemos que decir qué tipo de variable es

65
00:04:25,699 --> 00:04:28,660
Y le voy a llamar atributo1

66
00:04:28,660 --> 00:04:31,939
Aquí fijaros que sí que pongo en minúscula porque es una variable

67
00:04:31,939 --> 00:04:36,579
Voy a crear otra variable que va a ser de tipo integer, es decir, número entero

68
00:04:36,579 --> 00:04:37,720
Le voy a llamar atributo2

69
00:04:37,720 --> 00:04:40,639
Y voy incluso a crear un método

70
00:04:40,639 --> 00:04:59,079
Aquí, en este caso, también lo voy a declarar público. Esto es igual que en las variables. Si yo un método lo declaro público es que va a estar disponible en los objetos que instancie en la clase. Si es privado, no. Si es privado, el objeto no puede acceder al método. Pero este sí me interesa poder acceder desde mi objeto que luego instancie la clase.

71
00:04:59,079 --> 00:05:13,529
y lo voy a llamar, muy importante, decirle que va a devolver, ¿vale?

72
00:05:13,970 --> 00:05:18,689
Es decir, cuando declaro un método siempre le tengo que indicar qué tipo de parámetro va a devolver.

73
00:05:18,769 --> 00:05:20,069
En este caso no va a devolver ninguno.

74
00:05:20,689 --> 00:05:24,949
El nombre, que aquí también por convención, cuando llamo a métodos para diferenciarlo de las variables,

75
00:05:25,089 --> 00:05:26,029
lo ponemos con mayúscula.

76
00:05:26,850 --> 00:05:29,790
Y nada, y esto funciona como una función como las que hemos visto hasta ahora.

77
00:05:29,790 --> 00:05:32,790
Es decir, yo le podría pasar parámetros, le podría retornar un valor,

78
00:05:33,149 --> 00:05:36,949
entonces tendría que poner aquí un return, en fin, como lo que hemos visto en vídeos anteriores.

79
00:05:36,949 --> 00:05:42,310
Pero pensemos, por ejemplo, que en este caso lo único que voy a hacer es mandar un mensaje a consola.

80
00:05:44,110 --> 00:05:45,230
No va a hacer nada más.

81
00:05:45,430 --> 00:05:47,709
Pero bueno, lo normal es que un método haga muchas otras cosas.

82
00:05:48,529 --> 00:06:02,970
Por ejemplo, como hemos visto antes, si yo creo una variable privada de tipo boolean llamada resultado,

83
00:06:02,970 --> 00:06:10,720
pues a lo mejor el método lo que puede hacer es, y lo voy a declarar como false por determinado,

84
00:06:14,860 --> 00:06:20,259
pues a lo mejor lo que hace este método es cambiar el valor de esa variable booleana.

85
00:06:20,779 --> 00:06:24,920
Entonces, quiero que entendamos aquí que si yo he creado esta variable privada

86
00:06:24,920 --> 00:06:27,480
es porque no quiero que acceda nadie desde fuera de mi clase.

87
00:06:28,079 --> 00:06:31,379
El único que puede acceder a esta variable es la propia clase.

88
00:06:31,920 --> 00:06:36,360
Y por eso, como este método está dentro de la clase, pues sí que puede acceder a ello.

89
00:06:36,360 --> 00:06:37,259
Pero yo desde fuera no.

90
00:06:37,899 --> 00:06:39,800
Es una forma de proteger nuestras variables.

91
00:06:41,399 --> 00:06:46,699
Recuerdo que cada sistema de programación tiene su forma de llamar a las clases.

92
00:06:47,079 --> 00:06:50,660
A lo mejor nos toca estudiarlos y nos metemos en otro lenguaje.

93
00:06:51,060 --> 00:06:55,759
Me voy a centrar en Unity, obviamente, pero que sepamos que cómo se declaran o cómo se instancian unas clases

94
00:06:55,759 --> 00:06:57,360
depende del lenguaje de programación.

95
00:06:57,800 --> 00:07:02,980
Voy ahora mismo a instanciar esa clase que yo he creado y acceder a sus atributos y sus métodos.

96
00:07:03,120 --> 00:07:04,019
Veremos que es muy fácil.

97
00:07:04,019 --> 00:07:10,120
voy a instanciar el... crear un objeto de mi clase, lo que se llama instanciar la clase

98
00:07:10,120 --> 00:07:13,240
aquí le voy a decir que cree una variable

99
00:07:13,240 --> 00:07:18,939
normalmente le indicamos cuando vamos a crear una variable si es de tipo string, si es de tipo float

100
00:07:18,939 --> 00:07:24,379
en fin, pero en este caso no quiero un tipo de variable de ese tipo

101
00:07:24,379 --> 00:07:27,819
quiero un tipo de variable myClass

102
00:07:27,819 --> 00:07:31,720
y tengo acceso a ese tipo de variables, ¿por qué?

103
00:07:31,800 --> 00:07:33,079
porque hay una clase que se llama así

104
00:07:33,079 --> 00:07:42,459
Así que puedo disponer de ellos. Ya veremos que en Unity disponemos de muchas variables heredadas del MonoBehaviour. Luego hablaremos de ello.

105
00:07:42,980 --> 00:07:51,160
Ahora le doy un nombre a ese tipo de variable. Como podemos ver, él me sugiere llamarle con el nombre de la clase, pero en minúscula.

106
00:07:51,879 --> 00:07:59,379
Es habitual crear objetos de una clase, pero con el mismo nombre de la clase, pero en minúscula, para diferenciarlas.

107
00:07:59,379 --> 00:08:02,879
si está en minúsculas nos estamos refiriendo a un objeto de la clase

108
00:08:02,879 --> 00:08:05,620
y si está en mayúsculas nos estamos refiriendo a la clase

109
00:08:05,620 --> 00:08:09,779
pero bueno, para no liarlo y para no crear aquí muchos nombres

110
00:08:09,779 --> 00:08:11,180
a esto le voy a llamar mi objeto

111
00:08:11,180 --> 00:08:13,100
porque es un objeto de la clase

112
00:08:13,100 --> 00:08:18,399
lo pongo en minúscula para indicar que efectivamente es un objeto

113
00:08:18,399 --> 00:08:20,860
¿y cuál es el valor de esta variable?

114
00:08:22,379 --> 00:08:26,819
pues indico que es un nuevo objeto de una clase

115
00:08:26,819 --> 00:08:28,439
¿de cuál? de esta

116
00:08:28,439 --> 00:08:32,200
Y aquí sí tengo que terminar con paréntesis para cerrar.

117
00:08:33,379 --> 00:08:34,539
Muy importante.

118
00:08:34,779 --> 00:08:38,960
Cuando estemos instanciando una clase, le tenemos que poner los paréntesis aquí.

119
00:08:39,440 --> 00:08:39,759
Y ya está.

120
00:08:40,600 --> 00:08:42,139
Me interesa mucho que quede esto claro.

121
00:08:43,259 --> 00:08:49,320
Una clase lo puedo instanciar tantas veces como quiera y cuando la instancio lo asigno a una variable.

122
00:08:49,679 --> 00:08:50,779
¿Una variable de qué tipo?

123
00:08:51,100 --> 00:08:53,639
Del tipo de la clase que he creado.

124
00:08:54,320 --> 00:08:55,620
¿Y cuál es el valor de esa variable?

125
00:08:56,039 --> 00:08:56,840
Pues la instancia.

126
00:08:56,840 --> 00:09:02,600
Vale, esta sintaxis que es un poco liosa nos acostumbramos porque estaremos instanciando constantemente.

127
00:09:02,960 --> 00:09:18,240
La cuestión está en que ahora en este objeto, en mi objeto, tengo disponibles todos los atributos públicos, importante, tendré disponible el atributo 1, el atributo 2 y sin embargo el atributo resultado no lo tendré disponible porque es privado.

128
00:09:18,899 --> 00:09:23,100
Y tendré también disponible los métodos que en este caso sean públicos.

129
00:09:23,100 --> 00:09:28,779
Vamos a comprobarlo. Me voy a ir al método Start, porque si lo hago fuera no me va a permitir acceder a esa nueva variable.

130
00:09:29,639 --> 00:09:34,379
Y dentro, si empiezo a escribir mi objeto, vemos que me reconoce ya esa variable, como que existe.

131
00:09:35,399 --> 00:09:47,100
Y aquí viene lo interesante. Si escribo un punto, automáticamente el entorno de desarrollo me reconoce que esto es un objeto de la clase MyClass.

132
00:09:47,100 --> 00:09:55,440
y que a su vez tiene disponibles atributos, si vemos aquí estos son los campos o los atributos y estos son los métodos,

133
00:09:55,440 --> 00:10:08,059
pues tiene disponibles el atributo 1, el atributo 2, el método myMethod y luego ya otros métodos que vienen por defecto en Unity,

134
00:10:08,179 --> 00:10:14,519
pero no vamos a profundizar, solo veamos que efectivamente tengo disponible el método que yo he creado.

135
00:10:14,519 --> 00:10:18,500
y ahí es donde nosotros a este objeto que he creado

136
00:10:18,500 --> 00:10:20,019
pues le podemos empezar a decir

137
00:10:20,019 --> 00:10:23,179
pues mi atributo 1 es igual a Hola

138
00:10:23,179 --> 00:10:31,600
y el atributo 2 es igual a Cuidado

139
00:10:31,600 --> 00:10:35,279
porque yo aquí le he dicho que el atributo 2 es de tipo Entreguir

140
00:10:35,279 --> 00:10:36,100
así que Cuidado

141
00:10:36,100 --> 00:10:44,299
porque si le doy, como podemos ver, le doy un valor de cadena de texto

142
00:10:44,299 --> 00:10:46,100
me señala que hay un error grave

143
00:10:46,100 --> 00:10:50,480
¿Por qué? Porque este atributo es de tipo integir.

144
00:10:50,940 --> 00:11:00,500
Y por supuesto puedo llamar a mis métodos, terminando con paréntesis,

145
00:11:00,620 --> 00:11:02,759
porque obviamente esto es como si fuese una función.

146
00:11:03,480 --> 00:11:06,480
Donde además si tuviésemos que pasarle variables, se los pasaríamos ahí.

147
00:11:07,139 --> 00:11:09,419
Quiero que luego cuando empecemos a trabajar con Unity,

148
00:11:09,919 --> 00:11:14,279
veremos que estamos constantemente llamando a clases que no hemos declarado nosotros,

149
00:11:14,399 --> 00:11:15,639
pero que están disponibles para nosotros.

150
00:11:15,820 --> 00:11:18,399
Eso de nuevo es otra de las características de la programación orientada a objetos,

151
00:11:18,399 --> 00:11:20,960
que se llama herencia y que también lo veremos ahora.

152
00:11:21,559 --> 00:11:25,620
Pero tenemos que saber que cuando estamos llamando a una clase

153
00:11:25,620 --> 00:11:28,179
la estamos instanciando y una vez que la hemos instanciado

154
00:11:28,179 --> 00:11:31,980
tenemos a nuestra disposición los objetos y métodos de esa clase.

155
00:11:32,340 --> 00:11:35,960
Voy a poner un ejemplo, aunque más adelante lo desarrollaremos en Unity.

156
00:11:36,600 --> 00:11:39,539
Por ejemplo, veremos muy a menudo que en Unity

157
00:11:39,539 --> 00:11:42,919
estaremos llamando a variables de tipo vector3

158
00:11:42,919 --> 00:11:45,159
que ahora sabemos que son realmente clases.

159
00:11:45,740 --> 00:11:47,539
¿Y de dónde vienen esas clases? De aquí.

160
00:11:48,399 --> 00:11:50,940
Las está heredando, sencillamente.

161
00:11:51,899 --> 00:12:01,509
Y aquí le damos un nombre, en mayúscula, y le damos un valor.

162
00:12:01,850 --> 00:12:09,789
¿Y cuál es el valor? Pues, efectivamente, es una instancia de la clase Vector3.

163
00:12:10,009 --> 00:12:15,669
Así que tengo una variable de tipo Vector3 que ha instanciado la clase Vector3.

164
00:12:15,669 --> 00:12:22,190
Eso significa que ahora, igual que he hecho antes, si yo ahora escribo esta variable que he creado y le doy un punto,

165
00:12:22,730 --> 00:12:29,750
veremos a continuación que tenemos a nuestra disposición muchos atributos y muchos métodos propios de esa clase.

166
00:12:30,129 --> 00:12:33,769
De hecho, por ejemplo, tenemos aquí x, y, z, que son atributos de ese vector,

167
00:12:34,250 --> 00:12:42,590
donde yo le puedo decir que este vector tenga un valor de x cero, es decir, que se coloque en la posición cero del eje x.

168
00:12:43,889 --> 00:12:51,269
Así que nada, con la mente puesta en clases y objetos, instancias, atributos, métodos, es como enfrentaremos la programación en Unity.

169
00:12:52,190 --> 00:12:52,769
CC por Antarctica Films Argentina