Tema 2: Introducción a la Tecnología Java (Introducing

the Java Technology)

Características Clave de Java (Key Concepts of the Java

Programming Language)

La tecnología Java se basa en varios conceptos clave que definen su utilidad:

1.​ Orientado a Objetos (Object-Oriented - OO):
○​ El objetivo principal es crear objetos (piezas de código autónomo) que interactúan
para resolver un problema.
○​ Se diferencia de la Programación Procedural (Procedural Programming), que se
centra en la secuencia de pasos de codificación.
○​ Ventajas de la OO: Modularidad, ocultación de información (Information-hiding),
reutilización de código (Code re-use), y facilidad de depuración.
2.​ Distribuido (Distributed):
○​ El lenguaje soporta tecnologías de red distribuidas (como RMI, CORBA y URL).
○​ Permite descargar y ejecutar código a través de Internet (carga dinámica de clases).
3.​ Simple (Simple):
○​ Los diseñadores eliminaron características complejas como la manipulación directa
de punteros a memoria (memory pointers).
○​ En su lugar, utiliza referencias de objetos (object references).
○​ Gestiona la memoria automáticamente a través del Recolector de Basura (garbage
collector).
4.​ Multihilo (Multi-Threaded):
○​ Permite que varias tareas se ejecuten concurrentemente.
○​ Mejora la eficiencia del uso de recursos del sistema (ej. consultas a bases de datos y
la interfaz de usuario).
5.​ Seguro (Secure):
○​ Utiliza medidas de seguridad como prohibir que programas distribuidos (applets)
lean o escriban en el disco duro.
○​ Verifica que todo el código sea válido.
6.​ Independiente de la Plataforma (Platform-Independent):
○​ A diferencia de programas que requieren compilación en código específico de la
CPU (machine code) para una sola plataforma, los programas Java se compilan en
 bytecode (código de bytes de Java).
○​ El bytecode es interpretado (ejecutado) por una Máquina Virtual de Java (JVM /
Java Virtual Machine), que es un programa específico de la plataforma.
○​ La combinación de la JVM y las bibliotecas de clases estándar se llama Entorno de
Ejecución de Java (JRE).

Grupos de Productos de Tecnología Java (Java Technology Product

Groups)

Existen tres grupos principales de productos Java, que comparten la base del lenguaje:

Producto Descripción Uso Principal

Java SE (Standard Edition) Utilizado para desarrollar Ejecución en navegadores

applets y aplicaciones. web y ordenadores de
escritorio.

Java EE (Enterprise Utilizado para crear Aplicaciones del lado del

Edition) grandes aplicaciones servidor y del lado del
distribuidas. cliente (ej. comercio
electrónico).

Java ME (Micro Edition) Utilizado para crear Teléfonos celulares o Java

aplicaciones para TV.
dispositivos de consumo
con recursos limitados
(resource-constrained
consumer devices).

Ciclo de Vida del Producto (Product Life Cycle - PLC)

El PLC es un proceso iterativo usado para desarrollar nuevos productos:

1.​ Análisis (Analysis): Investigar el problema a resolver, definiendo el alcance (scope) e
identificando los subcomponentes clave.
 2.​ Diseño (Design): Aplicar los hallazgos del análisis para desarrollar planos o
especificaciones (blueprints or specifications).
3.​ Desarrollo (Development): Crear componentes usando los planos del diseño.
4.​ Pruebas (Testing):
○​ Asegurar que los componentes cumplen con los requisitos de la especificación.
○​ Generalmente realizado por un equipo distinto al de desarrollo.
5.​ Implementación (Implementation): Poner el producto a disposición de los clientes.
6.​ Mantenimiento (Maintenance): Corregir problemas y relanzar el producto (nueva
versión o revisión).
7.​ Fin de Vida (End-of-life - EOL): Tareas necesarias para informar que un producto ya no
se vende ni se soporta.

Tema 3: Pensando en Objetos (Thinking in Objects)

Esta lección se centra en el Análisis Orientado a Objetos (OOA) para identificar los bloques
de construcción de un programa: objetos, atributos y operaciones.

Identificación de Objetos (Identifying Objects)

●​ Primero se define el dominio del problema (problem domain), que es el alcance del
problema a resolver.
●​ Luego, se identifican los objetos dentro de ese dominio.

Propiedades de los Objetos (Object Properties)

Los objetos tienen tres propiedades principales:

1.​ Físicos o Conceptuales: Un objeto puede ser algo que se puede tocar (físico, ej. un
ATM) o una idea (conceptual, ej. una cuenta de cliente).
2.​ Atributos (Attributes): Características que definen el estado (state) del objeto (datos),
como tamaño, nombre, o color.
3.​ Operaciones (Operations): Las cosas que el objeto puede hacer, que representan el
comportamiento (behavior) y que a menudo modifican el estado de sus atributos.

Criterios Adicionales: Un objeto debe tener relevancia (relevance) para el dominio del
problema y existencia independiente (independent existence).

Modelado de Clases (Designing and Modeling Classes)

●​ Clase (Class): Es el plano (blueprint), plantilla o categoría descriptiva utilizada para

definir un objeto.
●​ Objeto (Object): Es una instancia (instance) única de una clase.
○​ Cada objeto creado a partir de una clase puede tener un estado (valores) específico
para cada uno de sus atributos, pero tendrá los mismos atributos y operaciones.
●​ Los nombres de variables y métodos se escriben en camelCase.
●​ El modelado tipo UML (Lenguaje Unificado de Modelado) visualiza la estructura de la
clase, listando el nombre, atributos y métodos.

Concepto OO Concepto Java

Clase (Class) Clase (Class)

Atributos (Attributes) Variables / Campos (Fields)

Operaciones (Operations) Métodos (Methods)

💻 Tema 4: Introducción al Lenguaje Java (Introducing

the Java Language)

Componentes de una Clase Java (Components of a Java Class)

El código de una clase se divide en cuatro secciones:

1.​ Declaración de Clase (Class declaration): Define la accesibilidad (usando modifiers o
modificadores, como public) y el nombre de la clase (usando la palabra clave class).
 2.​ Declaraciones de Campo (Field declarations): Variables que contienen los atributos
(datos) de la clase. También se les llama fields.
3.​ Métodos (Methods): Opcionales, contienen el comportamiento del objeto.
4.​ Comentarios (Comments): Opcionales. Pueden ser de línea simple (//) o tradicionales
(/* */).

Símbolos Clave de la Sintaxis (Symbols Used in Defining a Java

Source)

●​ Llaves {} (Braces): Delimitan un bloque de código (ej. el cuerpo de una clase o método).
●​ Paréntesis () (Parentheses): Indican datos de entrada (argumentos) de un método.
●​ Punto y coma ; (Semicolons): Señala el final de una sentencia (statement).

Métodos (Methods)

La sintaxis de un método es: [modifiers] return_type method_identifier ([arguments]) {

method_code_block }.
●​ Tipo de Retorno (Return Type): Indica el tipo de valor que el método devuelve. Si no
devuelve nada, se usa la palabra clave void.
●​ Argumentos (Arguments): Lista de variables cuyos valores se pasan al método para su
uso.

El Método main (The main Method)

●​ Es un método especial que la JVM (Java Virtual Machine) reconoce como el punto de
inicio de cualquier programa Java que se ejecute desde la línea de comandos.
●​ Sintaxis: public static void main (String[] args).

Compilación y Ejecución (Compiling and Executing)

1.​ Compilar (Compiling): Convierte el código fuente (.java) en bytecode (.class).

 ○​ Se utiliza el comando javac filename.
2.​ Ejecutar/Probar (Executing/Testing): Se utiliza la JVM con el comando java classname
(donde classname es la clase que contiene el método main).

Palabras Clave y Depuración

●​ Palabras Clave (Keywords): Son palabras reservadas por el lenguaje Java (ej. public,
class, int, if, else, while, for, static, void, return, try, catch, final, etc.) que no pueden
usarse como identificadores.
●​ Depuración (Debugging): Un Depurador de IDE (IDE Debugger) permite:
○​ Establecer puntos de interrupción (breakpoints) en el código fuente.
○​ Examinar y modificar los valores de las variables (campos y locales).
○​ Avanzar paso a paso (step through) en el código para resolver problemas de lógica.

Tema 5: Declaración, Inicialización y Uso de Variables

(Declaring, Initializing, and Using Variables)

Uso y Tipos de Variables (Variable Usage and Types)

Las variables se usan para almacenar y recuperar datos.

●​ Variables de Campo (Field Variables / Instance Variables):
○​ Almacenan datos únicos para una instancia de objeto.
○​ Se declaran fuera de los métodos.
●​ Variables Locales (Local Variables):
○​ Se definen dentro de los métodos y solo son accesibles localmente (su alcance es el
método o bloque donde se declaran).
○​ Nota: Deben inicializarse explícitamente antes de usarse.

Sintaxis de Declaración: [modifiers] type identifier [= value];.

●​ type (tipo): Define el tipo de dato que contiene la variable.
●​ identifier (identificador): El nombre que se le da a la variable (debe ser descriptivo y
seguir la convención camelCase).
Tipos de Datos Primitivos (Primitive Data Types)

Java tiene ocho tipos primitivos integrados:

Categoría Tipo (Keyword) Longitud Descripción

Enteros (Integral) byte, short, int, 8, 16, 32, 64 bits Números sin puntos
long decimales. int es el
tipo por defecto
para literales
enteros.

Punto Flotante float, double 32, 64 bits Números con

(Floating Point) valores a la
derecha del punto
decimal. double es
el tipo por defecto.

Textual (Textual) char 16 bits Un solo carácter,

usa el conjunto de
caracteres
Unicode. Se asigna
con comillas
simples (ej. 'U').

Lógico (Logical) boolean N/A Almacena solo true

o false.

Constantes (Constants)

●​ Se declaran usando la palabra clave final para indicar que su valor no puede cambiar
después de la inicialización.
●​ La convención de nombres es usar mayúsculas con guiones bajos (ej. MAX_COUNT).
Almacenamiento en Memoria (Memory Storage)

●​ Las variables locales se almacenan en la pila (Stack).

●​ Los objetos y sus campos se almacenan en el montón (Heap).

Shutterstock

Operadores Matemáticos (Mathematical Operators)

Además de los operadores estándar (+, -, *, /, %), existen:

●​ Operadores de Incremento/Decremento (++ y --): Se usan para sumar o restar 1 a una
variable.
○​ Pre-operadores (++i): La operación se aplica antes de cualquier cálculo o
asignación subsiguiente.
○​ Post-operadores (i++): La operación se aplica después de cualquier cálculo o
asignación subsiguiente.
●​ Precedencia de Operadores (Operator Precedence): Define el orden en que se
evalúan las operaciones complejas (ej. primero paréntesis, luego
incremento/decremento, luego multiplicación/división, y finalmente adición/sustracción,
 de izquierda a derecha).

Promoción y Conversión de Tipos (Promotion and Type Casting)

●​ Promoción (Promotion): El compilador cambia automáticamente el tipo de una variable

a un tipo más grande para evitar la pérdida de precisión.
●​ Conversión de Tipos Explícita (Type Casting):
○​ Se utiliza para cambiar manualmente un valor a un tipo más pequeño.
○​ Sintaxis: identifier = (target_type) value.
○​ Peligro: La conversión de tipos a un tamaño menor puede truncar (chop) parte de
los datos.

Tema 6: Trabajando con Objetos (Working with

Objects)

Referencias a Objetos (Object References)

Para trabajar con un objeto, se accede a él a través de una referencia. El proceso es:
1.​ Declarar la referencia: Classname identifier; (ej. Shirt myShirt;).
2.​ Instanciar el objeto: new Classname(); (usa la palabra clave new).
3.​ Asignar la referencia: myShirt = new Shirt(); (se usa el operador de asignación =).
●​ El operador punto (.) se utiliza para acceder a los campos o invocar los métodos de un
objeto (ej. [Link]()).

Referencias Múltiples (Multiple References)

●​ Dos o más referencias pueden apuntar al mismo objeto en memoria.

●​ Cualquier cambio realizado a través de una referencia afectará al objeto y será visible a
través de las otras referencias.
Recolección de Basura (Garbage Collection)

●​ Si un objeto pierde todas sus referencias, se vuelve inaccesible.

●​ La memoria que ocupa eventualmente será liberada por el recolector de basura
(garbage collector).

La Clase String (String Class)

La clase String permite almacenar una secuencia de caracteres.

●​ Sintaxis no estándar: Se puede instanciar sin la palabra clave new (ej. String hisName =
"Fred Smith";), lo cual es preferido por ser más eficiente en memoria.
●​ Inmutabilidad (Immutable): Un objeto String es inmutable; su valor no puede cambiarse
después de crearse.
●​ Concatenación (+): La concatenación de dos strings crea un nuevo objeto String.

Clase StringBuilder

●​ Proporciona una alternativa mutable (mutable) a String.

●​ Se utiliza cuando es probable que se realicen muchas modificaciones (como
concatenaciones), ya que evita el costo de crear nuevos objetos constantemente.
●​ Se instancia con new y se usa el método append() para añadir datos.

Documentación API de Java (Java API Documentation)

●​ Es un conjunto de páginas web que documentan las librerías de clases preescritas del
JDK.
●​ Es la mejor fuente de información para clases, campos y métodos.

Tema 7: Uso de Operadores y Constructos de

Decisión (Using Operators and Decision Constructs)

Se utilizan para evaluar condiciones y ejecutar diferentes bloques de código (ramas).

Operadores Relacionales y Condicionales (Relational and Conditional

Operators)

Tipo Operador Propósito Ejemplo

Relacional ==, !=, >, <, >=, <= Comparan dos if (nivelAceite <=
valores, el 0.5)
resultado es
boolean.

Condicional && (AND), ` (OR),!` (NOT)

Ternario ?: Atajo para if/else. String estado =

(velocidad > 100) ?
"Rápido" :
"Normal";

Nota importante: Para comparar el contenido de dos objetos String, se debe

usar el método equals() (ej. [Link](nombre2)), no el operador ==, ya que
== compara las direcciones de referencia en memoria.

Constructos de Decisión (Decision Constructs)

1.​ if Construct: Ejecuta un bloque de código si la boolean_expression es verdadera.

2.​ if/else Construct: Si la expresión es verdadera, ejecuta el bloque if; si es falsa, ejecuta el
bloque else.
3.​ else if Chaining (Encadenamiento): Permite probar múltiples expresiones
secuencialmente. Se usa else if después del if inicial.
4.​ switch Construct: Simplifica la lógica de decisión cuando se prueba una variable contra
múltiples valores fijos.
 ○​ La variable a probar (en switch(variable)) debe ser de tipo char, byte, short, int, o
String.
○​ Se utiliza la palabra clave case seguida de un valor literal (constante conocida en
tiempo de compilación).
○​ break; es crucial para salir del constructo; si se omite, el código continúa
ejecutándose en las siguientes etiquetas case (fall-through).
○​ default: es opcional y se ejecuta si ninguna etiqueta case coincide.

Tema 8: Creación y Uso de Arrays (Creating and Using

Arrays)

Arrays Unidimensionales (One-Dimensional Arrays)

●​ Un Array (Arreglo) es un objeto contenedor de tamaño fijo que mantiene un grupo de

valores del mismo tipo (primitivo u objeto).
●​ Cada valor se llama elemento (element) y se accede mediante un índice (index)
numérico que comienza en 0.

Proceso de Creación:

1.​ Declaración: Se declara una referencia al array.

○​ Sintaxis: type [] array_identifier; (ej. int [] edades;).
2.​ Instanciación: Se define el tamaño del array.
○​ Sintaxis: array_identifier = new type [length]; (ej. edades = new int[10];).
3.​ Inicialización: Se asignan valores a los elementos individuales (ej. edades[0] = 19;).
●​ Forma Abreviada: Permite declarar, instanciar e inicializar en una línea.
○​ Sintaxis: type [] array_identifier = {comma-separated_list_of_values}; (ej. String
nombres[] = {"Ana", "Luis", "Sofía"};).

Array args en main

●​ El método main recibe un array de tipo String llamado args[], que almacena los
argumentos pasados al programa desde la línea de comandos.
●​ Si se pasan números como argumentos, se tratan como String y deben convertirse a su
tipo numérico usando métodos estáticos (ej. [Link]()).

Arrays Bidimensionales (Two-Dimensional Arrays)

●​ Un array bidimensional es un "array de arrays", útil para representar matrices o tablas.

●​ Declaración: type [][] array_identifier;.
●​ Instanciación: array_identifier = new type [number_of_arrays][length]; (ej. int[][]
ventasAnuales = new int[5][4];).
●​ Acceso: Se usa un índice para la fila y otro para la columna (ej. ventasAnuales[0][0]).

Shutterstock
Clase ArrayList

●​ A diferencia de los arrays, ArrayList es una clase de lista especializada que no requiere
especificar un tamaño al instanciarla y crece dinámicamente según se añaden
elementos.
●​ Limitación: Solo puede almacenar objetos, no tipos primitivos.
●​ Paquete: Se encuentra en el paquete [Link], por lo que requiere una sentencia import
para ser referenciada directamente.
●​ Métodos: Incluye add(), get(), remove(), etc..

Tema 9: Uso de Constructos de Bucle (Using Loop

Constructs)

Los Bucles (Loops) se usan para repetir un conjunto de sentencias hasta que una condición
sea falsa.

Tipos de Bucles (Loop Types)

1.​ Bucle while (while loop):

○​ Repite mientras una boolean_expression sea verdadera.
○​ La condición se evalúa al inicio, por lo que se ejecuta cero o más veces.
○​ Sintaxis: while (boolean_expression) { code_block; }.
2.​ Bucle for (for loop):
○​ Utilizado principalmente para iterar un número predefinido de veces.
○​ Es compacto y agrupa la inicialización, la condición booleana y la actualización en la
cabecera.
○​ Sintaxis: for (initialize; boolean_expression; update) { code_block; }.
3.​ Bucle do/while (do/while loop):
○​ El cuerpo del bucle se ejecuta al menos una vez antes de evaluar la condición.
○​ La condición se evalúa al final.
○​ Sintaxis: do { code_block; } while (boolean_expression); (El punto y coma final es
obligatorio).
Bucles y Arrays

●​ Iteración Estándar: Los bucles for se utilizan comúnmente para acceder a cada
elemento de un array basándose en su índice, de 0 hasta [Link] - 1.
●​ Bucle for Mejorado (Enhanced for Loop):
○​ Simplifica la iteración a través de todos los elementos de arrays o ArrayLists sin
necesidad de manejar índices.
○​ Sintaxis: for (data_type var : array_name) { code_block; }.

Control de Flujo en Bucles

●​ break: Sale inmediatamente del bucle, continuando la ejecución en la primera sentencia

después del bucle.
●​ continue: Salta el resto del bloque de código actual en el bucle y continúa con la
siguiente iteración (re-evalúa la condición).

Tema 10: Trabajando con Métodos y Sobrecarga de

Métodos (Working with Methods and Method
Overloading)

Creación e Invocación de Métodos (Creating and Invoking Methods)

Los métodos son esenciales para distribuir el trabajo realizado por el programa.
●​ Método Llamador (Caller Method): Invoca a otro método.
●​ Método Trabajador (Worker Method): Realiza el trabajo para el método llamador.

Parámetros y Argumentos
 ●​ Parámetro (Parameter): Variable definida en la declaración del método (ej. int
desiredFloor en setFloor(int desiredFloor)).
●​ Argumento (Argument): Valor pasado durante la llamada al método (ej. 4 en
[Link](4)).

Valores de Retorno (Return Values)

●​ Un método puede devolver a lo sumo un valor de cualquier tipo (primitivo u objeto).

●​ El valor se define en la declaración del método (return_type) y se devuelve usando la
sentencia return.
●​ Si no devuelve nada, se usa void.

Paso de Argumentos por Valor (Passing Arguments by Value)

●​ En Java, todos los argumentos se pasan por valor.

●​ Si se pasa una referencia a un objeto (ej. myShirt), lo que se copia y pasa es el valor de la
referencia (la dirección de memoria).
●​ Aunque la referencia copiada es local al método, ambas referencias apuntan al mismo
objeto, por lo que los cambios realizados al objeto dentro del método son persistentes.

Miembros Estáticos (Static Members)

Los métodos y variables declarados con la palabra clave static pertenecen a la clase (class),
no a una instancia de objeto particular.
●​ Métodos Estáticos (Static Methods / Class Methods):
○​ Se invocan usando el nombre de la clase (ej. [Link]();) sin necesidad de
instanciar un objeto.
●​ Variables Estáticas (Static Variables / Class Variables):
○​ Solo existe una copia de la variable asociada a la clase en memoria.
○​ Se accede usando el nombre de la clase (ej. [Link]).

Sobrecarga de Métodos (Method Overloading)

●​ Permite que una clase tenga múltiples métodos con el mismo nombre, siempre y cuando
tengan diferentes firmas de método (method signatures).
●​ Firma del Método (Method Signature): Es la combinación única del nombre del
método y el número, tipo y orden de sus parámetros.
●​ El tipo de retorno NO forma parte de la firma del método.
●​ Cuando el programa invoca el método sobrecargado, el compilador utiliza el número y
tipo de argumentos pasados para determinar qué versión debe ejecutar.