Saltar navegación

20241129 Objetos 2 - Contenido educativo - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 29 de noviembre de 2024 por Stefano C.

21 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, segunda parte sobre objetos, ¿vale? 00:00:00
Si habláis, me dais la autorización a grabaros. 00:00:05
Entonces, hemos estado hablando del concepto de clase, el concepto de objetos, ¿vale? 00:00:08
La clase es un molde general que define las características generales del concepto que estoy modelizando 00:00:12
y luego a partir de este molde general voy a crear objetos concretos, instancias concretas de esta clase 00:00:21
que serán todos con la misma estructura pero con valores concretos distintos, ¿vale? 00:00:30
Entonces, este es un ejemplo, hemos dicho, de cómo se crea una clase, ¿vale? 00:00:38
Esta es la clase Persona, a continuación pongo sus atributos, o sea, las características relevantes para mí, para una persona, que son el nombre y la edad en este caso. 00:00:44
Luego, después, los métodos que hacen, o sea, los comportamientos, las funcionalidades que implementa una persona, lo que puede hacer una persona. 00:00:54
Que serán métodos sin el static, ¿vale? 00:01:04
Finalmente puedo tener o no, ahora veremos ejemplos 00:01:07
Un método main que es el punto de acceso de mi programa 00:01:11
Donde aquí crearé los objetos, los haré interactuar, haré que hagan lo que tienen que hacer 00:01:15
¿Vale? Ya veremos que hacemos aquí 00:01:20
Entonces, la clase en un archivo puede haber solo una clase pública 00:01:23
Puede haber más de una clase, pero la clase pública es una sola 00:01:32
Y tiene que llamarse con el nombre de la clase .java, ya lo hemos dicho 00:01:35
Los atributos de una clase son propios de la misma y se podrán consultar internamente por parte de los métodos de la misma 00:01:38
Vale, esto lo hemos dicho 00:01:45
Objetos, vale 00:01:46
Un objeto es un elemento concreto de la clase definida 00:01:47
Una instancia de clase, un objeto creado a partir del molde 00:01:51
Una configuración concreta de todas las posibles configuraciones que podría haber en esa clase 00:01:56
O sea, cuando yo digo una persona tiene un nombre, me vale cualquier nombre 00:02:09
Pero luego habrá la persona que se llama Estefano, esa es una persona concreta 00:02:13
En el momento de la ejecución, cuidado 00:02:18
Cuando se ejecuta, cuando se lanza el programa 00:02:23
Es cuando se crean los objetos 00:02:27
Yo en el programa diré que aquí me creas un objeto con una new o cosa por el estilo 00:02:30
Cuando vosotros hacéis scanner, scanner es igual a new scanner 00:02:34
Allí le estáis diciendo, mira, cuando pasará por aquí el flujo de ejecuciones del programa 00:02:37
Aquí es donde creará un objeto 00:02:43
Pero en tiempo de compilación, mientras nosotros estamos programando, el objeto no existe 00:02:45
Se creará cuando se ejecuta el programa 00:02:52
Cuando yo le digo, venga, le doy al triangulito verde, le digo, lanza el programa 00:02:56
El programa encontrará la instrucción new y es en ese momento que hará todo el trabajo que tiene que hacer para crear un objeto 00:03:00
¿Quién lo hace? Pues la Java Virtual Machine 00:03:09
El Java Virtual Machine interpretará el comando new como vete a la zona de memoria reservada para este proceso, recorta un trocito de esa memoria y guárdalo porque ese trocito de memoria ahora tiene un significado, ahora es un objeto. 00:03:11
Y dentro de este trocito de objeto, ponle los datos que tienes que ponerle. 00:03:28
Ahora veremos cómo. 00:03:33
Entonces es el momento de ejecutar que se crean los objetos de las clases para los cuales hemos escrito código 00:03:34
Cada objeto tendrá un nombre para poder reutilizarlo en nuestro programa 00:03:42
Cuidado, este nombre no es este nombre 00:03:48
Es el nombre que le doy yo a la variable que será un manejador, un handler en inglés de este objeto 00:03:52
Cuando yo hago scannerScan, ese scan es este nombre de aquí 00:04:03
Es una referencia a este objeto 00:04:11
Es como yo en el código luego puedo decir 00:04:16
Mira, ¿te acuerdas el objeto que has creado? 00:04:18
Pues ahora haz algo sobre ese objeto 00:04:21
Pues lo he llamado scan 00:04:22
Ahora cuando hago scan.next estoy diciendo llama el método next sobre el objeto scan 00:04:24
¿Se entiende? 00:04:32
Entonces, un objeto va a tener una identidad 00:04:35
Es decir, quién es, cómo se refiere a eso 00:04:38
Este nombre del que hablamos aquí 00:04:41
El nombre que le habré dado yo cuando lo he creado y metido en una variable 00:04:42
O en un array 00:04:46
Los atributos que conformarán su estado 00:04:48
Es decir, el valor de todos los atributos que tiene ese objeto 00:04:52
Yo le he puesto nombre y edad 00:04:58
Pues el valor de nombre y el valor de edad conforman, constituyen el estado de este objeto. 00:05:00
En este momento se llama Estefano y tiene 43 años. 00:05:08
Mañana cumple los años, pues ahora tiene Estefano y tiene 44 años. 00:05:12
¿Se entiende? El estado de un objeto es una fotografía de todos sus atributos y el valor que tienen en este momento. 00:05:17
Y luego están los métodos que definen el comportamiento de este objeto. 00:05:24
¿Qué puede hacer este objeto? 00:05:28
Yo los defino en abstracto, en general, en la clase y luego cuando creo un objeto, este objeto podrá hacer estos métodos que he definido abstractamente, pero utilizando los valores propios de ese objeto. 00:05:30
Yo he definido que el método saluda dice hola, pon tu nombre y luego diga ahí tengo, pon tu edad, años, cuando lo llamaré sobre persona 1, este objeto usará como nombre Paco y como edad 30. 00:05:49
Este objeto usará como nombre Sara y como edad 25. 00:06:08
Sería el identificador que he utilizado 00:06:12
Esto se haría con 00:06:18
Si es una persona 00:06:19
Persona, persuno 00:06:20
Es igual a new persona 00:06:23
De todas formas ahora como creamos un objeto 00:06:25
Lo vemos en dos minutos 00:06:28
La identidad 00:06:29
Los objetos se crean en la memoria RAM 00:06:36
Vosotros sabéis que hay dos memorias 00:06:38
Hay la memoria RAM 00:06:39
Y la memoria disco duro 00:06:41
Secundaria 00:06:44
Que es la que cuando apagáis 00:06:45
No se borra 00:06:47
La RAM, cada vez que apagáis el ordenador, se borra casi por completo, hoy en día hay dudas, pero se debería borrar todo, entonces entre una ejecución y otra he destruido todo lo que tenía en RAM y por lo tanto no tengo las variables que había usado antes. 00:06:48
Si quiero guardar entre ejecución algo de datos, tendré que usar ficheros, y eso lo veremos al final del curso. 00:07:05
Su identidad se definirá como un valor de referencia único del objeto 00:07:11
¿Os acordáis cuando yo os decía, creo una variable y aquí dentro está un numerito que apunta al objeto de verdad? 00:07:17
Pues ese numerito es la identidad, la referencia al objeto 00:07:27
Cada vez que yo usaré ese numerito, ese código, estoy referenciando un objeto concreto 00:07:32
Si yo copio esa referencia, tendré dos referencias al mismo objeto 00:07:38
En Java no se trabaja con direcciones de memoria 00:07:43
Se usa un concepto más abstracto, nombres simbólicos que identifican un objeto 00:07:47
Esto es los nombres que le damos, las variables al fin y al cabo 00:07:51
Un objeto es un valor que se puede asignar a una variable cuyo tipo es la clase misma 00:07:55
La clase define el tipo 00:08:01
El objeto es un valor específico de este tipo 00:08:04
Es decir, que cuando vosotros hacéis scanner, scan, estáis creando una variable. ¿Cómo se llama la variable? Scan. ¿De qué tipo es la variable? Scanner. ¿Y qué es scanner? Una clase del que yo estoy creando un objeto. 00:08:07
Cuando vosotros hacéis string gato es igual a algo, ¿qué es esto? Una variable. ¿Cómo se llama esta variable? Gato. ¿Qué tipo tiene? ¿String qué es? Una clase, del que yo estoy creando un objeto. 00:08:32
¿Se entiende? 00:08:53
Cualquier clase que vosotros creáis 00:08:55
Es sustancialmente un nuevo tipo 00:08:57
Nosotros tenemos los tipos primitivos 00:09:00
Int, flow, at, bla bla bla 00:09:03
Y luego hemos usado al menos dos otros tipos 00:09:06
Sin saber muy bien cómo utilizarlo 00:09:09
Pero hemos usado scanner 00:09:11
Que lo usamos como tipo 00:09:12
¿Os acordáis que en una declaración de variable es 00:09:13
Tipo, nombre de la variable, igual valor 00:09:15
Y nosotros usamos scanner 00:09:19
Scanner es igual a new scanner 00:09:20
Pues scanner es el tipo de esta variable 00:09:22
Y scanner es una clase 00:09:25
Cada vez que defino una clase 00:09:27
La puedo usar para definir un tipo 00:09:29
Mi clase persona 00:09:32
Está definiendo el tipo persona 00:09:35
Que serán objetos con una determinada estructura 00:09:37
Tendrán nombre y edad 00:09:40
Entonces podré crear 00:09:42
Una variable persona 00:09:44
Que se llama persona1 00:09:46
Y dentro le meteré un objeto de tipo persona 00:09:48
La clase define el tipo y por lo tanto puedo crear una variable del tipo de la clase 00:09:52
La clase coche, una vez definida, yo puedo hacer coche, mi coche es igual a new coche, bla bla bla 00:10:02
Esto de aquí 00:10:13
Si queremos crear un objeto de tipo persona, podemos crear persona alumno 00:10:16
alumno es el nombre de la variable 00:10:22
y persona es que te está diciendo que este de aquí será un objeto 00:10:25
que tiene como tipo persona 00:10:30
vete a la clase persona y mírate cuáles son sus atributos 00:10:33
y sabrás la estructura del alumno 00:10:37
vete a la clase persona y mírate los métodos 00:10:40
y sabrás qué puede hacer este alumno 00:10:43
los atributos, ¿vale? son las características que define el objeto 00:10:46
Repito que los pongo en la clase como abstracto 00:10:55
Y luego en los instancios le doy un valor concreto cuando creo un objeto 00:10:58
Cada atributo tiene una visibilidad 00:11:03
Que es public, private, protected 00:11:06
Por ahora lo dejamos allí 00:11:09
Es donde puedo ver esta variable 00:11:11
Si la puedo ver solo dentro del objeto 00:11:13
O si la puedo ver también desde fuera del objeto 00:11:16
Hablaremos de esto más adelante 00:11:19
Un tipo que puede ser primitivo 00:11:20
Puede ser un int como edad 00:11:24
o puede ser 00:11:25
otro objeto 00:11:28
como por ejemplo cuando pongo string 00:11:30
nombre, string es otro 00:11:32
objeto en realidad 00:11:34
identificador 00:11:35
del atributo 00:11:38
que es el nombre 00:11:39
que doy a este atributo, por ejemplo 00:11:42
nombre o por ejemplo edad 00:11:44
todo esto ahora lo vemos en práctica 00:11:45
pero es porque 00:11:48
necesito llegar a los constructores porque 00:11:50
si no, no podemos construir objetos 00:11:52
Por ejemplo, la persona tiene nombre y edad como atributos 00:11:54
Entonces tendrá nombre que es un string, que es una clase 00:12:00
Este tipo string en realidad es una clase, es un objeto 00:12:03
Y edad que es de tipo int, que es un tipo primitivo 00:12:08
El estado de un objeto está definido por los valores de sus atributos en un momento concreto 00:12:13
El estado puede variar al cambiar los valores del atributo 00:12:20
Si yo tengo una persona que se llama Estefano con 40 años, pues ahora su estado es Estefano con 40 años. 00:12:23
Si de mañana ejecuto el método cumplir años, o cumpleaños feliz, pues lo que hace es sumarle 1 a los 40 y ahora su estado es nombre Estefano y edad 41, porque ha cumplido los años. 00:12:30
¿Dudas? 00:12:47
Y luego tenemos los métodos, ¿vale? 00:12:48
Estamos aquí, estamos haciendo esto, identidad, tributos y métodos. 00:12:52
identidad, hemos visto identidad, atributos y métodos 00:12:55
los métodos pueden proporcionar unos servicios a otros objetos 00:12:59
pueden hacer algo, son los que yo tengo un objeto 00:13:03
y que puede hacer este objeto, que puede hacer string 00:13:07
si yo tengo un string, que puede hacer, que puedo pedir que haga 00:13:10
que le pedimos nosotros a string s, string s es igual a 00:13:16
hola, que puede hacer, s.length 00:13:29
Un servicio, dame cuantos caracteres contienes 00:13:33
Pues eso es algo que hace string 00:13:36
Otros 00:13:39
Equals 00:13:40
Esto es una función de string 00:13:42
Que se permite compararse con otro objeto string 00:13:46
Y decirme si somos iguales o no 00:13:50
¿Qué más servicios me proporciona? 00:13:52
Tu uppercase 00:13:58
Soy una string 00:13:58
Voy a darte una versión de mí mismo 00:14:00
Pero toda en mayúsculas 00:14:03
Todas estas son métodos que proporciona la clase string a quien quiera utilizarlo, y todo lo que hemos visto en la tanda de ejercicio de string. 00:14:05
Un método suele tener un nombre, por ejemplo, tu string, perdón, lo que hemos dicho ahora, tu uppercase o length, ese es el nombre del método. 00:14:16
Unos parámetros, por ejemplo, length no tiene ningún parámetro 00:14:30
Es abierta paréntesis, cerrada paréntesis 00:14:34
Pero el equals, para poder comparar dos 00:14:37
Tienes que pasarle como parámetro el segundo string con el que vas a comparar 00:14:40
Este string es .equals, abierta paréntesis 00:14:45
Y el segundo string que hace para ver si estos dos son iguales 00:14:49
Entonces admite un parámetro 00:14:53
Los parámetros que se hacen, como habéis hecho las funciones y los procedimientos. 00:14:56
Lo hemos visto ayer, por ejemplo, en los ejemplos que hemos hecho en la pizarra. 00:15:02
Y un valor que devuelve a quien ha llamado el método. 00:15:06
O sea, el return. 00:15:10
Que si no quiero devolver nada, será null. 00:15:13
Será void. 00:15:17
¿Sí? 00:15:19
Es importante saber qué métodos implementa una clase, 00:15:21
qué parámetros tienen los métodos 00:15:23
y que devuelven para que otros programas 00:15:26
puedan usar esos métodos 00:15:28
no es importante cómo hace las cosas 00:15:30
sino lo que puede hacer 00:15:34
yo no sé cómo se calcula la longitud de una string 00:15:35
¿sabéis cómo se hace dentro length? 00:15:40
¿estás seguro? 00:15:45
¿estás seguro que hace un for 00:15:47
y va haciendo y más más por cada posición? 00:15:48
o que dentro lo guarda como un array 00:15:52
y devuelve el atributo length del array 00:15:56
o que, ¿sabes cómo se hace? 00:15:59
No me interesa saber cómo se hace, ¿vale? 00:16:02
Yo sé que la string puede darme su longitud 00:16:05
como se hace por dentro no es importante 00:16:08
¿Sí? 00:16:12
Una clase, ¿vale? 00:16:18
Entonces, esta de aquí, por ejemplo 00:16:20
es un ejemplo de clase, la clase persona 00:16:21
public class persona 00:16:24
tiene string apellido 00:16:26
string nombre, fijaos 00:16:28
le he dado un valor 00:16:30
¿por qué no le he dado un valor? 00:16:31
¿por qué no le pongo string apellido igual a Estefano? 00:16:37
porque no estoy definiendo 00:16:47
un objeto 00:16:48
estoy definiendo una clase 00:16:50
estoy definiendo el molde 00:16:52
estoy diciendo la estructura que tendrán 00:16:54
los objetos 00:16:57
pero no puedo darte un valor concreto 00:16:57
porque habrá un objeto que se llama Estefano 00:17:00
un objeto que se llama Paco, un objeto que se llama Sara 00:17:02
un objeto que se llama Lidia 00:17:04
¿Me explico? 00:17:05
Entonces, aquí yo te digo que 00:17:10
Todas las personas tendrán un apellido y un nombre 00:17:11
Eso lo tienen que tener 00:17:14
¿Cuál será su valor? 00:17:16
Dependerá en el momento que creo el objeto 00:17:19
¿Qué valor le doy? 00:17:21
Y eso ahora lo veremos en un momento 00:17:23
¿Qué puede hacer una persona? 00:17:24
Puede pillar un apellido 00:17:26
¿Vale? 00:17:28
Le puedo pedir a una persona 00:17:29
Get apellido 00:17:30
Que sostanzamente me devuelve su apellido 00:17:31
Puedo poner set apellido 00:17:33
Y le paso un apellido nuevo. 00:17:36
Esto permite cambiar el apellido al objeto. 00:17:39
¿Lo veis? 00:17:44
GetNombre es este nombre. 00:17:46
Por ejemplo, estoy definiendo una clase Persona que tiene cuatro posibles servicios, cuatro posibles métodos que me proporciona. 00:17:48
Puedo saber cómo se llama tanto apellido como nombre y cambiarle tanto apellido como nombre. 00:17:57
¿Cómo se hace? Ahora lo vemos. 00:18:04
Estos de aquí que se llaman get algo y set algo de un atributo 00:18:05
¿Veis que? Get apellido, set apellido, get nombre, set nombre 00:18:12
Se suelen llamar getter y setters 00:18:17
Veremos por qué son útiles 00:18:20
Y aquí es donde quería llegar, ¿vale? 00:18:22
¿Cómo se crea un objeto? 00:18:27
Porque hemos dicho, vale, yo tengo la clase, creo los objetos 00:18:28
Pero ¿cómo se crea un objeto? 00:18:31
¿Vale? Para crear un objeto se necesita de un constructor. Un constructor es un método especial. ¿Vale? Es un método cuya función es crear un objeto de esa clase. 00:18:33
Entonces, coche tendrá su constructor que me permite crear una instancia de clase. Persona tendrá su constructor que me permite crear una instancia, un objeto de tipo persona. 00:18:48
Además una clase proporciona unos métodos especiales que se llaman constructores 00:19:01
Que son los que se encargan de crear nuevos objetos de esa clase 00:19:07
Se tiene que llamar exactamente igual que la clase 00:19:10
Ahora tanto hacemos ejemplos 00:19:13
Los métodos constructores no devuelven nada 00:19:14
No tienen void o int porque lo que devuelven es un objeto de esa clase 00:19:17
Se ejecutan al momento de la creación del objeto 00:19:22
Y para usar un constructor tengo que utilizar el new 00:19:26
Cuando vosotros hacéis newScanner 00:19:29
Estáis utilizando el constructor de Scanner 00:19:32
Cuando hacéis newArray 00:19:34
Estáis creando un constructor de Array 00:19:38
Pero el Array es raro, es un objeto el Array 00:19:40
Pero es raro 00:19:42
El código contenido de los constructores se suele usar 00:19:43
Para inicializar los atributos del objeto 00:19:46
¿Vale? 00:19:49
Entonces yo con esto creo que 00:19:50
Mira, esto es un constructor por ejemplo 00:19:52
PublicPersona 00:19:56
¿Veis que no es publicStaticVoid? 00:20:00
y no es public void 00:20:03
o no es public class 00:20:05
public class persona define la 00:20:07
esto está mal 00:20:09
define la clase 00:20:12
¿vale? dentro de la clase 00:20:15
hay un método especial que pone solo public 00:20:17
persona y me pilla 00:20:19
dos valores 00:20:21
nom y e 00:20:23
este nom lo guardaré en nombre 00:20:25
este e lo guardaré en edad 00:20:27
entonces para crear un nuevo 00:20:29
objeto 00:20:31
lo que tendré que hacer es 00:20:32
new persona 00:20:34
del nombre 00:20:36
coma la edad 00:20:38
esta de aquí me creará un nuevo objeto 00:20:40
que tiene como nombre Lola 00:20:43
y como edad 30 00:20:44
y lo guardará en una variable 00:20:47
de tipo persona 00:20:49
que se llama persona1 00:20:50
se entiende más o menos 00:20:52
esta era la teoría 00:20:54
vamos a hacer un poco de práctica 00:20:57
Vale, voy a crear un nuevo proyecto 00:20:59
Voy a mirar 00:21:12
Objetos 00:21:15
Entonces tengo aquí 00:21:20
Me creo un nuevo package 00:21:32
De ejemplo objetos 00:21:35
Y vamos a crear una nueva clase 00:21:38
Pregunta para vosotros 00:21:45
¿Qué queréis modelizar? 00:21:48
Un animal, una persona, un libro, un coche, un avión 00:21:53
¿En serio? ¿Fantasía cero? 00:21:56
¡Qué aburrido! ¡Coche! 00:22:11
¿Vale? 00:22:14
Podría haber sido bestia mitológica, pero no, coche 00:22:16
Entonces, aquí tenemos un coche 00:22:20
¿Sí? 00:22:25
Quiero 00:22:25
Definir 00:22:28
Qué es importante 00:22:30
Para mí y para un coach 00:22:33
Entonces 00:22:34
Yo no sé, ahora lo estamos haciendo en general 00:22:36
¿Vale? 00:22:39
Deberíamos 00:22:40
Plantearnos 00:22:41
¿Por qué estamos creando un coche? 00:22:44
¿Es para un taller? 00:22:48
¿Es para una carrera? 00:22:49
¿Es para...? No lo sé 00:22:52
¿Vale? Pero en general 00:22:53
Pensamos al coche en general 00:22:55
¿Qué es importante para vosotros en un coche? 00:22:57
El motor 00:23:03
¿Y qué del motor? 00:23:03
Porque vamos a la cilindrada 00:23:07
La potencia 00:23:09
Claro, pero ¿cómo defines un motor? 00:23:12
Porque motor, racías, secas, pues serían otros objetos 00:23:16
Vamos sobre el sencillo 00:23:18
Vamos antes sobre lo sencillo, ¿vale? 00:23:20
La matrícula, venga 00:23:27
String, matrícula 00:23:28
Importantísimo 00:23:31
Fijaos, ¿dónde la he escrito? 00:23:32
La he escrito dentro de Public Class 00:23:36
Pero no dentro de un método 00:23:39
¿Sí? 00:23:41
Perfecto, tengo una matrícula 00:23:45
¿Qué matrícula tiene este coche? 00:23:47
Ni idea 00:23:52
Yo estoy definiendo la idea abstracta 00:23:53
Cada coche tendrá una matrícula 00:23:57
¿Cuál es la matrícula de un coche concreto? 00:23:59
Pues eso es otro problema 00:24:02
¿Sí? 00:24:04
Sé que será un string. 00:24:07
¿Quiero que sea un int? 00:24:11
Pues le puedo poner que sea un int. 00:24:12
Si quiero. 00:24:14
Pero, y ahora sé que me vale un código alfanumérico. 00:24:15
Más. 00:24:19
¿Qué nos interesa del coche? 00:24:19
La marca. 00:24:23
¿Qué es la marca? 00:24:24
¿Pero qué tipo es? 00:24:29
String. 00:24:33
Modelo. 00:24:35
Más. 00:24:38
No, no pongamos todo igual porque si no luego nos sale complejo. 00:24:42
Pongamos un int. 00:24:45
Int. 00:24:47
Año. 00:24:52
velocidad máxima así es y nos movemos todo lo que habéis dicho es correcto y puede valer como 00:24:53
no sabemos qué estamos haciendo pues tampoco sé qué poner aquí podría poner mil cosas o podría 00:25:04
poner pocas vale pero estoy creando un objeto lo estoy definiendo que mi objeto las cosas 00:25:10
importantes de mi objeto es saber su matrícula saber su modelo saber su velocidad máxima inter 00:25:16
Año 00:25:24
Fabricación 00:25:26
¿Se dice así? 00:25:29
Año fab 00:25:30
Antigüedad, no sé 00:25:31
A lo mejor modelo es Megane 00:25:33
Y luego año de fabricación es 2010 00:25:38
Lo que tú quieras 00:25:40
Dices, esto ya no me vale 00:25:47
Pues a lo mejor lo cambio 00:25:50
Esto debería estar por algún lado 00:25:51
También descrito que qué se entiende con modelo 00:25:54
O sea, modelo es por ejemplo 00:25:56
Megane o Renault Megane 00:25:58
No lo sé, pero eso depende de ti 00:26:01
Porque lo estás creando tú 00:26:04
Entonces, pongámonos aquí para mantenerlo 00:26:05
Fácil, podría poner 37 00:26:10
Podría poner Arrays aquí 00:26:12
Pero somos buenos 00:26:13
Y por ahora nos molesto con los Arrays 00:26:15
¿Vale? 00:26:18
Entonces, ahora yo tengo este coche 00:26:19
¿Vale? 00:26:22
Para poder crear un coche 00:26:23
Necesito un constructor 00:26:25
entonces 00:26:28
public 00:26:32
coche 00:26:34
y la pregunta es 00:26:35
que me van a dar 00:26:38
cuando construyen un coche 00:26:41
cuando yo quiero crear 00:26:44
un objeto coche 00:26:45
que parámetros me pasan 00:26:46
para que yo pueda 00:26:49
rellenar estos 00:26:51
entonces me pasarían 00:26:52
string 00:26:57
String 00:27:00
String 00:27:04
No, int 00:27:07
Int 00:27:09
Yo tengo aquí un método especial 00:27:14
Que se llamará cuando se construye un nuevo objeto 00:27:19
En el que me pasarán dos string 00:27:21
Y dos int 00:27:23
Y yo lo que haré es decir 00:27:24
Oye mira, matrícula 00:27:26
Esma 00:27:28
Modelo 00:27:30
Esmo 00:27:33
Velocidad máxima es B 00:27:34
Y año fabricación es igual a 00:27:40
Oye, esto en su versión más sencilla absoluta 00:27:45
Yo me estoy imaginando que aquí me dan modelos correctos 00:27:57
La matrícula es formada como tiene que formar 00:28:03
La velocidad máxima no es 7 millones o no es negativa 00:28:06
el año de fabricación es un año humano, no es el 300 a.C., ¿sí? 00:28:10
Estoy pensando que lo que me están dando es todo correcto. 00:28:21
Si quisiera, podría intentar hacer algo, en plan, si v es mayor o igual que 0, 00:28:24
Entonces esto 00:28:34
El se 00:28:36
Velocidad máxima 00:28:39
Es igual a 1 00:28:44
El constructor es un método 00:28:45
Es un método que se llamará 00:28:52
Al construir el objeto 00:28:54
Esto me permite 00:28:56
Hacer lo que me da la gana 00:28:57
Lo que hacía en los métodos, lo puedo hacer aquí 00:28:59
O sea, no es que necesariamente lo he mandado B 00:29:01
Entonces B tiene que ser perfecto 00:29:04
¿Puedo yo comprobarlo? 00:29:05
¿Puedo yo hacer un while? 00:29:07
¿Hacer algo sobre esto? 00:29:08
La matrícula, la matrícula tiene un código, tiene cuatro números, luego una letra y cosas por el estilo 00:29:09
Yo puedo ir a mirar esta matrícula y decir, oye, la matrícula tiene que tener este formato 00:29:15
Y si no tiene ese formato, hacer algo 00:29:20
Desde avisar, desde meter una matrícula por defecto 0000AA 00:29:23
A explotar, a hacer saltar el programa entero 00:29:29
¿Me has dado matrícula que no me vale? Pues fuera 00:29:33
¿Sí? Eso depende de mí 00:29:36
Depende de quien usa coche 00:29:39
De si yo quiero que el coche sea seguro 00:29:43
Y quien lo use 00:29:46
Pues no pueda meter 00:29:48
Una matrícula como le da la gana 00:29:50
O si yo quiero que 00:29:52
No, me fío que estas comprobaciones 00:29:53
No se han hecho aquí 00:29:56
Si no se han hecho allá donde se crea el coche 00:29:57
No sé si me explico lo que quiero decir 00:30:00
Por ahora yo he asumido que 00:30:03
lo que me dan aquí, aquí y aquí 00:30:07
está bien 00:30:10
y la velocidad, si me dan 00:30:11
una velocidad negativa 00:30:14
le pongo 1 00:30:15
como velocidad máxima 00:30:17
si me dan una velocidad positiva 00:30:19
le pongo la que me han puesto 00:30:22
entonces aquí he hecho una pequeña 00:30:23
comprobación sobre este parámetro 00:30:27
aquí tengo 00:30:29
mi constructor 00:30:33
coche 00:30:34
¿qué puede hacer un coche? 00:30:35
vale 00:30:46
El problema es que tengo yo aquí 00:30:46
Algo que me defina la velocidad 00:30:49
A la que estoy yendo 00:30:51
Pero la velocidad máxima no cambia 00:30:52
Si acelero, aumenta la velocidad máxima 00:30:55
Aumenta la velocidad 00:30:59
Pero no la velocidad máxima 00:31:00
Entonces, por ejemplo, por la elección 00:31:01
De datos que he puesto aquí 00:31:04
El concepto de acelerar 00:31:06
No sé cómo reflejarlo 00:31:08
Yo hago acelerar, ¿y qué hago? 00:31:13
Lo puedo hacer, ¿eh? 00:31:14
Public 00:31:17
Devuelve algo 00:31:17
Voy a acelerar 00:31:19
Pero es que velocidad no la tengo 00:31:25
Entonces lo que hace acelerar es 00:31:26
Brrrrrr 00:31:29
Sí, tanto es para hacer pruebas 00:31:32
Entonces cada coche puede acelerar 00:31:39
Y cuando acelera simplemente te escribe 00:31:41
Brrrrrr 00:31:43
No hace nada más 00:31:46
Más cosas que puede hacer un coche 00:31:46
Frena, pero es lo mismo que antes 00:31:49
No me decís cosas interesantes 00:31:57
Frenar 00:32:00
Entonces cuando freno, ¿qué hace? 00:32:01
Ahora 00:32:04
Que un coche se venda 00:32:05
Es un poco raro 00:32:19
A lo mejor habrá otro que tendrá a vender un coche 00:32:20
Pero que el coche 00:32:24
Si, si, lo sé 00:32:25
Cambiar matrícula 00:32:27
Venga, podemos decir 00:32:32
Cambia dueño, entonces cambia la matrícula 00:32:33
Si, vale, perfecto 00:32:36
Public void 00:32:38
Cambia matrícula 00:32:40
Cambia matrícula 00:32:44
¿Qué le pasamos al cambio de matrícula? 00:32:46
Un string matrícula nueva, y lo que hacemos es que matrícula es igual a matrícula nueva. 00:32:47
Podría yo aquí preguntarme si la matrícula nueva es una matrícula real, entonces cámbiala, si no, no. 00:33:08
Podría hacer lo que me da la gana, esto es un método, estoy haciendo métodos sencillos. 00:33:20
Más 00:33:24
Sí 00:33:25
No cambiamos esto por ahora 00:33:44
Usamos año de fabricación 00:33:47
Hagamos un, no sé 00:33:48
Que te diga que si es 00:33:50
Anterior del 2010 00:33:52
Te diga la etiqueta 00:33:54
Si es 2010, antes del 2010 no tiene etiqueta 00:33:55
Y si no te dice 00:33:58
Soy eco 00:33:59
¿Sí? 00:34:00
Entonces, yo digo 00:34:02
Public 00:34:04
Por ejemplo, bolean 00:34:06
Soy eco 00:34:10
Y lo que contesto es, si año FAB es menor que 2010, por ejemplo, es para hacer ejemplos. 00:34:12
Entonces, return falso. 00:34:34
Elche, return true. 00:34:40
O si soy un pro 00:34:45
Return 00:34:49
Bueno, sería 00:35:02
Al revés, ¿no? 00:35:04
Otra cosa, por ejemplo 00:35:16
Public 00:35:17
Void 00:35:20
Descríbete 00:35:23
Que dirá 00:35:25
Soy un coche 00:35:29
Más 00:35:34
Modelo 00:35:36
Más 00:35:37
que hemos puesto 00:35:39
con matricula 00:35:40
más matricula 00:35:42
más 00:35:49
del año 00:35:51
más año 00:35:54
fab 00:36:03
lo escribe y luego me voy a hacer 00:36:04
un public string 00:36:09
get 00:36:15
descripción 00:36:18
que lo que hace es 00:36:20
return 00:36:24
esta cosa 00:36:26
Veis la diferencia entre uno y otro 00:36:28
Estos dos son métodos 00:36:31
Este de aquí directamente lo escribe en pantalla 00:36:35
Este de aquí no lo escribe en pantalla 00:36:38
Me devuelve un string 00:36:41
Que luego yo decidiré qué hacer con este string 00:36:42
Si escribirlo en pantalla o hacer otra cosa 00:36:45
Cuando pongo describete me saldrá esto en consola 00:36:47
Cuando pongo descripción no me saldrá absolutamente nada en consola 00:36:56
Porque no estoy escribiendo nada 00:36:59
Ahora los vamos a usar y veremos la diferencia 00:37:00
Pero estos son métodos distintos. Esto no devuelve nada y escribe en pantalla. Esto devuelve un string que es lo que aquí escribí en pantalla, pero sin escribirlo en pantalla, me lo devuelve nada más. Luego a lo mejor yo con eso lo pongo todo en mayúscula y lo escribo en pantalla. 00:37:03
Por ejemplo, estos son métodos, ahora los vamos a usar 00:37:17
Lo que quiero decir con esto es 00:37:25
Vamos aquí a rellenar las características del coche 00:37:27
Cómo se construye un coche y qué hace un coche 00:37:34
Qué puede hacer un coche 00:37:40
Si yo aquí no defino qué puede hacer el coche, no lo puede hacer 00:37:41
¿Se entiende? 00:37:44
Y ahora tengo que hacer algo con los coches 00:37:48
Fijaos que por ahora ya he definido un molde 00:37:51
Pero no he jugado con este molde 00:37:54
No he creado un objeto, no le he hecho hacer nada 00:37:56
¿Dónde se crean los objetos 00:37:58
Si se hacen hacer algo? 00:38:00
En el main, ¿vale? 00:38:04
Necesito un main, ¿dónde se encuentra este main? 00:38:05
Puede estar aquí 00:38:08
O en otra clase 00:38:09
Lo vamos a hacer aquí 00:38:11
Luego lo movemos en otra clase 00:38:13
Entonces aquí ahora tengo un main 00:38:15
Public, static 00:38:17
El main es static 00:38:20
Main 00:38:22
Perdón, void 00:38:23
Main 00:38:25
De string 00:38:26
Args 00:38:28
Y ahora empezamos a jugar 00:38:30
Quiero crear un coche 00:38:34
El coche1 00:38:38
¿Vale? 00:38:40
Entonces diré 00:38:42
Créeme una variable de tipo coche 00:38:42
Coche 00:38:45
Que se llama 00:38:46
Coche, coche, coche 00:38:49
Que se llama 00:38:51
coche1 00:38:54
y que le pongo dentro 00:38:55
un nuevo objeto 00:38:58
de tipo coche 00:39:00
y le tendré 00:39:02
que poner los parámetros 00:39:04
para construir un coche 00:39:06
entonces le diré 00:39:08
modelo, ¿no? 00:39:10
cuidado que tiene que ir con el orden que pone aquí 00:39:16
el primero es la matrícula 00:39:18
la matrícula es claramente 1, 2, 3 00:39:20
A, como la paso de muchos de vosotros 00:39:22
La segunda es el modelo 00:39:27
¿Qué modelo es? 00:39:30
No tenéis fantasía 00:39:35
Audi 00:39:36
Es una marca, pero me vale 00:39:38
Audi A3 00:39:40
¿Es Audi A3? 00:39:41
Más 00:39:44
¿Cuál es su velocidad máxima? 00:39:44
230 km por hora 00:39:48
¿Cuál es su año de fabricación? 00:39:50
2023 00:39:54
Pues esto me ha creado un nuevo objeto 00:39:55
¿Sí? 00:40:00
si yo lanzo el programa ahora, ¿qué hace? 00:40:02
nada, has creado el objeto y has acabado el programa 00:40:10
hagamos hacer algo al objeto, por ejemplo, oye 00:40:14
objeto, descríbete, fijaos 00:40:18
cuando pongo c1 punto, aquí 00:40:23
mi buen amigo el eclipse 00:40:27
ya me está dando todo lo que puedo hacer con este 00:40:31
objeto incluido los métodos que he definido yo los veis y cuando voy completando por ejemplo 00:40:36
escribo de me da todos los métodos que contienen de dentro entonces digo mira es esto descríbete 00:40:47
acordar que describe te me escribe directamente en pantalla por lo tanto si yo haga así me dice 00:40:54
Soy un coche Audi A3 00:41:03
Con matrícula 123A 00:41:06
Del año 2023 00:41:08
Que carácter demoníaco 00:41:09
Sabemos que es 00:41:11
Y me puedo preguntar 00:41:11
Si soy 00:41:17
Eres 00:41:18
Echo 00:41:20
Más C1 00:41:21
Punto Echo 00:41:26
Soy Echo 00:41:29
Entonces el me dirá 00:41:29
Soy Echo, eres Echo 00:41:34
Ahora si yo llamo C1 00:41:37
punto get descripción 00:41:46
me escribe 00:41:48
algo en pantalla 00:41:50
esto de aquí 00:41:53
hace lo mismo que antes 00:41:55
porque este de aquí 00:41:57
devuelve un string 00:41:59
pero yo me puedo guardar ese string 00:42:01
string descripción 00:42:03
de c1 00:42:05
y ahora por ejemplo puedo decir 00:42:06
imprímeme 00:42:11
descripción de c1 00:42:12
pero tu uppercase 00:42:14
Entonces ahora 00:42:17
Lo que me está haciendo 00:42:22
Escribiendo todo en mayúsculas 00:42:24
Creamos un segundo, coche 00:42:26
Coche C2 00:42:33
Es igual a qué 00:42:37
New 00:42:39
Coche 00:42:41
Claramente 2, 3, 4, B, B, B 00:42:43
¿Qué es esto? 00:42:49
Un Mazda 00:42:56
Coma 00:42:59
Diversidad máxima 00:43:03
200, está mal Mazda 3 00:43:04
Bajando 00:43:10
En caída libre, sí 00:43:14
¿Qué más? 00:43:16
Año, pongámoslo viejo 00:43:19
2000 00:43:21
Para que veamos 00:43:22
Fijámoslo en esto 00:43:23
Pongamos 00:43:27
Ah, no, porque no lo escribo 00:43:28
No lo he usado 00:43:29
Ahora he creado un segundo coche 00:43:31
¿Cómo hago para que se describa el segundo coche? 00:43:34
C2.descríbete 00:43:40
Fijaos, el método es el mismo, pero ahora lo estoy llamando sobre un objeto distinto 00:43:42
Entonces ahora es C2 que se describe 00:43:48
Entonces cuando hago C1 describete, me escribe esto, pero con los datos del objeto C1 00:43:51
Cuando se lo digo al C2, me dice, oye mira, uso los datos del coche C2 00:43:58
¿se entiende? es el mismo método, yo el método no lo he tocado 00:44:09
el método hace siempre lo mismo, el objeto, su comportamiento 00:44:13
es siempre lo mismo, solo que dos objetos distintos 00:44:18
producen un resultado distinto, porque utilizarán sus propias 00:44:21
variables, sus propios atributos 00:44:26
¿si o no? ¿dudas? ahora yo podría hacer 00:44:28
c2.soyeco 00:44:37
y esto me hace 00:44:43
nada 00:44:49
porque este es un boolean 00:44:52
pero no le he dicho que lo escriba 00:44:54
pero por ejemplo podría decir 00:44:56
c2 es soy eco 00:44:59
entonces 00:45:02
se escribe 00:45:04
c2.matricula 00:45:10
más 00:45:15
es viejo 00:45:16
no, es nuevo 00:45:19
Else es viejo 00:45:22
¿Qué estoy haciendo? 00:45:34
Estoy llamando el método soyEcho 00:45:36
Sobre el objeto C2 00:45:38
Si me devuelve true 00:45:40
Entonces escribiré esto 00:45:42
Si me devuelve false 00:45:44
Escribiré esto 00:45:46
¿Y qué escribo? 00:45:47
¿Notáis algo raro aquí? 00:45:49
Con respecto a aquí 00:45:53
Cuando yo tengo paréntesis 00:45:54
Estoy llamando un método 00:46:01
Cuando yo no tengo paréntesis 00:46:03
Estoy accediendo 00:46:06
Al atributo 00:46:08
De este objeto 00:46:10
Entonces aquí una pregunta 00:46:11
Para vosotros 00:46:25
Que pondré aquí abajo 00:46:26
String 00:46:28
S es igual a 00:46:33
Hola 00:46:35
Int 00:46:35
Gatos es igual 00:46:39
A new 00:46:43
Int 00:46:45
De 10 00:46:47
S.Length 00:46:48
Sí, son gatos.length 00:46:56
¿Qué me podéis decir ahora de estos length? 00:47:03
Este es un método de qué? 00:47:13
La clase string 00:47:19
Es decir, que dentro de la clase string 00:47:20
Habrá un método declarado 00:47:22
Que será public int 00:47:25
Porque devuelve un entero 00:47:28
Length, que no pilla parámetros 00:47:30
Que hará cosas y te devuelve un numerito 00:47:33
¿Y esto? 00:47:36
Esto es que este señor es un objeto y tiene dentro un atributo definido como length que yo voy a acceder. 00:47:41
Es decir, que esto es una llamada de método y esto es un acceso a una variable. 00:47:53
Son dos cosas completamente distintas. 00:47:59
¿Y ahora sabéis por qué? 00:48:03
Es la razón de por qué no estáis durmiendo bien en este mes, mes y medio. 00:48:11
Decíais más, length, length, más... 00:48:15
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
21
Fecha:
29 de noviembre de 2024 - 12:43
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
48′ 20″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
130.63 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid