Transcripciones
1. Introducción: Hola ahí. Mi nombre es Derek y bienvenido
a mi curso de Java. Probablemente tengas tus
razones para estar aquí. Tal vez has estado
trabajando Clinton recientemente solo para desplazarte hacia abajo hasta la sección de
calificaciones y te
diste cuenta de que requieren que conozcas Java y otros lenguajes de programación
como requisito previo básico. A lo mejor has estado buscando bandas de compensación y te
das cuenta de que
a los ingenieros de software
se les paga muy generosamente. O tal vez solo quieres
aprender algo interesante para dar
inicio al nuevo año. Independientemente de por qué
terminaste aquí, java es una gran habilidad para aprender. Pero, ¿qué es Java? Java es un lenguaje de programación
popular y performance, lo que significa que podrás
escribir programas rápidos. Tendrás una gran
demanda por tus habilidades. Java también es fácil de
recoger y transferible, lo que significa que una vez
que aprendas Java, hará
que aprender otros lenguajes de
programación sea
aún más fácil. Ahora eso suena genial, pero hay toneladas de otras clases de
programación por ahí. ¿Por qué deberían elegir esta? Bueno, tenemos lotes
en la tienda para ti. En primer lugar, tenemos todo
el código fuente este curso listo para ir por
ti en un entorno en línea, lo que significa que todo lo que tienes que hacer es presionar el botón verde Ejecutar. No es necesario pasar horas
golpeando tu cabeza contra tu computadora tratando de
averiguar qué hay de malo en
tu configuración local. Con un solo clic de un botón, estás listo para ver el
resultado de tus programas. También tenemos un
proyecto de currículum muy visual listo para YouTube, lo que significa que al
final de este curso, tendrás algo
para presumir ante tus amigos y
poner en tu currículum. Tenemos ejemplos concretos de código de
ejemplo en cada lección para que no
te
confundas con conceptos
abstractos, los conceptos se introducen con un recorrido visual y fácil de
seguir. Por último, voy a ser
mantenido activamente en este curso. Así que siéntete libre de publicar preguntas
si las cosas no están claras. Antes de que te suelte
en el contenido del curso, probablemente primero
debería
presentarme. Soy ingeniero de
software profesional y durante toda mi carrera, he trabajado en algunas
de las empresas
tecnológicas más famosas y valiosas del mundo. Tengo experiencia en el mundo real entregando productos
técnicos de concreto, algunos de los cuales puede
haber encontrado. Antes era ingeniero de
software. Enseñé licenciatura
en Ciencias de la
Computación en la Universidad de California, Berkeley, donde regularmente
resolvemos miles de
estudiantes este semestre. El curso fue nombrado uno de los
cinco primeros de la nación por Bloomberg. Y actualmente soy
uno de los instructores menores de 61 años más populares, un
canal departamental de YouTube donde hemos acumulado alrededor de 900,000
reproducciones a partir de 2022. Durante mi estancia en Berkeley, también
quiero múltiples premios a la
docencia y otorgaron el distinguido Premio
GSA en 2020, cual fue entregado a los 13
mejores instructores y toda
la informática departamento de
varios cientos. Por último, tengo un título de
posgrado en informática
también de Brooklyn. Como puedes ver, me encanta todo lo relacionado con la tecnología y
me encanta enseñar. Estoy súper emocionada de tenerlos a
ustedes juntos para el paseo conmigo. Una última cosa antes
de comenzar el curso, le
pido que por favor
cree una cuenta en repl it.com y verifique su correo electrónico
una vez que lo haya hecho. Ahora, sé que lo sé. A lo mejor acabas de crear una cuenta de
Skillshare y probablemente no
estés de
humor para hacer otra cuenta. Bueno, como aludí antes, tenemos una configuración de
entorno en línea
para que juegues y
construyas tu proyecto. Y créeme, la alternativa
es mucho, mucho peor. La alternativa al entorno
en línea sería configurar un
entorno de desarrollo local en su computadora. Hay 1 millón de
formas que podrían salir mal y podría tomar
horas solucionar problemas. Entonces te pido que ahorres
un par de minutos para que por favor haga
una cuenta aquí mismo. Eso es todo para mí en este video, te
veré en el siguiente. Si quieres
acceder a las diapositivas. El enlace será publicado en
la descripción del curso.
3. Métodos: Bienvenidos amigos. En este video, vamos
a hablar de métodos. En primer lugar, ¿qué es un método? Un método es
prácticamente cualquier cosa que realice una acción
dentro de una clase. Y la definición de
inacción es bastante amplia. Podría ser cualquier cosa.
Podría ser simple aritmética. Podría haber ejecutando un algoritmo
de aprendizaje automático. Podría estar renderizando un marco. Las clases contienen métodos y los métodos contienen toda la
lógica dentro de un programa. Ahora, los métodos deben ser declarados antes de que podamos comenzar a
escribir lógica en ellos. Hay cuatro componentes
en esta declaración. Primero, tenemos el modificador de
acceso. Contamos con cuatro tipos, públicos, privados,
privados y protegidos. El modificador de acceso
en un método mirth funciona exactamente de la misma
manera que funciona para las clases. Si el eje no se indica
explícitamente, el método por defecto es
empaquetar private, igual que lo haría una clase. Un método público es aquel al que
se puede hacer referencia desde cualquier clase. método privado del paquete Panda es uno al que solo se puede
acceder si se
hace referencia a él desde un método de una clase dentro del mismo paquete. También recordemos que
previamente
prometí, voy a explicar privado y protegido una vez que empezamos a
hablar de métodos, bueno, resulta que necesitamos
saber aún más sobre Java antes de poder
hablar de protegido. Entonces dejaremos eso
fuera por ahora. Sin embargo, podemos hablar de código
privado que está marcado como privado solo se puede acceder
dentro de la misma clase. Entonces, por ejemplo, si declaré que el
método X es privado, eso significa que solo
otros métodos dentro la misma clase
podrían hacer referencia al método X. Métodos de otras clases
independientemente de su paquete, no se le permitiría hacer
referencia a un método privado. A continuación, tenemos estática. Podemos optar por omitir la palabra
static en nuestra Declaración, en cuyo caso el método por defecto
será no estático. Ahora, no te preocupes por lo que realmente significa
estática todavía. Desafortunadamente,
necesitarás más contexto en Java antes de
poder entenderlo. Entonces, por ahora, solo ten en cuenta
que la palabra clave static existe y viene después
del modificador de acceso. A continuación tenemos el tipo de devolución que siempre debe estar presente. El tipo de retorno es, como su nombre indica, el tipo del valor
que devuelve un método. En este caso, no se
devuelve nada por este método. Entonces decimos que su
tipo de retorno es nulo. Ahora, puede que estés un poco
confundido acerca de lo que significa para un método
devolver algo. El valor de retorno de un
método es el valor de salida. ejemplo, imagina que tenemos
un método llamado add y todo lo que
hace es agregar dos enteros juntos. Entonces e.g Agregar de 1.2 nos da tres. En programación,
llamaremos a este tres el valor devuelto
de la función add. El valor de retorno es
sinónimo del valor de salida. Y en este campamento y
en nuestro ejemplo de anuncio, el tipo del
valor de retorno sería un entero, ya que tres es un entero. Por último, tenemos
el nombre del método. Los nombres generalmente pueden ser
lo que tú quieras que sean. La única restricción,
creo, es que el primer carácter del nombre del
método debe ser una letra. Ahora,
hablemos de tipos en Java. Como dijimos en la diapositiva
anterior, cada método necesita
devolver tipo. Entonces es importante que
entendamos cuáles pueden ser algunos
de esos tipos. Primero, tenemos una cadena, que es un fragmento de texto legible por
humanos doblemente citado. Recordemos en la diapositiva anterior, teníamos Hello World, aquí mismo, aquí mismo. Se trata de un texto doblemente
legible por humanos. Es un ejemplo de una cuerda. A continuación, tenemos un entero, un int, que es Java
speak for integer. También tenemos flotadores, que es la forma de Java de
decir un número con un punto decimal, como 1.3 por ejemplo tenemos booleanos que son valores que solo pueden
ser verdaderos o falsos. También tenemos tipos de matriz, que parecían int bracket, bracket o
bracket booleano. Una matriz de artículos es básicamente solo una colección ordenada
de elementos del tipo. Entonces, por ejemplo, si especificamos
int bracket bracket, entonces
eso significa que ese valor va a ser una
colección ordenada de enteros. Y si tenemos
corchete booleano, corchete, entonces eso va
a ser una colección de valores verdaderos o falsos. Java tiene muchos más
tipos que la justicia, pero estos son algunos de los tipos
más comunes que veremos. Y servirán como
una buena base para lo que resta
de este curso. A continuación, necesitamos
hablar de argumentos de método. Un argumento de método es solo
una forma formal de decir las entradas o
parámetros de un método. Los argumentos del
método se especifican entre paréntesis después del
nombre del método. Y el tipo Java
de los argumentos debe especificarse explícitamente. ejemplo, aquí tenemos un tipo de matriz de cadenas y se
nos da el nombre
del argumento args. Esto significa que cuando
llamamos a este método, debemos darle una entrada
de tipo string array. De lo contrario, Java se negará a compilar el código
y no se ejecutará. Hay un par de
puntos sutiles que debes conocer. El primero es que este método principal por aquí es muy especial. Normalmente una aplicación Java, tendremos varios archivos y necesitaríamos
especificar un punto de entrada. De lo contrario, Java no
tendría forma de saber qué pieza de código
acaba de comenzar a ejecutarse primero. Entonces en este caso,
especificaríamos que
queremos que la clase helloworld
sea nuestro punto de entrada. En ese punto java
buscaría entonces un método principal que tenga
exactamente esta firma, public static, void main con un argumento que tenga
type string array. Ejecutará este
método si existe como punto
de entrada inicial
al programa. De lo contrario, Java
lanzará un error diciendo que no hay ningún método
principal definido. Segundo, si quieres que un método tome
múltiples argumentos, necesitaremos escribir
explícitamente cada uno de esos argumentos y
separarlos con una coma. En este ejemplo de anuncio, tenemos dos argumentos, x e y, y especificamos los
tipos Int para ambos. Y esta función
add simplemente devuelve el resultado de sumar estos
dos números devuelven x más y. Como nota al margen, tenga en cuenta
que cuando especificamos un tipo de retorno y la firma del
método,
por ejemplo , por aquí, debe
incluir una línea dentro este método que
diga explícitamente return en Maine, por ejemplo, tenemos un vacío, lo que
significa que no devolvemos nada. Tenga en cuenta que no hay línea en este método que diga retorno. Tercero, está totalmente bien
tener cero argumentos para. Simplemente
pondrías un conjunto vacío de paréntesis después
del nombre del método. Ahora bien, puede estar pensando que
este requisito
escribir explícitamente todo
en Java es realmente gravoso y solo
existe para ralentizarlo. Pero si eso fuera cierto,
Java no sería uno de
los lenguajes de programación más populares y la industria del software hoy en día. La razón por la que tenemos estos
requisitos es que estos permiten a
Java realizar algo que
llamamos comprobación en tiempo de compilación. Antes de ejecutar un programa Java, su computadora primero debe convertir el código en algo
llamado código de bytes. A este proceso lo llamamos
compilación. Cuando hay
compilación completa y ejecutas el programa, en realidad
estás ejecutando el
bytecode que se produce. Ahora la ventaja
de tener un
paso de compilación antes de ejecutar
el código es que el compilador Java
es capaz de analizar tu código y realizar
algunas comprobaciones básicas de cordura. Una de esas
comprobaciones de cordura es que todos los tipos especificados en
tu lógica son consistentes. ejemplo, como mencionamos anteriormente aquí, espera dos enteros. Imagínese si intentara
pasar el número dos, una cadena, hola mundo
como argumentos al anuncio. Bueno, eso no tendría sentido. ¿Cómo se agrega el número dos a un fragmento de texto Hola Mundo?. Entonces la ventaja de Java
es que ejecutará estas comprobaciones de
cordura en tiempo de
compilación y te notificará de cualquier error antes de que se ejecute
el código. En otros lenguajes sin verificación en
tiempo de compilación, puede
haber un problema
en tu código que no
sabrías
hasta que se ejecute el código. Y eso podría ser
muy devastador si tu código se despliega en digamos, un banco o tal vez en Google, que es utilizado por
mil millones de personas todos los días. Ahora, hablemos del cuerpo
del método. Primero. El cuerpo del método es simplemente todo el código dentro de
estos corchetes. Realmente no hay ninguna
restricción sobre lo que puedes hacer en el cuerpo y el método cuerpo
puede ser el tiempo que quieras. Independientemente de la lógica
que decidas realizar. Lo principal que
debe asegurarse es que el tipo de valor
de retorno debe coincidir con el retorno
especificado en la declaración del método. Aquí, estamos devolviendo algunos, que es una variable que
declaramos e inicializamos con
el valor x más y Dado que x e y son ambos ints, la adición de dos también
es un int. Por lo tanto, devolver
sum cumple con nuestro requisito de
devolver un int en este método. El siguiente punto que
quiero destacar es que la
línea de retorno es terminal. compilación de Java
fallará si intentas poner algún código después de la línea de
retorno en un método, lo cual tiene sentido ya el valor de retorno es el valor de
salida del método. ¿Por qué realizar lógica adicional después de que ya hayas dado
salida a un valor final? También necesitamos hablar
un poco sobre las variables que creas y
usas dentro de un método. Al igual que los argumentos de método, las variables que definió
dentro del método
deben escribirse explícitamente
al crearlas. Y puedes nombrarlos como
quieras siempre el primer carácter
del nombre sea una letra. Después de declarar la variable
sum como un int, por ejemplo ya no
podemos cambiar su
tipo dentro del mismo método. Entonces no puedo hacer algo como
int sum es igual a x más y.
Y luego en la siguiente línea hacer string sum es igual a hello world. Aunque no se puede
cambiar el tipo de suma, se
puede cambiar su valor. Y cuando lo haces,
no necesitas escribirlo explícitamente. Entonces después de la mina int
sum es igual a x más y, puedo hacer algo así como sum
es igual a uno sin el, sin la declaración de
tipo explícito. Y por cierto, estas
tres afirmaciones
sólo son verdaderas dentro
de un mismo método. Podría tener un método completamente diferente
llamado Restar. Y restar, podría declarar sum como una
cadena si quiero que así sea. Esa variable tendría que
permanecer una cadena
dentro de ese método. Las variables de método
en un método son independientes de
las variables de método en otro método. Ahora que sabemos
definir métodos, veamos cómo los usamos. esto lo llamamos una llamada de método. Cuando hicimos referencia
al nombre del método y pasamos argumentos
entre paréntesis, como probablemente puedas adivinar, de 12 provocará se ejecute
el código return x más
y. Y ese
valor devuelto ahora va a estar vinculado a X en Maine. Por cierto, esta cosa que
hemos estado usando todo el tiempo, system dot out, dot print
LN también es un método. Consiste en una referencia
a un nombre de método y tiene paréntesis en los que pasamos un argumento para que nuestro viaje se imprima
a la pantalla. En este caso, el valor
de x, que es tres. La razón por la que necesitamos
todos estos puntos va a
tener más sentido en el futuro video. Quiz pop. ¿Cómo sabe Java imprimir el valor tres, en este caso, lugar del
carácter literal x que
pasamos a imprimir, seguir
adelante y pausar el video. Revelaré la respuesta en 321. La razón java
sabe para imprimir tres es que esta x no lo es,
CITAMOS en la X tenía
comillas dobles a su alrededor. Java trataría a x como
un carácter literal x, ya que no tiene comillas
dobles a su alrededor, java entiende que x es un nombre de variable con un
valor asociado a él. Por lo que primero
evaluará qué es x y luego imprimirá el
resultado de esa evaluación. Aquí están los enlaces a las
muestras de código usando este video. Ya que hemos cubierto bastante contenido en este video, les
pido que por favor
visiten estos enlaces. Haga clic, Horquilla, ondulación
y juegue con el código. No tiene que
ser nada elegante. Simplemente experimente agregando
variables a los cuerpos del método o tal vez cambie el tipo de retorno y la declaración del método. Y por cierto, recuerda
agregar punto y coma. Las líneas de Java deben
terminar en punto y coma a menos que estés abriendo un nuevo bloque de código con corchetes
ondulados.
4. Demo de respuesta: En este video,
quiero darte una visión general rápida del entorno
ripple. Y a lo que me refiero cuando
digo te animo a
jugar con el código. Primero, asegúrate de haber hecho
una cuenta en repl it.com. Sé que es un poco molesto
configurar otra cuenta, pero la alternativa
a esto es configurar un
entorno de programación local en tu computadora. El problema, es decir, no
sé qué
computadora tienes. No sé qué SO
estás ejecutando y no
sé qué son las variables de
entorno, alias que tienes configurados
en tu computadora. Cuando solía enseñar
en UC Berkeley porque a veces
me toma más de una hora solo para obtener una configuración de
entorno local para un pequeño grupo de
tal vez diez estudiantes. Y dado que las clases de
habilidades compartidas básicamente tienen capacidad
ilimitada, la sobrecarga
asociada con la configuración por sí sola tomaría un tiempo
prohibitivamente largo. Esta es una clase sobre Java, no sobre computadoras y repl, ya ha
configurado Java para ti. Creo que este es un recurso extremadamente valioso
que puedes usar, además es gratuito para
nuestros casos de uso. Ahora, si visitamos estos
enlaces en las diapositivas, así es como
se ve cuando
visitamos el enlace en la diapositiva. Una vez que haya creado una cuenta REPL, continúe y haga clic en este botón para
grappled aquí. Ahora tenemos una copia del
proyecto en tu cuenta. Este es el código del
video sobre anatomía de programación. La barra lateral de aquí
es donde puedes explorar la
estructura de archivos del proyecto. Podemos dar click en la carpeta para ampliar su contenido
y hacemos clic, Insertar un nombre de archivo para
mostrar su contenido aquí. En este ejemplo, el método principal aquí solo imprime Hello World. Entonces vamos a revisar la cordura. Adelante y haz clic en
el botón verde. Puedes ignorar los textos
crípticos de aquí. Esto es solo REPL su
sistema bajo el capó, emitiendo comandos de compilación y ejecución. Ahora intentemos bifurcar otra onda y
hacerle cambios. Aquí está el código
del video de métodos. Sigamos adelante e intentemos
hacer lo mismo. Entonces aquí está el enlace. Otra vez. Vamos a hacer clic en Ondulación horquilla
y bifurcarla en nuestra cuenta. Ahora veamos qué podemos hacer. Primero, solo verifica la cordura con el botón verde y
asegúrate de que esto, estos valores en el
método principal se imprimen. Bien, entonces ya podemos ver que imprimimos
el número tres. Y si le echas un
vistazo al código, esto debería, esto
debería tener sentido. Tenemos de 12 y
estamos imprimiendo el resultado de sumar
1.2, que es tres. Ahora veamos si somos capaces de
sumar dos llamadas a métodos juntas. Entonces este sería el primer ejemplo de
retoques con el código. Entonces digamos que sí
agregamos uno a más uno. Ya que llamar a uno
devolverá un número uno. Suena razonable
que quizás se
pueda agregar uno al
resultado de agregar 1.2. Sigamos adelante y ejecutemos esto. Ahora, ya ves que
nos sale un error. Dice que tenemos 21
dice no una declaración, hacer otras como se
esperaba, un punto y coma. Entonces, como habrás notado, todas las líneas de Java terminan
con un punto y coma, aparte de las que están abiertas, un nuevo bloque de código
como las declaraciones de métodos. Entonces tal vez
sería prudente que
agregáramos un punto y coma
al final aquí. Ahora sigamos adelante y volvamos a
ejecutar este código. Bien, así que todavía tenemos esto, no un error de declaración, pero al menos nos deshicimos
del error de punto y coma. Entonces no una declaración es
un error bastante grande. Entonces sigamos adelante
y busquemos eso en Google. Sigamos adelante y
copiemos y peguemos esto. Ve a Google y ve a Java. No es una declaración. Damos click en el
primer resultado Stack. El desbordamiento es un recurso extremadamente útil para la
mayoría de los programadores. Y podemos desplazarnos hacia abajo hasta
la respuesta aquí mismo. Y fíjense
en lo que dicen. Dicen. Java restringe los tipos
de expresiones que están permitidas y las llamadas declaraciones de
expresión. No permite declaraciones semánticamente
sin sentido como cero o a más b.
Oye, ¿adivina qué? No es esto exactamente lo
que estábamos haciendo antes. Estamos haciendo agregar uno a
más un punto y coma, que es básicamente lo mismo
para que a más b punto y coma. Si nos desplazamos hacia abajo un poco más, verás que
tienen una cita de la especificación del lenguaje Java. Ciertos tipos de
expresiones pueden ser utilizadas como declaraciones
siguiéndolas con punto y coma. Y luego echamos un
vistazo a la lista aquí mismo. Bueno, tenemos una
asignación que aparece listada como un ejemplo
de una expresión válida. Entonces volvamos a nuestro
código y convertiremos esto en una expresión de asignación
que se vería así. Y es igual a agregar uno a más uno. Sigamos adelante y corramos
esta una vez más. Y ahora el código compila
y se ejecuta con éxito. No vemos el
resultado de sumar 12.1 porque
no lo imprimimos. Entonces sigamos adelante y sumemos
esa línea y volvamos a correr. Bien, y ahora tenemos un cuatro, lo cual tiene sentido porque
hemos agregado uno a dos y luego agregamos
uno más a eso, que es cuatro. Ahora intentemos
encontrar un método, otro método
que no tenga la palabra clave static
y veamos qué pasa. Entonces tal vez esto llame a este
público a volver a. Y nuevamente, tenga en cuenta que he
omitido la palabra clave static. Ahora intentemos ver
qué pasa si
hacemos 12 más uno más dos. Sigamos adelante y
ejecutemos este código. Interesante. Esta vez tenemos otro
error de Java. No se puede
hacer referencia al método no estático desde un contexto
estático. Entonces incluso tienen este punto par directamente
al método no estático
que está causando el aire. Entonces este es uno de los errores de Java que en realidad es
un poco más útil. Te dicen que métodos
no estáticos no pueden ser referenciados desde métodos estáticos. Y dos es nuestro método
no estático. Ahora en realidad no hemos
hablado de lo que significa estática. Así que no te preocupes por ello. Vamos a
hablar de eso en un futuro video y este mensaje de error
va a tener más sentido. Entonces la conclusión clave es la importancia de
retocar con el código. A pesar de que rompimos el
código varias veces, aprendemos cosas sobre Java que nos
ayudarán más
adelante en el futuro. Lo mejor es que
cometas estos errores ahora en muchos proyectos
asociados a estos videos para que no
te confundas más adelante cuando trabajes
en proyectos más grandes.
5. Control: Bienvenidos amigos. En este video, vamos a
hablar de control. Para realizar un flujo lógico más
complejo en Java, primero
necesitamos entender
algunos operadores comunes. Primero, tenemos algunos operadores
aritméticos básicos que son bastante
autoexplicativos. Estos son los símbolos de más, menos y tiempos, y funcionan exactamente
como cabría esperar. Suman,
restan y multiplican respectivamente. El símbolo de barra diagonal es el operador de división de
Java. Pero una cosa que debes tener en cuenta es que la división en
enteros en Java, una operación de división de piso, lo que
significa que redondea
hacia abajo al entero más cercano, por ejemplo 3/2, y el lenguaje normal es 1.5. No obstante, en Java tres, Florida por dos es uno. Ya que redondeamos a la baja de 1.5% símbolo se llama
módulo o mod para abreviar. Devuelve el resto
de una división, por ejemplo 14 mod cuatro es dos. ¿Por qué? Porque cuatro entra en 143 veces y nos quedamos con
el resto de dos. Si no estás familiarizado
con lo que
es un resto , te recomiendo que lo busques, luego vuelve a este video y reproduce los
últimos segundos
para confirmar que 14 mod
cuatro de hecho equivale a dos. El signo igual aquí
es como asignamos valores a las variables
que vimos antes, como int x es igual a uno. También tenemos algunos operadores
booleanos, como su nombre indica, estos son operadores que devuelven
true o false. Primero, tenemos algunos
operadores bastante autoexplicativos mayores que, menores que,
mayores o iguales a, y menores o iguales a. Este signo de exclamación voltea verdadero a falso y falso a verdadero. Te veremos en
la siguiente diapositiva cómo funciona
la sintaxis precisa
de esto. Ahora tenemos dobles iguales. Esto significa que devuelve verdadero si es igual, devuelve falso si no es igual. Recuerda esto, ya que
es un poco complicado, signo
doble igual se
usa para comparar la igualdad. Se
utiliza un solo signo igual para asignar valores. Double ampersand
significa return true si ambas condiciones son verdaderas, de
lo contrario devuelve false. Y esta doble línea recta
significa devolver true si
alguna condición es verdadera, de
lo contrario devuelve false. Este operador podría no ser
familiar para la mayoría de las personas. Entonces aquí es donde está.
En un teclado Logitech. lo general, está al lado de las llaves
del soporte. Veamos algunos
ejemplos de uso. Primero, uno más dos es obviamente 3.1 menos dos es
obviamente negativo uno. nada complicado ahí. Ahora bien, para el cociente
donde tenemos 3/2, recordemos que la división de Java
en enteros es para la división 3/2 es uno. Como estamos redondeando a la
baja de 1.5, producto es igual a seis. nada complicado ahí.
Tres por dos es seis, y Java no hace
nada especial con eso. El resto es igual a
uno porque dos entra en cinco dos veces y tenemos un
uno sobrante después de obtener, después de multiplicar dos por dos,
este booleano true, true subrayado cero
es igual a true porque nosotros agregó este signo de
exclamación justo antes de un falso. Entonces el signo de exclamación
voltea las expresiones falsas a expresiones verdaderas y
las expresiones verdaderas a expresiones
falsas. Entonces, por lo tanto, esto es
cierto, cierto subrayado uno también es cierto porque tres es efectivamente
mayor que uno negativo. subrayado verdadero dos también
es cierto porque estamos negando cero
es igual a uno. Bueno, cero no equivale a uno. Entonces esta expresión
entre paréntesis, va a devolver false. Entonces la inversión de
eso va a ser cierta. Así que el verdadero subrayado
dos se vuelve cierto. subrayado falso cero
es igual a falso. Porque recuerda,
double ampersand solo devuelve true si ambas
expresiones son verdaderas. Cierto subrayado cero es cierto. No obstante, la inversión del verdadero subrayado uno
va a ser falsa. Entonces, por lo tanto, no es
cierto que ambos sean ciertos, y por lo tanto el
resultado es falso. Por último, el subrayado verdadero
tres va a ser igual a verdadero porque llamamos a esta cosa de
doble línea recta, vuelve true si alguna
de las condiciones es verdadera. En este caso, el falso
subrayado cero es falso. Sin embargo, el verdadero subrayado
cero es cierto. Y así pues, debido a que una
de las condiciones era cierta, toda
la expresión
evalúa a verdadera. Ahora que hemos cubierto los operadores
básicos, veamos cómo podemos controlar el flujo de lógica
dentro de un programa. Primero, tenemos
el patrón if-else. Colocamos una
expresión booleana entre paréntesis inmediatamente
después del operador IF. Si esta expresión aquí
se evalúa como true, entonces realizaremos
toda la lógica dentro las llaves que inmediatamente siguen a la expresión
booleana. En este caso, devuelve x más y. Esta expresión
se evalúa como false. Entonces saltaríamos todo el código que encierra las
llaves aquí mismo, y en su lugar ejecutaríamos
el código dentro de las llaves del caso
else aquí mismo, en este caso devuelve cero. Recordemos de un video anterior que mencioné que return es terminal y no deberíamos tener ninguna línea de código
después de una línea de retorno. Entonces, ¿por qué es que aquí tenemos múltiples
líneas de retorno aquí mismo? Piénsalo y te
revelaré la respuesta en el 321. La razón es que solo uno de estos Bloques de Código se ejecuta
cada vez que se llama al método. Estos bloques de código son mutuamente
excluyentes el 100% del tiempo. El punto sutil las minas de
retorno sean
terminales es que son terminales solo para
el bloque
de código dado en el que existen. Y esto tiene sentido
si lo piensas bien. Este método ejemplo uno ha sido declarado para
devolver un entero. Imagínese si solo escribiéramos
esta línea de retorno x más y, pero no tuviéramos
esta línea cero de retorno. Entonces imaginemos además
que pasamos en una x tal que esta expresión
se evalúa como falsa. Entonces saltaríamos esta línea de
retorno y llegaríamos
al bloque else donde ya
no tenemos un
cero de retorno, entonces este método no
devolverá nada. Y entonces este método
estaría rompiendo esta promesa de que
devolverá un entero. Entonces esto conduciría a una falla de compilación de
Java. Aquí hay otro patrón if-else, pero esta vez utilizando algunos operadores de los que
hablamos antes. Una vez más, encerramos toda
la
expresión booleana entre paréntesis. Si x mod dos es igual a uno, o y mm R2 es igual a cero. Entonces ejecutamos todo este bloque de
código devuelto X más Y. De lo contrario, si ambas condiciones
son falsas, devolvemos cero. Aquí hay otro ejemplo, esta vez presentando un nuevo operador. De lo contrario si el nombre del
operador es bastante intuitivo, y hace
lo que podría esperar si esta expresión booleana
se evaluara como falsa. Se saltaría la línea de retorno x más y y luego intentaría evaluar la expresión booleana contenida en la línea else-if. Si esta expresión x mod
tres es igual a uno, evalúa como true,
entonces devolvemos x. De lo contrario, si esta
expresión fuera falsa, saltaríamos return x
y llegaríamos al caso else, en cuyo caso volvemos y. Ahora, hablemos
del patrón salvaje. A veces puede
resultarle útil
ejecutar un determinado
bloque de código varias veces. Por ejemplo, diga que desea
imprimir números de
uno a mil. Una forma de hacerlo
sería escribir
system.out.print LAN 1,000 veces. Pero otra forma de
hacerlo sería
escribir un único sistema
dot out dot print LN, y encerrarlo dentro de
un bloque de código salvaje. Entonces aquí hay un ejemplo. La forma en que esto funciona es que
primero evaluamos la
expresión aquí. Y mientras n es
mayor que cero, si esto es cierto, entonces
ejecutamos todo el código dentro de
este bloque de código. Al final del bloque de código, volvimos al inicio y evaluamos nuevamente esta
expresión. ¿Es n mayor que cero? Si es así, volvemos a ejecutar el bloque de
código. Y luego repetimos,
volviendo de nuevo a esta expresión booleana una y
otra vez hasta que sea falsa. Esta sintaxis aquí puede ser un
poco desfamiliar para usted. Vamos a desglosarlo
comenzando con esta línea, n es igual a n menos uno. Recordemos, el operador equals significa asignar un
valor a una variable n. Pero antes de que podamos
asignar un valor a n, primero
necesitamos
entender cuál es el valor de esta
expresión, n menos uno. Entonces, básicamente, lo que esto hace es que primero resta
uno de n, y luego una vez que lo hace,
asigne este valor de nuevo a n Así que efectivamente, solo estamos disminuyendo el
valor de n en uno. Entonces, si n entra como un cinco, evaluamos cinco menos 15, menos uno es cuatro, y luego asignamos el
valor cuatro a n Entonces n es ahora para estas
otras dos líneas y menos, menos y menos es igual a uno, en realidad ambos
son
taquigrafía para lo mismo, n es igual a n menos uno. Por lo que todo este
bloque de código efectivamente está decrementando n en tres
cada vez que se ejecuta. Sintaxis similares existen
si se quiere aumentar
el valor de n, simplemente
podríamos hacer
n más más y
más es igual a uno y
n es igual a n más uno. También me gustaría
impartir una advertencia. Java realiza muchas
comprobaciones de cordura en tiempo de compilación. Pero una cosa que
no comprueba es si tu loop
terminará. Por ejemplo, imagina que estas tres líneas fueron
todas incrementando. Estamos aumentando el
valor de n. Así que n más más y más es igual a
uno y n es igual a n más uno. Ahora imagina que también
pasamos en un valor de n que ya es
mayor que cero, entonces este bloque de código
aumentará n aún más. Y esta expresión aquí mismo, y mayor que cero nunca
será falsa. Y así pues, este bloque de código va a correr para siempre. Si esto sucede, tu código no se
equivocará y el compilador
tampoco se equivocará. Simplemente seguirá funcionando para siempre hasta que reconozcas el
problema y detengas el código. Así que tenga en cuenta
cuando escriba bucles y asegúrese de que su condición
terminará eventualmente. Aquí está nuestro patrón
de control final para este video. He aquí un ejemplo. Tenemos cuatro
seguidas de tres expresiones encerradas entre paréntesis y delimitadas con punto y coma. La primera expresión está
en etapa de inicialización. La variable i aún no
existe en este método, por lo que ambos declaramos y la
asignamos a un valor cero. A continuación, tenemos la expresión
booleana, similar a la
expresión booleana en el bucle while. Esta es una
expresión booleana que va a ser evaluada antes de que se ejecute
el bloque de código. Si es cierto,
ejecutamos el bloque de código. Si es falso, salimos del bloque de código y ejecutamos cualquier código que venga
después de este for-loop. Por último, cambiamos el estado. Este I plus plus se ejecuta
después de ejecutar el bloque de código. Entonces ya que estamos empezando desde cero y corriendo
hasta que ya no es menor que n y estoy aumentando en uno en
cada iteración. Efectivamente estamos
imprimiendo números de cero a n menos uno. Aquí hay un par de
ejemplos más de for-loops. Observe aquí que
podemos inicializar i, una
línea de código completamente separada. Si no se
necesita inicialización para el bucle for. Déjame poner un
punto y coma y dejar vacía
la primera
expresión de inicialización. Aquí tenemos otro ejemplo. Quiero que tomen nota
particular de la inicialización aquí. Recordemos de nuestra lección anterior que una vez que se
ha declarado una variable, las referencias
futuras
a esa variable no necesitan escribir
para ser especificadas. Esa es la razón por la que aquí sólo
decimos que yo es igual a tres, pero no int I es igual a tres. Las mismas reglas se aplican
tanto a la
expresión
de inicialización las expresiones independientes fuera los paréntesis de bucle for. Ahora, tal vez te estés
preguntando a ti mismo, ¿Cuál es la diferencia
entre un bucle for y un bucle while aparte del hecho que hay sintaxis
es diferente? Bueno, la respuesta es que
en realidad son efectivamente
lo mismo. Realmente, la única
diferencia importante es su sintaxis. Así que no pienses demasiado cuáles podrían ser las diferencias
entre estos dos. Aquí está el enlace al
código utilizado en este video. Como siempre, por favor
haga clic en el enlace, haga clic para pinchar y
experimental en el código. Una cosa que me gustaría
que pruebes esta vez es si te encuentras con
algún error de Java que
puedas encontrar un poco
críptico y
te animas a copiar y pegar ese mensaje de
error en Google. La causa raíz de los mensajes de error suele ser bastante similar. Y muchas veces encontrarás resultados
realmente útiles de foros de programación
que Google dirige C2.
6. Objetos Parte 1: Bienvenidos amigos. Hoy vamos a
hablar de objetos. Ahora, me di cuenta de
que, eso suena muy tonto, que vamos a
hablar de objetos. Pero te prometo que
vas a aprender algo valioso
al final de esta lección. Ahora, antes de entrar en
el contenido de este video, déjame intentar
convencerte de por qué
deberías importarte en absoluto los
objetos. Hasta ahora, solo hemos estado tratando con el
aspecto funcional de Java, como los métodos
y la lógica de control. Sin embargo, Java es
en realidad lo que llamamos un lenguaje
orientado a objetos. Esto significa que vemos nuestros
programas como objetos con comportamientos más que como una
colección de funciones. Esto puede ser un poco
difícil de entender. Una analogía en
la que podrías pensar es cómo ves un videojuego. Digamos Mario, por ejemplo en caso de que no estés
familiarizado con Mario. Aquí tienes una captura de pantalla de
uno de los juegos de Mario. Este tipo de aquí es Mario. Y la premisa del
juego aún está por
superar un montón de obstáculos
para llegar a una princesa. Y estas cosas de
hongos de aspecto divertido de aquí, suelen moverse y que te toquen,
pierdes una vida. Ahora bien, un juego de Mario es obviamente
una pieza de código, ¿verdad? Probablemente haya algún trozo de código que comprueba la distancia
desde el hongo hasta Mario. Y a la distancia es
menor que algún umbral. Entonces restamos uno
de la vida de Mario. Pero no es así como
pensamos de este juego. No pensamos en estos
hongos como métodos que
constantemente están comprobando
la distancia a Mario. Y no pensamos a un Mario como un montón de métodos
que constantemente están calculando su velocidad vertical
y horizontal. Simplemente pensamos en Mario como una sola entidad que exhibe comportamiento de salto y
carrera. Y pensamos en estos
hongos como entidades que
activamente están tratando de impedir que salvaremos
a la princesa. Ese cambio de paradigma es el mismo
que tenemos hacia Java
como lenguaje funcional versus Java como uno orientado a objetos. Incluso si no estamos
codificando un videojuego, a
los desarrolladores les resulta
útil pensar su código como objetos discretos que exhiben comportamiento en lugar de como una colección de funciones
abstractas. A medida que trabaja en proyectos Java
cada vez más grandes, se vuelve significativamente más
fácil entender el
programa en su conjunto. Si tienes un diseño sólido orientado a
objetos, porque
así es como los humanos perciben el mundo como una
colección de objetos. Aquí hay un ejemplo
de una clase que exhibe programación
orientada a objetos, así
como un método principal que utiliza esta clase
como objeto. Primero, me gustaría señalar que
a pesar de alguna sintaxis poco familiar, en realidad
hay
mucho aquí que ya
hemos cubierto. Aquí. Tenemos paquetes,
tenemos clases públicas. Tenemos un método principal que sirve como
punto de entrada al programa. Y aquí tenemos
declaraciones de método. Y tenemos un bloque if else aquí con una expresión booleana. Así que la cantidad de cosas
que necesitamos saber para entender la programación
orientada a objetos no
es tan mala en absoluto. Hablemos de este bloque
de código aquí. Esto es algo que
llamamos constructor. Una forma de
saber que este es
un constructor es que no hay
ningún tipo de retorno y la declaración del método
y el nombre de este bloque de código coincide con
el nombre de la clase. Pero aparte del hecho de
que la declaración de este bloque de código es
diferente a la de un método. Básicamente actúa como un método. Y este bloque de código se
ejecuta tras la instanciación. instanciación es cuando
creamos una nueva instancia
de un objeto. Puede ser un poco difícil de
entender cuando instancias en términos
de esta clase Dog. En cambio, recordemos
nuestros ejemplos anteriores. Cuando creamos un
número entero variables. Imagina que tenemos dos
variables enteras, x e y. Tal vez x es igual a uno
e y es igual a dos. Dado que tanto x como y son enteros, se
puede pensar en ellos como dos instancias
del tipo entero. Sólo ellos tienen valores diferentes. De igual manera, se puede imaginar que
podríamos tener dos
variables, x e y, ambas han
escrito Dog y tienen valores
diferentes para
su nombre y edad. Una instancia de un objeto es
exactamente lo que parece. Es una versión de un objeto. Hablaremos sobre
cómo instanciar un objeto en el siguiente video. Por ahora, todo lo que necesitas saber es que cuando se produzca
la instanciación, este bloque de código será lo
primero que se ejecute. Y también hablaremos de
lo que esto realmente significa. Este nombre es igual al nombre y
esta edad de punto es igual a la edad. Estos aquí son ejemplos de lo que llamamos variables de instancia. Para ser más específicos, están declarando variables de
instancia, pero no inicializándolas
a ningún valor en particular. Podríamos dar estas
variables y valor
inicial a la declaración, como el
nombre de cadena privada es igual a Bob, aquí
mismo en esta línea. Sin embargo, normalmente delegamos la inicialización de la variable
al constructor, ya que el constructor
va a ser lo primero que
se llame de todos modos. Y tal vez no sea una idea inteligente nombrar a
todos nuestros perros, Bob. Eso sería
extremadamente confuso para todos nuestros amigos cachorros. Como puede ver, al igual que
cualquier otra variable en Java, estas variables de instancia deben tener un tipo explícitamente
declarado. También necesitan modificadores de acceso, igual que clases y métodos. Hay dos diferencias
importantes
entre las variables de método, variables de
instancia. La primera diferencia es que las variables de
instancia persisten
en las llamadas a métodos. Una variable de método solo existe mientras el
método siga ejecutándose. Una vez que un método devuelve todos sus valores variables
se borran de la memoria. Para los objetos, estos valores de
variable de instancia persistirán mientras exista la
instancia de objeto. Esto tendrá más
sentido cuando veamos un ejemplo de
instanciación de objetos en el siguiente video. La segunda diferencia
son sus reglas de acceso. Las variables de método
solo son accesibles dentro del bloque de código más interno
en el que se crean. ejemplo, si tuviéramos un bucle while
dentro del método getName. Y dentro de ese bucle while, creamos una variable. variable
solo sería accesible dentro del bloque
de código del bucle while. Sin embargo,
las variables de instancia son accesibles desde todos los
métodos no estáticos dentro de la misma clase. Vamos a
hablar de lo que
realmente significa estática en
el siguiente video. Pero por ahora, todo lo que
necesitas saber es que un método no estático
es aquel que no
tiene estática antes de que se declaren el tipo de retorno y
la declaración del método. Como puedes ver aquí, podemos devolver el valor de nombre y edad a partir de
estos métodos aquí. Estas variables de instancia
son accesibles para estos métodos ya que estos
métodos no son estáticos, el prefijo este punto le dice a Java que nos estamos refiriendo a una variable de
instancia llamada name. Ahora bien, se podría
pensar que este es un requisito ridículo que
tuvimos que agregar aún
más reglas de lenguaje
para referirnos a las variables de instancia. Pero hay una buena
razón para esto. ¿Se puede decir qué
es? Pausa el video y te revelaré
la respuesta en 321. La razón es que podríamos
tener conflictos de nombres entre variables de instancia
y variables de métodos. Un ejemplo de esto es en realidad aquí mismo en el constructor. Tenemos el nombre de la variable declarado en los argumentos
del constructor. Si tuviera que omitir el, este prefijo en esta línea,
esto.nombre es igual a nombre, entonces básicamente
solo tendríamos nombre igual a nombre, que no hace nada porque
nombre ya es igual a nombre. Entonces el, este prefijo
es importante para desambiguar entre instancia y variables de
métodos. Si no hay este
prefijo y hay una variable de método
con el
mismo nombre que la variable de instancia, entonces Java asumirá que te estás refiriendo a la variable
method. Aquí está el código
utilizado en este video. Como siempre, haga
clic en el enlace, haga clic en Ondulación de horquilla
y experimente. Si encuentra algún mensaje de error
críptico, intente pegar su mensaje de
error en Google y vea lo que otras
personas tienen que decir. De lo contrario, no dude en publicar
preguntas en este curso.
7. Objetos Parte 2: Bienvenidos amigos. En este video, vamos a concluir nuestra discusión sobre
los objetos. Mencionamos la instanciación de objetos
en el video anterior. Veamos cómo funciona. Primero, recordemos que el
constructor de perros se ve así. Tiene dos argumentos,
nombre y edad. En nuestra clase principal, creamos dos instancias de
la clase oscura así. Primero, según la tradición
Java, especificamos explícitamente el tipo de la variable que estamos creando, que es el tipo oscuro. La siguiente parte por aquí, parece casi una llamada a método, excepto que tenemos
esta palabra clave, nueva. La nueva palabra clave emparejada con la llamada al constructor le dice
a Java que primero asigne memoria para
una copia del objeto perro. Y una vez que esa memoria
ha sido asignada, llama al constructor. Ejecutando cualquier código que esté en
la definición del constructor. Después de ejecutar estas
dos líneas de código, Bobby y Sam ahora tienen
sus datos de nombre y edad guardados dentro de las instancias del primer perro
y segundo perro. Ya que guardamos esos datos en sus variables de instancia las
cuales persisten. Ahora, hablemos de estática. Aquí está la clase
de perros del último video, pero con algunos complementos. Hemos agregado la palabra clave estática entre el modificador de acceso y el tipo en la declaración de método
y variable. Recordemos que las variables
y los métodos sin la
palabra clave static o non-static, también conocidos como
variables de instancia y métodos de instancia. Como su nombre indica, las variables de
instancia y los métodos de instancia son específicos de las instancias
de un objeto. Sin embargo, las variables
estáticas y los métodos estáticos son lo contrario. No pueden vincularse a una instancia
específica de un objeto. Este oscuro ejemplo podría
ayudarte a entender. Si quieres saber el
número de patas de un perro, ¿necesitas un perro específico
para responder esa pregunta? Por supuesto que no. Sabes que los perros en
general tienen cuatro patas. El número de patas
de un perro no es específico de una
instancia particular de un perro. Por otro lado,
si quieres saber el nombre o la edad del perro, necesitamos un perro muy específico
para responder a esa pregunta. Así que los métodos de instancia
y las variables son específicos de
instancias particulares de la clase. Los métodos estáticos y
las variables se aplican a todas las instancias de la clase. Echemos un
vistazo a cómo consultamos métodos
estáticos versus métodos de
instancia. Dado que non legs es un atributo público
y estático, podemos pedir acceder directamente
con dog dot non legs. Tenga en cuenta que el perro no es una instancia específica
de la clase de perros. La clase canina en sí no
tiene nombre ni edad. También podemos acceder a
obtener colas entumecidos directamente a la clase punto
sin una instancia. Sin embargo, para conseguir la edad, necesitamos acceder a ella a través de
una instancia específica. Segundo perro, ya que solo instancias
específicas de perros tienen datos de edad
asociados a ellos. Además, tenga en cuenta que todavía
podemos acceder a métodos
estáticos y variables desde una instancia de un objeto. Y nuevamente, si
lo piensas, es bastante intuitivo. No te puedo decir la edad
del perro sin un perro específico, pero no puedo decirte
cuántas patas y colas tienen los perros en general, si te doy una referencia
específica de Dr.. Aquí está el código
utilizado en este video. Como siempre, por favor
haga clic en el enlace para ver la ondulación y juguetear con el código para ver qué
funciona y qué no.
8. Comentarios: Bienvenidos amigos. En este video, vamos
a hablar de comentarios. A veces el código Java
puede ser muy confuso, especialmente si tienes
un bloque de código que llama a otros métodos y esos métodos
llaman aún más métodos. Esto causa problemas más adelante ya que
encontrarás que a veces tienes problemas para entender tu código justo después de unos días. Y si alguna vez planeas
colaborar con otras personas, tendrás
que asegurarte de que tus colaboradores sean capaces de entender
tu código para. Para ayudar
con la legibilidad del código, Java tiene una forma para que
los desarrolladores agreguen notas
legibles por humanos a su
código. Aquí hay un ejemplo. Los comentarios en línea son prefaciados con doble slash y
generalmente se agregan ya sea después del código en la misma línea o en la línea
inmediatamente encima del código, el comentario está describiendo
los textos que caen. La doble diagonal es una pieza de
texto legible por
humanos que no es
ejecutable por Java. Existe únicamente para
ayudar al lector humano, el programa con comprensión con el código adyacente está haciendo. Aquí hay otro ejemplo. Esto es lo que llamamos
un comentario doc de Java. Existen herramientas por ahí que generarán documentación para tu código escaneando archivos busca de comentarios que
sigan este formato. No vamos a usar una herramienta de
doc Java en este curso, pero es bueno que sepas
cómo escribir descripciones de
métodos
aseadas y bonitas. Java, doc, comentarios
o multilínea. Comienzan con una estrella slash
star, y star slash. Las líneas entre medias deben tener un solo asterisco
al principio. Por lo general, los comentarios java
dot tienen una descripción de alto nivel
del método como la que tenemos aquí, seguido de Program
y at return tags. Si tuviéramos múltiples argumentos, tendríamos múltiples etiquetas de
app por m. Cada uno nombraría el
perímetro que está describiendo, seguido de una descripción
de lo que es el argumento. La etiqueta de retorno está presente para un método no void y contiene una descripción
de lo que se devuelve. No es necesario apegarse
estrictamente a este formato si no estás generando
documentación con la herramienta Java doc. Pero aunque no lo seas, generalmente
es una buena práctica
seguir este formato
siempre que puedas. Aquí está el código
utilizado en este video. Por favor visite el enlace, haga clic, Tenedor, ondulación
y juegue con el código.
9. Arrays y ArrayLists: Bienvenidos amigos.
Enhorabuena llegar tan lejos
en el curso. En este video,
vamos a
hablar de arrays y ArrayLists. Hace un par de videos. Cuando
cubrimos por primera vez los tipos de Java, mencionamos el tipo de matriz, pero realmente no entramos en demasiados detalles
sobre lo que es. Hoy. Vamos a revisar las matrices con mucho mayor detalle. Recordemos que primero
vimos una matriz de cadenas en la firma
del método del método principal. Aquí hay una forma en que
podemos crear una matriz. Si ya sabes
qué valores
queremos usar para inicializar, podemos poblarlo directamente
así especificando el
tipo de la matriz, en este caso una matriz entera, e incluyendo el valores
y llaves como así. Si aún no sabes qué valores
quieres usar, primero
podemos inicializar
una matriz de ceros con la nueva palabra clave y
especificando la longitud de
la matriz entre paréntesis. Entonces, cuando estemos listos
para poblar la matriz, podemos establecer los elementos
directamente así. Un par de cosas a tener en cuenta aquí. Primero, la longitud de una matriz es fija y no se puede
cambiar una vez creada. Así que tanto la matriz uno como la matriz dos van a ser de longitud
tres y siempre lo serán. Entonces. En segundo lugar, los índices de matriz
comienzan en cero. En muchos lenguajes,
incluido Java, casi todos los índices
a través de estructuras de datos, también
comenzaremos desde cero. Ahora bien, si quieres imprimir todos los elementos de
la matriz uno por uno, creamos una variable I para referirnos al
índice de la matriz. E incrementamos este valor I por uno hasta llegar a la
longitud de la matriz, que podemos buscar
usando este atributo length. Podemos acceder a un
elemento individual en la matriz con estos corchetes e
índice de 01 o dos, que se referían al primer, segundo y tercer elementos
respectivamente en la matriz. Entonces esas son matrices. A continuación tenemos ArrayLists, que son una
versión más flexible de arrays. Similar a las matrices. Las listas de matriz también son
colecciones ordenadas de artículos. Sin embargo, una distinción
conceptual importante es que ArrayLists son redimensionables y ArrayLists también tienen una sintaxis
diferente. Exploremos estas diferencias. El primero es que ArrayList
se inicializan así. La cosa en los
corchetes angulares especifica el tipo de elemento en
la colección ordenada. Y solo necesitamos proporcionar
explícitamente el tipo en el lado izquierdo de
la inicialización. Esta línea instanciaría
una ArrayList con longitud cero. También noté que usamos entero
capital aquí
en lugar de int minúscula. Esto es algo que llamamos
una caja para escribir en Java. No es súper relevante
para este curso, así que no necesitamos
dedicarle demasiado tiempo. Llamamos al tipo int
un tipo primitivo, y al tipo entero con una I
mayúscula, un tipo de referencia. Ints y enteros son generalmente interconvertibles y
mapean uno a uno entre sí. Por ejemplo, un valor int de uno se mapearía a un valor
entero de uno. Todo lo que realmente necesitas saber es que el
tipo de referencia integer con un I mayúscula es necesario para algunas estructuras de datos
como ArrayLists. Dado que ArrayLists sólo puede aceptar tipos de
referencia como sus elementos. Esta es solo la forma en que se diseñó
java. Así que no te detengas demasiado en ello. Solo tenlo en cuenta. Si
alguna vez intentaste usar una lista de arreglos la próxima vez
que vayas de compras de comestibles. Siguiente, Así es como agregas
elementos a la lista. Entonces uno está en el índice
012 está en el índice uno, negativo siete está en el índice
2.19 está en el índice tres. También podemos eliminar
elementos de la lista, lo que eliminará el elemento en
el índice especificado y
disminuirá el tamaño de la lista en uno. En este caso, vamos
a estar quitando el índice dos, que en nuestro ejemplo
va a ser el valor
de siete negativo. Entonces después de ejecutar esta línea, tendremos el valor
uno en el índice cero, el valor 12 en el índice uno, y devaluaremos 19 en el índice dos. Ya que todos los valores después del índice dos van a ser desplazados por uno para dar cuenta de la eliminación. Otra diferencia es la forma en que obtenemos la longitud de la matriz. Mientras borro tenía una longitud de atributo
público. Las listas de matriz tienen un
método público llamado size. También tenemos lista punto llegar aquí en lugar de corchetes
para acceder a los elementos. Estamos introduciendo muchos
métodos y atributos específicos para borrar una
ArrayList en este video, lo que podría ser un
poco abrumador. Si te sientes así. No te preocupes. La informática no es una disciplina basada
en la memorización. Si alguna vez olvidas
algo pequeño, o si estás tratando de encontrar
alguna funcionalidad extra para estas estructuras de datos,
solo búscalo en Google. Los resultados de Google para preguntas básicas de
programación suelen ser muy relevantes ya que muchas personas antes de
ti probablemente tenían las mismas preguntas que hacer cuando
comenzaron a programar. Por último, me gustaría mostrarles una forma abreviada de
iterar a través de la lista. Este bloque de código hace exactamente lo
mismo que este bloque de código sobre el elemento int
le dice a Java que estamos tratando cada elemento
de la lista como una variable llamada elemento con tipo int y la lista de dos puntos le dice a Java que esta es la
lista sobre la que queremos iterar. Como nota al margen, también
podríamos haber escrito el tipo como entero
con una mayúscula a aquí. Recuerde, int y integer son
generalmente interconvertibles. Solo necesitábamos usar
integer con una I mayúscula cuando declaramos que
el tipo de ArrayList aparece inicialmente. De todos modos en la primera iteración
de este bloque de código, elemento va a
estar enlazado a uno. En la segunda iteración, va a estar ligada a 12. Entiendes la idea. Java solo maneja
el incremento de la variable de índice por usted
con esta sintaxis simplificada. Ahora, tal vez te estés preguntando, ArrayList puede hacer todo lo
que las matrices pueden hacer. Y ArrayLists incluso tienen funcionalidades
adicionales
ya que pueden ser redimensionadas. Entonces, ¿por qué
los desarrolladores de Java no acaban de eliminar o
borrar del lenguaje? Pausa el video y te
revelaré la respuesta en 321. La razón es que hay
una compensación de rendimiento involucrada cuando se usa una
ArrayList en lugar de una matriz. Arraylist con tipos de
referencia son generalmente un poco más lentos que arrays que usan tipos primitivos. Sin embargo, para la mayoría de los casos de uso, la
compensación de rendimiento no es lo suficientemente
notable como para
marcar la diferencia. Pero es algo a tener en
cuenta si alguna vez estás trabajando en algo que
sea sensible a la latencia, como si estás programando y un láser de ultra alta precisión, o estás tratando de construir un
negociación de acciones ultrarrápida. Pero aquí está el código
que usa este video. Por favor visita el
enlace, haz clic en Horquilla, ondulación y
juguetea con el código.
10. Sudoku: Hola amigos. Enhorabuena por terminar todos los
videos instructivos de este curso. Hoy, llegamos a usar lo que
hemos aprendido para construir un juego visual interactivo que puedas compartirlo en mi
currículum y con tus amigos. He vinculado un documento bastante
completo en la pestaña de proyectos
y recursos. Adelante y haz clic en este enlace. Y debería
llevarte a este documento. Te dejaré leer
la mayor parte de este documento en tu propio tiempo, pero voy a
repasarlo brevemente ahora mismo, solo para que al menos tengas una idea general de
lo que está pasando. Me gustaría prefaciar
esto diciendo que este proyecto no está
destinado a ser súper duper,
fácil, o terminado dentro de los 10 min. Sé que algunos de los
otros cursos de esta plataforma son muy simples, como escribir una clase que
tenga tres métodos en ella. Pero realmente no creo que
vayas a aprender tanto
si eso es todo lo que estás haciendo después de revisar
estos videos. Por lo que este proyecto puede
requerir más pensamiento que otros proyectos si has realizado otros cursos de Java
en esta plataforma, pero no te desanimes. Fue diseñado de esa manera. Para que pueda obtener experiencia con una asignación de codificación real que realmente lo aliente a
comprender la programación
orientada a objetos. Asegúrese de leer
todo este documento. Es probable que tengas muchas preguntas sobre
el proyecto que
ya están respondidas aquí.
Antes de comenzar. Asegúrate de haber creado una cuenta en repl it.com, y también asegúrate de
haber verificado tu correo electrónico. De lo contrario no podrás
bifurcar y
hacer cambios en los archivos. Una vez que lo hayas hecho, visita
este enlace y bifurca el sorteo. Este proyecto que hemos vinculado
aquí se llama esqueleto. Lo que esto significa es que parte del código
se ha hecho por ti. Muchos métodos se han dejado en blanco y tienen un comentario para hacer bloques de código que tienen el comentario de todo significa que
tenías que rellenar el
código para esa sección. En este proyecto,
vas a estar implementando Sudoku por si no
estás familiarizado. He escrito una descripción de este juego en la sección de
resumen aquí. Aquí, he escrito
una breve descripción de cada uno de los archivos
de este proyecto. El orden en el que se listan
estos es el orden en el que
debes completar el proyecto. Primero debes hacer auto, luego remar, luego
bloquear, luego subir. Principal ya
se ha hecho para ti. Aquí, he escrito lo que
acabo de decirte explícitamente. Después de completar cada clase, debe ejecutar todas
las pruebas unitarias y asegurarse de que las
pruebas unitarias relacionadas con la clase que
acaba de terminar nuestro pase. Primero. Después de completar la celda, debes asegurarte de que todas las unidades tengan
relacionadas con el pase de venta. Después de completar la fila, debe asegurarse de
que todas las pruebas unitarias asociadas con celda y
fila pasen, así sucesivamente. La siguiente sección aquí
te dice cómo
ejecutar realmente la prueba. En el panel izquierdo de la sección de
herramientas en repl it, podrás acceder a herramientas. Herramientas. Y después de hacer
clic en la pestaña Herramientas, deberías poder ver
las pruebas unitarias. Una vez que haga clic en las pruebas unitarias, debería poder
ver esta ventana emergente, que tiene un botón Ejecutar prueba. A pesar de que aún no hemos
empezado a codificar. Simplemente ejecutemos la
prueba unitaria y veamos qué pasa. Volvamos a
nuestro esqueleto de Sudoku. Vamos, nuevamente, vamos
a la pestaña Herramientas. Hacemos clic en pruebas unitarias
y hacemos clic en Ejecutar pruebas. Después de hacer clic en Ejecutar pruebas, podemos pasar a
la pestaña de la consola. Ya lo tengo abierto aquí, pero por si no lo haces, lo
puedes encontrar en la sección de
herramientas. Entonces en herramientas, vas a consola. Y ahora podemos ver la salida. En este caso tuvimos cero de 20 pruebas pasan ver errores arriba. Entonces esto es bueno. Esto significa que todas nuestras
pruebas son realmente significativas. Piénsalo. Si alguna de nuestras pruebas pasara cuando ni
siquiera se ha escrito ningún código, eso sería una muy mala señal. Eso significaría
que la prueba en
realidad no está probando nada en absoluto. Entonces, después de completar
el proyecto, todas estas pruebas deben pasar. la siguiente sección aquí, he escrito algunos consejos de depuración en caso de que tengas algún problema. Sin embargo, como
es probable que seas nuevo en la programación, está totalmente bien si no puedes resolver el problema solo. Si te encuentras con algún problema,
tienes dos opciones. opción uno es echar un vistazo
rápido a la solución, que publiqué al
final de este documento. opción dos es publicar una pregunta en el
curso Skillshare bajo el, debajo de la pestaña de discusión. Y me pondré en
contacto contigo en cuanto pueda. Por último, después de haber
pasado todas las pruebas unitarias, puedes hacer clic en el botón verde
grande. Jugar al juego
debería verse así. Aquí está mi solución. Entonces haces clic en el botón verde. Después de que haya terminado de
compilar, ejecuta el programa
e imprime esta tabla de Sudoku que tiene
algunos valores rellenados. Ahora podemos jugar con este juego. Entonces digamos por ejemplo que nos gustaría
poner el número, digamos dos en dislocación. Entonces esta va a
ser la fila número uno, ya que esta fila de
periodos, fila cero. Entonces esta es la fila uno, y esta es la columna uno, porque esta de
aquí es la columna cero. Digamos que set 11 para ser dos. Y se puede ver que ahora dos han sido poblados en luxación. Si queremos deshacer eso, podemos hacer claro 11 porque
11 es la coordenada que estamos limpiando y vamos a
conseguir que vuelva a estar vacía. Ahora, intentemos
poner aquí un nueve, que no debería funcionar porque
ya tenemos un nueve
en este bloque. Establecemos 11 a B9. Es un poco decir
que el bloque cero tiene varios nombres y
no te dejará poner un nueve ahí. Si te frustras
y ya no quieres terminar un rompecabezas de Sudoku, puedes simplemente escribir solve. Y ahora resolverá
todo el tablero por ti. Y saldrá
del programa diciéndote que
necesitas volver a ejecutar
el botón de ejecución,
si quieres un nuevo rompecabezas, Existe la posibilidad de que
las pruebas unitarias
que escribí o
no sean exhaustivas. Estoy bastante seguro de que
si pasas una prueba unitaria, deberías poder ejecutar
el juego con éxito. Sin embargo, si pasas todas las pruebas unitarias y
sigues sin poder ejecutar
el juego correctamente. Te recomendaría
simplemente comparar tu solución con
la que publiqué. Cuando encuentre la discrepancia, por favor publique una nota en el curso de
Skillshare para que pueda arreglar el esqueleto o la prueba unitaria
si es necesario arreglarlos. Una vez más, recuerde
leer este documento en su totalidad y
remitirlo frecuentemente. Y eso es todo lo que tenía
que decir para este video. Diviértete en tu primera tarea de codificación
real.
11. Continúa tu viaje: Hola a todos. Soy Derek, y gracias por
ver mis videos He estado trabajando duro en
los últimos meses y acabo de lanzar un nuevo
seguimiento o uno de ciudadanos. Pondré el enlace
en la descripción. He renovado el curso para tener diapositivas de aspecto
más profesional y en general solo una mejor calidad de
producción Tengo este trípode, por ejemplo,
que sostiene mi cámara. Hay un nuevo proyecto
que incorpora las lecciones de esa clase. Pero esta vez he incluido para videos
tutoriales
intermedios para que no estés completamente perdido Esta clase que
acabas de terminar cubre conocimiento
fundamental de Java que es esencial para escribir programas de
trabajo Sin embargo, si alguna vez intentaste escalar tu código
a la
luz de
circunstancias imprevistas
o debido a cambios en la
luz de
circunstancias imprevistas los requisitos, encontrarás que es muy
difícil hacerlo, administrar complejidad del
código es una
habilidad esencial para un programador Y cubrimos muchos conceptos con
los que se espera que estés
familiarizado si alguna vez decides cursar
una educación formal en Programación o si
decides ir a buscar empleo. Espero que hayas disfrutado de
las lecciones de esta clase y que decidas continuar tu viaje
conmigo en la siguiente, te
veré en el siguiente video.