Manual:

IntroducciÓn a Java

2022

Tegucigalpa, M.D.C.
 ÍNDICE
INTRODUCCIÓN ............................................................................................................................ 4
1. INSTALACIONES: ................................................................................................................... 5
2. HOLA MUNDO EN JAVA ........................................................................................................ 6
3. ¿QUÉ ES INFORMACIÓN? ..................................................................................................... 8
4. ¿QUÉ ES UNA VARIABLE Y UNA CONSTANTE?..................................................................... 9
5. REGLAS DE NOMENCLATURA ............................................................................................. 10
6. ¿QUÉ ES UN LENGUAJE DE TIPADO FUERTE? .................................................................... 11
7. CONCATENACIÓN DE TEXTOS ............................................................................................ 12
8. OPERADORES ARITMÉTICOS EN JAVA ............................................................................... 13
9. TIPOS DE DATOS NUMÉRICOS EN JAVA ............................................................................. 13
10. BOOLEANOS Y LA SENTENCIA CONDICIONAL ................................................................ 14
11. OPERADORES DE COMPARACIÓN EN JAVA ................................................................... 14
12. OPERADORES LÓGICOS EN JAVA.................................................................................... 15
Operador “NOT”:..................................................................................................................... 15
Operador “AND”: .................................................................................................................... 15
Operador “OR”: ....................................................................................................................... 16
13. BUGS Y DEBUGGING ....................................................................................................... 17
14. ¿QUÉ ES UNA FUNCIÓN? ................................................................................................ 18
15. COMENTAR CÓDIGO ....................................................................................................... 20
Comentarios en Java de una sola línea: .................................................................................. 20
Comentarios en Java de múltiples líneas: ............................................................................... 21
Comentarios de documentación en Java (Javadoc): ............................................................... 22
16. BUCLES: WHILE, DO WHILE Y FOR .................................................................................. 23
While: ...................................................................................................................................... 23
do-while: ................................................................................................................................. 24
For: .......................................................................................................................................... 25
17. ¿QUÉ ES UN ARREGLO? (ARRAYS).................................................................................. 26
Arrays unidimensionales ......................................................................................................... 26
Arrays multidimensionales ...................................................................................................... 28
18. Programación Orientada a Objetos POO ....................................................................... 29
19. ¿QUÉ ES UNA CLASE?...................................................................................................... 30
20. ¿QUÉ ES UN OBJETO? ..................................................................................................... 31
21. ENCAPSULAMIENTO ....................................................................................................... 32
22. ABSTRACCIÓN ................................................................................................................. 34
23. HERENCIA ........................................................................................................................ 35
24. POLIMORFISMO .............................................................................................................. 37
 INTRODUCCIÓN
Desde los inicios de la computación, para que una computadora
pueda entender las instrucciones que le da el programador, estas deben
estar en código máquina (un lenguaje de primera generación), el cual para
las personas es complicado de desarrollar. Los lenguajes de programación
evolucionaron a ensamblador (segunda generación), lenguajes de
propósito general (tercera generación: estructurados, lógicos, funcionales,
orientados a objetos) y de propósito específico (cuarta generación: bases
de datos, graficación, gramáticas).
En esos tiempos, cada fabricante de hardware tenía su propia versión de los
lenguajes de programación populares. El lenguaje de programación Java
surge en la década de 1980. Llamado originalmente Oak, fue desarrollado
por James Gosling para la empresa Sun Microsystems con la intención de
programar dispositivos electrónicos. Fue concebido como un lenguaje
orientado a objetos, multiplataforma, basado en C++, la versión orientada
a objetos de C.
 1. INSTALACIONES:
Para crear nuestro primer proyecto en Java deberemos de realizar las
siguientes instalaciones:

• JDK de Java
• Configurar las variables de entorno
• Instalar un IDE como puede ser NetBeans, IntelliJ IDEA o Eclipse.
 2. HOLA MUNDO EN JAVA
Nos debemos dirigir a nuestro IDE, y seleccionamos File – New Project

Seleccionamos la categoría de Java With Maven – Java Application

Agregamos el nombre de nuestro proyecto y damos en finalizar:

