Capítulo 2

Estructura básica de Java

Objetivos

Al finalizar el capítulo, el alumno podrá:

• Comprender las clases y sus componentes.

• Crear clases que se pueden ejecutar.
• Identificar el alcance y miembros de clase.
• Utilizar los comentarios dentro del programa para incluir descripciones en las
porciones de código

Temas

1. Programas fuentes y compilados

2. Estructura de una clase
3. Variables
4. Tipo de datos primitivos
5. Operadores
6. Métodos
7. Método main
8. Consola
9. Clases Wrapper
10. String, StringBuffer y StringBuilder
11. Comentarios de línea, bloque y documentación
12. Depuración
 Estructura básica de Java

1. Programas fuentes y compilados

La carpeta de instalación de Java jdk-17.x.x/bin contiene todas las utilidades y

herramientas del lenguaje Java que trae el JRE. De este modo, el IDE de NetBeans se
comunica en todo momento con estas utilidades.

Por ejemplo:

• Para compilar el programa (Hola.java), NetBeans utiliza a javac.exe, el cual devuelve

un archivo .class (Hola.class).
• Para interpretar un archivo .class, NetBeans utiliza a java.exe, el cual lo muestra en
consola, solo si tiene el método main.

Asimismo, en la carpeta bin, se encuentran otras herramientas de Java, con las que se
podrá compilar, ejecutar, documentar, empaquetar y muchas otras tareas, propias del
entorno.

Con respecto al primer programa Hola.java, para llegar a ejecutarlo y verlo en consola,
deberá pasar por el proceso siguiente:
 Estructura básica de Java

2. Estructura de una clase

Una clase es uno de los pilares fundamentales en la programación orientada a objetos y

es parte integral del lenguaje Java. Los lenguajes de programación cuentan con clases y
bibliotecas, que pueden ser utilizadas por el usuario para llevar a cabo tareas con poco
esfuerzo de programación; sin embargo, el usuario también tiene la posibilidad de
modelar o crear sus propias clases según el proyecto de programación que esté creando.

Una clase es un prototipo que define las variables y los métodos comunes a un cierto
tipo de objetos. Las clases son las plantillas, de las que luego, se pueden crear múltiples
objetos del mismo tipo.
La clase define las variables y los métodos comunes a los objetos de ese tipo, pero
luego, cada objeto tendrá sus propios valores y compartirán las mismas funciones.

Existe una estructura fundamental para todas las clases definidas en Java, que se debe
tener en cuenta al momento de construirlas:

- Nombre: identifica la clase de forma única en el proyecto.

- Propiedades: referencia a los atributos o campos de la clase.
- Constructores: métodos especiales que se ejecutan cuando se crea un objeto a
partir de la clase.
- Métodos: procedimientos o acciones disponibles para el objeto creado a partir de la
clase o que provee lógica de negocio a la aplicación.
 Estructura básica de Java

Un programa básico en Java podría ser el siguiente.

Donde:

• La línea 1, indica el paquete (carpeta) donde se guardará el archivo.

• La línea 3, define una clase pública (Hola) y será el nombre del archivo físico.
• La línea 5, declara el método main por donde empezará la ejecución del programa.
• La línea 7, imprimirá en consola la cadena: “Hola mundo…”.

Este programa será guardado con el nombre de Hola.java, el nombre del archivo debe
ser completamente igual al nombre de la clase (Hola).

Cláusula package

Un package (paquete) es una agrupación de clases afines. Equivale al concepto de

librería existente en otros lenguajes o sistemas. Una clase puede definirse como
perteneciente a un package y puede usar otras clases definidas en ese o en otros
packages.

El nombre de una clase debe ser único dentro del package donde se define. Dos clases
con el mismo nombre en dos packages distintos, pueden coexistir e incluso, pueden ser
usadas en el mismo programa.
Una clase se declara perteneciente a un package con la cláusula package, cuya sintaxis
es la siguiente:

package nombre_package

La cláusula package debe ser la primera sentencia del archivo fuente. Cualquier clase
declarada en ese archivo pertenece al package indicado.

Por ejemplo, un archivo que contenga las sentencias siguientes declara que la clase
MiClase pertenece al package mipackage.

package mipackage;
...
class MiClase {
...

La cláusula package es opcional. Si no se utiliza, las clases declaradas en el archivo

fuente no pertenecen a ningún package concreto, sino que pertenecen a un package por
defecto sin nombre. La agrupación de clases en packages, es conveniente desde el punto
de vista organizativo para mantener bajo una ubicación común, clases relacionadas que
 Estructura básica de Java

cooperan desde algún punto de vista. También, resulta importante por la implicación
que los packages tienen en los modificadores de acceso.

Nombres de los packages

Los packages pueden usar nombres compuestos separados por puntos, de forma similar
a como se componen las direcciones URL de Internet.

Por ejemplo:

Se puede tener un package de nombre mispackages.parainfo.base. Cuando se utiliza

esta estructura se habla de packages y subpackages. En el ejemplo mispackages
corresponde al package base, parainfo es un subpackage de mispackages y base es un
subpackage de parainfo.

En los gráficos siguientes se puede apreciar la representación de un paquete de Java

“edu.cibertec.ejercicio4” en una vista de proyecto y después en una vista física:

De esta manera, se pueden tener los packages ordenados, según una jerarquía
equivalente a un sistema de archivos jerárquico. Asimismo, el API de java está
estructurado, de esta forma, con un primer calificador (java o javax) que indica la base;
un segundo calificador (awt, util, swing, etc.) que indica el grupo funcional de clases y
opcionalmente, subpackages en un tercer nivel, dependiendo de la amplitud del grupo.
Cuando se crean packages de usuario, no es recomendable usar nombres de packages
que empiecen por java o javax.

Cláusula import

Según la ubicación de las clases en el proyecto, existen diferentes modos de hacer

referencia a ellas. Por ejemplo, para referenciar cualquier clase dentro de otra, se
considera, que esta otra está declarada en el mismo package (carpeta).

package parainfo;
...
class Circulo {
Punto centro;
...
}
 Estructura básica de Java

En esta declaración, se define la clase Círculo que se encuentra en el package parainfo.

Esta usa la clase Punto. El compilador y la JVM, asumen que Punto pertenece también al
package parainfo, y así está hecha la definición, para que la clase Punto sea accesible por
el compilador; no obstante, es necesario que esté definida en el mismo package.
Si esto no fuese así, es necesario hacer accesible el espacio de nombres donde está
definida la clase Punto a la nueva clase. Esto se hace con la cláusula import.

Suponiendo que la clase Punto estuviera definida de la forma siguiente:

package parainfobase;
class Punto {
int x, y;
}

Entonces, para usar la clase Punto en la clase Círculo, se debe escribir lo siguiente:

package parainfoampliada;
import parainfobase.*;
class Circulo {
Punto centro;
...
}

Con la cláusula import parainfobase.*; se hacen accesibles todos los nombres (todas las
clases) declaradas en el package parainfobase. Si solo se quisiera tener accesible la clase
Punto, se podría declarar: import parainfobase.Punto.
También, es posible hacer accesibles el nombre de un package sin usar la cláusula
import, calificando completamente los nombres de aquellas clases pertenecientes a
otros packages. Por ejemplo:

package parainfoampliada;
class Circulo {
parainfobase.Punto centro;
...
}

Sin embargo, si no se usa import es necesario especificar el nombre del package cada
vez que se usa el nombre Punto.
La cláusula import indica al compilador dónde buscar las clases adicionales, cuando no
puedan ser encontradas en el package actual, asimismo, delimita los espacios de
nombres y modificadores de acceso. Cabe mencionar que, en una clase puede haber
tantas sentencias import como sean necesarias. Por otro parte, las cláusulas import se
colocan después de la cláusula package (si es que existe) y antes de las definiciones de
las clases.
 Estructura básica de Java

3. Variables

Una variable es un espacio de memoria en el que podemos almacenar un valor o dato.

En una variable se puede cambiar de valores durante la ejecución del algoritmo, es
decir, una variable puede haber almacenado “n” valores distintos, pero del mismo tipo;
es decir, si la variable es entera, podemos guardar en ella valores enteros, lo mismo
sería para cadenas u otros tipos de datos.

Para poder manejar variables de manera correcta, primero se debe declarar y luego,
asignar un valor. Por ejemplo:

int x;
x = 50;

En el ejemplo anterior, se declara la variable entera x y luego se asigna en ella, el valor

50. En las siguientes líneas, se puede asignar otros valores de manera opcional, por eso
se llama variable.
 Estructura básica de Java

3.1 Las constantes

Una constante es todo lo contrario a una variable. Es un espacio de memoria que

una vez asignado su tipo de dato y su valor, este ya no se puede modificar durante
la ejecución del algoritmo.

Si se quiere declarar una constante cuyo valor nunca podrá ser modificado, esta
debe ser inicializada en el momento de su definición, utilizando la palabra
reservada final.

Generalmente, se utiliza variables finales combinadas con la palabra reservada

static para crear constantes que son variables fijas; es decir que, nunca cambiarán
de valor.

Por convención, los nombres de las variables estáticas se definen en mayúsculas.

Si el nombre está formado por más de una palabra, las palabras se separan por un
carácter de subrayado.

Ejemplo:

static final int LUNES=1;

static final int MARTES=2;
static final int MIERCOLES=3;
static final int JUEVES=4;
static final int VIERNES=5;
static final int SABADO=6;
static final int DOMINGO=7;
//Ejemplo de constante cuyo nombre está formado por más de una palabra:
static final float IMPUESTO_IMPORTACION;
 Estructura básica de Java

4. Tipos de datos primitivos

En Java existe diferentes tipos de datos, los cuales, se encuentran en el siguiente cuadro
de valores primitivos:

Tipo Descripción

boolean Tiene dos valores true o false.

Caracteres Unicode de 16 bits. Los caracteres alfa-numéricos

son los mismos que los ASCII con el bit alto puesto a 0. El
char
intervalo de valores va desde 0 hasta 65535 (valores de 16-
bits sin signo).
Tamaño 8 bits. El intervalo de valores va desde -27 hasta 27 -1
byte
(-128 a 127).
Tamaño 16 bits. El intervalo de valores va desde -215 hasta
short
215-1 (-32768 a 32767).

Tamaño 32 bits. El intervalo de valores va desde -231 hasta

int
231-1 (-2147483648 a 2147483647).

Tamaño 64 bits. El intervalo de valores va desde -263 hasta

long
263-1 (-9223372036854775808 a 9223372036854775807).
 Estructura básica de Java

Tamaño 32 bits. Números en coma flotante de simple

float precisión. Estándar IEEE 754-1985 (de 1.40239846e–45f a
3.40282347e+38f).
Tamaño 64 bits. Números en coma flotante de doble
precisión. Estándar IEEE 754-1985. (de
double
4.94065645841246544e–324d a
1.7976931348623157e+308d.).

El cuadro muestra los tipos de datos y los rangos de valores que se tienen que
considerar.

Para asignar cadenas, Java utiliza objetos que observarás en capítulos posteriores.
Ejemplo: La clase String.
 Estructura básica de Java

5. Operadores

Existe una gran variedad de operadores en Java, que sirven para procesar datos, entre
ellos están:

Categoría Operadores

Aritméticos + - * / %++ --
Lógicos && || ! ^
Relacionales == != < > <= >=
Bits &| ^~
Asignación = += -= *= /= %=
Ternario ?:
 Estructura básica de Java

5.1 Aritméticos

+ Adición
- Sustracción
* Multiplicación
/ División
% Módulo. Toma el residuo de una división de enteros.
Ejemplo:
17%5 == 2; // Residuo de 17 entre 5 es 2.
++ Se incrementa en uno.
Ejemplo 1:
int a, b; // Se declara dos enteros a y b.
a = 5;
b = ++a; // a==6 y b==6
Ejemplo 2:
int a, b;
a = 5;
b = a++; // a==6 y b==5
-- Decremento en uno. Contrario al anterior.

Ejemplo:

//Suma de valores
int contador=10;
int otroOperador=5;
int resultado=contador+otroOperador;
//resultado tendrá el valor de 15

//Multiplicamos por 2 el valor de resultado

resultado= resultado *2;
//resultado tendrá el valor de 30

//Obtiene el residuo de una división

Int resto=resultado%7
//resto tendrá el valor de 2
 Estructura básica de Java

5.2 Lógicos

&& Y (and)

P q p && q
v v V
v f F
f v F
f f F

|| O (or)
Ejemplo: sean p y q 2 expresiones.

P q p || q
v v v
v f v
f v v
f f f

! No (not)

q !q
v F
f V

Ejemplo:

//Ejemplo AND
Int contador1=10;
Int contador2=20;
Boolean resultado=(contador1==contador2)&&(contador2<100);
// el resultado nos devuelve FALSE

//Ejemplo OR
resultado=(contador1!=contador2)&&(contador2<100);
// el resultado nos devuelve TRUE
 Estructura básica de Java

5.3 Relacionales

Igual que
== Ejemplo:
3+4 == 7; // 3 más 4 es igual que 7, resulta true
Diferente que.
!= Ejemplo:
5+6 != 7; // 5 más 6 es diferente de 7, resulta true
< Menor que
<= Menor o igual que
> Mayor que
>= Mayor o igual que

Ejemplo:

//Ejemplo Igual que

Int contador1=10;
Int contador2=20;
boolean opequal
opequal=contador1==contador2;
// el resultado nos devuelve FALSE

//Ejemplo Diferente que

Int contador1=10;
Int contador2=20;
boolean notequal
notequal=contador1!=contador2;
// el resultado nos devuelve TRUE

5.4 Bits

A & B Operación AND a nivel de bits. Si ambos bits comparados

& son 1, establece el resultado en 1. De lo contrario, da como
resultado 0.

A | B Operación OR a nivel de bits. Si por lo menos uno de los

| dos bits comparados es 1, establece el resultado en 1. De lo
contrario, da como resultado 0.

A ^ B Operación XOR a nivel de bits. Si uno de los bits

^ comparados es 0 y el otro 1, el resultado es 1. Si ambos bits
comparados son iguales, el resultado es 0.

~A Complemento de A, a nivel de bits. Solo invierte los bits, es

~
decir, convierte los ceros en unos y viceversa.
 Estructura básica de Java

5.5 Asignación

= Asigna un valor.

Compacta una adición.

+= Ejemplo:
a += 5; // Es igual a poner a = a + 5;

Compacta una sustracción.

-= Ejemplo:
x = 8; // Es igual a poner x = x - 8;

Compacta un producto.
*= Ejemplo:
y *= 12; // Es igual a poner y = y * 12;

Compacta una división.

/= Ejemplo:
b /= 100; // Es igual a poner b = b / 100;

%= Compacta el módulo.

5.6 Ternario

Tiene tres operandos, cada uno es una expresión; los cuales, se

?: ordenan de la siguiente forma:
expresión1 ? expresión2 : expresión3

El valor de la expresión completa y equivale al de la expresión2; si la expresión1 es

verdad, o al valor de la expresión3, en caso contrario.

Ejemplo:

(5>4)? 1:2 //Toma el valor 1

(5<4)? 1:2 //Toma el valor de 2
(x>y)? x:y// Toma el mayor entre x e y

Precedencia de operadores

Los operadores en una misma fila tienen la misma precedencia. La precedencia

disminuye según se baja en la tabla.
La regla de precedencia establece que los operadores de mayor nivel se ejecutan
primero.

Observa que los últimos son los de asignación, esto es lógico, ya que se debe
calcular, primeramente, la expresión antes de asignar un resultado a una variable.
 Estructura básica de Java

Ejemplo:

Int j=1 + 3 * 4;
// resultado de j=13

De acuerdo a la tabla de precedencia de Java y al igual que la aritmética, se calcula la

multiplicación antes que la suma.

Int j=1 + 3 -4;

// resultado de j=0

Si todos los operadores tienen un nivel idéntico de precedencia se evalúa la expresión

de izquierda a derecha.
 Estructura básica de Java

6. Métodos

Un método en Java es un conjunto de instrucciones definidas dentro de una clase, que

realizan una determinada tarea y a los que se les puede invocar mediante su nombre. El
nombre de un método debe ser un verbo, pues su responsabilidad es siempre ejecutar
lógica.

Cuando se llama a un método, la ejecución del programa pasa al método y cuando éste
acaba, la ejecución continúa a partir del punto donde se produjo la llamada, formando
una “pila” de llamadas entre métodos.

Algunas de las ventajas de usar métodos son las siguientes:

- Construcción de programas modulares.

- Reutilización de código. En lugar de escribir el mismo código repetido cuando
se necesite (por ejemplo, para validar una fecha), se hace una llamada al
método que lo realiza.
- Definición de responsabilidades en cada clase.

En Java un método siempre pertenece a una clase.

