Activa JavaScript para disfrutar de los vídeos de la Mediateca.
Primeros pasos en Unity. POO parte 2 - Contenido educativo
Ajuste de pantallaEl ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:
Segunda parte de los 3 videos que componen una explicación sobre qué es la Programación Orientada a Objetos. Ahora veremos cómo se aplica a C# para Unity.
Bien, antes de meterme en los conceptos un poco más abstractos de la programación orientada a objetos,
00:00:07
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.
00:00:14
Concretamente en código en C-Sharp y concretamente en C-Sharp para Unity,
00:00:19
que tiene sus peculiaridades, pero como es el que vamos a usar, pues directamente parto de un script creado para Unity.
00:00:23
Mi entorno de desarrollo ya me está avisando de aquí de un error, y es lo que he comentado antes,
00:00:28
que hay que seguir ciertas ciertas convenciones y él me está avisando como
00:00:33
podemos ver es un error no grave por eso no me lo indica ni en rojo ni en
00:00:38
amarillo ni nada pero me está diciendo que al ser eso una clase debería empezar
00:00:41
con mayúscula porque empieza con minúscula porque yo cuando cree este
00:00:46
script en unity pues lo cree con minúscula y él automáticamente creó una
00:00:50
clase con el nombre del archivo vale de hecho ahí está el archivo
00:00:55
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.
00:01:00
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.
00:01:09
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,
00:01:19
pero digamos que no era tan fácil como cuando programábamos en javascript
00:01:25
que podíamos empezar a escribir código y ya está
00:01:29
no, hay que seguir cierta estructura en cuanto a dónde están disponibles mis variables
00:01:31
mis métodos, mis clases, toda una historia que incluso a mí se me escapa
00:01:36
pero vamos a crear nuestra propia clase
00:01:39
por ejemplo, ya que estamos aquí voy a crear una clase mía
00:01:42
la voy a crear pública, ¿para qué? para que esté disponible fuera
00:01:46
y así otros pueden llamar a esta clase y crear objetos aunque estén fuera de este script
00:01:49
Y aquí definimos que es una clase, no es una variable ni nada, es una clase.
00:01:55
Aquí le damos el nombre que queremos, como he comentado antes, en mayúscula,
00:02:01
y directamente creamos las llaves que indican todo lo que contiene mi clase.
00:02:07
¿Y qué va a contener mi clase? Pues, por ejemplo, sus atributos.
00:02:14
Muy importante. Y aquí es donde empezamos a entender el ámbito de las variables de las clases.
00:02:18
ya comenté en un vídeo anterior
00:02:22
cuando hablaba del ámbito del scope
00:02:25
de las variables, es que en programación orientada
00:02:27
a objetos es un poco más complejo en el sentido de que
00:02:29
aparte de
00:02:32
declarar variables globales o locales
00:02:33
en este tipo de programación
00:02:36
también las declaramos públicas
00:02:38
es decir, están disponibles
00:02:40
fuera de la clase los atributos
00:02:42
de los que hemos hablado antes
00:02:44
mi coche tiene el atributo color
00:02:44
si yo ese atributo no lo hago público
00:02:47
luego no lo puedo declarar en mi objeto
00:02:49
No le puedo decir, este objeto de esa clase tiene este color rojo.
00:02:51
No, porque no es público.
00:02:55
Así que si es un atributo que va a estar disponible fuera de la clase, tiene que ser público.
00:02:57
Si va a ser un atributo que lo vamos a utilizar para las operaciones que hacemos dentro de la clase,
00:03:01
pues tiene que ser privado, no accesible desde fuera.
00:03:07
Así evitamos que alguien por error nos cambie una variable que en principio no debería tener acceso a él.
00:03:09
Y existe otro tipo de variable un poco más delicada de la que nunca he hablado hasta ahora,
00:03:14
que son las variables estáticas de las que hablaré luego,
00:03:19
pero que sepamos que existen, que son unas variables
00:03:24
cuyo valor se va repitiendo en todos los objetos.
00:03:26
Antes he dicho que, por ejemplo, la variable o el atributo color
00:03:29
luego en el objeto podría decirle, pues este objeto de coche es rojo,
00:03:32
este objeto es azul, este objeto es verde.
00:03:36
Pero en el caso, por ejemplo, de la cuenta bancaria
00:03:39
a lo mejor hay un atributo que es el interés.
00:03:41
Entonces a mí me interesa que el interés que se aplica
00:03:44
a las cuentas bancarias siempre sea el mismo.
00:03:47
Así que creo un atributo que se llama estático, que significa que todos los objetos comparten el valor de esa variable.
00:03:49
Es más, si yo lo cambio en un objeto, por ejemplo, digo, ahora el interés no es del 85%, es del 80%,
00:03:58
si lo cambio automáticamente todos los objetos que han instanciado esa clase actualizan el interés.
00:04:03
Es también un poco complejo, pero luego también me pararé un momentito a hablar de las clases estáticas.
00:04:09
Quedémonos con que yo ahora mismo voy a crear variables que sean públicas para poder acceder fuera de la clase
00:04:13
Acordémonos que siempre tenemos que decir qué tipo de variable es
00:04:22
Y le voy a llamar atributo1
00:04:25
Aquí fijaros que sí que pongo en minúscula porque es una variable
00:04:28
Voy a crear otra variable que va a ser de tipo integer, es decir, número entero
00:04:31
Le voy a llamar atributo2
00:04:36
Y voy incluso a crear un método
00:04:37
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.
00:04:40
y lo voy a llamar, muy importante, decirle que va a devolver, ¿vale?
00:04:59
Es decir, cuando declaro un método siempre le tengo que indicar qué tipo de parámetro va a devolver.
00:05:13
En este caso no va a devolver ninguno.
00:05:18
El nombre, que aquí también por convención, cuando llamo a métodos para diferenciarlo de las variables,
00:05:20
lo ponemos con mayúscula.
00:05:25
Y nada, y esto funciona como una función como las que hemos visto hasta ahora.
00:05:26
Es decir, yo le podría pasar parámetros, le podría retornar un valor,
00:05:29
entonces tendría que poner aquí un return, en fin, como lo que hemos visto en vídeos anteriores.
00:05:33
Pero pensemos, por ejemplo, que en este caso lo único que voy a hacer es mandar un mensaje a consola.
00:05:36
No va a hacer nada más.
00:05:44
Pero bueno, lo normal es que un método haga muchas otras cosas.
00:05:45
Por ejemplo, como hemos visto antes, si yo creo una variable privada de tipo boolean llamada resultado,
00:05:48
pues a lo mejor el método lo que puede hacer es, y lo voy a declarar como false por determinado,
00:06:02
pues a lo mejor lo que hace este método es cambiar el valor de esa variable booleana.
00:06:14
Entonces, quiero que entendamos aquí que si yo he creado esta variable privada
00:06:20
es porque no quiero que acceda nadie desde fuera de mi clase.
00:06:24
El único que puede acceder a esta variable es la propia clase.
00:06:28
Y por eso, como este método está dentro de la clase, pues sí que puede acceder a ello.
00:06:31
Pero yo desde fuera no.
00:06:36
Es una forma de proteger nuestras variables.
00:06:37
Recuerdo que cada sistema de programación tiene su forma de llamar a las clases.
00:06:41
A lo mejor nos toca estudiarlos y nos metemos en otro lenguaje.
00:06:47
Me voy a centrar en Unity, obviamente, pero que sepamos que cómo se declaran o cómo se instancian unas clases
00:06:51
depende del lenguaje de programación.
00:06:55
Voy ahora mismo a instanciar esa clase que yo he creado y acceder a sus atributos y sus métodos.
00:06:57
Veremos que es muy fácil.
00:07:03
voy a instanciar el... crear un objeto de mi clase, lo que se llama instanciar la clase
00:07:04
aquí le voy a decir que cree una variable
00:07:10
normalmente le indicamos cuando vamos a crear una variable si es de tipo string, si es de tipo float
00:07:13
en fin, pero en este caso no quiero un tipo de variable de ese tipo
00:07:18
quiero un tipo de variable myClass
00:07:24
y tengo acceso a ese tipo de variables, ¿por qué?
00:07:27
porque hay una clase que se llama así
00:07:31
Así que puedo disponer de ellos. Ya veremos que en Unity disponemos de muchas variables heredadas del MonoBehaviour. Luego hablaremos de ello.
00:07:33
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.
00:07:42
Es habitual crear objetos de una clase, pero con el mismo nombre de la clase, pero en minúscula, para diferenciarlas.
00:07:51
si está en minúsculas nos estamos refiriendo a un objeto de la clase
00:07:59
y si está en mayúsculas nos estamos refiriendo a la clase
00:08:02
pero bueno, para no liarlo y para no crear aquí muchos nombres
00:08:05
a esto le voy a llamar mi objeto
00:08:09
porque es un objeto de la clase
00:08:11
lo pongo en minúscula para indicar que efectivamente es un objeto
00:08:13
¿y cuál es el valor de esta variable?
00:08:18
pues indico que es un nuevo objeto de una clase
00:08:22
¿de cuál? de esta
00:08:26
Y aquí sí tengo que terminar con paréntesis para cerrar.
00:08:28
Muy importante.
00:08:33
Cuando estemos instanciando una clase, le tenemos que poner los paréntesis aquí.
00:08:34
Y ya está.
00:08:39
Me interesa mucho que quede esto claro.
00:08:40
Una clase lo puedo instanciar tantas veces como quiera y cuando la instancio lo asigno a una variable.
00:08:43
¿Una variable de qué tipo?
00:08:49
Del tipo de la clase que he creado.
00:08:51
¿Y cuál es el valor de esa variable?
00:08:54
Pues la instancia.
00:08:56
Vale, esta sintaxis que es un poco liosa nos acostumbramos porque estaremos instanciando constantemente.
00:08:56
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.
00:09:02
Y tendré también disponible los métodos que en este caso sean públicos.
00:09:18
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.
00:09:23
Y dentro, si empiezo a escribir mi objeto, vemos que me reconoce ya esa variable, como que existe.
00:09:29
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.
00:09:35
y que a su vez tiene disponibles atributos, si vemos aquí estos son los campos o los atributos y estos son los métodos,
00:09:47
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,
00:09:55
pero no vamos a profundizar, solo veamos que efectivamente tengo disponible el método que yo he creado.
00:10:08
y ahí es donde nosotros a este objeto que he creado
00:10:14
pues le podemos empezar a decir
00:10:18
pues mi atributo 1 es igual a Hola
00:10:20
y el atributo 2 es igual a Cuidado
00:10:23
porque yo aquí le he dicho que el atributo 2 es de tipo Entreguir
00:10:31
así que Cuidado
00:10:35
porque si le doy, como podemos ver, le doy un valor de cadena de texto
00:10:36
me señala que hay un error grave
00:10:44
¿Por qué? Porque este atributo es de tipo integir.
00:10:46
Y por supuesto puedo llamar a mis métodos, terminando con paréntesis,
00:10:50
porque obviamente esto es como si fuese una función.
00:11:00
Donde además si tuviésemos que pasarle variables, se los pasaríamos ahí.
00:11:03
Quiero que luego cuando empecemos a trabajar con Unity,
00:11:07
veremos que estamos constantemente llamando a clases que no hemos declarado nosotros,
00:11:09
pero que están disponibles para nosotros.
00:11:14
Eso de nuevo es otra de las características de la programación orientada a objetos,
00:11:15
que se llama herencia y que también lo veremos ahora.
00:11:18
Pero tenemos que saber que cuando estamos llamando a una clase
00:11:21
la estamos instanciando y una vez que la hemos instanciado
00:11:25
tenemos a nuestra disposición los objetos y métodos de esa clase.
00:11:28
Voy a poner un ejemplo, aunque más adelante lo desarrollaremos en Unity.
00:11:32
Por ejemplo, veremos muy a menudo que en Unity
00:11:36
estaremos llamando a variables de tipo vector3
00:11:39
que ahora sabemos que son realmente clases.
00:11:42
¿Y de dónde vienen esas clases? De aquí.
00:11:45
Las está heredando, sencillamente.
00:11:48
Y aquí le damos un nombre, en mayúscula, y le damos un valor.
00:11:51
¿Y cuál es el valor? Pues, efectivamente, es una instancia de la clase Vector3.
00:12:01
Así que tengo una variable de tipo Vector3 que ha instanciado la clase Vector3.
00:12:10
Eso significa que ahora, igual que he hecho antes, si yo ahora escribo esta variable que he creado y le doy un punto,
00:12:15
veremos a continuación que tenemos a nuestra disposición muchos atributos y muchos métodos propios de esa clase.
00:12:22
De hecho, por ejemplo, tenemos aquí x, y, z, que son atributos de ese vector,
00:12:30
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.
00:12:34
Así que nada, con la mente puesta en clases y objetos, instancias, atributos, métodos, es como enfrentaremos la programación en Unity.
00:12:43
CC por Antarctica Films Argentina
00:12:52
- Idioma/s:
- Materias:
- Programación
- Niveles educativos:
- ▼ Mostrar / ocultar niveles
- Formación Profesional
- Ciclo formativo de grado superior
- Primer Curso
- Segundo Curso
- Autor/es:
- Alvaro Holguera Gozalo
- Subido por:
- Alvaro H.
- Licencia:
- Reconocimiento - No comercial - Compartir igual
- Visualizaciones:
- 67
- Fecha:
- 11 de septiembre de 2025 - 20:37
- Visibilidad:
- Público
- Centro:
- CFP JOSÉ LUIS GARCI
- Descripción ampliada:
- Cómo se crean clases en C# para Unity y se instancian en objetos.
- Duración:
- 12′ 53″
- Relación de aspecto:
- 1.78:1
- Resolución:
- 1920x1080 píxeles
- Tamaño:
- 300.58 MBytes