Creamos nuestra clase Main y dentro de ella codificamos para que nos
muestre un mensaje en consola.
System.out.println("Hola Mundo!");
 3. ¿QUÉ ES INFORMACIÓN?
• Información es un conjunto de datos organizados que al leerlos nos
producen un significado.
• Para que una información sea útil tiene que ser en el momento
indicado y de la forma adecuada.
 4. ¿QUÉ ES UNA VARIABLE Y UNA
CONSTANTE?
Es un elemento de datos cuyo valor puede cambiar durante el curso de la
ejecución de un programa, básicamente una variable es una especie de
contenedor que nos permite guardar datos.

Una constante es un valor que no puede ser alterado/modificado durante

la ejecución de un programa, únicamente puede ser leído.
La diferencia con una variable es que no puede cambiar de valor, solo se le
asigna una vez.
 5. REGLAS DE NOMENCLATURA

• camelCase: Para declarar Variables.

• SCREAMING_SNAKE_CASE: Para declarer Constantes.
• Snake_case: Para Bases de Datos.
 6. ¿QUÉ ES UN LENGUAJE DE TIPADO
FUERTE?
En el lenguaje de tipado fuerte cuando definimos una variable tenemos que
definir el tipo de dato que se va a utilizar.
Un lenguaje de programación es fuertemente tipado si no se permiten
violaciones de los tipos de datos, es decir, dado el valor de una variable de
un tipo concreto, no se puede usar como si fuera de otro tipo distinto a
menos que se haga una conversión. No hay una única definición de este
término.

Ventajas
• Código expresivo: ahora sí sabremos de qué tipo espera un
argumento una función
• Menos errores: Nos olvidaremos de ver el tipo de variable antes de
hacer operaciones con ésta

Desventajas
• Escribir más código: tenemos que declarar el tipo de variable al
declararla

Lenguajes que lo usan: Por mencionar algunos…

• C
• C#
• Java
• Ruby
• Python
 7. CONCATENACIÓN DE TEXTOS

En nuestro proyecto anteriormente creado en la clase main vamos a realizar

el siguiente ejemplo de concatenación de datos.
8. OPERADORES ARITMÉTICOS EN JAVA

9. TIPOS DE DATOS NUMÉRICOS EN JAVA

 10. BOOLEANOS Y LA SENTENCIA
CONDICIONAL

11. OPERADORES DE COMPARACIÓN EN

JAVA
 12. OPERADORES LÓGICOS EN JAVA

Operador “NOT”:

Operador “AND”:
Operador “OR”:

Ejemplo:
 13. BUGS Y DEBUGGING
Bugs:
Esto quiere decir que cuando iniciamos el proceso de debug del código lo
que estamos haciendo es buscar errores o bugs que puedan entorpecer la
ejecución adecuada del software.

¿Para qué sirve el debug?

Su objetivo es encontrar errores que pueden impedir que los códigos
funcionen de forma adecuada. Con este, es posible determinar lo que está
ocurriendo dentro del código fuente y obtener sugerencias de acciones
para mejoras.

Debugging:
Un depurador es un programa que permite detectar y diagnosticar fallos en
programas informáticos. El objetivo de estas herramientas es garantizar, a
largo plazo, que el software funcione en todos los dispositivos y
plataformas para los que está pensado.
 14. ¿QUÉ ES UNA FUNCIÓN?
Funciones:
Las funciones son un conjunto de líneas de código (instrucciones),
encapsulados en un bloque, usualmente reciben parámetros, cuyos valores
utilizan para efectuar operaciones y adicionalmente retornan un valor. En
otras palabras, una función puede recibir parámetros o argumentos
(algunas no reciben nada), hace uso de dichos valores recibidos como sea
necesario y retorna un valor usando la instrucción return, si no retorna algo,
entonces no es una función. En java las funciones usan el modificador static.

Métodos:
Los métodos y las funciones en Java están en capacidad de realizar las
mismas tareas, es decir, son funcionalmente idénticos, pero su diferencia
radica en la manera en que hacemos uso de uno u otro (el contexto). Un
método también puede recibir valores, efectuar operaciones con estos y
retornar valores, sin embargo en método está asociado a un objeto,
SIEMPRE, básicamente un método es una función que pertenece a un
objeto o clase, mientras que una función existe por sí sola, sin necesidad de
un objeto para ser usada. Nota: Es aquí donde digo que en Java se debe
hablar de métodos y no de funciones, pues en Java estamos siempre
obligados a crear un objeto para usar el método. Para que sea una función
esta debe ser static, para que no requiera de un objeto para ser llamada.

Las funciones, también llamados métodos, nos permiten dividir el trabajo

que hace un programa, en tareas más pequeñas separadas de la parte
principal. Ese es el concepto de función en programación.
En programación, una función es una sección de un programa que calcula
un valor de manera independiente al resto del programa.
Una función tiene tres componentes importantes:
• los parámetros, que son los valores que recibe la función como
entrada;
• el código de la función, que son las operaciones que hace la función;
y
• el resultado (o valor de retorno), que es el valor final que entrega la
función.
 15. COMENTAR CÓDIGO
Los comentarios en Java y en cualquier lenguaje de programación son una
herramienta que sirve para apoyar la documentación de los programas que
desarrollamos y así facilitar su posterior comprensión por parte de alguna
otra persona que comprenda algo de Java o el lenguaje en particular. Los
comentarios, son líneas de código, que no son tenidas en cuenta por el
compilador en el momento de ejecutar nuestra aplicación (es como si no
estuviesen allí), por lo tanto, no están sujetas a restricciones de sintaxis ni
nada similar y podremos escribir cualquier cosa en éstas. El uso principal de
las líneas de comentario en Java, es dar orden al código y hacerlo más
comprensible, en especial cuando serán terceros los que verán y deberán
entender nuestro programa (como dije anteriormente). Por ejemplo, es
muy común usar las líneas de comentarios, para dar una breve explicación
de cómo funciona cierta parte de un código, lo cual permite identificar todo
con mayor rapidez.

En Java hay tres tipos de comentarios:

• Comentarios de una sola línea.
• Comentarios de múltiples líneas.
• Comentarios de la documentación.

Comentarios en Java de una sola línea:

Pueden ser colocados en cualquier parte de nuestro código en Java y

comienzan por un doble slash "//", al colocar el doble slash en cualquier
línea de código, todo lo que haya de ahí en adelante en dicha línea será
tomado como comentario, ten en cuenta que el doble slash solo convierte
en comentario al texto que haya justo después de éstos y que pertenezca a
su misma línea, las líneas de abajo de este, no se verán afectadas, tal como
es de esperarse, el doble slash "//", solo afecta una línea desde el lugar
donde se colocan.
Ejemplo:

Comentarios en Java de múltiples líneas:

Los comentarios multi-línea en Java tal como el nombre lo indica nos

permiten comentar varias líneas de nuestro código Java de manera mucho
más sencilla en vez de esta añadiendo doble slash "//" a cada línea. Estos
comentarios van cerrados entre "/*" y "*/", es decir comienzan donde se
ponga "/*" y terminan donde esté el "*/". Estos comentarios funcionan de
manera similar a los comentarios de una sola línea, pero deben tener un
comienzo y un final. A diferencia de los comentarios de una sola línea, al
poner el símbolo "/*" todo el código que haya tanto en la misma línea,
como en las línea posteriores de este se convertirán en comentarios hasta
que pongamos el "*/", de manera que si iniciamos un comentario de
múltiples líneas, debemos cerrarlo, tal como sucede con las llaves o los
corchetes en Java.

Ejemplo:
Comentarios de documentación en Java (Javadoc):

Los comentarios de documentación, también conocidos como Javadoc, son

de especial utilidad al momento de documentar no sólo el código fuente,
sino el proyecto como tal. Por medio de herramientas externas, podremos
generar de forma automática la documentación de un proyecto Java, a
partir de estos comentarios de documentación o Javadocs.
Estos comentarios van cerrados entre "/**" y "*/", es decir comienzan
donde se ponga "/**" y terminan donde esté el "*/". Nótese que los
comentarios de documentación, a diferencia de los comentarios de
múltiples líneas, inician con "/**" (doble asterisco) en lugar de "/*" (un solo
asterisco). Adicionalmente, se recomienda que cada línea que compone el
bloque de comentarios inicie con "*".