 Estructura básica de Java

La estructura general de un método Java, es la siguiente:

[especificadores] tipoDevuelto nombreMetodo([lista parámetros]) [throws listaExcepciones]

{
// instrucciones
[return valor;]
}

Donde:

Los elementos que aparecen entre corchetes son opcionales.

- especificadores (opcional): determina el tipo de acceso al método.

- tipoDevuelto: indica el tipo del valor que devuelve el método. En Java es
imprescindible que, en la declaración de un método, se indique el tipo de dato
que ha de devolver. El dato se devuelve mediante la instrucción return. Si el
método no devuelve ningún valor este tipo será “void”.
- nombreMétodo: es el nombre que se le da al método. Para crearlo hay que
seguir las mismas normas que se requieren para crear nombres de variables.
- lista de parámetros (opcional): después del nombre del método y siempre
entre paréntesis, puede aparecer una lista de parámetros (también llamados
argumentos) separados por comas. Además, estos parámetros son los datos
de entrada que recibe el método para operar con ellos; asimismo, un método
puede recibir cero o más argumentos. Por lo tanto, se debe especificar para
cada argumento su tipo. Los paréntesis son obligatorios, aunque estén vacíos.
- throws listaExcepciones (opcional): indica las excepciones que puede generar
y manipular el método.
- return: se utiliza para devolver un valor. La palabra clave “return” va seguida
de una expresión que será evaluada para saber el valor de retorno. Esta
expresión puede ser compleja o puede ser simplemente el nombre de un
objeto, una variable de tipo primitivo o una constante.

El tipo del valor de retorno debe coincidir con el tipoDevuelto que se ha

indicado en la declaración del método. Si el método no devuelve nada
(tipoDevuelto = void) la instrucción return es opcional.

Un método puede devolver un tipo primitivo, un array, un String o un objeto.

Un método tiene un único punto de inicio, representado por la llave de inicio “{“. La
ejecución de un método termina cuando se llega a la llave final “}” o cuando se ejecuta
la instrucción return.

La instrucción return puede aparecer en cualquier lugar dentro del método, no tiene
que estar necesariamente al final.

Ejemplo de método: método que suma dos números enteros.

import java.util.*;
public class Metodos1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int numero1, numero2, resultado;
System.out.print("Introduce primer número: ");
 Estructura básica de Java

numero1 = sc.nextInt();
System.out.print("Introduce segundo número: ");
numero2 = sc.nextInt();
resultado = sumar(numero1, numero2);
System.out.println("Suma: " + resultado);
}
public static int sumar(int a, int b){
int c;
c = a + b;
return c;
}
}

El método se llama sumar y recibe dos números enteros a y b. En la llamada al método

los valores de las variables numero1 y numero2 se copian en las variables a y b. El
método suma los dos números y guarda el resultado en c. Finalmente devuelve,
mediante la instrucción return, la suma calculada.
 Estructura básica de Java

7. Método main

El método “main”, es el punto de ejecución de una aplicación y será el punto de partida

del programa completo. Dentro de este método se podrán hacer las llamadas a todas las
rutinas que compondrán el proyecto.

La firma del método es siempre la misma.

• Siempre debe incluir los calificadores: public y static.

• Nunca puede retornar un valor como resultado, por lo tanto, siempre debe
indicar el valor void como retorno.
• Su parámetro de entrada siempre será un array de String's (String[]), el cual es
tomado de la línea de comandos o una fuente alterna.
 Estructura básica de Java

• Aunque no es un requerimiento definir el método main dentro de toda clase

Java, dicho método representa el único mecanismo automático para realizar
tareas al invocarse una clase. Por lo tanto, al momento de ejecutarse
determinada clase siempre será ejecutado todo el contenido dentro de dicho
método.

El método main, se puede escribir de tres maneras diferentes sin que esto produzca un
error.
• public static void main(String args[]) {}
• public static void main(String[] args){}
• public static void main(String... args){}

El método main () en Java es estático, ya que puede ser invocado por el motor del
tiempo de ejecución sin tener que crear una instancia de la clase padre.

Aunque se le suele dar el nombre de args, no es obligatorio que este parámetro se llame
así, se puede colocar el nombre que más te guste, por ejemplo:

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

 Estructura básica de Java

8. Consola

La consola usualmente es usada para mostrar información generada en un proyecto

determinado. Depende de dónde se esté ejecutando el proyecto, para saber en qué
consola se muestran los mensajes; por ejemplo, si es una aplicación de escritorio, la
consola será la salida de la clase, pero si es un proyecto web, la salida la tendrá el log del
servidor.

En el ejemplo mostrado, la sentencia System.out.println ("Hola mundo"); imprimirá un

mensaje en la consola de la clase.

Para ejecutar el programa, haz clic derecho sobre el código y selecciona “Run File”.
 Estructura básica de Java

Ingreso de datos por consola

No existe instrucción directa en Java para el ingreso de datos, pues el lenguaje asume
que el dispositivo lo proveerá. En este caso, para el ingreso de datos por consola, se
tiene a partir del JDK 1.5 la clase Scanner. El siguiente programa ilustra sus usos.

El programa solicita un nombre que después de ingresarlo y pulsar <enter>, muestra un

mensaje de bienvenida con el nombre ingresado.
 Estructura básica de Java

9. Clases Wrapper

Los primeros lenguajes de programación no usaban objetos, solo variables. Una variable,
es un espacio de la memoria del ordenador a la que se asigna un contenido que puede
ser un valor numérico (solo números, con su valor de cálculo) o de tipo carácter o
cadena de caracteres (valor alfanumérico que constará solo de texto o de texto
mezclado con números).

Una variable es un espacio de memoria en el que se puede almacenar un valor o dato;

además, permite cambiar valores durante la ejecución del algoritmo, es decir, una
variable puede haber almacenado “n” valores distintos, pero del mismo tipo. Por lo
tanto, si la variable es entera, se puede guardar en ella valores enteros, lo mismo sería
para cadenas u otros tipos de datos.

Por ejemplo, se puede definir una variable a que contenga 32 y esto lo escribimos como
a = 32. Posteriormente, se cambiar el valor de a y hacer a = 78. O hacer “a” equivalente
al valor de otra variable “b” así: a = b.

Dado que antes se ha definido que, un objeto también ocupa un espacio de memoria,
entonces, ¿En qué se parecen y en qué se diferencia un objeto de una variable?,
considera que las variables son entidades elementales: un número, un carácter, un valor
verdadero o falso; mientras que, los objetos son entidades complejas que pueden estar
formadas por la agrupación de muchas variables y métodos. Pero ambas cosas ocupan
lo mismo: un espacio de memoria (que puede ser más o menos grande).
 Estructura básica de Java

En los programas en Java, puede ser necesario, tanto el uso de datos elementales como
de datos complejos. Por eso, en Java se usa el término “Tipos de datos” para englobar a
cualquier cosa que ocupa un espacio de memoria y que puede ir tomando distintos
valores o características durante la ejecución del programa. Es decir, en vez de hablar de
tipos de variables o de tipos de objetos, se denomina tipos de datos.

Sin embargo, a veces “coloquialmente” no se utiliza la terminología de forma estricta:

puedes encontrar textos o páginas web donde se habla de una variable en alusión a un
objeto.

Java diferencia dos tipos de datos: por un lado, los tipos primitivos, que se corresponden
con los tipos de variables en lenguajes como C y que son los datos elementales que
hemos citado. Por otro lado, los tipos objeto (que normalmente incluyen métodos).

Observa los tipos de datos en Java sobre un esquema de síntesis:

 Estructura básica de Java

En resumen, un tipo de dato primitivo son:

Los tipos de datos básicos o primitivos no son objetos y se pueden utilizar directamente
en un programa, sin necesidad de crear objetos de este tipo.

Y un tipo de dato objeto es:

Aquella variable que tiene métodos asociados y necesitan una invocación para ser
creados.
 Estructura básica de Java

Existe una excepción en el tipo de dato objeto String, que se comporta como un tipo de
dato primitivo; ya que, no necesita un constructor para ser utilizado.

Preguntas comunes acerca de tipos de datos.

1. ¿Un objeto es una cosa distinta a un tipo primitivo, aunque “porten” la misma
información?

Tener siempre presente que los objetos en Java tienen un tipo de tratamiento y los
tipos primitivos, otro. Que en un momento dado contengan la misma información
no significa, en ningún caso que, sea lo mismo.

2. ¿Para qué tener esa aparente duplicidad entre tipos primitivos y tipos objeto o
envoltorio?

Esto es una cuestión que atañe a la concepción del lenguaje de programación. Tener
en cuenta una cosa: un tipo primitivo es un dato elemental y carece de métodos;
mientras que, un objeto es una entidad compleja y dispone de métodos. Por otro
lado, de acuerdo con la especificación de Java, es posible que sea necesario utilizar
dentro de un programa un objeto que “porte” como contenido un número entero.
Desde el momento en que sea necesario un objeto, se debe de pensar en un
envoltorio, por ejemplo, Integer. Inicialmente, puede costar un poco distinguir
cuándo usar un tipo primitivo y cuándo un envoltorio en situaciones en las que
ambos sean válidos. Para ello, sigue esta regla: usa por norma general tipos
primitivos. En el momento en que la estructura de datos o para el proceso a realizar
sea necesario un objeto, utiliza un envoltorio.

3. Los nombres de tipos primitivos y envoltorios se parecen mucho.

En realidad, excepto entre int e Integer y char y Character, la diferencia se limita en

que la inicial es minúscula (por ejemplo, double) y en el otro es mayúscula (Double).
Esa similitud puede confundir inicialmente, pero debes de tener muy claro qué es
cada tipo y cuándo utilizarlo.

4. Una cadena de caracteres es un objeto.

El tipo String en Java permite crear objetos que contienen texto (palabras, frases,
etc.), es importante que el texto debe ir siempre entre comillas. Muchas veces se
cree erróneamente, que el tipo String, es un tipo primitivo por analogía con otros
lenguajes donde String funciona como una variable elemental. En Java no es así.

5. Hay distintos tipos primitivos enteros. ¿Cuál usar?

Por norma general usael tipo int. Para casos en los que el entero pueda ser muy
grande utiliza el tipo long.

6. ¿Un array es un objeto?

Los arrays son objetos especiales, los únicos objetos en Java que carecen de
métodos.
 Estructura básica de Java

10. String, StringBuilder y StringBuffer

String, es una de las clases más utilizadas en la programación con Java, pues trabaja las
cadenas de texto casi de una forma primitiva. Uno de los mayores problemas que tiene
esta clase es su inmutabilidad, lo cual hace que una concatenación cree otro objeto en
memoria, incrementando la utilización de la misma.

La inmutabilidad se utiliza en la funcionalidad de hilos (threads), ya que esta

característica hace que sea “thread safe”. Es decir, al tratarse de una clase que genera
objetos inmutables, no es necesario preocuparse de cuántos hilos accedieran a ella. Sin
embargo, la clase StringBuffer posee métodos que son “synchronized”, lo que significa
que solo admiten un único Thread trabajando en forma directa en ellos.
 Estructura básica de Java

Concatenación en las diferentes clases

• String

El operador de suma está sobrecargado para los String, y es la forma más básica de
concatenar dos cadenas de caracteres. Y también, es la peor forma en cuanto a
rendimiento.

Al concatenar dos String con el operador suma, se crea un nuevo String resultante,
con lo que constantemente se están creando objetos nuevos.

La concatenación con el operador de suma es de la siguiente manera.

String hola = "Hola, ";

String mundo = "mundo";
String holamundo = hola + mundo;

• StringBuffer

Esta clase es una secuencia de caracteres mutable; es decir, permite concatenar

String de una manera simple y muy eficiente.

Los métodos de StringBuffer son sincronizados, por lo cual se puede usar de

manera segura en un ambiente de multihilos.

La concatenación se realiza mediante su método append:

StringBuffer holamundoBuffer = new StringBuffer();

holamundoBuffer.append("Hola, ");
holamundoBuffer.append("mundo");
String holamundo = holamundoBuffer.toString();

• StringBuilder

Esta clase apareció con el JDK 5 y es la más recomendada para la concatenación de

String, en la mayoría de los casos. Su uso es idéntico al StringBuffer (tienen el
mismo API), por lo que resulta relativamente simple reemplazar los StringBuffer
por StringBuilder.
Los métodos de StringBuilder no son sincronizados, por ello tiene mejor
rendimiento que StringBuffer. En general, la concatenación de String ocurre con
 Estructura básica de Java

variables locales a un método, entonces es seguro usar StringBuilder en lugar de

StringBuffer. En métodos que hacen uso intensivo de la concatenación, la
diferencia en rendimiento puede ser importante.

La concatenación de cadenas se realiza mediante su método append:

StringBuilder holamundoBuilder = new StringBuilder();

holamundoBuilder.append("Hola, ");
holamundoBuilder.append("mundo");
String holamundo = holamundoBuilder.toString();

Al realizar pruebas en una PC se obtuvieron los resultados de:

StringBuffer 93 milisegundos en concatenar un millón de String.

StringBuilder 47 milisegundos en concatenar un millón de String.

Es decir, en la mayoría de los casos, StringBuilder puede resultar un 50% más rápido que
el StringBuffer, para concatenar Strings.
 Estructura básica de Java

11. Comentarios de línea, bloque y documentación

Los comentarios en el código de un programa son importantes para el mantenimiento

futuro del mismo, así como, para interpretar más fácilmente una rutina compleja, sobre
todo, cuando trabaja un grupo de programadores para facilitar el entendimiento entre
ellos.

Java tiene los siguientes 3 tipos de comentarios:

Todo lo que esté a la derecha de // será considerado comentario por el compilador de

Java y es eliminado en el archivo compilado (.class).
 Estructura básica de Java

Todo lo que esté entre /* y */ será considerado comentario por el compilador de Java y
es eliminado en el archivo compilado (.class).

Todo lo que esté entre /** y */ será considerado comentario por el compilador de Java,
y permanece en el archivo compilado (.class). Usado normalmente, para describir al
desarrollador y a la aplicación.
 Estructura básica de Java

12. Depuración

La depuración es un aspecto importante en programación, pues con ella, se detecta

fácilmente donde está el error o un resultado no esperado.

Para depurar, primero agrega un break point a una línea del programa, esto se logra al
dar clic en el número de línea.

Luego, haz clic derecho sobre el código de programa y del menú flotante que se
muestra, selecciona “Debug File”. La ejecución del programa se detiene en la línea que
contiene el break point, la cual se pinta de verde; además, se activan los siguientes
toolbars:
 Estructura básica de Java

Estos botones, según el orden en el que se muestran, ejecutarán las siguientes acciones:

1. Step Over: permite avanzar a la siguiente línea.

2. Step Over Expression: avanza sobre partes de la línea.
3. Step Into: permite ingresar al código del método del cual se esté invocando.
4. Step Out: permite salir del código del método del cual se esté invocando.
5. Run to Cursor: hace un salto de ejecución hasta donde está el cursor.

También, se puede activar la ventana Variables (menú Window / Debugging /

Variables), para poder apreciar el valor que van tomando las variables conforme se van
ejecutando las líneas del programa.