DPJ - MODULO 1 - POO en JAVA - UNIDAD 01-CAPÍTULO 02

Unidad
1
DIPLOMATURA EN PROGRAMACION JAVA
Capítulo 2
Diplomatura en Programación Java
Capítulo 2 – Clases y Objetos en Java

De UML a Java
El refinamiento del diseño se hace tanto desde UML como del código. Para poder comprender la
relación constante y bidireccional entre ambos lenguajes, el de modelado y el de codificación,
vamos a realizar un seguimiento de los mismos. El ejemplo de la biblioteca se puede ver en la
Figura 2-1 y se realizará oportunamente la concordancia a lo largo del capítulo. A este diagrama se
lo suele denominar de paquetes.
entidades
+ Publico
+ Socio
gestion
+ Bibl ioteca prestamos
+ Calendario + Prestamo
+ Direccion
+ GestionBiblioteca
+ Lector
+ prestamos (from gestion)
+ reservas
+ salidas
reserv as
recursos + Reserva
+ Computadora
+ Escritorio
+ Libro
(from gestion)
+ PuestoDeTrabajo
+ Salon
+ Silla
salidas
+ Consola
test
+ BibliotecaTest
(from gestion)
Figura 2-1: Diagrama de paquetes del sistema para la biblioteca
Espacios de nombres o paquetes

Una forma de organizar proyectos en Java es mediante el uso de espacios de nombres, los cuales
se declaran a través de los paquetes. Estos son una forma de agrupar los nombres de los tipos
(clases) reduciendo de la probabilidad de conflictos de nombres. Un espacio de nombres además
puede contener otros espacios de nombres que tengan declarados en él sus propios tipos (a esto
Lic. Marcelo F. Samia

1
se lo conoce como anidamiento). El nombre completo de un tipo incluye la totalidad de espacios

de nombres que lo contienen.
Los paquetes son los lugares físicos y lógicos donde se almacenan las clases en Java. Tienen una
relación con los directorios del sistema de archivos en cada sistema operativo, de manera que el
nombre de un paquete donde se guardan las clases es igual al nombre del directorio en el sistema
operativo donde residen las mismas.
Se definen al principio de toda declaración de clase y debe ser la primera sentencia cuando se crea
una clase y es el lugar donde se guarda la clase compilada (archivos con extensión .class), no los
archivos fuentes (que tiene extensión .java). Sin embargo, algunos entornos de trabajo guardan en
el mismo directorio ambos archivos o utilizan una estructura igual para los archivos fuentes para
facilitar el desarrollo.
El nombre completo de una clase (o totalmente calificado) se construye mediante la

concatenación de los nombres de todos los espacios de nombres que lo contienen, separados por
un punto. Por ejemplo, el nombre completo de la clase Prestamo en el ejemplo de la biblioteca es
en Java biblioteca.gestion.prestamos.Prestamo. La jerarquía de espacios de nombres ayuda a
distinguir los tipos con el mismo nombre entre sí. Por ejemplo, se puede definir una clase propia
llamada Prestamo que podrían estar en otro espacio de nombres. La única limitación es que no
puede haber dos clases con el mismo nombre en un mismo espacio de nombres.
Cuando se declara un paquete, se define un espacio de nombres, por lo tanto no es sólo un lugar
de almacenamiento, sino que también es un espacio que define una visibilidad. De esta manera, si
se quiere utilizar una clase que se encuentra en un paquete, se debe definir explícitamente el
acceso al mismo.
Nota: en el caso de Java, los paquetes UML además de definir un espacio de nombres, tienen
una relación directa con el lugar dónde se almacenan los elementos que contienen. Sin
embargo, el uso de estos espacios de nombres como tal para definir visibilidades está fuera
del alcance de lo expuesto. Sólo se utilizarán las visibilidades mínimas y necesarias para
comprender los conceptos de la programación orientada a objetos de la forma más sencilla.
En el lenguaje, el espacio de nombre por defecto que se coloca en un proyecto, coincide con el
lugar físico al que apunta la variable de entorno para la máquina virtual de Java, llamada
CLASSPATH (por el momento no nos preocuparemos de este tema, ya que los entornos definen y
manejan automáticamente esta variable). Lo que se debe saber conceptualmente es que el lugar a
partir del cual se definen las clases y los paquetes en un proyecto se lo conoce como el paquete
por defecto y el espacio de nombres por defecto. Se debe tener en cuenta desde ahora la
siguiente recomendación:
Si bien se pueden declarar clases en el paquete por defecto, no utilizarlo nunca para este
fin, sino sólo para declarar paquetes dentro de él.

2
Nota: se puede omitir la declaración de un paquete cuando se crea una clase, lo cual determina
que dicha clase se asigne al paquete por defecto (se lo puede pensar como el paquete “raíz” del
cual dependen todos los paquetes). Sin embargo esto puede traer problemas al intentar usar
una clase debido a que no “tiene” un espacio de nombres asignado. Por lo tanto, no usar nunca
el paquete por defecto para las clases.
Sin embargo, se pueden declarar otros espacios de nombre en un proyecto. Cabe destacar que en
Java un espacio de nombre se declara siempre en forma explícita dentro de la definición de una
nueva clase mediante la instrucción para la creación de un paquete. Esto crea el mencionado
paquete, crea un directorio a partir del valor de la variable CLASSPATH (por el momento, diremos
que se crea a partir del directorio que se toma como raíz para dejar los archivos compilados .class,
dentro del proyecto que se crea en el entorno de desarrollo) y por último asocia “lógicamente” el
paquete como un espacio de nombres. El formato de la instrucción de creación de paquetes se
muestra en el Código 2-1 y un ejemplo de uso en el Código 2-2.
Se declara con la sentencia package. Si el paquete no existe, el compilador lo crea (así como
también el directorio asociado al nombre en el sistema de archivos del sistema operativo). Si el
paquete existe, sólo incorpora la clase compilada a éste.
Código 2-1: Formato UML de la declaración de un paquete

package <nombre elgido>[.nombre elegido[.nombre elegido[…]]];
Código 2-2: Ejemplo del uso de la instrucción para declarar un paquete

package inicio;
Para usar un espacio de nombre y que el compilador lo interprete correctamente, se debe utilizar
una sentencia diferente con el nombre totalmente calificado del dicho espacio de nombre (lo cual
da acceso – visibilidad – a todos los elementos que se encuentren en él usando luego del nombre
“.*”) o la clase en particular que se desee utilizar. El Código 2-3 muestra el formato y el Código 2-4
un ejemplo de uso.
Para acceder a una clase dentro de un paquete se debe utilizar la sentencia import, porque como
se mencionó anteriormente, los paquetes definen visibilidades, por lo tanto, se debe indicar
donde “mirar” para utilizar la clase.
Código 2-3: Formato UML del uso de un paquete o una clase que le pertenezca
import <espacio de nombre o clase totalmente calificada>
Código 2-4: Ejemplo del uso de un paquete con una clase que le pertenece
import ocultar.Persona;
Ejemplo
Estructura de paquetes en el sistema de la biblioteca desde el punto de vista del código. El diseño
UML correspondiente se puede apreciar en la Figura 2-1.

3
Figura 2-2: Estructura de paquetes del sistema para la biblioteca con las clases que les pertenecen
Comentarios
En Java existen tres formas de poner comentarios dentro del código, aunque por ahora solo
veremos dos y son las siguientes
// La doble barra se usa por cada línea