Ejemplo:
 16. BUCLES: WHILE, DO WHILE Y FOR
Los bucles, iteraciones o sentencias repetitivas modifican el flujo secuencial
de un programa permitiendo la ejecución reiterada de una sentencia o
sentencias. En Java hay tres tipos diferentes de bucles:

While:

Un bucle while es una sentencia de control de flujo que permite que el

código se ejecute repetidamente en función de una condición booleana
dada. El bucle while se puede considerar como una instrucción if repetitiva.

Sintaxis:

while (condición booleana)

{
declaraciones del bucle ...
}
do-while:

El bucle do while es similar al while con la única diferencia de que

comprueba la condición después de ejecutar las instrucciones, y por lo
tanto es un ejemplo de Exit Control Loop (Salir del bloque de control).

Sintaxis:
do {

sentencias;

[iteracion;]

} while (expresionLogica);
For:

El bucle for proporciona una forma concisa de escribir la estructura de

bucle. A diferencia de un ciclo while, una sentencia for consume la
inicialización, la condición y el incremento/decremento en una línea,
proporcionando así una estructura de bucle más corta y fácil de depurar.

Sintaxis:

for (condición de inicialización, condición de prueba;

incremento / decremento)
{
declaracion(es)
}
 17. ¿QUÉ ES UN ARREGLO? (ARRAYS)
Una array o arreglo es una colección de variables del mismo tipo, a la que
se hace referencia por un nombre común. En Java, los arrays pueden tener
una o más dimensiones, aunque el array unidimensional es el más común.
Los arrays se usan para una variedad de propósitos porque ofrecen un
medio conveniente de agrupar variables relacionadas. Por ejemplo, puede
usar una matriz para mantener un registro de la temperatura alta diaria
durante un mes, una lista de promedios de precios de acciones o una lista
de tu colección de libros de programación.
La ventaja principal de un array es que organiza los datos de tal manera que
puede ser manipulado fácilmente. Por ejemplo, si tiene un array que
contiene los ingresos de un grupo seleccionado de hogares, es fácil calcular
el ingreso promedio haciendo un ciclo a través del array. Además, los arrays
organizan los datos de tal manera que se pueden ordenar fácilmente.

Arrays unidimensionales

Un array unidimensional es una lista de variables relacionadas. Tales listas

son comunes en la programación. Por ejemplo, puede usar un array
unidimensional para almacenar los números de cuenta de los usuarios
activos en una red. Otro array podría usarse para almacenar los promedios
de bateo actuales para un equipo de béisbol.

La forma general de declarar un arreglo unidimensional es:

tipo nombre-array[];

tipo [] nombre-array;
La declaración de un array tiene dos componentes: el tipo y el nombre.
• tipo declara el tipo de elemento del array. El tipo de elemento
determina el tipo de datos de cada elemento que comprende la
matriz. Al igual que la matriz de tipo int, también podemos crear una
matriz de otros tipos de datos primitivos como char, float,
double..etc o tipo de datos definido por el usuario (objetos de una
clase). Por lo tanto, el tipo de elemento para la matriz determina
el tipo de datos que la matriz contendrá.

Ejemplo:

// ambas son declaraciones válidas

int intArray[];
int[] intArray;
//Tipo de datos primitivos
byte byteArray[];
short shortArray[];
boolean booleanArray[];
long longArray[];
float floatArray[];
double doubleArray[];
char charArray[];
//Tipos de datos definidos por el usuario
// una serie de referencias a objetos de
// la clase MyClass (una clase creada por
// el usuario)
MyClass myClassArray[];
Object[] ao, // array de Object
Collection[] ca; // array de Collection
Arrays multidimensionales

Las matrices multidimensionales son matrices de matrices o arrays de

arrays, donde cada elemento del array contiene la referencia de otro array.
Se crea una matriz multidimensional al agregar un conjunto de corchetes
([]) por dimensión. Ejemplos:

int[][] intArray = new int; //un array 2D o matrix

int[][][] intArray = new int; //una array 3D

Ejemplo:

class multiDimensional
{
public static void main(String args[])
{
// declarar e inicializar array 2D
int arr[][] = { {2,7,9},{3,6,1},{7,4,2} };

// imprimir array 2D
for (int i=0; i< 3 ; i++)
{
for (int j=0; j < 3 ; j++)
System.out.print(arr[i][j] + " ");

System.out.println();
}
}
}

Salida:

2 7 9
3 6 1
7 4 2

Documentación: https://javadesdecero.es/arrays/unidimensionales-
multidimensionales/
 18. Programación Orientada a Objetos POO
La Programación Orientada a Objetos (POO) es un paradigma de
programación, es decir, un modelo o un estilo de programación que nos da
unas guías sobre cómo trabajar con él. Se basa en el concepto de clases y
objetos. Este tipo de programación se utiliza para estructurar un programa
de software en piezas simples y reutilizables de planos de código (clases)
para crear instancias individuales de objetos.
Con el paradigma de Programación Orientado a Objetos lo que buscamos
es dejar de centrarnos en la lógica pura de los programas, para empezar a
pensar en objetos, lo que constituye la base de este paradigma. Esto nos
ayuda muchísimo en sistemas grandes, ya que, en vez de pensar en
funciones, pensamos en las relaciones o interacciones de los diferentes
componentes del sistema.
La Programación Orientada a objetos permite que el código sea reutilizable,
organizado y fácil de mantener. Sigue el principio de desarrollo de software
utilizado por muchos programadores DRY (Don’t Repeat Yourself),
para evitar duplicar el código y crear de esta manera programas eficientes.
Además, evita el acceso no deseado a los datos o la exposición de código
propietario mediante la encapsulación y la abstracción, de la que
hablaremos en detalle más adelante.
 19. ¿QUÉ ES UNA CLASE?
Las clases son la base de la programación orientada a objetos, una clase es
una plantilla, molde o modelo para crear objetos.
Una clase está compuesta por características, propiedades o
atributos (variables) y por su comportamiento (métodos) que trabajan
sobre las propiedades.

Ejemplo de una clase:

 20. ¿QUÉ ES UN OBJETO?
Un objeto es una instancia de una clase, una instancia es un ejemplar, un
caso específico de una clase.
un objeto en Java es la unidad básica de este lenguaje de programación y
representa las entidades de la vida real. Un programa típico de Java crea
muchos objetos que interactúan al invocar métodos. De esta forma,
podemos decir que un objeto consiste en:
• Estado: está representado por atributos de un objeto. También
refleja las propiedades de un objeto.
• Comportamiento: se representa mediante métodos de un objeto.
También refleja la respuesta de un objeto con otros objetos.
• Identidad: le da un nombre único a un objeto y permite que un
objeto interactúe con otros objetos.

Ejemplo 1:

Ejemplo 2:
 21. ENCAPSULAMIENTO
Este principio consiste en ocultar el estado interno del objeto y obligar a
que toda interacción se realice a través de los métodos del objeto. Esto se
hace para tener mejor control de flujo de la información.

Hay muchos datos que no tiene porque conocerlo aquel que este usando la
clase Persona; ya que son inherentes al objeto y solo controlan su
funcionamiento interno; por ejemplo, cuando alguien te ve puede saber
inmediatamente si eres hombre o mujer (propiedad) o puede hablarte y
obtener una respuesta procesada (método); también puede conocer el
color de tu cabello y ojos. En cambio, jamás sabrá que cantidad de energia
exacta tienes o cuantas neuronas te quedan, ni siquiera preguntandote ya
que ninguna de tus propiedades externas visibles o funciones de
comunicación al publico te permiten saber esos datos.

Esto es la encapsulación u ocultación; hacer las variables que son

innecesarias para el tratamiento del objeto pero necesarias para su
funcionamiento privadas, asi como las funciones que no necesitan
interacción del usuario o que solo pueden ser llamadas por otras funciones
dentro del objeto (Como por ejemplo, palpitar).

La encapsulación es muy conveniente y nos permite (Si programamos bien)

colocar en funcionamiento nuestro objeto en cualquier tipo de sistema, de
una manera modular y escalable (algunas de las reglas de la ingenieria del
software).
Ejemplo Encapsulamiento:
 22. ABSTRACCIÓN
El término abstracción consiste en ver a algo como un todo sin saber cómo
está formado internamente.
Se dice que las personas gestionan la complejidad a través de la abstracción,
que quiere decir esto, por ejemplo para alguien es difícil entender todos los
componentes, circuitos de un televisor y como trabajan, sin embargo es
más fácil conocerlo como un todo, como un televisor, sin pensar en sus
detalles o partes internas.
Para entender mejor pensemos en un Smartphone, es un sistema muy
complejo que a su vez está compuesto por otros subsistemas internos o
partes que lo componen, por ejemplo: sistema operativo, aplicaciones,
sensores, cámara, pero en definitiva el usuario lo ve como un todo, un
Smartphone sin importar cómo está compuesto, qué versión tiene el kernel
del sistema operativo, que controladores se debe instalar para utilizar un
sensor etc
Al usuario lo que le interesa es usarlo, saber que es un Smartphone y nada
más, se abstrae de los detalles internos
Si te das cuenta, si el usuario quisiera entender todo los detalles y partes
del Smartphone, incluso le sería más complicado usarlo.
En conclusión, el concepto de abstracción trata la descomposición de
sistemas complejos en partes sencillas, las cuales se pueden describir
fácilmente.
Un ejemplo de abstracción en Java es una clase, ya que se la define como
un todo.
El objetivo es que el usuario pueda crear objetos de esa clase, que utilice
sus métodos, y que no se preocupe por su implementación o como está
diseñada.
 23. HERENCIA

La herencia de clases es uno de los conceptos básicos de la programación

orientada a objetos. Decir que una clase hereda de otra quiere decir que
esa clase obtiene los mismos métodos y propiedades de la otra clase.
Permitiendo de esta forma añadir a las características heredadas las suyas
propias.
Supongamos que tenemos una clase "Persona" con los métodos y
propiedades básicas de una objeto persona como podrian ser "caminar" o
"hablar", podríamos tener otras clases como "Guillermo" o "Elder" que
comparten todas las características de una "Persona" pero que añaden
características propias. Por lo que "Guillermo" y "Elder" pueden realizar las
mismas funciones que puede realizar una "Persona" y además cada una
puede realizar las suyas propias, por ejemplo, "Guillermo" sabe nadar pero
"Elder" no, y "Elder" sabe bailar reggeton pero "Guillermo" no.
En términos de programación estaríamos diciendo que "Guillermo" y
"Elder" son dos clases especializadas que heredan o extienden de la
superclase "Persona".

Tipos de herencia de clases Existen dos tipos de herencia:

• Herencia por especialización
• Herencia por generalización

En realidad, la herencia es la misma, esta es una diferenciación puramente

conceptual sobre la forma en que se a llegado a ella. Una herencia por
especialización es la que se realiza cuando necesitamos crear una clase
nueva que disponga de las mismas características que otra pero que le
añada funcionalidades. Por ejemplo, si tenemos una clase que genera un
botón simple, y necesitamos crear un botón que sea igual que el anterior
pero que además añada un efecto al ser clicado.
La herencia por generalización es la que realizamos cuando tenemos
muchas clases que comparten unas mismas funcionalidades y por
homogeneizar las partes comunes se decide crear una clase que
implemente toda esa parte común y se dejan solo las partes especificas en
cada clase. Por ejemplo si tenemos clases para dibujar formas geométricas
todas ellas disponen de las mismas propiedades (un color de fondo, color
de linea, etc.), todas estas características pueden estar en una clase general
de la que hereden todas las clases concretas, evitando tener que escribir
todo ese código común en todas ellas.

Public, private o protected

Una consideración a tener en cuenta de la herencia es que una clase no
hereda las propiedades o métodos privados, con lo que no tendrán acceso
a ellas. Si necesitamos heredar propiedades o métodos que no queremos
que sean accesibles desde fuera de las clases las definiremos como
protected.

Ejemplo Herencia:
 24. POLIMORFISMO

El polimorfismo es la habilidad de una función, método, variable u objeto

de poseer varias formas distintas. Podríamos decir que un mismo
identificador comparte varios significados diferentes.
El propósito del polimorfismo es implementar un estilo de programación
llamado envío de mensajes en el que los objetos interactúan entre ellos
mediante estos mensajes, que no son más que llamadas a distintas
funciones.

Ejemplo Polimorfismo: