![Curso Java Unidad II.ppt [Modo de compatibilidad] · Fundamentos de programación en Java Ing. ... St iSystem.in Et bjt t lEste objeto pertenece a la clase InputStream, esto significa](https://static.fdocuments.ec/doc/165x107/5bdc568009d3f2bc1c8dbba7/curso-java-unidad-iippt-modo-de-compatibilidad-fundamentos-de-programacion.jpg)
Tutorial Java St
172
Tutorial Java
-
Upload
cesar-guerrero -
Category
Documents
-
view
64 -
download
8
description
traducción
Transcript of Tutorial Java St
-
Tutorial Java
-
Contents Leccin: Lenguaje bsico .......................................................................................................... 8
Variables .................................................................................................................................. 8
Operadores .............................................................................................................................. 8
Expresiones, declaraciones y bloques ................................................................................ 8
Instrucciones de flujo de control ........................................................................................... 8
Variables ...................................................................................................................................... 8
Nomenclatura ........................................................................................................................ 10
Tipos de datos primitivos ......................................................................................................... 10
Valores por defecto .............................................................................................................. 12
Literales .............................................................................................................................. 13
Usando caracteres de subrayado en literales de valores numricos ........................... 15
Arreglos ...................................................................................................................................... 16
Declarar una Variable para hacer referencia a un Arreglo ............................................ 18
Crear, inicializar y acceder a una arreglo ......................................................................... 19
Copia de Arrays .................................................................................................................... 20
Manipulacin de arreglos .................................................................................................... 21
Resumen de Variables ............................................................................................................ 22
Preguntas: Variables ................................................................................................................ 22
Operadores ................................................................................................................................ 22
Asignacin, aritmtica y operadores unarios ....................................................................... 24
El operador de asignacin Simple ..................................................................................... 24
Los operadores aritmticos ................................................................................................. 24
Los operadores unarios ....................................................................................................... 25
Operadores de igualdad y relacionales ............................................................................ 27
Los operadores condicionales ............................................................................................ 28
El operador de comparacin de tipo instanceof .............................................................. 29
Operadores Bitwise y Bit Shift ................................................................................................ 30
Resumen de operadores ......................................................................................................... 30
Operador de asignacin simple.......................................................................................... 30
Operadores aritmticos ....................................................................................................... 30
Operadores unarios ............................................................................................................. 31
Igualdad y operadores relacionales ................................................................................... 31
Operadores condicionales .................................................................................................. 31
Operador de comparacin de tipo ..................................................................................... 31
Operadores Bitwise bit a bit y Bit Shift (mover bits) ........................................................ 31
-
Preguntas y ejercicios: operadores ....................................................................................... 31
Preguntas............................................................................................................................... 31
Ejercicios ................................................................................................................................ 32
Expresiones, instrucciones y bloques ................................................................................... 33
Expresiones ........................................................................................................................... 33
Instrucciones o sentencias .................................................................................................. 34
Bloques .................................................................................................................................. 34
Preguntas y ejercicios: expresiones, instrucciones y bloques .......................................... 35
Preguntas............................................................................................................................... 35
Ejercicios ................................................................................................................................ 35
Instrucciones de control de flujo ............................................................................................. 35
Las instrucciones if-then e if-then-else .................................................................................. 36
La instruccin if-then ...................................................................................................... 36
La instruccin if-then-else .......................................................................................... 37
La instruccin switch ............................................................................................................ 38
El uso de Strings en la instruccin switch ..................................................................... 41
Las instrucciones while y do-while ................................................................................. 43
La instruccin for .................................................................................................................... 44
Instrucciones de ramificacin ................................................................................................. 46
La instruccin break ........................................................................................................... 46
La instruccin continue .................................................................................................... 48
La instruccin return ......................................................................................................... 49
Resumen de las instrucciones de flujo de Control .............................................................. 50
Preguntas y ejercicios: Control de flujo ................................................................................. 50
Preguntas............................................................................................................................... 50
Ejercicios ................................................................................................................................ 50
Leccin: Clases y objetos ....................................................................................................... 52
Clases..................................................................................................................................... 52
Objetos ................................................................................................................................... 52
Ms tipos ................................................................................................................................ 52
Clases anidadas ................................................................................................................... 52
Tipos de enumeracin ......................................................................................................... 52
Clases......................................................................................................................................... 52
Declarar Clases ........................................................................................................................ 54
Declarar las Variables miembro ............................................................................................. 55
Modificadores de acceso ..................................................................................................... 55
-
Tipos ....................................................................................................................................... 56
Nombres de variables .......................................................................................................... 56
Definir Mtodos ......................................................................................................................... 57
Nombrando un mtodo ........................................................................................................ 57
Sobrecarga de mtodos ...................................................................................................... 58
Proporcionar constructores para tus clases ......................................................................... 58
Pasar informacin a un mtodo o a un Constructor ........................................................... 59
Tipos de parmetros ............................................................................................................ 60
Nmero arbitrario de argumentos ...................................................................................... 60
Nombres de parmetros ...................................................................................................... 61
Pasando argumentos de tipo de datos primitivo ............................................................. 62
Pasando argumentos de tipo de datos de referencia ..................................................... 62
Objetos ....................................................................................................................................... 63
Creacin de objetos ................................................................................................................. 64
Declarar una Variable para hacer referencia a un objeto .............................................. 64
Crear instancias de una clase ............................................................................................ 65
Inicializar un objeto ............................................................................................................... 65
Uso de objetos .......................................................................................................................... 67
Referenciando a los campos de un objeto ....................................................................... 67
Llamar los mtodos de un objeto ....................................................................................... 68
El recolector de basura ........................................................................................................ 69
Ms sobre clases ...................................................................................................................... 70
Devuelve un valor desde un mtodo ..................................................................................... 70
Devolviendo una clase o una interfaz ............................................................................... 71
Usando la palabra clave this ................................................................................................... 72
Usando this con un campo .............................................................................................. 72
Usando this con un Constructor ..................................................................................... 72
Controlar el acceso a los miembros de una clase............................................................... 73
Entendiendo a los miembros de la clase .............................................................................. 74
Variables de clase ................................................................................................................ 75
Mtodos de la clase ............................................................................................................. 76
Constantes............................................................................................................................. 76
La clase de Bicycle .......................................................................................................... 77
Inicializar campos ..................................................................................................................... 78
Bloques de inicializacin esttica ...................................................................................... 78
Inicializar miembros de instancia ....................................................................................... 79
-
Resumen de crear y utilizar clases y objetos ....................................................................... 79
Preguntas y ejercicios: clases ................................................................................................ 80
Preguntas............................................................................................................................... 80
Ejercicios ................................................................................................................................ 81
Preguntas y ejercicios: objetos ............................................................................................... 81
Preguntas............................................................................................................................... 81
Ejercicios ................................................................................................................................ 82
Clases anidadas ....................................................................................................................... 82
Por qu utilizar clases anidadas? .................................................................................... 82
Clases anidadas estticas .................................................................................................. 83
Clases internas ..................................................................................................................... 83
Sombreado ............................................................................................................................ 84
Ejemplo de la clase interna ................................................................................................. 84
Clases locales y annimas.................................................................................................. 86
Modificadores ........................................................................................................................ 86
Clases locales ........................................................................................................................... 86
Declarar clases locales ........................................................................................................ 86
Acceso a miembros de una clase envolvente .................................................................. 88
Clases de sombreado y locales ..................................................................................... 89
Las clases locales son similares a las clases internas ................................................... 89
Clases de annimas ................................................................................................................. 90
Declarar clases annimas ................................................................................................... 90
Sintaxis de clases annimas .............................................................................................. 91
Acceder a las Variables locales del mbito envolvente y declarando y acceder a los
miembros de la clase annima ........................................................................................... 91
Ejemplos de clases de annimos ...................................................................................... 92
Cundo utilizar clases anidadas, Local clases, clases de annimas y expresiones
Lambda ...................................................................................................................................... 94
Preguntas............................................................................................................................... 95
Ejercicios ................................................................................................................................ 95
Las respuestas a las preguntas y ejercicios: clases anidadas .......................................... 96
Preguntas............................................................................................................................... 96
Ejercicio .................................................................................................................................. 97
Tipos enumerados .................................................................................................................... 97
Leccin: anotaciones ............................................................................................................. 101
Conceptos bsicos de anotaciones ................................................................................. 101
-
El formato de una anotacin ......................................................................................... 101
Donde pueden ser utilizadas las anotaciones ........................................................... 102
Declarar un tipo de anotacin ....................................................................................... 102
Tipos de anotacin predefinidos ...................................................................................... 104
Tipos de anotacin utilizados por el lenguaje Java................................................... 104
Anotaciones que se aplican a otras anotaciones ...................................................... 105
Preguntas y ejercicios: anotaciones ................................................................................ 106
Preguntas ......................................................................................................................... 106
Leccin: Interfaces y herencia .............................................................................................. 106
Interfaces ............................................................................................................................. 106
Herencia ............................................................................................................................... 106
Interfaces ................................................................................................................................. 107
Interfaces en Java .............................................................................................................. 107
Interfaces como APIs ......................................................................................................... 108
Definir una interfaz ............................................................................................................. 108
El cuerpo de la interfaz ...................................................................................................... 109
Implementar una interfaz ....................................................................................................... 109
Una interfaz de muestra, Relatable ................................................................................. 109
Implementa la interfaz Relatable...................................................................................... 110
Usando una interfaz como un tipo ....................................................................................... 111
Evolucin de las Interfaces ................................................................................................... 112
Mtodos por defecto .............................................................................................................. 112
Extender Interfaces que contienen mtodos por defecto............................................. 115
Mtodos estticos ............................................................................................................... 116
Integracin de mtodos por defecto en bibliotecas existentes ................................... 117
Resumen de Interfaces ......................................................................................................... 121
Preguntas y ejercicios: Interfaces ........................................................................................ 121
Preguntas............................................................................................................................. 121
Ejercicios .............................................................................................................................. 121
Herencia ................................................................................................................................... 122
La jerarqua de clases de la plataforma Java ................................................................ 122
Un ejemplo de herencia ..................................................................................................... 123
Lo que se puede hacer en una subclase ........................................................................ 124
Miembros privados en una superclase ........................................................................... 124
Casting de Objetos ............................................................................................................. 124
Herencia mltiple de estado, la implementacin y el tipo ................................................ 125
-
Sobreescribir y ocultar mtodos ....................................................................................... 126
Mtodos de instancia ..................................................................................................... 126
Mtodos estticos ........................................................................................................... 126
Mtodos de interfaz ........................................................................................................ 127
Modificadores .................................................................................................................. 129
Resumen .......................................................................................................................... 129
Polimorfismo ............................................................................................................................ 130
Ocultar campos ....................................................................................................................... 132
Usando la palabra clave super ............................................................................................. 132
Acceso a miembros de la superclase .............................................................................. 132
Los constructores de la subclase ..................................................................................... 133
Objeto como una superclase ................................................................................................ 134
El mtodo clone() ............................................................................................................... 134
El mtodo equals() ............................................................................................................. 135
El mtodo finalize() ............................................................................................................. 136
El mtodo getClass() ......................................................................................................... 136
El mtodo hashCode() ....................................................................................................... 136
El mtodo toString() ........................................................................................................... 136
Escribir clases y mtodos finales ......................................................................................... 137
Clases y mtodos abstractos................................................................................................ 137
Las clases abstractas en comparacin con las Interfaces........................................... 138
Un ejemplo de clase abstracta ......................................................................................... 139
Cuando una clase abstracta implementa una interfaz ................................................. 140
Miembros de la clase ......................................................................................................... 140
Resumen de la herencia ....................................................................................................... 140
Preguntas y ejercicios: herencia .......................................................................................... 140
Preguntas............................................................................................................................. 140
Leccin: Nmeros y cadenas ............................................................................................... 141
Nmeros............................................................................................................................... 141
Strings .................................................................................................................................. 141
Nmeros................................................................................................................................... 141
Las clases de nmeros .......................................................................................................... 142
Formato de impresin numrica .......................................................................................... 144
Los mtodos printf y formato ............................................................................................ 144
Un ejemplo........................................................................................................................... 145
La clase DecimalFormat .................................................................................................... 146
-
Ms all de la aritmtica bsica ........................................................................................... 147
Constantes y mtodos bsicos ........................................................................................ 148
Mtodos de funciones logartmicos y exponenciales ................................................... 149
Mtodos de funciones trigonomtricos ........................................................................... 150
Nmeros aleatorios ............................................................................................................ 152
Resumen de nmeros ........................................................................................................... 152
Caracteres ............................................................................................................................... 152
Secuencias de escape ....................................................................................................... 154
Strings ...................................................................................................................................... 154
Creacin de strings ............................................................................................................ 154
Longitud de cadena ............................................................................................................ 155
Concatenacin de cadenas .............................................................................................. 156
Creacin de cadenas de formato ..................................................................................... 157
Conversin entre nmeros y cadenas ................................................................................ 157
Conversin de cadenas a nmeros ................................................................................. 157
Convertir nmeros en cadenas ........................................................................................ 158
Manipulacin de caracteres de una cadena ...................................................................... 159
Caracteres y subcadenas ndice ...................................................................................... 159
Otros mtodos para manipular cadenas ......................................................................... 160
La bsqueda de caracteres y subseries de caracteres en una cadena .................... 160
Sustitucin de caracteres y subseries de caracteres en una cadena ........................ 161
Un ejemplo........................................................................................................................... 162
Comparacin de cadenas y porciones de cadenas .......................................................... 163
La clase StringBuilder ............................................................................................................ 165
Longitud y capacidad ......................................................................................................... 165
Operaciones de StringBuilder ........................................................................................... 166
Un ejemplo........................................................................................................................... 167
Resumen de caracteres y cadenas ..................................................................................... 169
Autoboxing y Unboxing .......................................................................................................... 169
-
Leccin: Lenguaje bsico
Variables
Ya has aprendido que objetos almacenan su estado en los campos. Sin embargo, el lenguaje de programacin Java tambin utiliza el trmino "variable". Esta seccin analiza esta relacin, ms las variables y sus reglas de nomenclatura y convenciones, los tipos de datos bsicos (tipos primitivos, matrices y cadenas de caracteres), los valores por defecto y literales.
Operadores
Esta seccin describe los operadores del lenguaje de programacin Java. Primero presenta los operadores ms comnmente utilizados, y por ltimo los operadores menos utilizados. Cada discusin incluye ejemplos de cdigo que se pueden compilar y ejecutar.
Expresiones, declaraciones y bloques
Los operadores pueden utilizarse en la construccin de expresiones, que computan los valores; las expresiones son los componentes bsicos de las instrucciones; las instrucciones pueden agruparse en bloques. Esta seccin analiza expresiones, instrucciones y los bloques usando el cdigo de ejemplo que ya has visto.
Instrucciones de flujo de control
Esta seccin describe las sentencias de los flujos de control soportados por el lenguaje de programacin Java. Cubre la toma de decisiones, bucles y ramificaciones de sentencias que permiten a sus programas ejecutar condicionalmente bloques particulares de cdigo.
Variables
Como has aprendido en la leccin anterior, un objeto almacena su estado en campos.
int cadence = 0;
int speed = 0;
int gear = 1;
Ya hemos presentado a los campos, pero probablemente tiene todava un par de preguntas, tales como:
Cules son las reglas y convenciones para nombrar un campo?
Adems de int, qu otros tipos de datos existen?
Los campos se tienen que inicializar cuando se declaran?
A los campos se les asigna un valor predeterminado si no se inicializan explcitamente?
Exploraremos las respuestas a estas preguntas en esta leccin, pero antes de hacerlo, hay algunas distinciones tcnicas de las que primero debes ser consciente.
En el lenguaje de programacin Java, se usan ambos trminos "campo" y "variable";
Esto es una fuente comn de confusin entre los nuevos desarrolladores, ya que ambas parecen a menudo referirse a lo mismo.
-
El lenguaje de programacin Java define los siguientes tipos de variables:
Variables de Clase (campos estticos) Una variable de clase es cualquier campo declarado con el modificador static;
Esto indica al compilador que hay exactamente una copia de esta variable en existencia, sin importar cuntas veces la clase ha creado una instancia. Un campo define el nmero de marchas para una clase particular de bicicleta que podra
ser marcado como static ya que conceptualmente el mismo nmero de marchas se
aplicar a todas las instancias.
El cdigo static int numGears = 6; creara un campo esttico. Adems, la palabra
clave final podra aadirse para indicar que el nmero de marchas nunca cambiar.
Variables de Instancia (campos no-estticos) Tcnicamente hablando, los objetos almacenan sus Estados individuales en "campos no
estticos", es decir, los campos se declararan sin la palabra clave static.
Los campos no estticos son tambin conocidos como las variables de instancia porque sus valores son nicos para cada instancia de una clase (para cada objeto, en otras
palabras); el currentSpeed de una bicicleta es independiente de la currentSpeed de
otra.
Variables Locales Similar a cmo un objeto almacena su estado en los campos, un mtodo almacenar temporalmente el estado en las variables locales. La sintaxis para declarar una variable local es similar a declarar un campo (por ejemplo,
int count = 0;).
No hay ninguna clave especial designando una variable como local; la determinacin proviene totalmente de la situacin en la que se declara la variable est entre la apertura y cierre de llaves de un mtodo. Por lo tanto, las variables locales slo son visibles para los mtodos en los que se declaran; No son accesibles desde el resto de la clase.
Parmetros
Ya has visto ejemplos de parmetros tanto en el mtodo main de la aplicacin "Hello
World!" y en la clase Bicycle.
Recordemos que la firma para el mtodo main es public static void
main(String[] args).
Aqu, la variable args es el parmetro de este mtodo. Lo importante a recordar es que
los parmetros siempre son clasificados como "variables" no como "campos". Esto se aplica a otras construcciones de parmetros aceptados tambin (como constructores y los controladores de excepciones) que aprender ms adelante en el tutorial.
Una vez dicho esto, el resto de este tutorial utiliza las siguientes directrices generales cuando se habla de campos y variables:
Si estamos hablando de "campos en general" (excluyendo las variables locales y los parmetros), podemos decir simplemente "campos".
Si la discusin se aplica a "todas las anteriores", podemos decir simplemente "variables".
Si el contexto pide una distincin, usaremos trminos especficos (campo esttico, variables locales, etc.) segn corresponda. Ocasionalmente tambin puede ver el trmino "miembro" usado tambin. Los tipos de campos, mtodos y tipos anidados se denominan colectivamente miembros.
-
Nomenclatura
Cada lenguaje de programacin tiene su propio conjunto de reglas y convenciones para las clases de nombres que puedes usar, y el lenguaje de programacin Java no es diferente.
Las reglas y convenciones para nombrar sus variables pueden resumirse como sigue:
Los nombres de variables distinguen maysculas de minsculas. El nombre de una variable puede ser cualquier identificador legal una secuencia de longitud ilimitada de Unicode de letras y dgitos, comenzando con una letra, el signo de dlar "$" o el carcter
subrayado "_". La Convencin, sin embargo, es siempre comenzar sus nombres de
variables con una letra, no "$" o "_". Adems, el carcter de signo de dlar, por
Convencin, nunca se utiliza en absoluto. Usted puede encontrar algunas situaciones donde se generan automticamente nombres que contienen el signo de dlar, pero sus nombres de variable siempre deben evitar usarlo. Un convenio similar existe para el carcter de subrayado; Aunque es tcnicamente legal para comenzar un nombre de la
variable con '_', se desaconseja esta prctica. El espacio en blanco no est permitido.
Los caracteres posteriores pueden ser Letras, nmeros, signos de dlar, o caracteres resaltados. La convencin (y el sentido comn) se aplican a esta regla tambin. Al elegir un nombre para sus variables, utilice palabras completas en lugar de abreviaturas crpticas. Hacerlo asi har su cdigo fcil de leer y comprender. En muchos casos tambin
har su cdigo auto-documentado; los campos denominados cadence, speed y gear,
por ejemplo, son mucho ms intuitivos que versiones abreviadas, como s, c y g. Tambin
tenga en cuenta que el nombre que usted elige no debe ser una palabra clave o palabra reservada.
Si el nombre que usted elige consta de una nica palabra, escriba esa palabra en letras minsculas. Si consta de ms de una palabra, la primera letra de cada palabra
subsiguiente ser mayscula. Los nombres gearRatio y currentGear son los
principales ejemplos de esta Convencin. Si la variable almacena un valor constante,
tales como static final int NUM_GEARS = 6, la Convencin cambia
ligeramente, cada letra ser mayscula y se separa las palabras posteriores con el carcter de subrayado. Por Convencin, el carcter de subrayado nunca se utiliza en otros lugares.
Tipos de datos primitivos
El lenguaje de programacin Java es estticamente-tipado, lo que significa que:
todas las variables primero deben ser declaradas antes de que puedan ser utilizadas.
Esto implica declarar el tipo de la variable y el nombre, como ya lo has visto:
int gear = 1;
As dice el programa que un campo llamado "gear" existe, contiene datos numricos y tiene un valor inicial de "1". El tipo de dato de una variable determina los valores que puede contener, adems de
las operaciones que pueden realizarse con l. Adems de int, el lenguaje de programacin Java
soporta otros siete tipos de datos primitivos.
Un tipo primitivo est predefinido por el lenguaje y es nombrado por una palabra clave reservada.
Los valores primitivos no comparten el estado con otros valores primitivos. Los ocho tipos de datos primitivos soportados por el lenguaje Java de programacin son:
-
byte: el tipo de dato byte de 8-bit es un entero con signo en complemento a dos (0 para
positivo y 1 para negativo).
o Tiene un valor mnimo de -128 y un valor mximo de 127 (inclusivo). o til para guardar memoria en grandes arreglos, donde importa el ahorro de
memoria.
Pueden tambin ser utilizados en lugar de int donde sus lmites ayudan a clarificar el
cdigo; el hecho de que el rango de una variable es limitado puede servir como una forma de documentacin.
short: el tipo de dato short es de 16-bit es un entero con signo en complemento a dos.
o Tiene un valor mnimo de -32,768 y un valor mximo de 32,767 (inclusivo).
o Puede utilizar un short para guardar memoria en arreglos grandes, en situaciones
donde realmente importa el ahorro de memoria.
int: por defecto, el tipo de datos int es de 32-bit es un entero con signo en complemento a
dos,
o Tiene un valor mnimo de -231 y un valor mximo de 231-1.
o Utilice la clase Integer para utilizar el tipo de datos int como un entero sin signo.
En Java SE 8 y versiones posteriores, puede utilizar el tipo de datos int para representar
un entero sin signo de 32 bits, que tiene un valor mnimo de 0 y un valor mximo de 232-1. Consulte la seccin el nmero de clases para obtener ms informacin. Mtodos estticos
como compareUnsigned, divideUnsigned etc. se han aadido a la clase Integer
para apoyar las operaciones aritmticas de nmeros enteros sin signo.
long: el tipo de datos long es de 64-bit complemento a dos con cualquier otro.
o La firma de long tiene un valor mnimo de -263 y un valor mximo de 263-1. o Utilice este tipo de datos cuando se necesita un rango de valores ms amplio que
las ofrecidas por int.
En Java SE 8 y versiones posteriores, puede utilizar el tipo de datos long para representar
64 bits sin signo, que tiene un valor mnimo de 0 y un valor mximo de 264-1.
La clase Long tambin contiene mtodos como compareUnsigned, divideUnsigned
etc. para apoyar operaciones aritmticas de long sin signo.
float: el tipo de datos float es un punto flotante de precisin simple de 32 bits del
estandar IEEE 754 (Instituto de Ingeniera Elctrica y Electrnica para aritmtica en coma flotante). Su rango de valores est fuera del alcance de esta discusin, pero se especifica en la seccin tipos de coma flotante, formatos y valores de la Java Language Specification.
Como con las recomendaciones de byte y short,
o Use un float (en vez de double) si necesita guardar memoria en grandes conjuntos de nmeros de punto flotante.
o Este tipo de datos no debe utilizarse para valores precisos, como moneda. o Para eso, usted necesitar utilizar la clase java.math.BigDecimal en su lugar.
Numbers and Strings cubre BigDecimal y otras clases tiles proporcionados por
la plataforma Java.
doble: el tipo de datos double es un punto flotante de precisin doble de 64 bits IEEE 754.
Su rango de valores est fuera del alcance de esta discusin, pero se especifica en la seccin tipos de coma flotante, formatos y valores de la especificacin del lenguaje Java.
o Para valores decimales, este tipo de datos es generalmente la opcin predeterminada.
o Este tipo de datos no debe utilizarse para valores precisos, como moneda.
-
booleano: el tipo de datos boolean tiene slo dos valores posibles: true y false.
o Utilice este tipo de datos para indicadores simples que siguen condiciones
del tipo verdadero o falso. o Este tipo de datos representa un bit de informacin, pero su "tamao" no es
algo que se define con precisin.
char: el tipo de datos char es un solo carcter Unicode de 16 bits.
o Tiene un valor mnimo de '\u0000' (o 0) y un valor mximo de '\uffff' (o
65.535 inclusivo).
Adems de los ocho tipos de datos primitivos mencionados anteriormente, el lenguaje de programacin Java tambin proporciona un apoyo especial para cadenas de caracteres mediante la clase java.lang.String .
Encerrando tu cadena de caracteres entre comillas dobles crear automticamente un nuevo objeto String; por ejemplo,
String s = "this is a string";.
Los objetos String son inmutables, que significa que una vez creado, no se pueden cambiar sus
valores.
La clase String no es tcnicamente un tipo de datos primitivo, pero teniendo en cuenta el apoyo
especial dado por el lenguaje, probablemente tendern a pensar en l como tal. Usted aprender ms acerca de la clase String en Objetos de datos simples.
Valores por defecto
No siempre es necesario asignar un valor cuando se declara un campo.
Los campos que son declarados pero no inicializados establecern una moratoria razonable por el compilador.
En trminos generales, por defecto ser cero o null, dependiendo del tipo de datos.
Confiar en estos valores por defecto, sin embargo, se considera generalmente mal estilo de programacin.
La siguiente tabla resume los valores por defecto para los tipos de datos anteriores.
Tipo de datos Valor por defecto (de campos)
Byte 0
short 0
int 0
long 0L
float 0.0F
double 0.0d
Char '\u0000'
String (o cualquier objeto) null
Boolean false
-
Las variables locales son ligeramente diferentes;
El compilador nunca asigna un valor predeterminado a una variable local sin inicializar. Si no puede inicializar la variable local donde se declara, asegrese de asignarle un valor antes de intentar usarla.
El acceso a una variable local sin inicializar producir un error en tiempo de compilacin.
Literales
Usted puede haber notado que no se utiliza la palabra clave new al inicializar una variable de un tipo
primitivo.
Los tipos primitivos son tipos de datos especiales incorporados en el lenguaje;
No son objetos creados de una clase.
Una literal es la representacin de cdigo fuente de un valor fijo; los literales estn representados directamente en el cdigo sin necesidad de cmputo.
Como se muestra a continuacin, es posible asignar un literal a una variable de un tipo primitivo:
boolean result = true;
char capitalC = 'C';
byte b = 100;
short s = 10000;
int i = 100000;
Literales enteros
Un literal entero es de tipo long si termina con la letra L o l; de lo contrario es de tipo int.
Se recomienda utilizar la letra mayscula L porque la minscula letra l es difcil distinguir el dgito 1.
Los valores de los tipos integrales byte, short, int y long pueden crearse desde
literales int.
Los valores de tipo long que exceden el rango de int pueden crearse de literales de
long.
Los literales enteros pueden ser expresados por estos sistemas de numeracin:
Decimales: Base 10, cuyas cifras consta de los nmeros 0 a 9; Este es el sistema de numeracin que utiliza todos los das.
Hexadecimal: Base 16, cuyos dgitos consisten en los nmeros 0 a 9 y las letras A F
Binario: Base 2, cuyas cifras se compone de los nmeros 0 y 1 (puede crear literales binarios en Java SE 7 y versiones posteriores)
Para la programacin de propsito general, es probable que el sistema de numeracin nico que nunca usar es el sistema decimal. Sin embargo,
Si usted necesita usar otro sistema de numeracin, el ejemplo siguiente muestra la sintaxis correcta. El prefijo 0x indica hexadecimal y 0b binario:
-
// The number 26, in decimal
int decVal = 26;
// The number 26, in hexadecimal
int hexVal = 0x1a;
// The number 26, in binary
int binVal = 0b11010;
Literales de coma flotante
Un literal de coma flotante es de tipo float si termina con la letra F o f; de lo contrario su
tipo es double y opcionalmente puede terminar con la letra D o d.
Los tipos de punto flotante (float y double) tambin puede expresarse utilizando E o e (para la
notacin cientfica), F o f (literal float de 32 bits) y D o d (64 bits double literal; esta es la opcin predeterminada y por Convencin se omite).
double d1 = 123.4;
// mismo valor que d1, pero en notacin cientfica
double d2 = 1.234e2;
float f1 = 123.4f;
Carcteres y literales String
Los literales de tipo char y String pueden contener cualquier carcter Unicode (UTF-16).
Si tu editor y sistema de archivos lo permiten, se pueden utilizar tales caracteres directamente en el
cdigo. Si no, puede utilizar un "escape Unicode" como '\u0108' (mayuscula C con acento
circunflejo), o "S\u00ED Se\u00F1or" (S Seor en Espaol).
Utilice siempre 'comillas simples' para literales char y "comillas dobles" para literales de
String.
Las secuencias de escape Unicode pueden utilizarse en cualquier parte en el programa (como en los nombres de campo, por ejemplo), no slo en literales char o String.
El lenguaje de programacin Java tambin soporta algunas secuencias de escape especial para
literales char y String:
\b (retroceso)
\t (tab),
\n (avance de lnea),
\f (forma de alimentacin),
\r (retorno de carro),
\" (comilla doble),
\' (comilla simple) y
\\ (barra invertida).
Tambin hay una literal especial null que puede utilizarse como un valor para cualquier tipo de
referencia.
null puede asignarse a cualquier variable, excepto las variables de tipos primitivos.
Es poco lo que puede hacer con un valor null ms all de pruebas de su presencia. Por lo tanto,
-
null es a menudo utilizado en programas como marcador para indicar que un objeto no
est disponible.
Finalmente, tambin hay un tipo especial de literal llamada
Una clase literal, se forma al tomar un nombre de tipo y anexar (.class);
Por ejemplo, String.class. Esto se refiere al objeto (de tipo Class) que representa el tipo de s
mismo.
Usando caracteres de subrayado en literales de valores numricos
En Java SE 7 y versiones posteriores, cualquier nmero de caracteres de subrayado (_) puede
aparecer en cualquier parte entre los dgitos en un literal numrico.
Esta caracteristica le permite separar grupos de dgitos en literales numricos, que pueden mejorar la legibilidad del cdigo.
Por ejemplo, si su cdigo contiene nmeros con muchos dgitos, usars un carcter de subrayado para separar dgitos en grupos de tres, similar a cmo usaras un signo de puntuacin como una coma o un espacio, como un separador.
El siguiente ejemplo muestra otras maneras en que puede utilizar el carcter de subrayado en literales de valores numricos:
long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
float pi = 3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;
Usted puede colocar subrayados slo entre los dgitos;
No puede colocar subrayado en los siguientes lugares:
Al principio o al final de un nmero
Adyacente a un punto decimal en un literal de coma flotante
Antes de un sufijo F o L
En las posiciones donde se espera una cadena de dgitos
Los siguientes ejemplos demuestran las colocaciones de subrayado vlido y no vlido (que destacan) en literales de valores numricos:
// Invalido: no se puede poner subrayado
// adyacente a un punto decimal
float pi1 = 3_.1415F;
// Invalido: no se puede poner subrayado
// adyacente a un punto decimal
float pi2 = 3._1415F;
// Invalido: no se puede poner subrayado
-
// antes de un sufijo L
long socialSecurityNumber1 = 999_99_9999_L;
// OK (literal decimal)
int x1 = 5_2;
// Invalido: no se puede poner subrayado
// Al final de una literal
int x2 = 52_;
// OK (decimal literal)
int x3 = 5_______2;
// Invalido: no se puede poner subrayado
// en el prefijo 0x
int x4 = 0_x52;
// Invalido: no se puede poner subrayado
// en el comienzo de un nmero
int x5 = 0x_52;
// OK (literal hexadecimal)
int x6 = 0x5_2;
// Invalido: no se puede poner subrayado
// al final del numero
int x7 = 0x52_;
Arreglos
Un arreglo es un objeto contenedor que contiene un nmero fijo de valores de un solo tipo.
La longitud de un arreglo se establece cuando se crea el arreglo.
Despus de la creacin, su longitud es fija.
Usted ya ha visto un ejemplo de arreglo, en el mtodo main de la aplicacin "Hello World!". Esta
seccin analiza detalladamente los arreglos.
Una arreglo de 10 elementos.
Cada item de un arreglo se llama un elemento, y cada a elemento se accede por su ndice numrico.
Como se muestra en la ilustracin anterior, la numeracin comienza con 0. El noveno elemento, por ejemplo, sera por lo tanto para acceder al ndice 8.
-
El siguiente programa, ArrayDemo, crea un arreglo de enteros, pone algunos valores del
arreglo e imprime cada valor en salida estndar.
class ArrayDemo {
public static void main(String[] args) {
// declara una arreglo de enteros
int[] anArray;
// asigna memoria para 10 nmeros enteros
anArray = new int[10];
// inicializa primer elemento
anArray[0] = 100;
// inicializa segundo elemento
anArray[1] = 200;
// y as sucesivamente
anArray[2] = 300;
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;
System.out.println("Element at index 0: "
+ anArray[0]);
System.out.println("Element at index 1: "
+ anArray[1]);
System.out.println("Element at index 2: "
+ anArray[2]);
System.out.println("Element at index 3: "
+ anArray[3]);
System.out.println("Element at index 4: "
+ anArray[4]);
System.out.println("Element at index 5: "
+ anArray[5]);
System.out.println("Element at index 6: "
+ anArray[6]);
System.out.println("Element at index 7: "
+ anArray[7]);
System.out.println("Element at index 8: "
+ anArray[8]);
System.out.println("Element at index 9: "
+ anArray[9]);
}
}
La salida de este programa es:
Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000
-
En una situacin de programacin del mundo real, es probable que utilice una de las construcciones de bucle soportados para iterar a travs de cada elemento de la matriz, en lugar de escribir cada lnea individual como en el ejemplo anterior.
Sin embargo, el ejemplo ilustra claramente la sintaxis de la matriz. Usted aprender acerca de las diferentes construcciones de bucles (for, while, y do-while) en la seccin de Control de flujo .
Declarar una Variable para hacer referencia a un Arreglo
El programa anterior declara un arreglo (llamada anArray) con la siguiente lnea de cdigo:
// declara un arreglo de enteros
int[] anArray;
Al igual que las declaraciones de variables de otros tipos,
una declaracin de arreglo tiene dos componentes: tipo de arreglo y el nombre del arreglo.
Tipo de arreglo se escribe como type[], donde type es el tipo de datos de los elementos
contenidos;
los corchetes son smbolos especiales que indica que esta variable contiene un arreglo.
El tamao del arreglo no es parte de este tipo (razn por la cual los corchetes estn vacos). El nombre de un arreglo puede ser cualquier cosa que quieras, siempre que sigas las reglas y convenciones como se discute en la seccin de nomenclatura . Al igual que con las variables de otros tipos,
la declaracin en realidad no crea un arreglo; simplemente indica al compilador que esta variable mantendr un arreglo del tipo especificado.
Del mismo modo, puede declarar arreglos de otros tipos:
byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;
Tambin puede colocar los parntesis despus del nombre de la matriz:
// esta forma se desaconseja
float anArrayOfFloats[];
Sin embargo, la convencin desalienta esta forma.
Los corchetes identifican el tipo de arreglo y deben aparecer con la designacin del tipo.
-
Crear, inicializar y acceder a una arreglo
Otra forma de crear un array es con el operador new.
La siguiente instruccin en el programa ArrayDemo asigna un array con suficiente memoria para
10 elementos de tipo entero y asigna el arreglo a la variable anArray.
// crea un arreglo de enteros
anArray = new int[10];
Si falta esta instruccin, entonces el compilador imprime un error como el siguiente, y falla la compilacin:
ArrayDemo.java:4: Variable anArray may not have been initialized.
Las siguientes lneas asignan valores a cada elemento de la matriz:
anArray[0] = 100; // inicializa el primer elemento
anArray[1] = 200; // inicializa el segundo elemento
anArray[2] = 300; // y as sucesivamente
A cada elemento del array se accede por su ndice numrico:
System.out.println("Element 1 at index 0: " + anArray[0]);
System.out.println("Element 2 at index 1: " + anArray[1]);
System.out.println("Element 3 at index 2: " + anArray[2]);
Como alternativa, puede utilizar la sintaxis de mtodo abreviado para crear e inicializar un arreglo:
int[] anArray = {
100, 200, 300,
400, 500, 600,
700, 800, 900, 1000
};
Aqu la longitud del arreglo se determina por el nmero de valores proporcionados entre corchetes y separados por comas.
Tambin puede declarar un arreglo de arreglos (tambin conocido como un arreglo multidimensional) mediante el uso de dos o ms conjuntos de corchetes, tales como
// arreglo multidimensional
String[][] names
Cada elemento, por lo tanto, debe accederse por el nmero correspondiente de los valores del ndice.
En el lenguaje de programacin Java, un arreglo multidimensional es un arreglo cuyos componentes son ellos mismos, los arreglos.
Esto es a diferencia de los arreglos en C o Fortran. Una consecuencia de esto es que las filas pueden variar en longitud, como se muestra en el siguiente programa MultiDimArrayDemo :
class MultiDimArrayDemo {
public static void main(String[] args) {
String[][] names = {
{"Mr. ", "Mrs. ", "Ms. "},
-
{"Smith", "Jones"}
};
// Mr. Smith
System.out.println(names[0][0] + names[1][0]);
// Ms. Jones
System.out.println(names[0][2] + names[1][1]);
}
}
La salida de este programa es:
Mr. Smith
Ms. Jones
Finalmente, usted puede utilizar la propiedad incorporada length para determinar el tamao de
cualquier arreglo. El cdigo siguiente imprime el tamao de la matriz a la salida estndar:
// para determinar el tamao del arreglo
System.out.println(anArray.length);
Copia de Arrays
La clase System tiene un mtodo arraycopy que puede utilizar para eficientar
copiar datos desde un arreglo a otro:
// obj origen, posicin inicial del obj origen,
// obj destino, posicin inicial del obj destino,
// numero de elementos a copiar
public static void arraycopy(Object src, int srcPos,
Object dest, int destPos, int length)
Los dos argumentos Object especifican el arreglo a copiar y el arreglo al que se copiara. Los tres
argumentos int especifican la posicin de partida en el arreglo de origen, la posicin de partida en
el arreglo de destino y el nmero de elementos del arreglo para copiar.
El siguiente programa, ArrayCopyDemo, declara un array de elementos char, deletrea la palabra
"descafeinado". Se utiliza el mtodo System.arraycopy para copiar un subsecuencia de
componentes del arreglo en un segundo arreglo:
class ArrayCopyDemo {
public static void main(String[] args) {
char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
'i', 'n', 'a', 't', 'e', 'd' };
char[] copyTo = new char[7];
System.arraycopy(copyFrom, 2, copyTo, 0, 7);
System.out.println(new String(copyTo));
}
}
La salida de este programa es:
caffein
-
Manipulacin de arreglos
Los arreglos son un concepto potente y til usado en programacin.
Java SE proporciona mtodos para realizar algunas de las manipulaciones ms comunes
relacionadas con arreglos. Por ejemplo, el ejemplo ArrayCopyDemo utiliza el mtodo
arraycopy de la clase de System en lugar de recorrer manualmente los elementos del arreglo
origen y colocar cada uno en el arreglo de destino. Esto se lleva a cabo detrs de escena, permitiendo a los desarrolladores usar una sola lnea de cdigo para llamar al mtodo.
Para su conveniencia, Java SE proporciona varios mtodos para realizar las manipulaciones de los arreglos (tareas comunes, como copiar, clasificar y bsqueda de arreglos) en la clase java.util.Arrays .
Por ejemplo, el ejemplo anterior puede modificarse para utilizar el mtodo copyOfRange de la
clase java.util.Arrays , como se puede ver en el ejemplo ArrayCopyOfDemo .
La diferencia es que mediante el mtodo copyOfRange no requiere crear el array de destino
antes de llamar al mtodo, porque el arreglo de destino es devuelto por el mtodo:
class ArrayCopyOfDemo {
public static void main(String[] args) {
char[] copyFrom = {'d', 'e', 'c', 'a', 'f', 'f', 'e',
'i', 'n', 'a', 't', 'e', 'd'};
char[] copyTo = java.util.Arrays.copyOfRange(copyFrom, 2, 9);
System.out.println(new String(copyTo));
}
}
Como puede ver, la salida de este programa es el mismo (caffein), aunque requiere menos
lneas de cdigo.
Tenga en cuenta que el segundo parmetro del mtodo copyOfRange es el ndice inicial del rango
a ser copiado, inclusivo, mientras que el tercer parmetro es el ndice final del rango que se copiar, exclusivamente. En este ejemplo, el rango a copiar no incluye el elemento del arreglo en el
ndice 9 (que contiene el carcter a).
Algunas otras operaciones tiles proporcionados por mtodos de la clase java.util.Arrays,
son:
Buscar en una matriz un valor especfico para obtener el ndice en el cual se coloca (el mtodo binarySearch).
Comparar dos arreglos para determinar si son iguales o no (el mtodo equals).
Llenar una matriz para colocar un valor especfico en cada ndice (el mtodo fill).
Clasificar un arreglo en orden ascendente. Esto puede hacerse ya sea secuencialmente, utilizando el mtodo de sort, o al mismo tiempo, usando el parallelSort mtodo
introducido en Java SE 8. La clasificacin paralela de grandes arreglos en sistemas multiprocesador es ms rpido que la matriz secuencial de clasificacin.
-
Resumen de Variables
El lenguaje de programacin Java utiliza "variables" y "campos" como parte de su terminologa.
Las variables de instancia (campos no estticos) son nicas para cada instancia de una clase.
Las variables de clase (campos estticos) son campos declarados con el modificador
static; hay exactamente una copia de una variable de clase, sin importar cuntas veces
se ha creado una instancia de la clase.
Las variables locales almacenan temporalmente el estado dentro de un mtodo.
Los parmetros son variables que proporcionan informacin extra para un mtodo; parmetros y variables locales siempre se clasifican como "variables" (no "campos").
Al nombrar sus campos o variables, hay reglas y convenciones que se deben (o debe) seguir.
Los ocho tipos de datos primitivos son: byte, short, int, long, float, double, boolean y char.
La clase java.lang.String representa cadenas de caracteres.
El compilador asigna un valor razonable por defecto para los campos de los tipos anteriores; para las variables locales, nunca se asigna un valor predeterminado.
Un literal es la representacin de cdigo fuente de un valor fijo.
Un arreglo es un objeto contenedor que contiene un nmero fijo de los valores de un solo tipo.
La longitud de un arreglo se establece cuando se crea el arreglo. Despus de la creacin, su longitud es fija.
Preguntas: Variables
1. El trmino "variable de instancia" es otro nombre para ___. 2. El trmino "variable de clase" es otro nombre para ___. 3. Una variable local almacena el estado temporal; se declara dentro de un ___. 4. Una variable declarada dentro de la apertura y cierre de parntesis de la firma de un
mtodo se llama un ___. 5. Cules son los ocho tipos de datos primitivos, apoyados por el lenguaje de programacin
Java? 6. Cadenas de caracteres estn representadas por la clase ___. 7. Un ___ es un objeto contenedor que contiene un nmero fijo de los valores de un solo tipo.
Operadores
Ahora que ha aprendido a declarar e inicializar variables, probablemente quieras saber cmo hacer algo con ellas. Aprender los operadores del lenguaje de programacin Java es un buen lugar para empezar.
Los operadores son smbolos especiales que realizan operaciones concretas en uno, dos o tres operandos y luego devuelven un resultado.
Mientras exploramos los operadores del lenguaje de programacin Java, puede ser til para usted saber con anticipacin qu operadores tienen la mas alta precedencia. Los operadores en la tabla siguiente se enumeran segn el orden de precedencia.
Cuanto ms cerca de la parte superior de la tabla un operador aparece, es ms alta su procedencia.
-
Los operadores con mayor prioridad se evalan antes que los operadores con precedencia relativamente menor.
Los operadores en la misma lnea tienen la misma precedencia.
Cuando los operadores de igual prioridad aparecen en la misma expresin, debe regir una regla de cul se evala primero.
Los operadores binarios se evalan de izquierda a derecha;
Los operadores de asignacin se evalan de derecha a izquierda.
Precedencias de los operadores
Operadores Precedencia
Postfix expr++ expr--
Unario ++expr --expr +expr -expr ~ !
Multiplicativo * / %
Aditivo + -
Shift (desplazar) > >>>
Relacionales < > = instanceof
Igualdad == !=
bitwise AND &
bitwise exclusive OR ^
bitwise inclusive OR |
AND lgico &&
OR lgica ||
ternario ? :
asignacin = += -= *= /= %= &= ^= |= = >>>=
En la programacin de propsito general, ciertos operadores tienden a aparecer con ms frecuencia
que otros; por ejemplo, el operador de asignacin "=" es mucho ms comn que el operador de
desplazamiento a la derecha sin signo ">>>". Con esto en mente, la siguiente discusin se centra
primero en los operadores que es ms probable que utilice en forma regular y termina enfocndose en aquellas que son menos comunes. Cada discusin va acompaada de cdigo de ejemplo que se puede compilar y ejecutar. Estudiar la salida en consola le ayudar a reforzar lo aprendido.
-
Asignacin, aritmtica y operadores unarios
El operador de asignacin Simple
Uno de los operadores ms comunes que te vas a encontrar es el operador de asignacin simple
"=". Viste a este operador en la clase de bicicleta; asigna el valor a su derecha con el operador
de la izquierda:
int cadence = 0;
int speed = 0;
int gear = 1;
Este operador puede usarse en objetos para asignar referencias a objetos, como se discute en Crear objetos.
Los operadores aritmticos
El lenguaje de programacin Java proporciona operadores que realizan la adicin, sustraccin, multiplicacin y divisin. Hay una buena posibilidad de que les reconocers por sus homlogos en
matemtica bsica. El nico smbolo que puede parecer nuevo para ti es "%", l cual divide un
operandor por otro y devuelve el resto como su resultado.
Operador Descripcin
+ Operador aditivo (tambin utilizada para la concatenacin de cadenas)
- Operador de resta
* Operador de multiplicacin
/ Operador divisin
% Operador del resto
El siguiente programa, ArithmeticDemo, prueba los operadores aritmticos.
class ArithmeticDemo {
public static void main (String[] args) {
int result = 1 + 2;
// el resultado es ahora 3
System.out.println("1 + 2 = " + result);
int original_result = result;
result = result - 1;
// el resultado es ahora 2
System.out.println(original_result + " - 1 = " + result);
original_result = result;
result = result * 2;
// el resultado es ahora 4
System.out.println(original_result + " * 2 = " + result);
original_result = result;
result = result / 2;
// el resultado es ahora 2
System.out.println(original_result + " / 2 = " + result);
original_result = result;
-
result = result + 8;
// el resultado es ahora 10
System.out.println(original_result + " + 8 = " + result);
original_result = result;
result = result % 7;
// el resultado es ahora 3
System.out.println(original_result + " % 7 = " + result);
}
}
Este programa imprime lo siguiente:
1 + 2 = 3
3 - 1 = 2
2 * 2 = 4
4 / 2 = 2
2 + 8 = 10
10 % 7 = 3
Tambin puedes combinar los operadores aritmticos con el operador de asignacin simple
para crear asignaciones compuestas. Por ejemplo, x+=1; y x=x+1; ambos incrementan el valor
de x por 1.
El + operador puede utilizarse tambin para concatenar (unir) dos cadenas juntas, como se
muestra en el siguiente programa ConcatDemo :
class ConcatDemo {
public static void main(String[] args){
String firstString = "This is";
String secondString = " a concatenated string.";
String thirdString = firstString+secondString;
System.out.println(thirdString);
}
}
Al final de este programa, la variable thirdString contiene " This is a concatenated
string.", que queda impreso a la salida estndar.
Los operadores unarios
Los operadores unarios requieren slo uno de los operadores; realizan diversas operaciones como un valor de incremento/decremento en uno, negar una expresin, o invertir el valor de tipo booleano.
Operador Descripcin
+ operador aditivo unario ; indica el valor positivo (sin embargo, los nmeros son positivos sin esto)
- Menos; operador unario, niega una expresin
++ Operador de incremento; incrementa un valor de 1
-- Operador de decremento; disminuye un valor de 1
! Operador complemento lgico; invierte el valor de tipo booleano
-
El siguiente programa, UnaryDemo, prueba los operadores unarios:
class UnaryDemo {
public static void main(String[] args) {
int result = +1;
// el resultado es ahora 1
System.out.println(result);
result--;
// el resultado es ahora 0
System.out.println(result);
result++;
// el resultado es ahora 1
System.out.println(result);
result = -result;
// el resultado es ahora -1
System.out.println(result);
boolean success = false;
// false
System.out.println(success);
// true
System.out.println(!success);
}
}
Los operadores de incremento/decremento pueden aplicarse antes del (prefijo) o despus del
(posfijo) operador. En el cdigo result++; y ++result; ambos terminarn en que result se
incrementa en uno. La nica diferencia es que la versin prefija
(++result) evala sobre el valor incrementado,
(result++) se evala sobre el valor original.
Si slo est realizando un simple incremento/decremento, no importa qu versin elegir. Pero si utiliza este operador en una parte de una expresin ms grande, elegir indistintamente puede hacer una diferencia significativa.
El siguiente programa, PrePostDemo, ilustra el operador de incremento unario prefijo/postfijo:
class PrePostDemo {
public static void main(String[] args){
int i = 3;
i++;
// imprime 4
System.out.println(i);
++i;
// imprime 5
System.out.println(i);
// imprime 6
System.out.println(++i);
// imprime 6
-
System.out.println(i++);
// imprime 7
System.out.println(i);
}
}
Operadores de igualdad y relacionales
Los operadores de igualdad y relacionales
determinan si uno de los operadores es mayor, menor, igual, o no es igual a otro operador.
La mayora de estos operadores probablemente se ver familiar tambin. Tenga en mente que
debe utilizar "==", no "=", cuando se prueba si dos valores primitivos son iguales.
== igual a
!= no es igual a
> mayor que
>= mayor o igual que
< menor que
value2)
System.out.println("value1 > value2");
if(value1 < value2)
System.out.println("value1 < value2");
if(value1
-
Los operadores condicionales
Los operadores && y || realizan operaciones Y-condicional e O-condicional en dos
expresiones boolean.
Estos operadores muestran un comportamiento "cortocircuito", que significa que se evala el segundo operador slo si es necesario.
&& Condicional-AND
|| Condicional-OR
El siguiente programa, ConditionalDemo1, prueba estos operadores:
class ConditionalDemo1 {
public static void main(String[] args){
int value1 = 1;
int value2 = 2;
if((value1 == 1) && (value2 == 2))
System.out.println("value1 is 1 AND value2 is 2");
if((value1 == 1) || (value2 == 1))
System.out.println("value1 is 1 OR value2 is 1");
}
}
Otro operador condicional es ?:, que puede ser considerado como abreviatura para una instruccin
if-then-else.
Este operador es tambin conocido como el operador ternario porque utiliza tres operandos.
En el siguiente ejemplo, este operador debe leerse como:
"Si someCondition es true, asigne el valor de value1 a result. De lo contrario, asigne el
valor de value2 a result."
El siguiente programa prueba el operador ?: en la ConditionalDemo2.
class ConditionalDemo2 {
public static void main(String[] args){
int value1 = 1;
int value2 = 2;
int result;
boolean someCondition = true;
result = someCondition ? value1 : value2;
System.out.println(result);
}
}
Porque someCondition es true, este programa imprime "1" en la pantalla.
-
Use este operador ?: en lugar de una instruccin if-then-else si hace el cdigo ms
legible;
Por ejemplo, cuando las expresiones son compactas y sin efectos secundarios (tales como las asignaciones).
El operador de comparacin de tipo instanceof
El operador instanceof compara un objeto con un tipo especificado.
Se utiliza para comprobar si un objeto es una instancia de una clase, una instancia de una subclase o una instancia de una clase que implementa una interfaz determinada.
El siguiente programa, InstanceofDemo, define una clase padre (llamado Parent), una interfaz
sencilla (llamado MyInterface) y una clase de hija (llamado Child) que hereda de los padres e
implementa la interfaz.
class InstanceofDemo {
public static void main(String[] args) {
Parent obj1 = new Parent();
Parent obj2 = new Child();
System.out.println("obj1 instanceof Parent: "
+ (obj1 instanceof Parent));
System.out.println("obj1 instanceof Child: "
+ (obj1 instanceof Child));
System.out.println("obj1 instanceof MyInterface: "
+ (obj1 instanceof MyInterface));
System.out.println("obj2 instanceof Parent: "
+ (obj2 instanceof Parent));
System.out.println("obj2 instanceof Child: "
+ (obj2 instanceof Child));
System.out.println("obj2 instanceof MyInterface: "
+ (obj2 instanceof MyInterface));
}
}
class Parent {}
class Child extends Parent implements MyInterface {}
interface MyInterface {}
Salida:
obj1 instanceof Parent: true
obj1 instanceof Child: false
obj1 instanceof MyInterface: false
obj2 instanceof Parent: true
obj2 instanceof Child: true
obj2 instanceof MyInterface: true
Cuando usa el operador instanceof , tenga en cuenta que null no es una instancia de nada.
-
Operadores Bitwise y Bit Shift
El lenguaje de programacin Java tambin proporciona operadores que realizan operaciones bit a bit y de desplazamiento de bit en tipos integros.
Los operadores discutidos en esta seccin se utilizan poco. Por lo tanto, su cobertura es breve; la intencin es simplemente hacerle consciente de que existen estos operadores.
El operador unario de complemento Bitwise "~" invierte un patrn de bits; se puede aplicar a
cualquiera de los tipos integros, haciendo todos los "0" a "1" y todos los "1" a "0".
Por ejemplo, un byte contiene 8 bits; aplicar este operador a un valor cuyo patrn es "00000000"
cambiara su patrn a "11111111".
El operador de desplazamiento a la izquierda con signo ">" dezplaza el patrn de bit a la derecha.
El patrn de bits esta dado por el operando de la izquierda y el nmero de posiciones a desplazar por el operando de la derecha. El operador de desplazamiento a la derecha sin signo ">>>" cambia un cero en la posicin ms a la izquierda, mientras que la posicin ms a la izquierda despus de ">>" depende de la extensin del signo.
El operador Bitwise & realiza una operacin bitwise AND.
El operador Bitwise ^ realiza una operacin bitwise OR exclusiva.
El operador Bitwise | realiza una operacin bitwise OR inclusiva.
El siguiente programa, BitDemo, utiliza el operador bitwise AND para imprimir el nmero "2" en
salida estndar.
class BitDemo {
public static void main(String[] args) {
int bitmask = 0x000F;
int val = 0x2222;
// prints "2"
System.out.println(val & bitmask);
}
}
Resumen de operadores
La siguiente referencia rpida resume los operadores soportados por el lenguaje de programacin Java.
Operador de asignacin simple
= Operador de asignacin simple
Operadores aritmticos
+ Operador aditivo (tambien usado para la concatenacin de
String)
- operador de resta
* operador de multiplicacin
-
/ operador de Division
% operador de resto
Operadores unarios
+ operador aditivo unario:indica el valor positivo
(sin embargo, los nmeros son positivos sin esto)
- Menos; operador unario, niega una expresion
++ Operador de incremento; incrementa un valor de 1
-- Operador de decremento; disminuye un valor de 1
! Operador complemento lgico; invierte el valor
de tipo booleano
Igualdad y operadores relacionales
== Equal to
!= Not equal to
> Greater than
>= Greater than or equal to
< Less than
Signed right shift
>>> Unsigned right shift
& Bitwise AND
^ Bitwise exclusive OR
| Bitwise inclusive OR
Preguntas y ejercicios: operadores
Preguntas
1. Considere el siguiente fragmento de cdigo.
arrayOfInts[j] > arrayOfInts[j+1]
-
Que operadores contiene el cdigo?
2. Considere el siguiente fragmento de cdigo. int i = 10;
int n = i++%5;
a. Cules son los valores de i y n despus de que se ejecuta el cdigo?
b. Cules son los valores finales de i y n si en lugar de utilizar el operador postfijo
de incremento (i++), utiliza la versin prefija (++i))?
3. Para invertir el valor de un boolean, que operador usaras?
4. Qu operador se utiliza para comparar dos valores, = o ==?
5. Explica el siguiente ejemplo de cdigo: result = someCondition ? value1 : value2;
Ejercicios
1. Cambiar el siguiente programa para utilizar asignaciones compuestas:
class ArithmeticDemo {
public static void main (String[] args){
int result = 1 + 2; // result is now 3
System.out.println(result);
result = result - 1; // result is now 2
System.out.println(result);
result = result * 2; // result is now 4
System.out.println(result);
result = result / 2; // result is now 2
System.out.println(result);
result = result + 8; // result is now 10
result = result % 7; // result is now 3
System.out.println(result);
}
}
En el siguiente programa, explique por qu el valor "6" se imprime dos veces seguidas:
class PrePostDemo {
public static void main(String[] args){
int i = 3;
i++;
System.out.println(i); // "4"
++i;
System.out.println(i); // "5"
System.out.println(++i); // "6"
System.out.println(i++); // "6"
System.out.println(i); // "7"
}
}
-
Expresiones, instrucciones y bloques
Ahora que comprende las variables y los operadores, es tiempo de aprender acerca de las expresiones, instrucciones y bloques.
Los operadores se utilizan en la construccin de expresiones, que computan los valores; las expresiones son los componentes bsicos de las instrucciones; las instrucciones pueden agruparse en bloques.
Expresiones
Una expresin es una construccin compuesta por variables, operadores y las invocaciones de mtodo, que fueron construidas segn la sintaxis del lenguaje, se evala como un valor nico.
Ya hemos visto ejemplos de expresiones, ilustrados en negrita abajo:
int cadence = 0;
anArray[0] = 100;
System.out.println("Element 1 at index 0: " + anArray[0]);
int result = 1 + 2; // result is now 3
if (value1 == value2)
System.out.println("value1 == value2");
El tipo de datos del valor devuelto por una expresin depende de los elementos utilizados en la expresin.
La expresin cadence = 0 devuelve un int porque el operador de asignacin devuelve un valor
del mismo tipo de datos que el de su operador de la izquierda; en este caso, cadence es un int.
Como se puede ver en las otras expresiones, una expresin puede devolver otros tipos de valores, tales como boolean o String.
El lenguaje de programacin Java permite construir expresiones compuestas de varias expresiones ms pequeas, siempre y cuando el tipo de datos requerido por una parte de la expresin coincide con el tipo de datos del otro. Aqu hay un ejemplo de una expresin compuesta:
1 * 2 * 3
En este caso particular, el orden en el cual se evala la expresin es importante porque el resultado de la multiplicacin es independiente del orden; el resultado es siempre el mismo, no importa en qu orden se aplican las multiplicaciones. Sin embargo, esto no es cierto de todas las expresiones. Por ejemplo, la siguiente expresin da resultados diferentes, dependiendo de si se realiza la adicin o la operacin de divisin primero:
x + y / 100 // ambiguo
Puede especificar exactamente cmo una expresin sern evaluadas utilizando parntesis: (y). Por ejemplo, para hacer la anterior expresin inequvoca, puede escribir lo siguiente:
(x + y) / 100 // no ambiguo, recomendado
Si usted no indica explcitamente el orden para las operaciones a realizar, el orden es determinado por la precedencia asignada a los operadores en el uso dentro de la expresin. Los operadores que tienen una mayor prioridad consiguen ser evaluados primero. Por ejemplo, el operador divisin tiene una mayor prioridad que el operador de suma. Por lo tanto, los siguientes dos comandos son equivalentes:
-
x + y / 100
x + (y / 100) // no ambiguo, recomendado
Al escribir expresiones compuestas, debe ser explcito e indicar entre parntesis que los operadores deben ser evaluados primero. Esta prctica hace ms fcil leer y mantener el cdigo.
Instrucciones o sentencias
Las instrucciones son ms o menos equivalentes a las oraciones en lenguas naturales.
Una instruccin forma una unidad completa de ejecucin.
Los siguientes tipos de expresiones se pueden realizar en una instruccin por la expresin de un punto y coma (terminacin;).
Expresiones de asignacin
Cualquier uso de +