// de comentario
/* Comienza el comentario
La combinación barra – asterisco para comenzar y asterisco - barra para
finalizar se utiliza si el comentario abarca más de una línea.
Finaliza el comentario. */
Variables
Las variables en un lenguaje de programación es el medio por el cual se almacenan valores
transitoriamente en un programa. Particularmente, en un lenguaje de programación orientado a
Objetos como Java, las variables son directamente asociadas a los atributos de las clases, aunque
se utilicen en otros lugares que no sean directamente atributos, como los parámetros de un
método. Si bien es cierto que en otros lenguajes orientados a objetos existen variables fuera de las
clases, en Java no. Por lo tanto en este lenguaje hablar de variables o atributos es lo mismo salvo
que estén en un método. Para comprender mejor el concepto se puede ver a la variable como el
resultado de utilizar en conjunto dos elementos y definirla de la siguiente manera:

4
Una variable es la suma de una dirección en memoria con un espacio de almacenamiento

que tiene un tamaño fijo según el tipo al cual pertenece la variable.
Luego, en base a esta definición, es necesario saber en qué lugar se encuentra en la memoria
(dirección) y el rango de valores que puede almacenar (lo cual lo determina el tipo al que
pertenece la variable, como veremos posteriormente).
Las variables se diferencian en un programa por sus nombres y su tipo. Los nombres se utilizan
para asociarlos al lugar de la memoria donde se almacenará la variable. Estos siguen ciertas reglas
de escritura a las que están circunscriptas los identificadores (todo aquello a lo que un
programador le puede asignar un nombre se llama identificador). La razón de esto es para evitar
ambigüedades entre posibles operadores e instrucciones y los nombres de los identificadores.
En Java se puede hacer una primera clasificación de las variables según dos grupos:
Tipos primitivos
Tipos Referenciados
La principal diferencia entre estos dos grupos es que el primero son los tipos de datos prexistentes
definidos en el lenguaje mientras que los segundos son aquellos que pueden almacenar las
referencias que se obtienen al crear un objeto de cualquier clase que se haya definido.
Es necesario mencionar un área gris en el lenguaje. Hay ciertos tipos referenciados, o sea, que
provienen de clases definidas, que el lenguaje los maneja como tipos prexistentes o primitivos. El
motivo de esto es que dichas clases se consideraron con la importancia suficiente como para que
el lenguaje las maneje internamente. Este es el caso del tipo String o los vectores. Retomaremos el
tema posteriormente.
Propiedades de las variables

Las variables en Java poseen propiedades que permiten su control y manejo a lo largo de un
programa. Las propiedades de una variable son las siguientes:
Son espacios en memoria que almacenan datos

Siempre tienen almacenado un valor desde su declaración
Siempre deben ser declaradas por un tipo primitivo o referenciado
Poseen visibilidad y alcance (lugares desde donde se pueden acceder y lugares desde los
cuales no)
Se pueden utilizar como parámetros de los métodos
Se puede retornar el valor que almacenen desde un método
El manejo de estas propiedades es lo que garantiza el buen uso de las mismas, por lo tanto, si se
puede asociar una variable con los atributos de una clase, es fundamental dominar el concepto
para saber dónde utilizarlas y como.
Identificadores
Hay una regla muy simple para determinar si algo es un identificador:

5
Cuando en el código un programador debe decidir qué nombre ponerle a un elemento,

dicho elemento es un identificador
Como se puede apreciar, dentro de esta característica entran varios de los elementos antes
mencionados, como ser, nombres de clases, variables, métodos, etc...
Hay otros elementos del lenguaje Java todavía no mencionados que son identificadores. Estos se
irán descubriendo como tales a medida que se aprenda más del lenguaje siguiendo la simple regla
que se formuló.
Es preciso aclarar que cualquier palabra que el lenguaje defina como reservada o clave, no podrá
ser utilizada como identificador.
Por otro lado, crear un identificador es asignarle un nombre a un elemento que permite definir un
lenguaje de programación. Esta asignación de nombres debe seguir ciertas normas prestablecidas
en el formato del mismo que variarán de lenguaje a lenguaje. En el caso de Java, las reglas a seguir
son las siguientes:
El primer carácter de un identificador debe ser uno de los siguientes:

Una letra en mayúsculas (A~Z)
Una letra en minúsculas (a~z)
El carácter de subrayado (_)
El símbolo pesos o dólar ($)
Del segundo carácter en adelante:
Cualquier elemento de los que sirve para el primer carácter
Caracteres numéricos (0~9)
Vale la pena mencionar que el espacio en blanco no es un carácter permitido como se puede
apreciar, por lo tanto no debe utilizarse para nombrar un identificador.
Además existen ciertas normas estandarizadas para crear identificadores, que si bien no son
obligatorias, han sido adoptadas por la mayoría de los programadores y seguirlas ayudan mucho a
la legibilidad del código. Algunas de ellas son las siguientes
Si es una clase, el nombre debe comenzar con mayúsculas

Si es un método o una variable, el nombre debe comenzar con minúsculas
Si el nombre tiene más de una palabra, a partir de la segunda palabra separarlas sólo
comenzando con mayúsculas (primera letra de cada palabra a partir de la segunda)
No se debe olvidar el hecho que Java es un lenguaje sensible al caso (diferencia entre mayúsculas
y minúsculas), por lo tanto si dos identificadores son iguales en su significado a la lectura pero se
diferencia tan sólo en el caso de una letra, el lenguaje los considerará identificadores distintos.
Nota: Como los compiladores se desarrollaron teniendo en cuenta el lenguaje inglés, es

altamente recomendable no usar acentos en los identificadores para evitar posibles
comportamientos extraños. Por lo tanto, no se usarán acentos.
6
Tipos primitivos y referenciados

Todo elemento que tenga las propiedades de una variable es un tipo. Por ejemplo, un objeto, que
es un tipo referenciado, tiene las mismas propiedades de una variable.
Los tipos primitivos de Java permiten clasificarlos según su uso en los siguientes grupos:
Tipos enteros
• byte
• short
• int
• long
Tipos de punto flotante
• float
• double
Tipo texto
• char
Tipo lógico
• boolean
Las declaraciones de las variables se realizan con el formato UML que muestra el código 2-5.
Código 2-5: Formato de la declaración de variables de la clase en Java

[<modificador>] <tipo primitivo> <identificador> [= valor inicial];
Mientras que las variables locales usan el formato sintáctico definido en UML que muestra el
Código 2-6.
Código 2-6: Formato de la declaración de variables locales en Java

<tipo > <identificador> [= <valor inicial>];
En otras palabras:
Si aparece “<>”, quiere decir “elegir uno entre los posibles”

Si aparece “[]”, quiere decir que es opcional
Si una palabra o símbolo aparece sin ninguna otra cosa, indica que ponerlo es obligatorio
Este formato debe leerse de la siguiente manera:
Modificador (opcional): Es el modificador de visibilidad de la variable (indica como se lo

puede utilizar y desde donde). Las posibilidades se muestran en la Tabla 2-1.
Tipo: Es obligatorio poner un tipo, pero se debe elegir uno de los posibles
Identificador: Es obligatorio poner un identificador, se debe elegir cual nombre poner
Asignación inicial: Existe la opción de elegir poner un “=” y un literal de asignación si se
desea que la variable tenga un valor inicial
Fin de la declaración: Siempre hay que finalizar la declaración con un “;” que indica fin de
línea de programa.

7
Tabla 2-1: Modificadores de visibilidad para los elementos de una clase

Modificador Misma Clase Otra Clase
private Si No
defecto (sin modificador) Si No
protected Si No
public Si Si
Nota: En este punto es bueno señalar que en Java toda sentencia termina con un “;”. El otro
símbolo que indica el fin de algo es la “}”, pero se utiliza para ciertas declaraciones a las que se
llaman bloques de sentencias. Sólo hay un caso especial, llamado inicializador, en el cual son
asignados un grupo de valores a un elemento, en el que se combinan ambos símbolos de la forma
“};”
Ejemplo
Código 2-7: Declaraciones e inicializaciones de tipos primitivos
int nroEmpleados=10;
int edad=20;
float sueldoFijo;
long documento;
Nota: Cuando a una variable se le asigna un valor numérico dentro del código, dicho número se lo
identifica como “literal de asignación”. El lenguaje toma esos caracteres y los convierte al valor
binario que debe almacenar en la memoria para dicha variable
Tipos referenciados
Cada vez que se crea una clase se define un nuevo tipo, pero para poder hacer uso de él, se debe
crear un objeto. Esto es similar a declarar una variable de un tipo base, con la diferencia que la
memoria requerida para la operación será determinada por los elementos declarados en dicha
clase.
Por otro lado, el lenguaje utiliza la definición de la clase como plantilla de la memoria a utilizar y
en base a esto se realiza la creación del objeto.
En Java cuando se declara un objeto se utiliza un operador diseñado para este fin: new. Este
operador es quien toma la clase como molde y reserva la memoria para la creación del objeto.
Sin entrar en detalles acerca de la manera en que esto se realiza, el operador efectúa las
operaciones necesarias en memoria y luego devuelve el valor de la dirección o referencia de la
memoria donde lo hizo, de ahí el nombre de las declaraciones de tipo referenciados.
Evidentemente el valor devuelto debe almacenarse en algún lugar para su posterior uso y ese
lugar es una variable de tipo referencia. Como este tipo de variables almacenan la dirección de
memoria donde se creó el objeto y como toda clase genera un nuevo tipo, es evidente que la
declaración debe efectuarse con la clase que la define.

8
De esta manera, con el nombre de la clase seguido del identificador elegido se crea la variable
referencia. Cuando esta deba almacenar el valor devuelto por el operador new, al identificador lo
seguirá un operador de asignación “=”, el operador new y por último en nombre de la clase que
indica el tipo de objeto a crear. El formato se puede apreciar en el Código 2-8.
Código 2-8: Formato en UML para declarar tipos referenciados

<Nombre del tipo clase> <identificador> [= new nombre del tipo clase ()];
Al igual que las variables, se pueden crear tipos referenciados sin necesidad de inicializarlos con un
valor (referencia al objeto creado por new), pero se debe usar el operador posteriormente para
crear un objeto y utilizarlo. Distintos ejemplo se pueden ver en el Código 2-9.
Código 2-9: Declaraciones e inicializaciones de tipos referenciados

Empleado e = new Empleado();
Persona p = new Persona();
Persona p2;
Strings
Las cadenas de caracteres o “strings” en Java se manejan con una clase interna del lenguaje, por lo
tanto, siempre será un tipo referenciado.
El lenguaje permite dos formas de asignar una cadena de caracteres: cuando se crea el objeto y
mediante el operador de asignación. El Código 2-10 muestra posibles usos de cadenas.
Código 2-10: Uso de cadenas

public static void main(String[] args) {
String string1 = "Esta es una cadena creada por asignación.";
String string2 = new String(
"Esta es otra cadena creada por asignación.");
String string3;
System.out.println(string1);
string3 = string1 + string2;
System.out.println("El resultado de concatenar con + es :" + string3);

}
Explorando los tipos primitivos

Los tipos primitivos se clasifican según el uso que se le dé a la variable que se declare a partir de
ellos. Para comprenderlos mejor, se los clasificará por el valor que manejan y el espacio de
almacenamiento que necesitan.
Tipos entero
Existen cuatro tipos enteros y se diferencian en su capacidad de almacenamiento como muestra la
Tabla 2-2. Un ejemplo de cómo declarar variables enteras se puede ver en el código 2-11.

9
Tabla 2-2: Los tipos enteros

Nombre del tipo Longitud Rango
byte 8 bits -27 ~ 27-1
short 16 bits -215 ~ 215-1
int 32 bits -231 ~ 231-1
long 64 bits -263 ~ 263-1
Código 2-11: Declaración e inicialización del tipo int

int a;
int b=10;
El lenguaje por defecto convierte a todo literal de asignación en un tipo entero int, por lo tanto
cuando se asigna un literal a otro tipo entero diferente se debe especificar con una letra o un
modificador de tipo (cast), como se muestra en el Código 2-12.
Código 2-12: Las conversiones de tipo (cast) en los tipos enteros

long p = 10L;
long n = (long)10;
short s = (short)5;
byte b = (byte)1;
Las formas utilizadas para p y n son análogas. La letra “L” utilizada en la asignación a la variable p
es un camino corto que provee el lenguaje. El lenguaje permite la omisión de las conversiones de
tipo en los primeros dos ejemplos debido a que long es de mayor tamaño que int. A esto se lo
denomina promoción automática.
Tipos punto flotante

Existen dos tipos primitivos de punto flotante y se diferencian por su capacidad de
almacenamiento. Las variables de punto flotante en Java pueden utilizar notación científica
automáticamente, por eso no es posible asignar un rango de valores que pueden almacenar con
exactitud. La Tabla 2-3 muestra los tipos.
Tabla 2-3: Los tipos punto flotante

Nombre del tipo Longitud
float 32 bits
double 64 bits
Java toma la asignación de un literal numérico en punto flotante por defecto como un double, por
lo tanto si es un float hay que especificarlo de una de las formas que muestra el Código 2-13.
Código 2-13: Conversiones de tipo en el punto flotante

float f = 10.5F;
float g = (float)10.5;
Tipo Texto
Este tipo se utiliza para almacenar un solo caracter. Tiene la capacidad de almacenar cualquier
caracter en formato Unicode (formato estándar de cualquiera de ellos en Java).

10
Se debe notar que sólo almacena uno, para almacenar una palabra o tan sólo más de un caracter,
se debe utilizar otro tipo de datos que provee el lenguaje, el tipo String.
Otro punto importante es que cuando se asigna en el código un literal caracter, este debe ir
rodeado de comillas simples, como se muestra a continuación:
Código 2-14: Asignación de un caracter

char c = ‘a’;
Tipo booleano
Este tipo sólo puede almacenar dos valores: true o false (que son literales que internamente se
convierte en 0 y 1 respectivamente).
Los valores que almacenan son considerados palabras clave en el lenguaje y se deben utilizar para
cualquier asignación a variables de este tipo. Generalmente es utilizado para la toma de
decisiones. El Código 2-15 muestra un ejemplo de uso.
Ejemplo
Código 2-15: Asignación de un tipo booleano
boolean b = false;
Las clases y los elementos que las componen

La unidad principal de programación en Java es la clase. Estas se componen principalmente de
atributos o variables de instancia, constructores y métodos (existen otros elementos pero no se
tratarán porque están fuera del alcance). Cada elemento se tratará individualmente para luego ver
como se componen.
Atributos de una clase

Son las variables que se declaran en el cuerpo de la clase y se almacenarán en el heap cuando se
cree un objeto. En el ejemplo del Código 2-16 se puede apreciar las declaraciones típicas.
Código 2-16: Declaraciones de atributos

private int nroEmpleados = 10;
private int edad=20;
private float sueldoFijo;
private long documento;
Son importantes porque al almacenar el valor de las variables que pertenecen a un objeto en
tiempo de ejecución, poseen los datos que definen su estado.
Los atributos pueden presentar un problema interesante. En el ejemplo del sistema de la

biblioteca la clase Lector, presentada en el Código 2-17, debe ser un socio o público en general de
la biblioteca. Sin embargo, estos son objetos representados por clases en sí mismos, con lo cual nos
damos cuenta que nos falta una definición, la de cómo declarar un atributo que sea un objeto.
Este problema se resolverá en el próximo capítulo.

11
Código 2-17: La clase Lector en el ejemplo del sistema de la biblioteca

package gestion;
public class Lector {
public boolean esSocio = false;
public boolean isEsSocio() {

return esSocio;
}
public String getDetalles() {

return null;
}
}
Métodos en Java
Los métodos, o como se los llama en otros lenguajes “funciones”, son los elementos de una clase
mediante los cuales se define una operación que un objeto de su tipo puede realizar. La
declaración de un método en Java siempre se debe realizar dentro de una clase y adopta el
formato que muestra el Código 2-18.
Código 2-18: Formato de la declaración de un método

[<modificador>] <tipo retornado> <identificador>([lista de argumentos]){
[declaraciones y / o métodos a utilizar]
[return [valor retornado];]
}
El formato de la declaración del método es incompleta (falta la posibilidad de declarar

excepciones, pero este tema escapa al contenido del curso), se usará así de momento porque la
parte faltante es un tema avanzado para este punto.
El formato quiere decir lo siguiente:
Modificador: Es el modificador de visibilidad del método (indica como se lo puede utilizar

y desde donde). Las posibilidades se mostraron para los atributos en la Tabla 2-1 porque
son los mismos modificadores que afectan a ambos elementos.
Tipo retornado: se debe elegir entre un tipo primitivo o uno referenciado. Si el método no
devuelve ningún valor se puede indicar poniendo en este lugar la palabra clave void.
Identificador: es el nombre que se le asignará al método y mediante el cual se lo invocará
Lista de argumentos: en este lugar se indican los parámetros que recibirá el método. Los
argumentos se declaran igual que las declaraciones de variables con la diferencia que no
se pone el “;” final. Si el método posee varios argumentos, se deben separa unos de otros
con el operador de continuación de declaración (“,”). Si el método no recibe argumentos,
se dejan sólo los paréntesis del mismo.
Comienzo del bloque de sentencias: Obligatoriamente poner la llave de apertura de
bloque de sentencias
Sentencias: Opcionalmente agregar declaraciones e invocaciones a métodos. Existe la
posibilidad de no poner nada a lo que se llama método de cuerpo vacío.

12
Fin de ejecución de sentencias del método: Opcionalmente poner una sentencia return
para terminar la ejecución del método. Si se indicó que el método retorna un valor
(recordar que puede ser void), este se debe poner a continuación
Fin del bloque de sentencias: Poner obligatoriamente la llave de cierre
El Código 2-19 muestra un ejemplo de un método que es público, devuelve un entero y recibe tres
enteros como parámetros.
Código 2-19: Ejemplo de un método de una clase de Java
public int calculaVolumen(int ancho, int largo, int alto){
//bloque de sentencias
}
Salidas por consola

Todas las salidas que se realizan en los programas de ejemplo se producen por la consola. Los
distintos entornos de programación ofrecen por lo general una ventana que hace las veces de
consola (aunque en realidad es una emulación del funcionamiento de la misma). Sin entrar en
detalles técnicos del funcionamiento del método que se utilizará para este fin por estar fuera del
alcance de lo expuesto, basta con saber que utilizará lo que recibe como parámetro para producir
una salida en modo texto por la consola. Dicha salida es interceptada por el entorno de
programación y expuesta en la ventana que dedica a tal fin.
En el Código 2-20 se puede ver el uso de esta instrucción que se repite en el Código 2-21. Se pasa
como parámetro del método una variable para mostrar el valor almacenado.
Código 2-20: Método para realizar salidas por consola

En este caso en particular, el método println(string3) muestra por consola el contenido

almacenado en la variable string3. Cabe destacar que el funcionamiento es análogo con
cualquier tipo de variable.
¿Dónde empiezan los programas y por qué?

En Java, el comienzo de un programa se coloca dentro de una clase en un método. A diferencia de
otros métodos escritos por el programador este tiene un nombre prestablecido: main. Este
método es el punto de entrada para el comienzo de un programa.
Como no está definido que un programa deba comenzar en una clase en particular, esto indica
que puede haber muchas clases que posean el método main, pero sólo puede haber un método de
este tipo por clase. El intérprete de Java sabe por dónde arrancar el programa porque el primer
argumento que recibe para empezar a ejecutarlo debe ser la clase que posee el método main que
se desea utilizar como comienzo de programa. El Código 2-20 muestra un ejemplo de su uso.

13
Código 2-21: Comienzo de un programa

package inicio;
public class Programa {

String string1 = "Esta es una cadena creada por asignación.";
// Creación de un string mediante un constructor.

String string3 = new String("Bienvenidos");
}
}
Se debe tener en cuenta que sólo puede existir un método main por clase.
Constructores
Las clases tienen un método especial que se denomina constructor. Cuando se crea un objeto
mediante la creación de una instancia de una clase, luego que se reserva en memoria los lugares
de almacenamiento necesarios para el objeto, se ejecuta siempre el constructor.
Cómo es un método especial se diferencia de los otros por las siguientes dos características:
Se llaman igual que la clase

Nunca se le pone el valor retornado
Si la clase no posee uno, como en el ejemplo anterior, se ejecuta uno por defecto que el lenguaje
provee más allá que no se especifique en el código.
Además, si se lo desea, se puede poner más de un constructor. La existencia de más de un

constructor tiene su explicación en otra herramienta que proveen los lenguajes orientados a
objetos llamada sobrecarga. Este tema se explicará posteriormente, por el momento alcanza con
saber que para poner más de un constructor se debe cumplir al menos una de las siguientes
reglas:
La cantidad de los parámetros es diferente

El tipo de los parámetros es diferente
Los constructores permiten que se les pase parámetros, pero cuando se declara un objeto se le
deben pasar tantos parámetros como los que figure en alguno de sus constructores o la
declaración será un error. De esta manera, si se le quiere poner en una clase un constructor que
reciba un entero, quedaría como lo muestra el Código 2-22.

14
Código 2-22: Declaración de un constructor

package constructor;
public class Ejemplo {

public Ejemplo(int v){ var1=v;}
private int var1;
private int var2;
public int getVar2() {

return var2;
}
public void setVar2(int var2) {
this.var2 = var2;
}
public int getVar1(){return var1;}
}
Clases en Java
En este punto se pueden unir los conceptos explicados para analizar a las clases como la
importante unidad de programación que resulta ser en los lenguajes orientados a objetos. Tiene el
formato mostrado en el Código 2-23.
Código 2-23: Formato de la declaración de una clase

<modificador> class <identificador>{
[declaraciones de variables y métodos]
}
El caso más simple para analizar es la declaración de una clase que no tiene constructores
declarados explícitos y sólo posee atributos y métodos, como muestran el Código 2-24.
Código 2-24: Declaración de la clase Ejemplo con un constructor por defecto

package constructor.defecto;

private int var1;
private int var2;

return var2;
}

this.var2 = var2;
}

return var1;
}

this.var1 = var1;
}
}

15
Los objetos siempre se construyen a partir de clases, por lo tanto, si la anterior no posee uno,
¿cómo lo hace? Los lenguajes crean automáticamente un constructor por defecto que no recibe
parámetros ni posee sentencias en su interior.
No se debe olvidar que cuando se declara una clase se crea un nuevo tipo. En este caso dicho tipo
es Ejemplo. Las clases son sólo moldes o plantillas para los objetos de su tipo que se creen. Se
puede apreciar en ella las interfaces de la clase declaradas con el modificador public.
A continuación, se muestra en el Código 2-25, el caso en el cual con una pequeña modificación se
le agrega un constructor a la clase. De esta manera, si se le quiere poner a la clase anterior un
constructor que reciba un entero, quedaría con formato declarado en el ejemplo.
Código 2-25: Declaración de la clase Ejemplo con un constructor explícito

package constructor;

public Ejemplo(int v) {
var1 = v;
}
private int var1;

private int var2;

return var2;
}

this.var2 = var2;
}

return var1;
}
}
Sólo nos resta ver cómo utilizar un constructor sobrecargado con otros (hay más de uno) y
declarar un método. Esto se muestra en el Código 2-26. Notar el uso de la palabra clave this para
resolver visibilidad. Esto se explicará posteriormente.

16
Código 2-26: Declaración de una clase con un constructor sobrecargado y un servicio

package constructor.sobrecargado;
public class Ejemplo{

private int atrib1;
private char atrib2;
public Ejemplo(int a){ atrib1 = a;}

public Ejemplo(char b){ atrib2 = b;}
public Ejemplo (char atrib2,int atrib1){
this.atrib1 = atrib1;
this.atrib2 = atrib2;
}
public void metodo(){

//[sentencias;]
atrib2 = 'a';
}
public int getAtrib1() {

return atrib1;
}
public char getAtrib2() {

return atrib2;
}
}
Ejemplo
En el sistema de la biblioteca, se puede ver como la clase Socio que se obtiene como resultado del
análisis del mismo en UML codificado en Java que se muestra en la Figura 2-3.
Socio
- apellido: String
- celular: String
- dni: String
- email: String
- nombre: String
- segundoNombre: String
- tel: String
+ cantidadDePrestamos(): int
+ cantidadDeReservas(): int
+ getApellido(): String
+ getCelular(): String
+ getDetalles(): String
+ getDni(): String
+ getEmail(): String
+ getNombre(): String
+ getSegundoNombre(): String
+ getTel(): String
+ obtenerLibrosUsadosPorSocioEnElSalon(): void
+ obtienePrestamo(Prestamo): void
+ obtieneReserva(Reserva): void
+ setApellido(String): void
+ setCelular(String): void
+ setDni(String): void
+ setEmail(String): void
+ setNombre(String): void
+ setSegundoNombre(String): void
+ setTel(String): void
Figura 2-3 Diagrama UML de la clase Socio

17
El Código 2-27 muestra la clase en Java.
Código 2-27: La clase Socio

package entidades;
public class Socio {

private String nombre;
private String segundoNombre;
private String apellido;
private String dni;
private String email;
private String tel;
private String celular;
public String getNombre() {

return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getSegundoNombre() {
return segundoNombre;
}
public void setSegundoNombre(String segundoNombre) {
this.segundoNombre = segundoNombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
:
:
:
public void obtenerLibrosUsadosPorSocioEnElSalon() {
}
public int cantidadDeReservas(){
return 0;
}
public void obtieneReserva() {
}
public int cantidadDePrestamos(){
return 0;
}
public void obtienePrestamo(){
}
public String getDetalles() {
return null;
}
}
La palabra clave this

Esta palabra clave tiene como finalidad almacenar la referencia del objeto que se encuentra en ese
momento en ejecución y se utiliza para encontrar los elementos que pertenecen a éste y es por
esta referencia que se encuentran las variables de instancia de un objeto.

18
Sólo los elementos de un objeto, métodos y atributos, poseen asociada una referencia del tipo
this, por lo tanto se lo puede utilizar para resolver ambigüedades.
Normalmente, dentro del cuerpo de un método de un objeto se puede referir directamente a las
variables miembros del objeto. Sin embargo, algunas veces es necesario evitar algún tipo de
ambigüedad acerca del nombre de un atributo y uno o más de los argumentos del método que
tengan el mismo nombre.
Por ejemplo, si una clase tiene declaradas variables de instancia que tienen el mismo nombre que
los argumentos de un método, utilizando this se resuelve la ambigüedad porque los métodos
poseen parámetros y variables locales que se alojan en el stack, por lo tanto nunca podrán tener
estos elementos un this asociado.
En el Código 2-26 se muestra la resolución de visibilidad dentro del constructor de la clase. Si no se

utilizará la palabra clave this, y como respecto de la visibilidad siempre tiene prioridad los
elementos locales, no se podrían diferenciar los parámetros (locales) de los atributos del objeto.
Uso de un objeto
Para utilizar los servicios que presta un objeto se invocan los elementos declarados en su interfaz
pública. Por lo tanto, el primer paso es declarar una instancia de la clase (también llamado
declaración de un objeto) que será el que se quiera utilizar. En el Código 2-28 se pude apreciar el
primer paso, la declaración de un objeto en base al tipo que define la clase a que pertenece si no
tiene definido un constructor explícito.
Código 2-28: Declaración de un objeto en Java usando el constructor por defecto

Ejemplo obj1 = new Ejemplo();
En la clase Ejemplo el único elemento en dicha interfaz son los elementos públicos. Para poder
invocarlos se debe utilizar la notación de punto y la referencia almacenada en la variable obj1, ya
que esta indica el lugar de almacenamiento del mismo. La declaración de un objeto de esta clase
cuando usa un constructor explícito es como lo muestra el Código 2-29.
Código 2-29: Creación de un objeto usando el constructor

Ejemplo obj = new Ejemplo(8);
Una descripción general (sin entrar en detalles como la reserva de memoria) de lo que ocurre
cuando se declara un objeto de una clase que tiene constructor, como en el ejemplo anterior, es lo
siguiente:
Se reserva el espacio en memoria para el objeto

Se le pasa el parámetro 8 al constructor
Se empieza a ejecutar el constructor y se asigna el valor del parámetro a la variable
var1
Se termina la ejecución del constructor
Se devuelve la referencia al objeto y se almacena en la variable obj

19
El Código 2-30 muestra como declarar un objeto con diferentes declaraciones de constructores.
Notar que la clase siempre tiene el mismo nombre (lo cual se hizo adrede para notar las distintas
versiones) y que se usan los espacios de nombres que definen los paquetes para diferenciarlas
mediante el nombre totalmente calificado.
Código 2-30: Declaraciones de objetos de clases con el mismo nombre en diferentes paquetes
package inicio;
import constructor.defecto.Ejemplo;

Ejemplo obj1 = new Ejemplo();
obj1.setVar1(33);
System.out.println(obj1.getVar1());
// Se usa el nombre completo para evitar la ambigüedad porque las
// clases se llaman igual
constructor.Ejemplo obj2 = new constructor.Ejemplo(8);
int aux = 0;
aux = obj2.getVar1();
System.out.println(aux);
// Se usa el nombre completo para evitar la ambigüedad porque las
// clases se llaman igual
constructor.sobrecargado.Ejemplo obj3 = new
constructor.sobrecargado.Ejemplo('a', 10);
constructor.sobrecargado.Ejemplo obj4 = new
constructor.sobrecargado.Ejemplo(30);
aux = 0;
aux = obj3.getAtrib1();
System.out.println(aux);
obj3.metodo();
System.out.println(obj3.getAtrib2());
System.out.println(obj4.getAtrib1());
}
}
Ocultamiento de la información
Para proteger los datos que se almacenan dentro de un objeto, la clase utiliza la declaración de
visibilidad private para que no se pueda acceder la variable, ya que esta declaración indica que la
variable no pertenece a la interfaz de la clase. Cuando un elemento no pertenece a la interfaz no
se puede acceder por notación de punto una vez creado un objeto, sólo lo podrán acceder
aquellos elementos que pertenezcan a la clase. Con este fin se colocan en la interfaz métodos
especiales de acceso y mutación, llamados “getters and setters” en inglés, para obtener y
modificar el contenido de una variable de instancia. Esto se puede ver en el Código 2-31.

20
Código 2-31: Ocultamiento de la información

package ocultar;
public class Persona {
private String primerNombre;

private String documento;
public Persona() {
}
public Persona(String primerNombre, String segundoNombre,

String apellido, String documento) {
this.primerNombre = primerNombre;
this.documento = documento;
}
public String getPrimerNombre() {

return primerNombre;
}
public void setPrimerNombre(String primerNombre) {

}
public String getSegundoNombre() {

return segundoNombre;
}
public void setSegundoNombre(String segundoNombre) {

}
public String getApellido() {

return apellido;
}
public void setApellido(String apellido) {

}
public String getDocumento() {

return documento;
}
public void setDocumento(String documento) {

}
}
Encapsulado
Como se mostró con anterioridad, en toda clase existe una parte pública y una privada. La primera
define los elementos de la clase que son accesibles a través de su interfaz. Muchas veces se hace
referencia a este hecho como “accesible por el mundo exterior o el universo”. Esta frase puede
simplificarse de la siguiente manera:

21
Los elementos públicos de una clase serán accesibles por notación de punto una vez creado
un objeto de su tipo
En cambio, la parte privada, define todo lo contrario. Los elementos declarados como privados en
una clase no serán accesibles por ningún elemento salvo que este se encuentre en la misma clase.
Este último concepto es el que permite separar los servicios que brinda un objeto de la forma en
que lo hace, por lo tanto, en otras palabras, un objeto debe verse como una serie de servicios que
presta a través de sus interfaces y la forma en que lo hace se oculta del mundo exterior porque no
es accesible.
Cuando una clase oculta una serie de operaciones (métodos y variables de la clase que éstos usan)
declarándolos privados y los utiliza posteriormente para brindar un servicio, se dice que este
servicio está encapsulado dentro de la clase.
Otra forma común de denominar a las operaciones o métodos privados de una clase es servicio
privado.
Se puede decir que el ocultamiento de la información y los métodos privados son en conjunto
conocidos como “encapsulado”, estén presente uno de ellos o ambos. Se debe notar en este
punto que si los métodos se ocultan pero no así las variables de la clase, no existe encapsulado
porque un cambio de valor en una variable puede determinar un cambio de comportamiento en
los métodos privados.
No existe encapsulado sin ocultamiento de la información. Sin embargo, al ocultamiento de

la información muchas veces se la denomina erróneamente encapsulado
Un ejemplo claro de esto es cuando en una clase se oculta la información pero se quiere brindar la
posibilidad de acceder a los datos almacenados, ya sea para guardar valores como para leerlos. En
este caso se deben crear métodos públicos que cumplan ese rol.
Otro ejemplo es el que se muestra en el Código 2-32, donde un servicio se encapsula y la única
forma de acceder a él es mediante otro método de la misma clase.

22
Código 2-32: Encapsulamiento de un servicio

package encapsulado;
public class Persona {
private String primerNombre;

private String documento;
private String detalles;
public Persona() {
}
public Persona(String primerNombre, String segundoNombre, String apellido,

String documento) {
}
public String getPrimerNombre() {

return primerNombre;
}
public void setPrimerNombre(String primerNombre) {

}
:
:
:
public String getDetalles(){
armaDetalles();
return detalles;
}
public void armaDetalles() {

detalles = "Persona [primerNombre=" + primerNombre
+ ", segundoNombre=" + segundoNombre
+ ", apellido=" + apellido
+ ", documento=" + documento + "]";
}
}
Operadores
Los operadores realizan operaciones entre uno, dos o tres operandos. Sólo se van a presentar
aquellos que sean necesarios para operaciones básicas.
Los operadores que requieren un operador se llaman operadores unarios. Por ejemplo, ++ es un
operador unario que incrementa el valor su operando en uno.
Los operadores que requieren dos operandos se llaman operadores binarios. El operador = es un
operador binario que asigna un valor del operando derecho al operando izquierdo.

23
Existe un único operador ternario que trabaja con tres operandos y funciona como un condicional
y dependiendo de cómo evalúa la condición devuelve un valor u otro. Este operador es :?. Sin
embargo está fuera del alcance de los temas a tratar.
Los operadores unarios en Java pueden utilizar la notación de prefijo o de sufijo (también
conocidas como pre y post, por ejemplo, un pre incremento de la variable i es ++i, mientras que un
post incremento es i++). La notación de prefijo significa que el operador aparece antes de su
operando, por ejemplo,
operador operando
La notación de sufijo significa que el operador aparece después de su operando:
operando operador
Todos los operadores binarios de Java tienen la misma notación, es decir aparecen entre los dos
operandos:
op1 operador op2
Además de realizar una operación también devuelven un valor. El valor y su tipo dependen del
tipo del operador y del tipo de sus operandos. Por ejemplo, los operadores aritméticos (realizan
las operaciones de aritmética básica como la suma o la resta) devuelven números, el resultado
típico de las operaciones aritméticas.
El tipo de datos devuelto por los operadores aritméticos depende del tipo de sus operandos: si se
suma dos enteros, se obtiene un entero. Se dice que una operación evalúa su resultado.
Es muy útil dividir los operadores Java en las siguientes categorías: aritméticos, relacionales y
condicionales, lógicos, de desplazamiento y de asignación. Recordar que sólo veremos algunos de
ellos.
Operadores aritméticos
El lenguaje Java soporta varios operadores aritméticos, incluyendo los que presenta la Tabla 2-4.
Tabla 2-4: Operadores aritméticos
Operador Descripción
+ suma
- resta
* multiplicación
/ división
% módulo
En todos los números enteros y de coma flotante. Por ejemplo, se puede utilizar este código Java
para sumar dos números:
sumarEsto + aEsto

24
O este código para calcular el resto de una división:
dividirEsto % porEsto
La Tabla 2-5 resume algunas de las operaciones aritméticas binarias más importantes en Java.
Ejemplos de uso se pueden apreciar en el Código 2-33.
Tabla 2-5: Uso de operadores aritméticos en operaciones binarias
Operador Uso Descripción
+ op1 + op2 Suma op1 y op2
- p1 - op2 Resta op2 de op1
* op1 * op2 Multiplica op1 y op2
/ op1 / op2 Divide op1 por op2
% op1 % op2 Obtiene el resto de dividir op1 por op2
Nota: El lenguaje Java extiende la definición del operador + para incluir la concatenación (una a
continuación de la otra) de cadenas (Strings).
Código 2-33: Operaciones aritméticas binarias

package inicio;

int a = 4, b = 5, c = 8, d = 0;
d = a + b;
System.out.println("Con a = 4 y b = 5. Valor de d = a + b: " + d);
System.out.println("----------------------------------------------");
d = a - b;
System.out.println("Con a = 4 y b = 5. Valor de d = a - b: " + d);
d = 0;
d = a * b;
System.out.println("Con a = 4 y b = 5. Valor de d = a * b: " + d);
d = 0;
d = c / a;
System.out.println("Con a = 4 y c = 8. Valor de d = c / a: " + d);
d = 0;
d = b % a;
System.out.println("Con a = 4 y b = 5. Valor de d = b % a: " + d);
d = 0;
d = a % b;
System.out.println("Con a = 4 y b = 5. Valor de d = a % b: " + d);
}
}
Los operadores + y - tienen versiones unarias que seleccionan el signo del operando. La Tabla 2-6
los muestra.

25
Tabla 2-6: Los signos que indican positivo o negativo también son operadores, pero unarios (afectan un solo operando)
+ +op Indica un valor positivo
- - op Niega el operando
Además, existen dos operadores de incremento y decremento aritméticos, ++ que incrementa en

uno su operando, y -- que decrementa en uno el valor de su operando. La Tabla 2-7 los muestra.
Tabla 2-7: Operadores unarios de incremento y decremento
++ op ++ Incrementa op en 1; evalúa el valor antes de incrementar
++ ++ op Incrementa op en 1; evalúa el valor después de incrementar
-- op -- Decrementa op en 1; evalúa el valor antes de decrementar
-- -- op Decrementa op en 1; evalúa el valor después de decrementar
Nota: el operador unario de incremento y decremento cambio su prioridad dependiendo del lugar
en el que se encuentre. Cuando se encuentra previo al operando al que afecta es uno de los
operadores de mayor prioridad. Sin embargo cuando esta post operando pasa a ser el de menor
prioridad, incluyendo la asignación. El tema de la prioridad de operadores está fuera del alcance
de lo expuesto.
El siguiente ejemplo muestra el comportamiento de los operadores unarios.
Ejemplo
Código 2-34: El uso más simple de los operadores unarios
public class OperadoresUnarios {

int a = 4;
++a;
System.out.println("Valor de ++a: " + a);
a++;
System.out.println("Valor de a++: " + a);
--a;
System.out.println("Valor de --a: " + a);
a--;
System.out.println("Valor de a--: " + a);
}
}
Operador de asignación
Se puede utilizar el operador de asignación =, para asignar un valor a otro.
Además del operador de asignación básico, Java proporciona varios operadores de asignación que
permiten realizar operaciones aritméticas, lógicas o de bits y una operación de asignación al
mismo tiempo, pero están fuera del alcance de los temas a explicar.
Por ejemplo, la operación

26
a = a + 1;
Toma el valor almacenado en el lugar de la memoria que ocupa la variable a, lo incrementa en 1 y

vuelve a colocar el resultado en la misma ubicación de memoria. Esta operación que en
ecuaciones matemáticas es incorrecta, en informática tiene sentido porque las variables en
realidad son locaciones de memoria donde se almacenan valores.
Operadores lógicos o condicionales

Se utilizan para construir expresiones de decisión complejas. Uno de estos operadores es && que
realiza la operación Y lógico o booleano. Por ejemplo, se puede utilizar dos operadores
relacionales (que se verán posteriormente y retornan un valor booleano) diferentes y evaluar la
totalidad de la expresión uniéndola con && para determinar si ambas relaciones son ciertas. El
Código 2-35 utiliza el operador para determinar si un valor es verdadero.
Código 2-35: Operador lógico AND en Java
resultado = true && true;
En algunas situaciones, el segundo operando de un operador lógico no será evaluado. Por

ejemplo, si se usa una conjunción lógica y el primer operando es falso, no es necesario tener en
cuenta el segundo porque el resultado será siempre falso. El operador && sólo devuelve true si los
dos operandos son verdaderos. Por eso, en esta situación se puede determinar el valor de && sin
evaluar el operador de la derecha. El ejemplo del Código 2-36 muestra su uso más simple.
Los operadores condicionales son:

Tabla 2-8: Los operadores condicionales
Operador Uso Devuelve true si
&& op1 && op2 op1 y op2 son verdaderos
|| op1 || op2 uno de los dos es verdadero
! ! op op es falso
En el ejemplo se puede ver el uso de @SuppressWarnings("unused"). Se debe ignorar esta marca

ya que fue puesta a propósito para que el compilador no marque una advertencia de “código
muerto”. Esto ocurre por lo mismo que se explicó anteriormente: a veces no es necesario evaluar
el segundo operando en una expresión lógica. Pero por motivos didácticos (mostrar fácil como se
forma la instrucción) se hace intencionalmente y el compilador lo señala como código innecesario.

27
Código 2-36: Uso de operadores lógicos en Java

package inicio;
@SuppressWarnings("unused")
boolean resultado;
System.out.println("-----------------------------------------------");
System.out.println("Tabla de verdad del AND (Y)");
resultado = true && true;
System.out.println("Verdadero Y Verdadero = " + resultado);
resultado = true && false;
System.out.println("Verdadero Y Falso = " + resultado);
resultado = false && true;
System.out.println("Falso Y Verdadero = " + resultado);
resultado = false && false;
System.out.println("Falso Y Falso = " + resultado);
System.out.println("Tabla de verdad del OR (O incluyente)");

resultado = true || true;
System.out.println("Verdadero O Verdadero = " + resultado);
resultado = true || false;
System.out.println("Verdadero O Falso = " + resultado);
resultado = false || true;
System.out.println("Falso O Verdadero = " + resultado);
resultado = false || false;
System.out.println("Falso O Falso = " + resultado);
}
}
Operadores relacionales
Los operadores relacionales comparan dos operandos y determinan la relación entre ellos,
retornando un valor de verdadero o falso. Por ejemplo, !=, devuelve true si los dos operandos
son distintos.
La Tabla 2-8 resume los operadores relacionales de Java y el Código 2-37 muestra su uso.
Tabla 2-9: Los operadores relacionales
Operador Uso Devuelve true si
> op1 > op2 op1 es mayor que op2
>= op1 >= op2 op1 es mayor o igual que op2
< op1 < op2 op1 es menor que op2
<= op1 <= op2 op1 es menor o igual que op2
== op1 == op2 op1 y op2 son iguales
!= op1 != op2 op1 y op2 son distintos

28
Código 2-37: Uso de operadores relacionales en Java

package inicio;

int a = 2;
int b = 2;
int c = 3;
boolean resultado;
resultado = a == b;
System.out.println("Si a=2 y b=2, a == b : " + resultado);
resultado = a == c;
System.out.println("Si a=2 y c=3, a == c : " + resultado);
resultado = a != b;
System.out.println("Si a=2 y b=2, a != b : " + resultado);
resultado = a != c;
System.out.println("Si a=2 y c=3, a != c : " + resultado);
resultado = a < b;
System.out.println("Si a=2 y b=2, a < b : " + resultado);
resultado = a < c;
System.out.println("Si a=2 y c=3, a < c : " + resultado);
resultado = a <= b;
System.out.println("Si a=2 y b=2, a <= b : " + resultado);
resultado = a <= c;
System.out.println("Si a=2 y c=3, a <= c : " + resultado);
resultado = a > b;
System.out.println("Si a=2 y b=2, a > b : " + resultado);
resultado = a > c;
System.out.println("Si a=2 y c=3, a > c : " + resultado);
resultado = a >= b;
System.out.println("Si a=2 y b=2, a >= b : " + resultado);
resultado = a >= c;
System.out.println("Si a=2 y c=3, a >= c : " + resultado); }
Uso de Bloques, Espacios en Blanco y Finalización de Sentencia

Una sentencia se compone de una o más líneas terminadas con un punto y coma (;) y es lo único
importante, como muestra el Código 2-38, para determinar que pertenece a una sentencia de Java
(obviamente no se puede cortar un nombre con blancos en el medio, sea identificador o no).
Código 2-38: Finalización de una sentencia y espacios en blanco

totales = a + b + c
+ d + e + f;
El compilador separa las sentencias o llamados a función por cada “;” que encuentre. Además, se
pueden utilizar los espacios en blanco que se necesiten sin que afecte al código.

29
Por otra parte, las sentencias del lenguaje se colocan dentro de bloques, los cuales se definen con
un par de llaves. Por lo tanto, se puede definir un bloque como una colección de sentencias
limitadas por la apertura y cierre de llaves, como muestra el Código 2-39.
Código 2-39: Bloques

{
x = y + 1;
y = x + 1;
}
Otra característica de los bloques es que definen sus propias visibilidades, por lo tanto las
variables declaradas dentro de ellos tienen alcance del bloque (se pueden ver o utilizar sólo dentro
de él).
Los bloques se pueden anidar, por lo tanto, cuando se anidan bloques los que están anidados ven
las variables de los bloques que los contienen.
Los bloques se utilizan para separaciones sintácticas, como por ejemplo, el contenido de una clase:
Código 2-40: Uso de bloques para declarar una clase

public class Calendario {
private String fechaInicio;
private String fechaFin;
:
:
}
Palabras clave
Las palabras clave en Java son las que se muestran en la Tabla 2-1:
Tabla 2-10: Palabras reservadas
abstract default goto package synchronized

boolean do if private this
break double implements protected throw
byte else import public throws
case extends instanceof return transient
catch false int short true
char final interface static try
class finally long strictfp void
const float native super volatile
continue for new switch while
Sin embargo, algunas de las palabras clave son sólo reservadas y no las utiliza el lenguaje, como
por ejemplo:
const

30
goto
También, true y false para los tipos boolean, no son sentencias sino por el contrario, son
literales constantes que se utilizan como palabras reservadas.

31
Ejercicios
Los temas de los que tratan los ejercicios de este módulo son los siguientes:
Clases en Java
Tipos básicos
Ocultamiento de la información

32
Índice de Figuras
Figura 2-1: Diagrama de paquetes del sistema para la biblioteca ......................................................... 1
Figura 2-2: Estructura de paquetes del sistema para la biblioteca con las clases que les pertenecen 4
Figura 2-3 Diagrama UML de la clase Socio .......................................................................................... 17
Índice de Tablas
Tabla 2-1: Modificadores de visibilidad para los elementos de una clase ............................................ 8
Tabla 2-2: Los tipos enteros .................................................................................................................... 10
Tabla 2-3: Los tipos punto flotante ........................................................................................................ 10
Tabla 2-4: Operadores aritméticos ......................................................................................................... 24
Tabla 2-5: Uso de operadores aritméticos en operaciones binarias .................................................... 25
Tabla 2-6: Los signos que indican positivo o negativo también son operadores, pero unarios
(afectan un solo operando) ..................................................................................................................... 26
Tabla 2-7: Operadores unarios de incremento y decremento .............................................................. 26
Tabla 2-8: Los operadores condicionales ............................................................................................... 27
Tabla 2-9: Los operadores relacionales .................................................................................................. 28
Tabla 2-10: Palabras reservadas ............................................................................................................ 30
Índice de Código
Código 2-1: Formato UML de la declaración de un paquete .................................................................. 3
Código 2-2: Ejemplo del uso de la instrucción para declarar un paquete ............................................. 3
Código 2-3: Formato UML del uso de un paquete o una clase que le pertenezca ................................ 3
Código 2-4: Ejemplo del uso de un paquete con una clase que le pertenece ........................................ 3
Código 2-5: Formato de la declaración de variables de la clase en Java ............................................... 7
Código 2-6: Formato de la declaración de variables locales en Java ..................................................... 7
Código 2-7: Declaraciones e inicializaciones de tipos primitivos ............................................................ 8
Código 2-8: Formato en UML para declarar tipos referenciados ........................................................... 9
Código 2-9: Declaraciones e inicializaciones de tipos referenciados ..................................................... 9
Código 2-10: Uso de cadenas.................................................................................................................... 9
Código 2-11: Declaración e inicialización del tipo int......................................................................... 10
Código 2-12: Las conversiones de tipo (cast) en los tipos enteros ....................................................... 10
Código 2-13: Conversiones de tipo en el punto flotante ....................................................................... 10
Código 2-14: Asignación de un caracter ................................................................................................ 11
Código 2-15: Asignación de un tipo booleano ....................................................................................... 11
Código 2-16: Declaraciones de atributos ............................................................................................... 11
Código 2-17: La clase Lector en el ejemplo del sistema de la biblioteca ......................................... 12
Código 2-18: Formato de la declaración de un método........................................................................ 12
Código 2-19: Ejemplo de un método de una clase de Java ................................................................... 13

33
Código 2-20: Método para realizar salidas por consola ....................................................................... 13

Código 2-21: Comienzo de un programa ............................................................................................... 14
Código 2-22: Declaración de un constructor.......................................................................................... 15
Código 2-23: Formato de la declaración de una clase .......................................................................... 15
Código 2-24: Declaración de la clase Ejemplo con un constructor por defecto................................... 15
Código 2-25: Declaración de la clase Ejemplo con un constructor explícito ........................................ 16
Código 2-26: Declaración de una clase con un constructor sobrecargado y un servicio .................... 17
Código 2-27: La clase Socio ................................................................................................................. 18
Código 2-28: Declaración de un objeto en Java usando el constructor por defecto ........................... 19
Código 2-29: Creación de un objeto usando el constructor .................................................................. 19
Código 2-30: Declaraciones de objetos de clases con el mismo nombre en diferentes paquetes ..... 20
Código 2-31: Ocultamiento de la información....................................................................................... 21
Código 2-32: Encapsulamiento de un servicio ....................................................................................... 23
Código 2-33: Operaciones aritméticas binarias..................................................................................... 25
Código 2-34: El uso más simple de los operadores unarios .................................................................. 26
Código 2-35: Operador lógico AND en Java ........................................................................................... 27
Código 2-36: Uso de operadores lógicos en Java .................................................................................. 28
Código 2-37: Uso de operadores relacionales en Java .......................................................................... 29
Código 2-38: Finalización de una sentencia y espacios en blanco ....................................................... 29
Código 2-39: Bloques ............................................................................................................................... 30
Código 2-40: Uso de bloques para declarar una clase .......................................................................... 30

34

DPJ - MODULO 1 - POO en JAVA - UNIDAD 01-CAPÍTULO 02

Caricato da

Informazioni sul documento

Descrizione originale:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

DPJ - MODULO 1 - POO en JAVA - UNIDAD 01-CAPÍTULO 02

Caricato da

Copyright:

Formati disponibili

Unidad

Capítulo 2 – Clases y Objetos en Java

+ Bibl ioteca prestamos

Figura 2-1: Diagrama de paquetes del sistema para la biblioteca

Espacios de nombres o paquetes

Lic. Marcelo F. Samia

se lo conoce como anidamiento). El nombre completo de un tipo incluye la totalidad de espacios

El nombre completo de una clase (o totalmente calificado) se construye mediante la

Lic. Marcelo F. Samia

Código 2-1: Formato UML de la declaración de un paquete

Código 2-2: Ejemplo del uso de la instrucción para declarar un paquete

Lic. Marcelo F. Samia

// La doble barra se usa por cada línea

Lic. Marcelo F. Samia

Una variable es la suma de una dirección en memoria con un espacio de almacenamiento

Propiedades de las variables

Son espacios en memoria que almacenan datos

Lic. Marcelo F. Samia

Cuando en el código un programador debe decidir qué nombre ponerle a un elemento,

El primer carácter de un identificador debe ser uno de los siguientes:

Si es una clase, el nombre debe comenzar con mayúsculas

Nota: Como los compiladores se desarrollaron teniendo en cuenta el lenguaje inglés, es

Tipos primitivos y referenciados

Código 2-5: Formato de la declaración de variables de la clase en Java

Código 2-6: Formato de la declaración de variables locales en Java

Si aparece “<>”, quiere decir “elegir uno entre los posibles”

Este formato debe leerse de la siguiente manera:

Modificador (opcional): Es el modificador de visibilidad de la variable (indica como se lo

Lic. Marcelo F. Samia

Tabla 2-1: Modificadores de visibilidad para los elementos de una clase

Lic. Marcelo F. Samia

Código 2-8: Formato en UML para declarar tipos referenciados

Código 2-9: Declaraciones e inicializaciones de tipos referenciados

Código 2-10: Uso de cadenas

System.out.println("El resultado de concatenar con + es :" + string3);

Explorando los tipos primitivos

Lic. Marcelo F. Samia

Tabla 2-2: Los tipos enteros

Código 2-11: Declaración e inicialización del tipo int

Código 2-12: Las conversiones de tipo (cast) en los tipos enteros

Tipos punto flotante

Tabla 2-3: Los tipos punto flotante

Código 2-13: Conversiones de tipo en el punto flotante

Lic. Marcelo F. Samia

Código 2-14: Asignación de un caracter

Las clases y los elementos que las componen

Atributos de una clase

Código 2-16: Declaraciones de atributos

Los atributos pueden presentar un problema interesante. En el ejemplo del sistema de la

Lic. Marcelo F. Samia

Código 2-17: La clase Lector en el ejemplo del sistema de la biblioteca

public class Lector {

public boolean esSocio = false;

public boolean isEsSocio() {

public String getDetalles() {

Código 2-18: Formato de la declaración de un método

El formato de la declaración del método es incompleta (falta la posibilidad de declarar

El formato quiere decir lo siguiente:

Modificador: Es el modificador de visibilidad del método (indica como se lo puede utilizar

Lic. Marcelo F. Samia

Salidas por consola

Código 2-20: Método para realizar salidas por consola