Introducción a Java

Bienvenido al mundo de la programación Java.

Los lenguajes de programación permiten a los humanos escribir instrucciones que

una computadora puede realizar. Con instrucciones precisas, las computadoras
coordinan aplicaciones y sistemas que ejecutan el mundo moderno.

Sun Microsystems lanzó el lenguaje de programación Java en 1995. Java es

conocido por ser simple, portátil, seguro y robusto. Aunque se lanzó hace más de
veinte años, Java sigue siendo uno de los lenguajes de programación más
populares en la actualidad.

Una razón por la que a la gente le encanta Java es la máquina virtual de Java, que
garantiza que el mismo código de Java se pueda ejecutar en diferentes sistemas
operativos y plataformas. El eslogan de Sun Microsystems para Java era "escribir
una vez, ejecutar en todas partes".
Estás interactuando con un sistema usando Java varias veces al día . A partir de
2019, el 88% de los teléfonos inteligentes funcionan con Android, ¡el sistema
operativo móvil escrito en Java!

Los lenguajes de programación se componen de sintaxis, las instrucciones

específicas que Java entiende. Escribimos la sintaxis en archivos para
crear programas, que son ejecutados por la computadora para realizar la tarea
deseada.

Empecemos con el saludo universal para un lenguaje de

programación. Exploraremos la sintaxis en el próximo ejercicio.
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}

Estás viendo un programa de computadora escrito en Java.

¡Hola archivo de Java!

Java se ejecuta en diferentes plataformas, pero los programadores lo
escriben de la misma manera. Vamos a explorar algunas reglas para
escribir Java.

En el último ejercicio, vimos el archivo HelloWorld.java . Los archivos

Java tienen una extensión .java . ¡Algunos programas son un archivo,
otros son cientos de archivos!

Dentro de HelloWorld.java , tuvimos una clase :

clase pública HelloWorld {

}
Hablaremos más sobre las clases en el futuro, pero por ahora
consideremos que son un concepto único .

El HelloWorldconcepto es: Hello World Printer. Otros conceptos de clase

podrían ser: Bicicleta, o: Cuenta de ahorros.

Marcamos el dominio de este concepto se utilizan llaves: {}. La sintaxis

dentro de las llaves es parte de la clase.

Cada archivo tiene una clase primaria nombrada después del

archivo. Nuestro nombre de clase: HelloWorldy nuestro nombre de
archivo: HelloWorld . Cada palabra está en mayúscula.
Dentro de la clase teníamos un main() método que enumera nuestras
tareas de programa:

public static void main ( String [ ] args ) { }

Al igual que las clases, utilizamos llaves para marcar el principio y el final
de un método.

public, staticy voidson sintaxis de las que aprenderemos en futuras

lecciones. String[] argses un marcador de posición para la información
que queremos transmitir a nuestro programa. Esta sintaxis es necesaria
para que el programa se ejecute, pero más avanzada de lo que
necesitamos explorar en este momento.

Nuestro programa imprimió “Hello World” con la línea:

Sistema . a cabo . println ( "Hola Mundo" ) ;

Instrucciones
1.
El editor de texto tiene un archivo, HelloYou.java , que contiene
una HelloYouclase con un main()método.

Adentro main(), agregue una declaración que se imprima Hello someName!,

con su nombre reemplazado someName.

Por ejemplo, mi programa se imprimiría Hello Patrick!.

Código de comentarios
Escribir código es un proceso emocionante de instruir a la computadora
para completar tareas fantásticas.

Las personas también leen el código y queremos que nuestras intenciones

sean claras para los humanos, al igual que queremos que nuestras
instrucciones sean claras para la computadora.
Afortunadamente, no estamos limitados a escribir la sintaxis que realiza
una tarea. También podemos escribir comentarios , notas a lectores
humanos de nuestro código. Estos comentarios no se ejecutan, por lo que
no hay necesidad de una sintaxis válida dentro de un comentario.

Cuando los comentarios son cortos utilizamos la sintaxis de una sola

línea: //.

// calcular el índice de satisfacción del cliente

Cuando los comentarios son largos usamos la sintaxis multilínea: /*y */.

/ *
Elegimos almacenar información en varias bases de datos
para
minimizar la posibilidad de pérdida de datos. ¡Tendremos
que tener cuidado
para asegurarnos de que no se desincronice!
* /
Así es como se vería un comentario en un programa completo:

público de clase CommentExample { // Estoy un comentario

dentro de la clase públicas estáticas vacíos principales (
cadena [ ] args ) { // Estoy un comentario dentro de un
método de sistema . a cabo . println ( "Este programa tiene
comentarios!" ) ; } }

Los comentarios son diferentes de imprimir en la pantalla, cuando los

usamos System.out.println(). Estos comentarios no se mostrarán en nuestra
terminal, son solo para personas que leen nuestro código en el editor de
texto.
Instrucciones
1.
El archivo Timeline.java tiene información de texto plano sobre Java.
Los hechos de texto simple no son sintaxis válida. Usaremos comentarios
para evitar romper el programa.

Utilice la sintaxis de comentario de una sola línea para el primer hecho.

Cambia esta línea en un comentario:

Sun Microsystems announced the release of Java in 1995

2.
Adentro main(), agregue una nueva declaración que muestre cómo se
siente con respecto a la codificación.

Comience el mensaje con: "La programación es ...".

¡Recuerde colocar un punto y coma al final de la declaración!

Compilación: Atrapando errores.

Java es un lenguaje de programación compilado , lo que significa que
un compilador transforma el código de bytes en un código .java antes de
que lo ejecute la Máquina Virtual Java en su computadora.

Un compilador es un programa que traduce lenguajes de programación

amigables para el ser humano a otros lenguajes de programación que las
computadoras pueden ejecutar.

Los ejercicios anteriores han compilado automáticamente y ejecutan los

archivos por usted. Los entornos de desarrollo fuera de la plataforma
también pueden compilar y ejecutar archivos por usted, pero es
importante entender este aspecto del desarrollo de Java, así que lo
haremos nosotros mismos.

El proceso de compilación detecta errores antes de quela computadora

ejecute nuestro código.

El compilador de Java ejecuta una serie de comprobaciones mientras

transforma el código. El código que no pase estas verificaciones no será
compilado.

Este ejercicio utilizará un terminal interactivo. Codecademy tiene

una lección en la línea de comandossi desea obtener más información.

Compilamos un .java archivo con el comando en el terminal: javac

ExampleFile.java.

Una compilación exitosa produce un archivo .class : ExampleFile.class ,

que ejecutamos con el comando de terminal java ExampleFile.

Una compilación fallida produce una lista de errores. No se crea

un archivo .class hasta que se corrigen los errores y se ejecuta
nuevamente el comando de compilación.
Instrucciones
1.
¡Practiquemos la compilación y ejecución de un archivo ingresando
comandos en el terminal!

Nuestro editor de texto contiene un programa dañado para que podamos

ver cómo los compiladores nos ayudan a detectar errores. ¡No hagas
correcciones!

En el terminal, escriba este comando: javac Compiling.javay

presione enter o return .

Utilice el Check Workbotón para avanzar a través de los puntos de control.

2.
¿Ves el error?

El compilador nos dice que a una de las declaraciones de impresión le

falta un punto y coma.

En la terminal, escriba lsy presione return o enter.

El lscomando enumera todos los archivos disponibles.

Solo hay un archivo: Compiling.java , no compilamos el archivo

correctamente debido al error.
3.
Agregue el punto y coma que falta en el editor de texto.

¡Compilaremos y ejecutaremos este archivo en el próximo ejercicio!

Compilación: Creando Ejecutables

La compilación nos ayudó a atrapar un error. Ahora que hemos corregido
el archivo, veamos una compilación exitosa.

A modo de recordatorio, podemos compilar una .javaarchivo de la

terminal con el comando: javac FileName.java.

Si el archivo se compila correctamente, este comando produce

una clase ejecutable : FileName.class . Ejecutable significa que podemos
ejecutar este programa desde el terminal.

Se corre el ejecutable con el comando: java FileName. Tenga en cuenta

que omitimos la parte .class del nombre de archivo.

Aquí hay un ciclo completo de compilación como ejemplo:

// dentro del archivo: Welcome.java

public class Welcome { public static void main ( String
[ ] args ) { System . a cabo . println ( "¡Bienvenido al
curso de Java de Codecademy!" ) ; } }

Tenemos un archivo: Welcome.java . Compilamos con el comando: javac

Welcome.java. El terminal no muestra errores, lo que indica una compilación
exitosa.

Ahora tenemos dos archivos:

1. Welcome.java , nuestro archivo original con sintaxis Java.

2. Welcome.class , nuestro archivo compilado con código de bytes de
Java, listo para ser ejecutado por la Máquina Virtual de Java.

Podemos ejecutar la clase compilada con el comando: java Welcome.

Se imprime lo siguiente en la pantalla:

Bienvenido a Codecademy ' s Java supuesto !

Instrucciones

1.

¡Vamos a compilar y ejecutar nuestro programa!

Ejecute el lscomando en el terminal para ver

el archivo .java sin compilar .

Revisión de Java: Poniendo todo junto

En esta lección, comenzamos a escribir nuestros primeros programas en
Java.
También hemos aprendido reglas y pautas sobre cómo escribir programas
Java:

• Los programas de Java tienen al menos una clase y

un main()método.
o Cada clase representa una idea del mundo real.
o El main()método ejecuta las tareas del programa.
• Los comentarios de Java agregan un contexto útil a los lectores
humanos.
• Java tiene espacios en blanco, llaves y puntos y comas.
o El espacio en blanco es para que los humanos lean el código
fácilmente.
o Las llaves de rizo marcan el alcance de una clase y un método.
o Los puntos y coma marcan el final de una declaración.
• Java es un lenguaje compilado.
o Compilación de errores de captura en nuestro código.
o Los compiladores transforman el código en una clase
ejecutable.
Instrucciones
1.
El editor de texto contiene un archivo vacío
llamado Review.java . ¡Rellenarlo!

Definir un public classnombre Review.

Use llaves de apertura y cierre para el alcance de la clase.

Recuerda, ¡no hay punto y coma para las clases o métodos!

Los programas Java tienen una estructura específica en cómo se
escribe el código. Hay elementos clave que todos los programas de
Java comparten.

El programa
Tenemos el texto de un programa dentro del archivo
llamado HelloWorld.java .

// Este programa muestra el mensaje "¡Hola mundo!" al

monitor

clase pública HelloWorld { public static void main (

String [ ] args ) { System . a cabo . println ( "Hello
World!" ) ; } }

Este programa escribe Hello World!en su terminal cuando se ejecuta.

Mayúsculas y minúsculas
Java es un lenguaje que distingue entre mayúsculas y minúsculas. La
sensibilidad a mayúsculas y minúsculas significa que la sintaxis , las
palabras que entiende nuestra computadora, deben coincidir con el
caso. Por ejemplo, el comando de Java para enviar texto a la pantalla
es System.out.println(). Si tuviera que
escribir system.out.println()o System.Out.println(), el compilador no sabría
que su intención era usar Systemo out.

Repasemos este programa HelloWorld.java línea por línea:

Comentarios
// Este programa muestra el mensaje "¡Hola mundo!" al
monitor
Este es un comentario de una sola línea que documenta el código. El
compilador ignorará todo después //hasta el final de la línea. Los
comentarios proporcionan información fuera de la sintaxis del
lenguaje.

Las clases
clase pública HelloWorld { // código de clase }

Esta es la clase del archivo. Todos los programas de Java están

hechos de al menos una clase. El nombre de la clase debe coincidir
con el archivo: nuestro archivo es HelloWorld.java y nuestra clase
es HelloWorld. Capitalizamos cada palabra, un estilo conocido
como camel case . Las llaves, {y }, marcan el alcance de la clase. Todo
dentro de las llaves es parte de la clase.

Métodos
public static void main ( String [ ] args ) { //
Statements }

Cada programa de Java debe tener un método llamado main(). Un

método es una secuencia de tareas para que la computadora
ejecute. Este main()método contiene todas las instrucciones para
nuestro programa.

Declaraciones
Sistema . a cabo . println ( "Hello World!" ) ;
Este código utiliza el método println()para enviar el texto "Hello
World!" Al terminal como salida. println()proviene de
un objeto llamado out, que es responsable de varios tipos de
salida. Los objetos son paquetes de estado y comportamiento, y a
menudo se modelan en cosas del mundo real.

outestáubicado dentro System, que es otro objeto responsable de

representar nuestra computadora dentro del programa! Podemos
acceder a partes de un objeto con a ., lo que se conoce
como notación de puntos .
Esta línea de código es una declaración , porque realiza
una sola tarea. Las declaraciones siempre concluyen con un punto y
coma.

Espacio en blanco
Los programas Java permiten el uso juicioso de los espacios en
blanco (pestañas, espacios, nuevas líneas) para crear un código que
sea más fácil de leer. El compilador ignora los espacios en blanco,
¡pero los humanos lo necesitan! Use espacios en blanco para sangrar
y separar líneas de código. Los espacios en blanco aumentan la
legibilidad de su código.

Práctica
La estructura de un programa Java le resultará familiar cuanto más
trabaje con este lenguaje. ¡Continúa aprendiendo en Codecademy y
serás un profesional de Java en poco tiempo!
¿Qué es un IDE?
Un IDE, o entorno de desarrollo integrado, permite a los
programadores consolidar los diferentes aspectos de la escritura de
un programa de computadora.

Los IDE aumentan la productividad del programador al combinar las

actividades comunes de escribir software en una sola aplicación:
editar código fuente, crear ejecutables y depurar.

Edición del código fuente

Escribir código es una parte importante de la
programación. Comenzamos con un archivo en blanco, escribimos
unas pocas líneas de código y ¡nace un programa! Los IDE facilitan
este proceso con características como el resaltado de sintaxis y el
autocompletar.

Resaltado de sintaxis
Un IDE que conoce la sintaxis de su idioma puede proporcionar
señales visuales. Las palabras clave, palabras que tienen un
significado especial como classen Java, se resaltan con diferentes
colores.

Compara estos dos ejemplos de código:

// sin sintaxis destacando

pública clase NiceDay {

públicas estáticas vacíos principales ( cadena [ ]
args) {
System.out.println ( " Se ' s un buen día fuera
! " );
}
}
// con la sintaxis que resalta
la clase pública NiceDay { public static void main (
String [ ] args ) { System . a cabo . println ( "¡Es un
buen día!" ) ; } }

El resaltado de sintaxis facilita la lectura del código al aclarar

visualmente los diferentes elementos de la sintaxis del lenguaje.

Autocompletar
Cuando el IDE conoce su lenguaje de programación, ¡puede anticipar
qué escribirá a continuación!

Hemos visto declaraciones con System.out.println()bastante hasta

ahora. En un IDE, podríamos verlo Systemcomo una opción de
autocompletar solo después de escribir Sy. Esto ahorra pulsaciones
para que el programador pueda concentrarse en la lógica de su
código.
Edificio ejecutables
Java es un lenguaje compilado. Antes de programas se ejecutan, el
código fuente de un .java archivo debe ser transformado en un
archivo ejecutable .class por el compilador. Una vez compilado, el
programa puede ejecutarse desde el terminal.

Este proceso de compilación es necesario para cada programa, ¿por

qué no hacer que el IDE lo haga por nosotros? Los IDE proporcionan
procesos de compilación automatizados para los idiomas, por lo que
el acto de compilar y ejecutar el código se extrae, como en las
lecciones de Codecademy.

Depuración
Ningún programador evita escribir errores y programas con errores.

Cuando un programa no se ejecuta correctamente, los IDE

proporcionan herramientas de depuración que permiten a los
programadores examinar diferentes variables e inspeccionar su
código de manera deliberada.

Los IDE también proporcionan sugerencias durante la codificación

para evitar errores antes de la compilación.

Codificación en su computadora
El mayor beneficio de usar un IDE es que le permite codificar y
ejecutar programas Java en su propia computadora. Recomendamos
IntelliJ IDEA , que puede descargar para macOS , Windows o Linux .
APRENDER JAVA: VARIABLES

Introducción
Digamos que necesitamos un programa que conecte a un usuario con nuevos
trabajos. Necesitamos el nombre del usuario, su salario y su situación laboral. Toda
esta información se almacena en nuestro programa.

Almacenamos información en variables , ubicaciones nombradas en memoria.

Nombrar una parte de la información nos permite usar ese nombre más tarde,
accediendo a la información que almacenamos.

Las variables también dan contexto y significado a los datos que estamos
almacenando. El valor 42podría ser la edad de alguien, un peso en libras o el
número de pedidos realizados. Con un nombre, que conocemos el
valor 42es age, weightInPoundso numOrdersPlaced.

En Java, especificamos el tipo de información que estamos almacenando. Los tipos

de datos primitivos son tipos de datos incorporados al sistema Java.

Debemos declarar una variable para referenciarla dentro de nuestro

programa. Declarar una variable requiere que especifiquemos el tipo y el nombre:

// datatype variableName
int age ; Requerimiento de doble salario ; boolean isEmployed ;

Los tipos de estas variables son int, doubley boolean. Esta lección introducirá estos
tipos incorporados y más.

Los nombres de las variables son age, salaryRequirementy isEmployed.

Estas variables no tienen ningún valor asociado. Para asignar un valor a una
variable, usamos el operador de asignación =:

edad = 85 ;
¡Es común declarar una variable y asignar el valor en una línea!

Por ejemplo, para asignar 2011a una variable llamada yearCodecademyWasFoundedde

tipo int, escribimos:
int yearCodecademyWasFounded = 2011 ;

ints
El primer tipo de datos que almacenaremos es el número entero. Los números
enteros son muy comunes en la programación. Con frecuencia, los utiliza para
almacenar edades, tamaños máximos o la cantidad de veces que se ha ejecutado
algún código, entre muchos otros usos.

En Java, los números enteros se almacenan en el tipo de datos primitivos int .

ints mantener números positivos, números negativos y cero. No almacenan

fracciones ni números con decimales.

El inttipo de datos permite valores entre -2,147,483,648 y 2,147,483,647, inclusive.

Para declarar una variable de tipo int, usamos la intpalabra clave antes del nombre
de la variable:

// int variable declaración

int yearJavaWasCreated ; // asignación yearJavaWasCreated = 1996
; // declaración y asignación int numberOfPrimitiveTypes = 8 ;

dobles
Los números enteros no logran lo que necesitamos para cada programa. ¿Y si
quisiéramos almacenar el precio de algo? Necesitamos un punto decimal. ¿Y si
quisiéramos almacenar la población mundial? Ese número sería mayor que
el inttipo que puede contener.

El doubletipo de datos primitivo puede ayudar. doublePuede contener decimales, así

como números muy grandes y muy pequeños. El valor máximo es
1.797.693.134.862.315,7 E + 308, que es aproximadamente 17 seguido de 307
ceros. El valor mínimo es 4.9 E-324, que es 324 lugares decimales!
Para declarar una variable de tipo double, usamos la doublepalabra clave en la
declaración:

// los dobles pueden tener decimales:

precio doble = 8.99 ; // los dobles pueden tener valores más
grandes de lo que podría contener un int: double gdp = 12237700000
;

booleanos
A menudo, nuestros programas se enfrentan a preguntas que solo se pueden
responder con un sí o un no.

¿Está encendido el horno? ¿Es la luz verde? ¿Comí desayuno?

Estas preguntas se responden con un valor booleano , un tipo que hace referencia a
uno de dos valores: trueo false.

Declaramos las variables booleanas usando la palabra clave booleanantes del

nombre de la variable.

javaIsACompiledLanguage booleano = verdadero ;

javaIsACupOfCoffee booleano = falso ;

En lecciones futuras, veremos cómo los booleanvalores ayudan a navegar las

decisiones en nuestros programas.

Char
¿Cómo respondemos preguntas como: ¿Qué grado obtuviste en el examen? ¿Con
qué letra comienza tu nombre?

El chartipo de datos puede contener cualquier carácter, como una letra, un espacio
o un signo de puntuación.
Debe ser rodeado por comillas simples, '.

Por ejemplo:

grado de char = 'A' ; char firstLetter = 'p' ; Char puntuacion

= '!' ;

String
Hasta ahora, hemos aprendido tipos de datos primitivos, que son los tipos de
datos más simples sin comportamiento incorporado. Nuestros programas también
usarán Strings, que son objetos , en lugar de primitivos. Los objetos tienen un
comportamiento incorporado.

Las cuerdas contienen secuencias de caracteres. Ya hemos visto instancias de una

cadena, por ejemplo, cuando imprimiste "Hello World".

Al igual que con una primitiva, declaramos la variable especificando primero el

tipo:

Cadena de saludo = "Hola Mundo" ;

Comprobación estática
El lenguaje de programación Java tiene tipificación estática . Los programas Java no
se compilarán si a una variable se le asigna un valor de un tipo incorrecto. Este es
un error , específicamente un error de declaración de tipo.

¡Los insectos son peligrosos! Provocan un fallo en nuestro código o producen

resultados incorrectos. La escritura estática ayuda porque los errores se detectan
durante la programación y no durante la ejecución del código.
El programa no se compilará si el tipo declarado de la variable no coincide con el
tipo del valor asignado:

saludo int = "Hola Mundo" ;

La cadena "Hello World"no se puede mantener en una variable de tipo int.

Para el ejemplo anterior, vemos un error en la consola en la compilación:

error : tipos incompatibles : la cadena no se puede convertir a

int int greeting = " Hello World " ;

Cuando los errores no se detectan en la compilación, interrumpen la ejecución del

código causando errores de tiempo de ejecución . El programa se bloqueará.

La escritura estática de Java ayuda a los programadores a evitar errores de tiempo

de ejecución y, por lo tanto, tienen un código mucho más seguro y libre de errores.

Nombrar
Imaginemos que estamos almacenando el nombre de un usuario para su
perfil. ¿Qué ejemplo de código crees que es mejor?

Cadena de datos = "Delilah" ;

o

String nameOfUser = "Delilah" ;

Mientras que ambos compilarán, el segundo ejemplo es mucho más fácil de
entender. Los lectores del código serán conocer el propósito del valor: "Delilah".

Nombrar variables de acuerdo con la convención conduce a un código claro,

legible y mantenible. Cuando alguien más, o nuestro yo futuro, lee el código, no
hay confusión sobre el propósito de una variable.

En Java, los nombres de las variables distinguen entre mayúsculas y

minúsculas. myHeightes una variable diferente a myheight. La longitud del nombre de
una variable es ilimitada, pero debemos mantenerlo conciso y al mismo tiempo
mantener el significado claro.
Una variable comienza con una letra válida, o a $, o a _. Ningún otro símbolo o
número puede comenzar un nombre de variable. 1stPlacey *Gazerno son nombres
de variables válidos.

Los nombres de variable de una sola palabra están escritos en letras

minúsculas. Los nombres de variable de más de una palabra tienen la primera letra
en minúscula, mientras que la letra inicial de cada palabra subsiguiente está en
mayúscula. Este estilo de mayúsculas se llama camelCase .

// buen estilo
booleano es Humano ; // malos estilos // sin mayúsculas para la
nueva palabra boolean ishuman ; // la primera palabra debe ser
minúscula booleana IsHuman ; // los guiones bajos no separan las
palabras boolean is_human ;

revisión
Crear y completar variables es un concepto poderoso que nos permite realizar un
seguimiento de todos los tipos de datos en nuestro programa.

En esta lección, aprendimos cómo crear e imprimir varios tipos de datos diferentes
en Java, que utilizará al crear programas más grandes y complejos.

Cubrimos

• ints,que almacenan números enteros

• doubles, que almacenan números enteros más grandes y números decimales
• booleans, que almacenan trueyfalse
• chars, que almacenan caracteres individuales utilizando comillas simples.
• Strings, que almacenan varios caracteres utilizando comillas dobles.
 • Escritura estática , que es una de las características de seguridad de Java
• Convenciones de nomenclatura de variables.

¡Practica la declaración de variables y la asignación de valores para asegurarte de

tener una base sólida para aprender conceptos Java más complicados y
emocionantes!

Variables de Java: Mad Libs

En este proyecto, usaremos Java para escribir un juego de palabras Mad Libs . Los
Mad Libs tienen historias cortas con espacios en blanco que un jugador puede
completar. El resultado suele ser divertido (o extraño).

APRENDE JAVA: MANIPULANDO VARIABLES

Introducción
Digamos que estamos escribiendo un programa que representa la cuenta bancaria
de un usuario.

Con variables, ¡sabemos cómo almacenar un saldo! Usaríamos a double, el tipo

primitivo que puede contener grandes números decimales.

Pero, ¿cómo depositaríamos y retiraríamos de la cuenta?

¡Java tiene operaciones matemáticas integradas que realizan cálculos en valores

numéricos!

Depositar:

// declarar saldo inicial

doble equilibrio = 20000,99 ; // declarar el monto del depósito
double depositAmount = 1000.00 ; // almacenar el resultado del
cálculo en la nueva variable double updatedBalance = balance +
depositAmount ;
A lo largo de esta lección, aprenderemos cómo realizar operaciones matemáticas
en diferentes tipos de datos y comparar valores.

Adición y sustracción
En nuestro ejemplo de cuenta bancaria del último ejercicio, ¡solíamos +añadir!

doble balance = 20000.99 ; doble depositAmount = 1000.0 ; doble

updatedBalance = balance + depositAmount ; // updatedBalance ahora
tiene 21000.99

Si quisiéramos retirar del saldo, utilizaríamos -:

doble retiro de cantidad = 500 ; doble updatedBalance =

equilibrio - withdrawAmount ; // updatedBalance ahora tiene
19500.99

¡La suma y la resta también funcionan con ints!

int numPicturesOfCats = 60 + 24 ;
Si usted tenía 60 imágenes de gatos en su teléfono, y que tomó más de 24, se
puede utilizar la línea de código anterior para almacenar 84en numPicturesOfCats.

Multiplicación y división
Digamos que nuestro empleador está calculando nuestro cheque de pago y
depositándolo en nuestra cuenta bancaria. La semana pasada trabajamos 40 horas,
a una velocidad de 15,50 por hora. Java puede calcular esto con el operador de
multiplicación *:

doble cheque de pago cantidad = 40 * 15.50 ; //

paycheckAmount ahora tiene 620.0
Si queremos ver cuántas horas representa nuestro saldo total, usamos el operador
de la división /:

doble balance = 20010.5 ; tasa de hora doble = 15.5 ; double

hoursWorked = balance / hourlyRate ; // hoursWorked ahora tiene
1291.0

La división tiene diferentes resultados con enteros. El /operador hace una división
entera , lo que significa que cualquier resto se pierde.

int evenlyDivided = 10 / 5 ; // evenlyDivided sostiene 2,

porque 10 dividido por 5 es 2 int unevenlyDivided = 10 / 4 ; //
UnevenlyDivided retiene 2, porque 10 dividido por 4 es 2.5

evenlyDividedalmacena lo que espera, pero

se unevenlyDividedmantiene 2porque ints no puede almacenar decimales!

Java elimina el 0.5 para ajustar el resultado en un inttipo!

Modulo
Si cocináramos 10 galletas y las repartiéramos en lotes de 3, ¿cuántos nos
quedarían después de repartir todos los lotes completos que pudiéramos?

El operador de módulo %, nos da el resto después de dividir dos números.

int cookiesBaked = 10 ; int cookiesLeftover = 10 % 3 ; //

cookiesLeftover tiene 1

¡Te queda 1 cookie después de repartir todos los lotes de 3 que pudiste!

Módulo puede ser un concepto complicado, así que probemos otro ejemplo.
Imagina que necesitamos saber si un número es par o impar. Un número par es
divisible por 2.

Modulo puede ayudar! Dividir un número par por 2 tendrá un resto de 0. Dividir un
número impar por 2 tendrá un resto de 1.

7 % 2
// 1, impar!
8 % 2
// 0, incluso!
9 % 2
// 1, impar!

Mayor que y menos que

Ahora, estamos retirando dinero de nuestro programa de cuentas bancarias, y
queremos ver si estamos retirando menos dinero de lo que tenemos disponible.

Java tiene operadores relacionales para tipos de datos numéricos que

hacen booleancomparaciones. Estos incluyen menos que ( <) y mayor que ( >), que
nos ayudan a resolver nuestro problema de abstinencia.

doble balance = 20000.01 ; cantidad dobleToWithdraw = 5000.01 ;

Sistema . a cabo . imprimir ( amountToWithdraw < balance ) ; //
esto se imprimirá verdadero, ya que amountToWithdraw es menor que
el saldo

Puede guardar el resultado de una comparación como una boolean, que aprendió
en la última lección.

doble MyBalance = 200.05 ; doble costOfBuyingNewLaptop =

1000.05 ; boolean canBuyLaptop = myBalance > costOfBuyingNewLaptop
; // canBuyLaptop es falso, ya que 200.05 no es más que 1000.05
Iguales y no iguales
Entonces, ¿cómo validaríamos nuestro cheque de pago para ver si nos pagaron la
cantidad correcta?

Podemos usar otro operador relacional para hacer esto. ==nos dirá si dos variables
son iguales:

doble cheque de pago cantidad = 620 ; Comprobación de pago

doble calculado = 15.50 * 40 ; Sistema . a cabo . print (
paycheckAmount == calculadoPaycheck ) ; // esto se imprimirá como
verdadero, ya que paycheckAmount es igual a CalculatePaycheck

Observe que el control de igualdad es dos signos iguales, en lugar de uno. Un

signo igual =, es cómo asignamos valores a las variables. Es fácil mezclarlos, así que
asegúrese de revisar su código para ver el número correcto de signos iguales.

Para verificar si dos variables no son iguales, podemos usar !=:

doble balance = 20000.0 ; doble amountToDeposit = 620 ; doble

updatedBalance = balance + amountToDeposit ; booleano
balanceHasChanged = equilibrar =! updatedBalance ; //
depositWorked se mantiene verdadero, ya que el saldo no es igual a
updatedBalance

Mayor / Menor o igual a

¿Cómo podemos asegurarnos de que nos paguen al menos la cantidad que
esperábamos en nuestro cheque de pago? ¡Podríamos usar mayor o igual que >=, o
menor o igual que <=!
doble cheque de pago cantidad = 620 ; Comprobación de pago
doble calculado = 15.50 * 40 ; Sistema . a cabo . println (
paycheckAmount > = calculadoPaycheck ) ; // esto se imprimirá como
verdadero, ya que paycheckAmount es igual a CalculatePaycheck

.equals ()
Hasta ahora, solo hemos estado usando operaciones en tipos primitivos. No tiene
mucho sentido multiplicar cadenas, o ver si una cadena es menor que la otra. Pero,
¿y si tuviéramos dos usuarios iniciando sesión en un sitio y quisiéramos ver si sus
nombres de usuario eran iguales?

Con objetos, como cadenas, no podemos usar el operador de igualdad

primitiva. Para probar la igualdad con las cadenas, usamos un método incorporado
llamado .equals().

Para usarlo, lo llamamos en una Cadena, usando ., y pasamos la Cadena para

comparar entre paréntesis:

String person1 = "Paul" ; String person2 = "John" ; String

person3 = "Paul" ; Sistema . a cabo . println ( person1 . iguales
( person2 ) ) ; // imprime falsa, ya que "Paul" no es "Juan"
Sistema . a cabo . println ( person1 . iguales ( persona3 ) ) ; //
imprime verdad, ya que "Paul" es "Paul"

Concatenación de Strings
Hemos cubierto muchas funcionalidades integradas en Java a lo largo de esta
lección. Hemos visto +, -, <, ==, y muchos otros operadores. La mayoría de estos
solo funcionan con primitivos, pero algunos también funcionan con cadenas.
Digamos que queremos imprimir una variable, y queremos describirla a medida
que la imprimimos. Para nuestro ejemplo de cuenta bancaria, imaginemos que
queremos decirle al usuario:

Su nombre de usuario es : < nombre de usuario >

Con el valor de la variable usernamemostrada.

El +operador, que usamos para sumar números, puede usarse

para concatenar cadenas. En otras palabras, ¡podemos usarlo para unir dos Cuerdas
juntas!

String username = "PrinceNelson" ; Sistema . a cabo . println (

"Su nombre de usuario es:" + nombre de usuario ) ;

Este código se imprimirá:

Tu nombre de usuario es : PrinceNelson

Incluso podemos usar un tipo de datos primitivo como la segunda variable para
concatenar, y Java lo convertirá en una cadena inteligente de manera inteligente:

balance de int = 10000 ; Mensaje de cadena = "Su saldo es:" +

balance ; Sistema . a cabo . println ( mensaje ) ;

Este código se imprimirá:

Su equilibrio es : 10000

revisión
¿De qué sirve tener variables si no puedes hacer nada con ellas? Ahora hemos visto
algunas formas en que puedes operar con variables y compararlas. ¡Las
posibilidades son infinitas!

Cubrimos

• Suma y resta, usando +y-

• Multiplicación y división, utilizando *y./
 • El operador de módulo para la búsqueda de residuos, %
• Mayor que >y menor que<
• Igual a, ==y no igual a,!=
• Mayor o igual que >=, y menor o igual que<=
• .equals() para comparar cuerdas y otros objetos
• Usando +para concatenar cadenas

¡Practica algunos de estos conceptos aquí, para asegurarte de tener una base
sólida para aprender conceptos Java más complicados y emocionantes!

Introducción a las clases

Todos los programas requieren una o más clases que actúan como modelo para el
mundo.

Por ejemplo, un programa para realizar un seguimiento de resultados de las

pruebas de los estudiantes podría tener Student, Coursey Gradeclases. Nuestras
preocupaciones del mundo real, los estudiantes y sus calificaciones, están dentro
del programa como clases.

Representamos a cada estudiante como una instancia , u objeto , de la Studentclase.

Esta es una programación orientada a objetos porque los programas se construyen

alrededor de los objetos y sus interacciones. Un objeto contiene estado y
comportamiento.
Las clases son un plano para los objetos. Los planos detallan la estructura
general. Por ejemplo, todos los estudiantes tienen una identificación, todos los
cursos pueden inscribir a un estudiante, etc.

Una instancia es la cosa misma. Este estudiante tiene una identificación

de 42, este curso inscribió a eseestudiante, etc.

Revisemos con otro ejemplo, una cuenta de ahorros en un banco.

¿Qué debe saber una cuenta de ahorros?

• El saldo de dinero disponible.

¿Qué debe hacer una cuenta de ahorros?

• Depositar dinero.
• Retirar dinero.
Imagina que dos personas tienen cuentas que son instancias de
la SavingsAccountclase. Comparten el comportamiento (cómo depositan y retiran)
pero tienen un estado individual (sus saldos), e incluso con el mismo monto de
saldo, estas cuentas son entidades separadas.

Clases: Sintaxis
El concepto fundamental de la programación orientada a objetos es la clase. Una
clase es el conjunto de instrucciones que describen cómo se puede comportar una
instancia y qué información contiene.

Java tiene clases predefinidas como las Systemque hemos usado para registrar texto
en nuestra pantalla, pero también necesitamos escribir nuestras propias clases para
las necesidades personalizadas de un programa.
Aquí hay una definición de una clase de Java:

clase pública Car { // el alcance de la clase Car comienza aquí

pública static void main ( String [ ] args ) { // el alcance

de main () comienza aquí // tareas del programa } // el alcance de
main () termina aquí } // alcance de clase de coches termina aquí

Este ejemplo define un classnombre Car. publices un modificador de nivel de

acceso que permite que otrasclases interactúen con esta clase. Por ahora, todas las
clases serán public.

Esta clase tiene un main()método, que enumera las tareas realizadas por el
programa. main()Se ejecuta cuando ejecutamos el archivo compilado Car.class .

Clases: Constructores
Creamos instancias con un método constructor definido dentro de la clase.

Aquí está la Carclase con un constructor:

public class Car { public Car ( ) { // el método del

constructor comienza // crear Car instance } // el método del
constructor termina public static void main ( String [ ] args ) {
// programe las tareas } }

El constructor Car(),, comparte un nombre con la clase.

Creamos instancias llamando o invocando al constructor dentro main(). Este
ejemplo asigna una instancia a la variable ferrari:

public class Car { public Car ( ) { } public static void main (

String [ ] args ) { / * invoca a un constructor usando 'new', el
nombre y los paréntesis: new Car () * / Car ferrari = new Car ( )
; } }

Al igual que con otras declaraciones de variables, se especifica el tipo: Cary el

nombre de: ferrari. Las variables que hacen referencia a una instancia tienen un
tipo de nombre de clase.

Invocamos el método constructor:, Car()y usamos la palabra clave newpara indicar

que estamos creando una instancia. Omitir newcausa un error.

Esta es la primera vez que llamamos un método que también hemos

definido. main()Se ejecuta automáticamente y no definimos el println()método.

Introducir un segundo método es un gran paso en su viaje de programación,

¡felicidades!

Clases: Campos de instancia

Nuestro último ejercicio terminó con la impresión de una instancia de Store, que
parecía algo así Store@6bc7c054. La primera parte, se Storerefiere a la clase, y la
segunda parte se @6bc7c054refiere a la ubicación de la instancia en la memoria de la
computadora.
No nos importa la ubicación de la memoria, ¡pero nuestras instancias no tienen
otras características!

Agregaremos datos asociados a un objeto introduciendo variables de instancia o

campos de instancia . Los campos de instancia son el estado en nuestros objetos.

Queremos Carinstancias de diferentes colores, por lo que declaramos un String

colorcampo de instancia.

public class Car { / * declara los campos dentro de la clase

especificando el tipo y el nombre * / String color ; public Car (
) { / * campos de instancia disponibles en el alcance del método
del constructor * / } public static void main ( String [ ] args )
{ // body of main method } }

La declaración está dentro de la clase y la variable de instancia estará disponible

para la asignación dentro del constructor.

Los campos son un tipo de estado que cada instancia poseerá. Una instancia puede
tener "red"como su color, otra "blue", etc. Aprenderemos cómo asignar valores en
el próximo ejercicio.

Clases: Parámetros del constructor

Usaremos una combinación de método de constructor y campo de instancia para
crear instancias con estado individual.

Necesitamos alterar el método del constructor porque ahora necesita acceder a los
datos que estamos asignando a la instancia.

Nuestro Carconstructor tiene ahora un parámetro : String carColor.

Clase pública de coches { color de la cuerda ; // método del

constructor con un parámetro public Car ( String carColor ) { //
parámetro valor asignado al campo color = carColor ; } public
static void main ( String [ ] args ) { // tareas del programa } }

Necesitamos un valor para el campo de instancia color, por lo que hemos

agregado String carColorcomo parámetro.

Los parámetros especifican el tipo y el nombre de los datos disponibles para

referencia dentro del alcance de un método.

Ya hemos visto un parámetro en el main()método:, String[] argspero esta es la

primera vez que usamos el valor del parámetro dentro del cuerpo del método.

El parámetro hace carColorreferencia al valor pasado durante una llamada de

método:

Coche nuevo ( "azul" ) ; // carColor hace referencia a "azul"

dentro del constructor nuevo Car ( "amarillo" ) ; // carColor hace
referencia a "amarillo" dentro del constructor

Dentro del constructor, asignamos el valor del parámetro al campo de instancia.

Los campos de instancia están disponibles para asignación dentro del constructor
porque los declaramos dentro de la clase.
Clases: Asignación de valores a campos
de instancia
Ahora que nuestro constructor tiene un parámetro, debemos pasar valores al
método de llamada. Estos valores se convierten en el estado de la instancia.

Aquí creamos una instancia, ferrarien el main()método con "red"como

su colorcampo:

Clase pública de coches { color de la cuerda ; public Car (

String carColor ) { // asigna un valor de parámetro al campo de
instancia color = carColor ; } public static void main ( String [
] args ) { // valor de parámetro proporcionado al llamar al
constructor Car ferrari = new Car ( "red" ) ; } }

Pasamos por el valor de cadena "red"a nuestro llamado método constructor: new
Car("red");.

El tipo del valor dado a la invocación debe coincidir conel tipo declarado por el
parámetro.

Dentro del constructor, el parámetro carColorse refiere al valor pasado en durante

la invocación: "red". Este valor se asigna al campo de instancia color.

color ya se ha declarado, por lo que no especificamos el tipo durante la asignación.

El objeto ferrari,, mantiene el estado de colorcomo un campo de instancia que

hace referencia al valor "red".
Accedemos al valor de este campo con el operador de puntos ( .):

/ *
accediendo a un campo:
objectName.fieldName
* /

ferrari . el color ; // "rojo"

Clases: Campos Múltiples

Los objetos no están limitados a un solo campo de instancia. Podemos declarar
tantos campos como sean necesarios para los requisitos de nuestro programa.

Cambiemos las Carinstancias para que tengan múltiples campos.

Agregaremos una boolean isRunning, que indica que el motor del automóvil está
encendido y una int velocity, que indica la velocidad a la que el automóvil está
viajando.

Clase pública de coches { color de la cuerda ; // nuevos

campos! boolean isRunning ; int velocidad ; // nuevos parámetros
que corresponden a los nuevos campos public Car ( String carColor
, boolean carRunning , int milesPerHour ) { color = carColor ; //
asignar nuevos parámetros a los nuevos campos isRunning =
carRunning ; velocidad = millas por hora ; } público
 static void main ( String [ ] args ) { // los nuevos valores
pasados al método call Car Ferrari = new Car ( "red" , true , 27 )
; Auto renault = nuevo Car ( "azul" , falso , 70 ) ; Renault .
isRunning ; // falso ferrari . velocidad ; // 27 } }

El constructor ahora tiene múltiples parámetros para recibir valores para los nuevos
campos. Seguimos especificando el tipo y el nombre de cada parámetro.

¡Ordenar los asuntos! Debemos pasar los valores a la invocación del constructor en
el mismo orden en que aparecen en los parámetros.

// los valores coinciden con los tipos, sin error

Car honda = new Car ( "verde" , falso , 0 ) ; // los valores
no coinciden con los tipos, error! Junker de coches = Carro nuevo
( verdadero , 42 , "marrón" ) ;

Clases: Revisión
Java es un lenguaje de programación orientado a objetos donde cada programa
tiene al menos una clase. Los programas a menudo se construyen a partir de
muchas clases y objetos, que son las instancias de una clase.

Las clases definen el estado y el comportamiento de sus instancias. El

comportamiento proviene de métodos definidos en la clase. El estado proviene de
los campos de instancia declarados dentro de la clase.

Las clases se basan en las cosas del mundo real que queremos representar en
nuestro programa. Más adelante exploraremos cómo se puede hacer un programa
desde varias clases. Por ahora, nuestros programas son de una sola clase.
público de clase Perro { // campo de instancia Cadena raza ; //
método del constructor public Dog ( String dogBreed ) { / * valor
del parámetro dogBreed asignado al campo de instancia de raza * /
breed = dogBreed ; } public static void main ( String [ ] args ) {
/ * create instance: usa el operador 'nuevo' e invoca al
constructor * / Dog fido = new

Perro ( "caniche" ) ; Se accede a los campos / *

utilizando: el nombre de la instancia, el operador `.` y el nombre
del campo. * / fido . reproducirse ; // "caniche" } }

Metodos
Introducción
En la última lección, creamos una instancia de la Storeclase en el método
principal. Aprendimos que los objetos tienen estado y comportamiento.
Hemos visto cómo dar estado a los objetos a través de campos de instancia. Ahora,
vamos a aprender sobre el comportamiento. Recuerda nuestro ejemplo de una
cuenta de ahorro.

Una cuenta de ahorros debe saber:

• El saldo de dinero disponible.

Debe poder realizar:

• Depositando
o Aumentar la cantidad disponible.
• Retirando
o Disminuyendo el importe disponible.
• Comprobando el saldo
o Viendo la cantidad disponible.
Ha definido y llamado métodos de construcción, que crean una instancia de una
clase. También ha definido los métodos principales, que son las tareas que se
ejecutan cuando se ejecuta el programa. Estos son ejemplos específicos de
métodos. También podemos definir el nuestro que tendrá entrada, haga algo con
él y devuelva el tipo de salida que queremos.

¿Y si se necesitaran 20 líneas de código para hacer un sandwich? Nuestro

programa se haría muy largo muy rápidamente si estuviéramos haciendo varios
sándwiches. Los métodos son poderosos porque nos permiten crear bloques de
código que son repetibles y modulares.

Definiendo metodos
¿Recuerdas nuestro Carejemplo de la última lección? Agreguemos un método a
este Carllamado startEngine()que se imprima:

¡Arrancando el coche !
Vroom !
Este método se ve como:

public void startEngine ( ) { System . a cabo . println (

"¡Arrancando el coche!" ) ; Sistema . a cabo . println ( "Vroom!"
) ; }

La primera línea,, public void startEngine()es la firma del método . Le da al

programa alguna información sobre el método:

• publicsignificaque otras clases pueden acceder a este

método. Aprenderemos más sobre eso más adelante en el curso.
• La voidpalabra clave significa que no hay una salida específica del
método. Veremos métodos que no están voidmás adelante en esta lección,
pero por ahora todos nuestros métodos lo serán void.
• startEngine() Es el nombre del método.

Un checkBalance()método para la cuenta de ahorros de la que hablamos

anteriormente se parece a algo como:

checkBalance del vacío público ( ) { Sistema . a cabo . println

( "¡Hola!" ) ; Sistema . a cabo . println ( "Tu saldo es" + saldo
) ; }
Las dos declaraciones impresas están dentro del cuerpodel método, que está
definido por las llaves.

Cualquier cosa que podamos hacer en nuestro main()método, podemos hacerlo en

otros métodos. Todas las herramientas Java que conoces, como los operadores
matemáticos y de comparación, pueden usarse para crear métodos interesantes y
útiles.

Métodos de llamada
¡Genial! Cuando agregamos el startEngine()método a la Carclase, queda disponible
para usar en cualquier Carobjeto. Podemos hacerlo llamando al método en
el Carobjeto que creamos, por ejemplo.

Aquí hay un ejemplo de cómo llamar a un método en un objeto usando la Carclase:

clase de coches { color de la cuerda ; Coche público ( String

carColor ) { color = carColor ; } public void startEngine ( ) {
System . a cabo . println ( "¡Arrancando el coche!" ) ; Sistema .
a cabo . println ( "Vroom!" ) ; } public static void main ( String
[ ]

args ) { Car myFastCar = new Car ( "red" ) ; myFastCar .

startEngine ( ) ; } }
En el ejemplo anterior, llamamos al startEngine()método en
el myFastCarobjeto. Esta llamada al método ocurre dentro del main()método. Al
ejecutar los resultados del programa se imprime Vroom!en el terminal de salida.

Alcance
Un método es una tarea que realiza un objeto de una clase.

Marcamos el dominio de esta tarea usando llaves:, {y }. Todo dentro de las llaves
es parte de la tarea. Este dominio se llama el alcance de un método.

No podemos acceder a las variables que se declaran dentro de un método en el

código que está fuera del alcance de ese método.

Mirando a la Carclase de nuevo:

clase de coches { color de la cuerda ; int milesDriven ; Coche

público ( String carColor ) { color = carColor ; milesDriven = 0 ;
} public void drive ( ) { String message = "Millas conducidas:" +
milesDriven ; Sistema . a cabo . println ( mensaje ) ; } estática
pública

void main ( String [ ] args ) { Car myFastCar = new Car (

"red" ) ; myFastCar . conducir ( ) ; } }
La variable message, que se declara y se inicializa dentro de drive, no se puede usar
dentro de main()! Solo existe dentro del alcance del drive()método.

Sin embargo, milesDrivenque se declara en la parte superior de la clase, se puede

utilizar dentro de todos los métodos de la clase, ya que está en el alcance de toda
la clase.

Añadiendo parametros
Vimos cómo el alcance de un método nos impide utilizar variables declaradas en
un método en otro método. ¿Qué pasaría si tuviéramos alguna información en un
método que debíamos pasar a otro método?

De manera similar a como agregamos parámetros a los constructores , podemos

personalizar todos los otros métodos para aceptar parámetros.

clase de coches { color de la cuerda ; Coche público ( String

carColor ) { color = carColor ; } public void startRadio ( String
station ) { System . a cabo . println ( " Encendiendo la radio a"
+ estación + "!" ) ; Sistema . a cabo . println ( "Enjoy!" ) ; }
público

static void main ( String [ ] args ) { Car myCar = new Car (

"red" ) ; miCarro . startRadio ( "Estación de Meditación" ) ; } }
En este código, creamos un startRadio()método que acepta un Stringparámetro
llamado station. En el main()método, llamamos al startRadio()método en
el myCarobjeto y proporcionamos un Stringparámetro de"Meditation Station".

Una llamada al startRadio()método de myCarresultados en impresión:

Volviendo a la Radio de la meditación estación !

Disfrutar !

Reasignación de campos de instancia

Anteriormente, pensamos en una cuenta de ahorro como un tipo de objeto que
podríamos representar en Java.

Dos de los métodos que necesitamos son depositar y retirar:

Cuenta de ahorro pública { doble saldo ; cuenta de ahorros

pública ( doble saldo inicial ) { balance = partida inicial ; }
Pública vacío depósito ( doble amountToDeposit ) { // Añadir
amountToDeposit al saldo } pública vacío retirar ( doble
amountToWithdraw ) { // Restar amountToWithdraw del saldo }
pública estática vacío principal (

Cadena [ ] args ) { } }
Estos métodos cambiarían el valor de la variable balance. Podemos reasignar
el saldo para que sea un nuevo valor utilizando nuestro operador de asignación =,
nuevamente.

depósito público anulado ( doble amountToDeposit ) { double

updatedBalance = balance + amountToDeposit ; balance =
updatedBalance ; }

Ahora, cuando llamamos deposit(), debería cambiar el valor del campo de

instancia balance:

public static void main ( String [ ] args ) { SavingsAccount

myAccount = new SavingsAccount ( 2000 ) ; Sistema . a cabo .
println ( myAccount . balance ) ; Cuenta de ahorro . depósito (
100 ) ; Sistema . a cabo . println ( myAccount . balance ) ; }

Este código primero imprime 2000, el valor inicial de myAccount.balance, y luego

imprime 2100, que es el valor de myAccount.balancedespués de que
el deposit()método se haya ejecutado.

Cambiar campos de instancia es cómo cambiamos el estado de un objeto y

hacemos que nuestros objetos sean más flexibles y realistas.

Devoluciones
Recuerde, las variables solo pueden existir en el ámbitoen el que se declararon.

Podemos usar un valor fuera del método en el que se creó si lo devolvemos desde
el método.

Devolvemos un valor usando la palabra clave return:

public int numberOfTires ( ) { int tires = 4 ; neumáticos de
retorno ; }

Este método, llamado numberOfTires, devuelve 4. En ejercicios anteriores, al crear

nuevos métodos, usamos la palabra clave void. Aquí, estamos
reemplazando voidcon int, para indicar que el tipo de retorno es un int.

La palabra clave void (que significa "completamente vacío") indica al método que
no se devuelve ningún valor después de llamar a ese método.

Alternativamente, podemos usar palabras clave de tipo de datos (como int, char,
etc.) para especificar que un método debe devolver un valor de ese tipo.

public static void main ( String [ ] args ) { Car myCar = new

Car ( "red" ) ; int numTires = myCar . numberOfTires ( ) ; }

Dentro main(), llamamos al numberOfTires()método myCar. Como el método

devuelve un intvalor de 4, almacenamos el valor 4 en una variable entera
llamada numTires. Si imprimiéramos numTires, lo veríamos 4.

El método toString ()
Cuando imprimimos Objetos, a menudo vemos una Cadena que no es muy útil
para determinar qué representa el Objeto. En la última lección, vimos que cuando
imprimimos nuestros Storeobjetos, veríamos resultados como:

Tienda @ 6bc7c054
donde Storees el nombre del objeto y 6bc7c054es su posición en la memoria.

Esto no nos dice nada sobre lo que Storevende, el precio o los otros campos de
instancia que hemos definido. Podemos agregar un método a nuestras clases que
hace que esta impresión sea más descriptiva.

Cuando definimos un método toString () para una clase, podemos devolver

un Stringque se imprimirá cuando imprimamos el objeto:
clase de coches { color de la cuerda ; Coche público ( String
carColor ) { color = carColor ; } public static void main ( String
[ ] args ) { Car myCar = new Car ( "red" ) ; Sistema . a cabo .
println ( myCar ) ; } public String toString ( )

{ return "¡Este es un coche " + color + "! ; } }

Cuando esto se ejecuta, System.out.println(myCar)se imprimirá el comando This is

a red car!, que nos informa sobre el objeto myCar.

revisión
¡Buen trabajo! Los métodos son una forma poderosa de abstraer tareas y hacerlas
repetibles. Nos permiten definir el comportamiento de las clases, de modo que los
Objetos que creamos puedan hacer las cosas que esperamos que
hagan. Repasemos todo lo que hemos aprendido acerca de los métodos hasta
ahora.

• Definición de un método : los métodos tienen una firma de método que

declara su tipo de retorno, nombre y parámetros
• Llamando a un método : los métodos se invocan con un .y()
• Parámetros : las entradas al método y sus tipos se declaran entre paréntesis
en la firma del método
• Cambio de campos de instancia : los métodos se pueden usar para cambiar
el valor de un campo de instancia
• Ámbito : las variables solo existen dentro del dominio en el que se crean
 • Retorno : el tipo de las variables que se emiten se declaran en la firma del
método

A medida que avance a través de más material Java, será útil enmarcar las tareas
que cree en términos de métodos. Esto le ayudará a pensar qué entradas puede
necesitar y qué salida espera.

Una calculadora básica

En este proyecto, utilizará clases, métodos y objetos para crear una calculadora
aritmética simple. La calculadora podrá:

• Sumar dos enteros

• Resta dos enteros
• Multiplicar dos enteros
• Divide dos enteros
• Aplicar el operador de módulo en dos enteros.

Las instrucciones proporcionadas son pautas generales. Al finalizar el proyecto,

siéntase libre de explorar más en el entorno de aprendizaje.

Importante: En el futuro, todos los proyectos requerirán que defina el mainmétodo

manualmente. Cuando hace clic en el botón "Guardar" a continuación, se realiza un
intento de ejecutar su código Java. Sin embargo, Java devolverá un error si intenta
ejecutar un programa Java sin definir primero un mainmétodo. Si encuentra un error
de este tipo, no se preocupe, puede definir el mainmétodo con anticipación para
evitar ver el error.

Si te quedas estancado durante este proyecto, mira el video que se encuentra en

la parte inferior de la página después del último paso del proyecto.

CONDICIONALES Y FLUJO DE CONTROL.

Decisiones
Hasta ahora, hemos explorado tipos de datos primitivos y la sintaxis de Java. Como
hemos visto, los programas Java siguen las instrucciones que les proporcionamos,
como la impresión de valores en la consola.

También podemos escribir programas Java que pueden seguir diferentes conjuntos
de instrucciones dependiendo de los valores que les proporcionemos. Esto se
llama flujo de control . En esta lección, aprenderemos cómo usar el flujo de
control en nuestros programas.

Operadores booleanos: &&

Veamos un conjunto de operadores que nos permiten usar el flujo de control en
nuestros programas. Estos operadores se llaman operadores booleanos.

Hay tres operadores booleanos que exploraremos. Comencemos con el primero: y .

1. El operador y está representado en Java por &&.

2. Devuelve un valor booleano de truesolo cuando las expresiones en ambos
lados de &&son verdaderas.

Por ejemplo, el siguiente código muestra un resultado del operador booleano &&:

// La siguiente expresión utiliza el "y" operador booleano

sistema . a cabo . println ( true && true ) ; // imprime verdad
El siguiente código muestra el resto de los posibles resultados de los operadores
booleanos &&:

// Las siguientes expresiones usan el "y"

Sistema operador booleano . a cabo . println ( false && false )
; // imprime falso sistema . a cabo . println ( false && true ) ;
// imprime falso sistema . a cabo . println ( true && false ) ; //
imprime falso
También podemos usar el operador &&booleano con expresiones booleanas como
las siguientes:

Sistema . a cabo . println ( 2 < 3 && 4 < 5 ) ;

El ejemplo anterior se imprimirá trueporque las declaraciones " 2es menor
que 3" y " 4es menor que 5" son verdaderas.

Operadores Booleanos: ||
¡Genial! El segundo operador booleano que exploraremos se llama o .

1. El operador o está representado en Java por ||.

2. Devuelve un valor booleano de truecuando al menos una expresión a cada
lado de ||es verdadera.

El siguiente código muestra todos los resultados del operador booleano ||:

// El "o" operador booleano:

sistema . a cabo . println ( falso || falso ) ; // imprime falso

sistema . a cabo . println ( falso || verdadero ) ; // imprime el
verdadero sistema . a cabo . println ( true || false ) ; //
imprime el verdadero sistema . a cabo . println ( true || true ) ;
// imprime verdad

También podemos usar el operador ||booleano con expresiones booleanas como

las siguientes:

Sistema . a cabo . println ( 2 > 1 || 3 > 4 ) ;

El ejemplo anterior se imprimirá trueporque al menos una declaración - " 2es
mayor que 1" - es verdadera aunque la otra declaración - " 3es mayor que 4" - es
falsa.
Operadores booleanos: !
¡Fantástico! El último operador booleano que exploraremos se llama no .

1. El operador no está representado en Java por !.

2. Devolverá lo contrario de la expresión inmediatamente después de
ella. Volverá falsesi la expresión es verdadera y truesi la expresión es falsa.

El siguiente código muestra todos los resultados del operador booleano !:

// El operador "no" booleano:

sistema . a cabo . println ( ! false ) ; // imprime el verdadero

sistema . a cabo . println ( ! true ) ; // imprime falso

También podemos usar el operador !booleano con expresiones booleanas como

las siguientes:

Sistema . a cabo . println ( ! ( 4 <= 10 ) ) ;

El ejemplo anterior se imprimirá falseporque la declaración " 4es menor o igual
que 10" es verdadera, pero el !operador devolverá el valor opuesto, que es false.

Operadores Booleanos: Precedencia

Los tres operadores booleanos &&, ||y !también se pueden utilizar juntos y utilizar
varias veces para formar expresiones booleanas más grandes.

Sin embargo, al igual que los operadores numéricos, los operadores booleanos
siguen reglas que especifican el orden en el que se evalúan. Este orden se
llama precedencia del operador booleano .

La precedencia de cada operador booleano es la siguiente:

1. ! se evalúa primero
2. && es evaluado segundo
3. || es evaluado tercero
Al igual que las expresiones numéricas, cada expresión entre paréntesis se evalúa
primero. Las expresiones también se leen de izquierda a derecha.

La siguiente declaración demuestra cómo funciona la precedencia del operador

booleano:

Sistema . a cabo . println ( ! ( false ) || true && false ) ;

El ejemplo anterior se imprimirá true. En orden, la expresión se evalúa de la
siguiente manera:

1. Primero, el !operador booleano en !(false)devoluciones true.

2. En segundo lugar, true && falseevalúa a false.
3. Finalmente, la expresión restante se true || falseevalúa como true.

Declaración If
Familiarizémonos con cómo se pueden usar los operadores relacionales, de
igualdad y booleanos para controlar el flujo de nuestro código.

Comenzaremos por explorar la sentencia if .

1. En Java, la palabra clave if es la primera parte de una expresión condicional.

2. Le sigue una expresión booleana y luego un bloque de código. Si la
expresión booleana se evalúa como true, se ejecutará el bloque de código
que sigue.

Aquí hay un ejemplo de la sentencia if utilizada con una expresión condicional:

si ( 9 > 2 ) { Sistema . a cabo . println ( "Control de flujo

de rocas!" ) ; }

En el ejemplo anterior, 9 > 2es la expresión booleana que se comprueba. Dado que
la expresión booleana " 9es mayor que 2" es true, Control flow rocks!se imprimirá
en la consola.
La ifdeclaración no es seguida por un punto y coma ( ;). En su lugar, utiliza llaves
( {y }) para rodear el bloque de código que se ejecuta cuando la expresión
booleana es true.

Declaración If-Else
A veces ejecutamos un bloque de código cuando la expresión booleana después
de la ifpalabra clave es true. Otras veces podemos querer ejecutar un bloque de
código diferente cuando la expresión booleana es false.

Podríamos escribir una segunda ifdeclaración con una expresión booleana que sea
opuesta a la primera, pero Java proporciona un acceso directo
llamado if/ elsecondicional.

1. El if/ elsecondicional ejecutará el bloque de código asociado con

la ifinstrucción si su expresión booleana se evalúa como true.
2. De lo contrario, si la expresión booleana se evalúa false, se ejecutará el
bloque de código después de la elsepalabra clave.

Aquí hay un ejemplo de if/ elsesintaxis:

si ( 1 < 3 && 5 < 4 ) { Sistema . a cabo . println ( "¡

Desafío las leyes booleanas!" ) } else { System . a cabo . println
( "¡Puedes agradecer a George Boole!" ) ; }

En el ejemplo anterior, la expresión booleana " 1es menor que 3" y " 5es menor
que 4" se evalúa false. El código dentro del ifbloque se omitirá y el código dentro
del elsebloque se ejecutará en su lugar. El texto "You can thank George Boole!" se
imprimirá en la consola.
Declaración If-ElseIf-Else
¡Buen trabajo! En algunos casos, necesitamos ejecutar un bloque de código
separado dependiendo de las diferentes expresiones booleanas. Para ese caso,
podemos usar la declaración if/ else if/ elseen Java.

1. Si la expresión booleana después de la ifinstrucción se evalúa como true, se

ejecutará el bloque de código que sigue directamente.
2. De lo contrario, si la expresión booleana después de la else ifinstrucción se
evalúa como true, se ejecutará el bloque de código que sigue directamente.
3. Finalmente, si todas las expresiones booleanas anteriores lo
evalúan false, elsese ejecutará el código dentro del bloque.

Aquí hay un ejemplo de flujo de control con la declaración if/ else if/ else:

int shoeSize = 10 ; if ( shoeSize > 12 ) { Sistema . a cabo .

println ( "Lo sentimos, tu talla de zapato no está actualmente en
stock." ) ; } else if si ( shoeSize > = 6 ) { System . a cabo .
println ( "¡Tu talla de zapato está en stock!" ) ; } else { System
. a cabo . println (

"Lo sentimos, esta tienda no tiene zapatos más pequeños que un

tamaño 6." ) ;
}
En el ejemplo anterior, la intvariable shoeSizees igual a 10, que no es mayor que 12,
pero es mayor o igual que 6. Por lo tanto, el bloque de código después de la else
ifinstrucción se ejecutará.

Condicional Ternario
ifLas elsedeclaraciones / pueden volverse largas incluso cuando simplemente
desea devolver un valor dependiendo de una expresión
booleana. Afortunadamente, Java proporciona un acceso directo que le permite
escribir if/ elsedeclaraciones en una sola línea de código. Se llama
la declaración condicional ternaria .

El término ternaryproviene de una palabra latina que significa "compuesto de tres

partes".

Estas tres partes son:

1. Una expresion booleana

2. Una sola declaración que se ejecuta si la expresión booleana es verdadera
3. Una sola declaración que se ejecuta si la expresión booleana es falsa

Aquí hay un ejemplo de una declaración condicional ternaria:

int pointsScored = 21 ; char gameResult = ( pointsScored > 20 )

? 'W' : 'L' ; Sistema . a cabo . println ( gameResult ) ;

En el ejemplo anterior, la intvariable llamada pointsScoredes igual a 21.

La expresión booleana es (pointsScored > 20), que se evalúa como true. Esto
devolverá el valor de 'W', que se asigna a la variable gameResult. El valor 'W'se
imprime en la consola.

Declaración Switch
Las declaraciones condicionales que hemos cubierto hasta ahora requieren
expresiones booleanas para determinar qué bloque de código se ejecutará. Java
también proporciona una forma de ejecutar bloques de código en función de si un
bloque es igual a un valor específico. Para esos casos específicos, podemos usar
la switchdeclaración, que ayuda a mantener el código organizado y con menos
palabras.

La instrucción de cambio se utiliza de la siguiente manera:

int restaurantRating = 3 ; interruptor ( restaurantRating ) {
caso 1 : sistema . a cabo . println ( "Este restaurante no es mi
favorito." ) ; romper ; caso 2 : Sistema . a cabo . println (
"Este restaurante es bueno." ) ; romper ; caso 3 : sistema . a
cabo . println ( "Este restaurante es fantástico!"

) ; romper ; por defecto : el sistema . a cabo . println (

"Nunca he cenado en este restaurante." ) ; romper ; }

En el ejemplo anterior, asignamos a la intvariable restaurantRatingun valor de 3. El

código imprimirá un mensaje a la consola según el valor de restaurantRating.

En este caso, This restaurant is fantastic!se imprime a la consola.

La breakdeclaración saldrá de la switchdeclaración después de que se cumpla una

condición. Sin la breakdeclaración, Java continuará verificando si el valor
de restaurantRatingcoincide con otros casos.

El defaultcaso se imprime sólo si restaurantRatingno es igual a una intcon el valor

de 1, 2o 3.

Generalizaciones
¡Buen trabajo! El flujo de control permite que los programas Java ejecuten bloques
de código en función de expresiones booleanas. ¿Qué aprendimos sobre el flujo de
control hasta ahora?
• Los operadores booleanos : &&, ||y !se utilizan para construir expresiones
booleanas y tienen un orden definido de operaciones
• Declaraciones : if, if/ else, y if/ else if/ elsedeclaraciones se utilizan para
ejecutar condicionalmente bloques de código
• Condicional ternario : una versión abreviada de una declaración if/ elseque
devuelve un valor basado en el valor de una expresión booleana
• Switch : nos permite verificar la igualdad de una variable o expresión con un
valor que no necesita ser booleano.