Вы находитесь на странице: 1из 60

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

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

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

HelloWorld

concepto es: Hello World Printer. Otros conceptos de clase

Marcamos el dominio de este concepto se utilizan llaves:

dentro de las llaves es parte de la clase.

{}
{}

. La sintaxis

Cada archivo tiene una clase primaria nombrada después del

archivo. Nuestro nombre de clase:

archivo: HelloWorld . Cada palabra está en mayúscula.

HelloWorld

y nuestro nombre de

Dentro de la clase teníamos un tareas de programa:

método que enumera nuestras que enumera nuestras

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 ,
public
,

static

y

void

son sintaxis de las que aprenderemos en futuras

lecciones.

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.

String[] args

es un marcador de posición para la información

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

.

HelloYou
HelloYou

clase con un

main()
main()

método.

Adentro

con su nombre reemplazado

main()
main()

, agregue una declaración que se imprima

someName .
someName
.

Por ejemplo, mi programa se imprimiría

Hello Patrick!

.

Hello someName!

,

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

terminal, son solo para personas que leen nuestro código en el editor de texto.

System.out.println()

. Estos comentarios no se mostrarán en nuestra

Instrucciones

. El archivo Timeline.java tiene información de texto plano sobre Java.

1

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()
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.

de programación que las computadoras pueden ejecutar. Los ejercicios anteriores han compilado automáticamente y

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:

ExampleFile.java

.

javac
javac

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.java

y

presione

enter
enter

o

return .
return
.

Utilice el

Check Work

botó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

ls
ls

y presione

return
return

o

enter.
enter.

El

ls
ls

comando 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:

que omitimos la parte .class del nombre de archivo.

java FileName

. Tenga en cuenta

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

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

exitosa.

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

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

el archivo .java sin compilar .

ls
ls

comando en el terminal para ver

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()
main()

método.

o

Cada clase representa una idea del mundo real.

o

El

main()
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

. El editor de texto contiene un archivo vacío llamado Review.java . ¡Rellenarlo!

1

Definir un

public class

nombre

Review .
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

System.out.println()

System.out.println()

System.out.println() system.out.println()
System.out.println() system.out.println()
system.out.println()

system.out.println()

es

escribir

. Si tuviera que

o

System.Out.println()

System

o

out

.

que su intención era usar

, el compilador no sabría

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

como camel case . Las llaves,

dentro de las llaves es parte de la clase.

HelloWorld

. Capitalizamos cada palabra, un estilo conocido

{ y }
{
y
}

, marcan el alcance de la clase. Todo

Métodos

public static Statements }

void

main ( String [ ] args ) { //

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

nuestro programa.

main()
main()

método contiene todas las instrucciones para

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

salida. Los objetos son paquetes de estado y comportamiento, y a menudo se modelan en cosas del mundo real.

out
out

, que es responsable de varios tipos de

out
out

está ubicado dentro

System
System

, que es otro objeto responsable de

representar nuestra computadora dentro del programa! Podemos

acceder a partes de un objeto con a como notación de puntos .

.
.

, lo que se conoce

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 colores.

class
class

en Java, se resaltan con diferentes

Compara estos dos ejemplos de código:

// sin sintaxis destacando

pública clase NiceDay { públicas estáticas vacíos principales ( cadena [ ]

args)

fuera

{ System.out.println ( " Se ' s

un

buen

día

!

" );

}

}

// con la sintaxis que resalta

{ public static void main (

String [ ] args ) { System . a cabo . println ( "¡Es un buen día!" ) ; } }

la clase pública NiceDay

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

ahora. En un IDE, podríamos verlo

autocompletar solo después de escribir

para que el programador pueda concentrarse en la lógica de su código.

System.out.println()

System

bastante hasta

como una opción de

Sy

. Esto ahorra pulsaciones

Edificio ejecutables Java es un lenguaje compilado. Antes de programas se ejecutan, el código fuente

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.

para evitar errores antes de la compilación. Codificación en su computadora El mayor beneficio de usar

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

número de pedidos realizados. Con un nombre, que conocemos el

42
42

podría ser la edad de alguien, un peso en libras o el

valor 42 es age , weightInPounds o
valor
42 es
age
, weightInPounds
o

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 tipos incorporados y más.

int

,

double

y

boolean

. Esta lección introducirá estos

Los nombres de las variables son

age ,
age
,

salaryRequirement

y

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

tipo

int
int

, escribimos:

2011
2011

a una variable llamada

yearCodecademyWasFounded

de

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 .

int
int

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

fracciones ni números con decimales.

El

int
int

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

Para declarar una variable de tipo de la variable:

int
int

, usamos la

int
int

palabra clave antes del nombre

// 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

int
int

tipo que puede contener.

 

El

double
double

tipo de datos primitivo puede ayudar.

double
double

Puede 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

declaración:

double
double

, usamos la

double
double

palabra clave en la

// 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:

true o false .
true
o false
.

Declaramos las variables booleanas usando la palabra clave nombre de la variable.

boolean
boolean

antes del

javaIsACompiledLanguage booleano = verdadero ; javaIsACupOfCoffee booleano = falso ;

En lecciones futuras, veremos cómo los decisiones en nuestros programas.

boolean

valores ayudan a navegar las

Char

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

El

char
char

tipo 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

comportamiento incorporado.

String
String

s, que son objetos , en lugar de primitivos. Los objetos tienen un

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.

una variable es ilimitada, pero debemos mantenerlo conciso y al mismo tiempo mantener el significado claro.

myHeight
myHeight

es una variable diferente a

myheight
myheight

. La longitud del nombre de

Una variable comienza con una letra válida, o a

número puede comenzar un nombre de variable. de variables válidos.

$ , o a _ 1stPlace y *Gazer
$ , o a
_
1stPlace
y *Gazer

. Ningún otro símbolo o

no son nombres

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

int double boolean char String
int
double
boolean
char
String

s, que almacenan números enteros

s, que almacenan números enteros más grandes y números decimales

s, que almacenan

true y false
true
y false

s, que almacenan caracteres individuales utilizando comillas simples.

s, 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 primitivo que puede contener grandes números decimales.

double
double

, el tipo

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

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

int

s!

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

84
84

numPicturesOfCats

.

en

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 paycheckAmount ahora tiene 620.0

=

40

*

15.50 ; //

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

 

/

operador hace una división

La división tiene diferentes resultados con enteros. El 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

evenlyDivided

almacena lo que espera, pero

 

se

unevenlyDivided

mantiene

2
2

porque

int
int

s no puede almacenar decimales!

Java elimina el 0.5 para ajustar el resultado en un

Modulo

int
int

tipo!

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.

= cookiesLeftover tiene 1

int cookiesBaked

10 ; int cookiesLeftover = 10 % 3 ; //

¡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.

% // 1, impar!

8 %

// 0, incluso!

9 %

// 1, impar!

7

2

2

2

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

nos ayudan a resolver nuestro problema de abstinencia.

boolean
boolean

comparaciones. Estos incluyen menos que (

<
<

) y mayor que (

>
>

), que

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 en la última lección.

boolean

, que aprendió

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. son iguales:

==
==

nos dirá si dos variables

doble cheque de pago cantidad

doble calculado = 15.50 * 40 ; Sistema . a cabo . print ( paycheckAmount == calculadoPaycheck ) ; // esto se imprimirá como

verdadero, ya que paycheckAmount es igual a CalculatePaycheck

=

620 ; Comprobación de pago

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

signo igual

asegúrese de revisar su código para ver el número correcto de signos iguales.

=
=

, es cómo asignamos valores a las variables. Es fácil mezclarlos, así que

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

menor o igual que

<= !
<=
!
>=
>=

, o

doble cheque de pago cantidad

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

=

620 ; Comprobación de pago

.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 comparar entre paréntesis:

.
.

, y pasamos la Cadena para

String person1

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"

=

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

Concatenación de Strings

Hemos cubierto muchas funcionalidades integradas en Java a lo largo de esta

lección. Hemos visto

solo funcionan con primitivos, pero algunos también funcionan con cadenas.

+ , - , < , ==
+
,
-
,
<
,
==

, y muchos otros operadores. La mayoría de estos

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

username

mostrada.

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

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

=

"PrinceNelson" ; Sistema . a cabo . println (

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.
• 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

Igual a,

Mayor o igual que

> ==
>
==
< != >=
<
!=
>=

y menor que

y no igual a,

, y menor o igual que

<=
<=
.equals() Usando +
.equals()
Usando
+

para comparar cuerdas y otros objetos

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

preocupaciones del mundo real, los estudiantes y sus calificaciones, están dentro del programa como clases.

Student , Course y Grade
Student
, Course
y Grade

clases. Nuestras

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

Student
Student

clase.

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

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
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 pero tienen un estado

Imagina que dos personas tienen cuentas que son instancias de

la

pero tienen un estado individual (sus saldos), e incluso con el mismo monto de saldo, estas cuentas son entidades separadas.

SavingsAccount

clase. Comparten el comportamiento (cómo depositan y retiran)

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

en nuestra pantalla, pero también necesitamos escribir nuestras propias clases para las necesidades personalizadas de un programa.

que hemos usado para registrar texto

System
System

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

class

nombre

Car

.

public

es 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
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

clase con un constructor:constructor definido dentro de la clase. Aquí está la public class Car { public Car (

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

ejemplo asigna una instancia a la variable

ferrari :
ferrari
:
main()
main()

. Este

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:

Car

y el

nombre de:

tipo de nombre de clase.

ferrari
ferrari

. Las variables que hacen referencia a una instancia tienen un

Invocamos el método constructor:,

que estamos creando una instancia. Omitir

Car()
Car()

y usamos la palabra clave

new
new

causa un error.

new
new

para indicar

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

definido.

main()
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

parecía algo así

segunda parte se computadora.

Store
Store

, que

Store@6bc7c054 @6bc7c054
Store@6bc7c054
@6bc7c054

. La primera parte, se

Store
Store

refiere a la clase, y la

refiere a la ubicación de la instancia en la memoria de la

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

color
color
Car
Car

instancias de diferentes colores, por lo que declaramos un

campo de instancia.

String
String

public class

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 } }

Car

{ / * declara los campos dentro de la clase

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 el próximo ejercicio.
tener
"red"
como su
color
el próximo ejercicio.

, otra

"blue"
"blue"

, etc. Aprenderemos cómo asignar valores en

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

Car
Car

constructor 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 carColor

como 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

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

main()
main()

método:,

String[] args

pero esta es la

El parámetro hace método:

carColor
carColor

referencia al valor pasado durante una llamada de

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,

su

color
color

campo:

ferrari
ferrari

en el

método conAquí creamos una instancia, su color campo: ferrari en el "red" como Clase pública de coches

"red"
"red"

como

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

la invocación:

carColor
carColor

se refiere al valor pasado en durante

color .
color
.
"red"
"red"

. Este valor se asigna al campo de instancia

ya se ha declarado, por lo que no especificamos el tipo durante la asignación.. "red" . Este valor se asigna al campo de instancia El objeto hace referencia al

El objeto

hace referencia al valor

ferrari
ferrari

,, mantiene el estado de

"red" .
"red"
.

como un campo de instancia queel tipo durante la asignación. El objeto hace referencia al valor ferrari ,, mantiene el estado

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

Car
Car

instancias para que tengan múltiples campos.

Agregaremos una

encendido y una viajando.

boolean isRunning

boolean isRunning

int velocity

boolean isRunning int velocity

, que indica que el motor del automóvil está

, que indica la velocidad a la que el automóvil está

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

no coinciden con los tipos, error! Junker de coches = Carro nuevo ( verdadero , 42 , "marrón" ) ;

=

new

Car ( "verde" , falso , 0 ) ; // los valores

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.

{ // 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

público de clase

Perro

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

principal. Aprendimos que los objetos tienen estado y comportamiento.

Store
Store

clase en el método

Hemos visto cómo dar estado a los objetos a través de campos de instancia. Ahora,

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

este

Car startEngine()
Car
startEngine()

ejemplo de la última lección? Agreguemos un método a

que se imprima:

Car
Car

llamado

¡Arrancando

Vroom !

el

coche !

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:

public
public

significa que otras clases pueden acceder a este

método. Aprenderemos más sobre eso más adelante en el curso.

La

void
void

palabra clave significa que no hay una salida específica del

método. Veremos métodos que no están

void
void

más adelante en esta lección,

pero por ahora todos nuestros métodos lo serán

void .
void
.

startEngine()

Es el nombre del método.

Un

anteriormente se parece a algo como:

checkBalance()

método para la cuenta de ahorros de la que hablamos

público ( ) { Sistema . a cabo . println

( "¡Hola!" ) ; Sistema . a cabo . println ( "Tu saldo es" + saldo

) ;

checkBalance del vacío

}

Las dos declaraciones impresas están dentro del cuerpo del método, que está definido por las

Las dos declaraciones impresas están dentro del cuerpodel método, que está definido por las llaves.

Cualquier cosa que podamos hacer en nuestro

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.

main()
main()

método, podemos hacerlo en

Métodos de llamada

¡Genial! Cuando agregamos el

para usar en cualquier

el

método a la

objeto. Podemos hacerlo llamando al método en

startEngine()

Car
Car

clase, queda disponible

Car
Car
Car
Car

objeto que creamos, por ejemplo.

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

Car
Car

clase:

clase de coches

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

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

[

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

En el ejemplo anterior, llamamos al

startEngine()

método en

el

ejecutar los resultados del programa se imprime

myFastCar

objeto. Esta llamada al método ocurre dentro del

Vroom!
Vroom!

método. Al

en el terminal de salida.

main()
main()

Alcance

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

Marcamos el dominio de esta tarea usando llaves:,

es parte de la tarea. Este dominio se llama el alcance de un método.

{ y }
{
y
}

. Todo dentro de las llaves

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

Car
Car

clase de nuevo:

clase de coches

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

{ color de la cuerda ; int milesDriven ; Coche

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,

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

milesDriven

que se declara en la parte superior de la clase, se puede

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

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

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

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

"red" ) ; miCarro . startRadio ( "Estación de Meditación" ) ; } }

static void

En este código, creamos un

llamado

el

station myCar
station
myCar

. En el

main()

startRadio()

método que acepta un

String
String

parámetro

método, llamamos al

String
String

startRadio()

método en

 

"Meditation Station"

.

objeto y proporcionamos un

parámetro de

Una llamada al

startRadio()

método de

myCar
myCar

resultados 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

el saldo para que sea un nuevo valor utilizando nuestro operador de asignación nuevamente.

balance
balance

. Podemos reasignar

= ,
=
,

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 :
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.balance

después de que

el

deposit()
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 :
return
:

public int retorno ; }

numberOfTires ( )

{ int tires = 4 ; neumáticos de

Este método, llamado

numberOfTires

, devuelve

4

. En ejercicios anteriores, al crear

nuevos métodos, usamos la palabra clave

void

. Aquí, estamos

reemplazando

void
void

con

int
int

, para indicar que el tipo de retorno es un

int .
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

int

valor de 4, almacenamos el valor 4 en una variable entera

llamada

numTires

. Si imprimiéramos

numTires
numTires

, lo veríamos

4 .
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

Store
Store

objetos, veríamos resultados como:

Tienda @ 6bc7c054

 

donde

Store

es el nombre del objeto y

6bc7c054

es su posición en la memoria.

Esto no nos dice nada sobre lo que

instancia que hemos definido. Podemos agregar un método a nuestras clases que hace que esta impresión sea más descriptiva.

vende, el precio o los otros campos declases que hace que esta impresión sea más descriptiva. Cuando definimos un método toString () para

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

un

String
String

que 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.