1

Programación Estructurada (PE) con estructuras: secuencial, decisión, repeticiones y funciones.

Programación Orientada a Objetos (POO): amplía a PE, le incluye:
• Objetos: que representan a cosas reales o imaginarias. Los objetos amplían los tipos de datos
nativos: int, long, float, etc.
• Nuevas estructuras, como: herencia, polimorfismo y modularidad entre aplicaciones.
• Muchos servicios, como: gestión de excepciones (errores), patrones, librerías estándar, etc.
interface gráfica, etc.
• Integración total para el desarrollo de grandes aplicaciones: ubicación física del software,
portabilidad, versionamiento, corrección de errores, etc.

Un programa PE puede ser convertido fácilmente en un programa POO: se mantiene la lógica

(semántica), cambia un poco la sintaxis:
Salida monitor: Hola José y María
PE POO
#include<cstdio> class Saludo{
char nombre1[] = "José"; static String nombre1 = "José";
void saludar(){ static void saludar(){
char nombre2[] = "María"; String nombre2 = "María";
printf("Hola %s y %s\n", nombre1, nombre2); System.out.printf("Hola %s y %s\n", nombre1, nombre2);
} }
int main(){ public static void main(String[] args){
saludar(); saludar();
} }
}

Cambio de vocabulario
Aspecto PE POO
Programa en un lenguaje programa clase
funciones funciones Métodos, que definen el comportamiento del objeto
Tipos de variables int, long, float, ...
int, long, float, …
Clases desarrolladas por los programadores
Variables globales Variables globales atributos
Variables locales (dentro Variables variables
de métodos)
Componente de la clase No aplica Se refiere a un atributo o método
Representación de cosas No hay Objetos

Identificadores para atributos, variables y métodos

• Inicia con letra, _ , o $; continua con: letras, $s, _s, o números.
• Usar hasta 255 caracteres.
• No usar Java keywords.
• Sensible a mayúsculas y minúsculas.
Ejemplos: Invoice, $orderTotal, _orderTotal, input_string, $_64_Valid, TITLE

Keywords
boolean if interface class true
char else package volatile false
byte final switch while throws
float private case return native
void protected break throw implements
short public default try import
 2

double static for catch synchronized

int new continue finally const
long this do transient goto
abstract super extends instanceof null

Definiciones
Indicadores para la sintaxis:
[opcional] : No se escriben [ ], indica que el contenido es opcional
a|b : No se escribe | , indica que se escriba a o b; pero no los dos.

Sintaxis para declarar una clase:

[public|private] class ClassName { // contenido}
[modificadores] nombre

Ejemplo del contenido de una clase

class MiCuadrado{
static int cantidad; // atributo de la Clase Cuadrado
int lado, precio; // atributo de un objeto de tipo Cuadrado.
public static costoTotal(int cantidad){//...} ; // método de la Clase Cuadrado
int area(){//...}; // método de objeto de tipo Cuadrado.
// los métodos pueden contener variables locales: invisibles desde fuera, no usan modificadores.
}

Ejemplo de una clase utilizando el lenguaje Java:

public class SaludoApp{
public static void main(String[] args){
System.out.println("¡Hola mundo!");
}
}
Salida en el monitor: ¡Hola mundo!

En el lenguaje Java se especifica con precisión todos los detalles necesarios de las instrucciones, al
principio esto es tedioso; pero permite integrar: la lógica, las flexibilidades, la completitud físico/lógica:
portabilidad, cambios en la lógica, trabajo en equipos.
Explicación de los detalles:
public : accesible para todos.
class : tipo de componente.
SaludoApp : nombre de la clase.
{…} : bloque de instrucciones.
static : (el método main) no pertenece a objeto.
void : el método main no retorna nada.
main : nombre del método, en ingles, principal.
(String[] args) : main recibe al parámetro args, el cual es un arreglo de tipo String.
System.out.println(..) : la clase System, tiene el objeto out, que tiene el método println("mensaje")
que escribe el mensaje en el monitor.

Reglas para el identificador (nombre) de una clase, atributo, variable y método

1. Clase Inicia con letra mayúscula, atributos/variables y métodos con minúscula.
2. Usar solo letras y dígitos.
3. Seguir las otras reglas de identificadores
4. Use la notación camello.
 3

5. El nombre debe ser significativo (mnemónico): cosa o verboCosa, ejemplos: largo, limpiarLente

5, de 8, Tipos de datos primitivos (nativos, definidos por Java)

Tipo Bytes Uso
int 4 Entero
float 4 Simple precisión, números de punto flotante
double 8 Doble-precisión, números de punto flotante, de uso comercial
char 2 Un caracter Unicode simple
boolean 1 Un valor true o falso

Operaciones con tipos de datos nativos

Operación Sintaxis Ejemplo
Declarar tipo varNombre; int contador;
Asignar VarNombre = valor; Contador = 1;
Declarar y asignar tipo varNombre = value; int contador = 1;
Declarar y asignar int m, n= 100, k;
varias variables

Operación de atributos de tipo MiClase

Una clase (programada por un desarrollador) representa a objetos, puede ser usada en modo análogo a
como se usan las variables de tipo nativo para declarar, asignar valores y usar en diferentes operaciones:
Operación Sintaxis Ejemplo
Declarar variable tipo varNombre; MiClase miOb;
int in; // tipo nativo
Asignar valor VarNombre = miObj; miOb = new MiClase();
in = 4; // tipo nativo
miOb = TuClase.tuMetodo();
in = suma(2,3) // tipo nativo
Declarar y asignar tipo varNombre = MiClase miOb = new MiClase();
valor value; int in = 4; // tipo nativo
Declarar y asignar MiClase ob1 = new MiClase(), ob2 = new MiClase();
varias variables int in1 = 4 , in2 = 8; // tipo nativo

Recomendaciones para el nombre de atributos, variables y métodos

• Iniciar con letra minúscula.
• Usar la notación camello.
• El nombre de un atributo o variable es una cosa, seguida de adjetivo si es necesario.
El nombre de un método representa es un verbo, seguido de un sujeto si es necesario.
• Tratar de usar nombres significativos

Operaciones artiméticas: +, -, *, /, % como en C++

 4

Operaciones con Strings

Operación Sintaxis Ejemplo
Declarar y String varNombre = valor; String nombre = "Alberto";
asignar String apellido = "Campos";
Unir strings String nombreComp = nombre + " " + apellido;
Unir string y double precio = 14.95;
número String CadenaPrecio = "Precio: " + precio;
Uso de += nombreCompleto = “Carlos”;
nombreCompleto += “ “ +”Bazán”;
Secuencias de \n: nueva línea Imprimir las variables:
escape usadas en \t : tabulador "Código: JSP\nPrecio: $49.50" =>
impresión \r: regresa al inicio de línea Código: JSP
\": comillas Precio: $49.50
\\: backslash "Juan\tEspejo\rKaty\tLeyva" =>
Katy Leivao : se superpuso
"Tipee \"x\" para salir" => Tipee "x" para salir
"C:\\java\\files" => C:\java\files

Carpeta -directorio- de trabajo (ct): es una carpeta cualquiera en la cual se ubicará al abrir el aplicativo
terminal. En ct y sus subcarpetas alojará los archivos que utilizará en una sesión de Java.

Paquete es un subconjunto de una carpeta, por el momento asumiremos que paquete es sinónimo de
carpeta. Atento no incluye a las subcarpetas. Un paquete contiene clases que serán utilizadas por otras
clases.
Las carpetas de una ruta se separan por: “/” en el ambiente Terminal, ejemplo: c1/c2
Los paquetes de una ruta se separan por: “.” en el ambiente Java, ejemplo: c1.c2

Paquetes más frecuentes

Paquete Contenido
java.lang Clases fundamentales de Java, incluyendo String; clases que trabajan con datos de
tipo primitivo, incluyendo las clases Integer y Double. Suministrada
automáticamente por Java. Esta clase no se importa.
java.util Clases de utilidades, incluye la clase Scanner para leer del teclado; clase Date para
operación de fechas.
java.text Clases para trabajar con textos, incluyendo la clase NumberFormat para formatear
números.
java.time Clases para trabajar con fechas y horas.
java.io Clases que leen y escriben datos a archivos.

Importar las clases antes de usarlas.

Operación Sintaxis Ejemplo
Importar una clase en import paquete.ClassName; import java.util.Scanner; // para leer datos
un paquete import java.util.Date; // para usar fechas
Importar todas las import paquete.*; import java.util.*;
clases de un paquete
Leer datos (crea el objeto sc):
 5

import java.util.Scanner; // importar al iniciar un archivo .java

Scanner sc = new Scanner(System.in); // crea el objeto sc, System.in es el objeto teclado
Equivalente a las dos anteriores:
java.util.Scanner sc = new java.util.Scanner(System.in);
Leer datos:
sc.nextDouble(); // lee un dato double

Crear objetos y llamar a métodos

Dada una clase MiClase con:
datos (atributos)
métodos (funciones o comportamientos)

Crear objetos
Operación Sintaxis Ejemplos
Declarar la variable mi MiClase mi; Date ahora; // Date opera fechas
(objeto) de tipo MiClase Scanner sc;
asignar valor a mi mi = new MiClase(); 1) ahora = new Date();
// new es un operador 2) sc = new Scanner(System.in);
3) obj = metodo(); // metodo retorna un
// objeto tipo Obj
Crear: Declarar y asignar MiClase mi = new MiClase(); Date ahora = new Date();
valores Scanner sc = new Scanner(System.in);

Llamar métodos de objetos

Operación Sintaxis Ejemplos
Llamar a un método ob.metodo(argumentos) sc.nextDouble(); // lee un dato double
de un objeto ob // objeto inicia con minúscula String fecha = ahora.toString();
Llamar a un método MiClase.metodo(argumentos) // convierte un double a una string
estatic de una clase // Clase inicia con mayúscula String precioSt = Double.toString(precio);

// convierte un string a double

double total = Double.parseDouble(precioSt);
 6

Application Programming Interface (API): Conjunto de clases (programas) para ser utilizadas en otras
clases. Las API se guardan en paquetes (carpetas), buscar en google: Java 18 API documetation:
https://docs.oracle.com/en/java/javase/18/docs/api/index.html . Busquemos, por ejemplo la clase Scanner

Muestra:
Al inicio Más adelante
Resumen de constructores

Resumen de médodos

Detalles

Salida de información al monitor (consola) Se usan 3 métodos:

Descripción Sintaxis del método Ejemplos
Escribe sin formato print(dato); System.out.print("Total: ");
System.out.print(100 + "\n");
=> Total: 100
Escribe sin formato println(dato); System.out.print("Total: ");
y salta de línea System.out.println(100);
=> Total: 100
System.out.println("Total: " + 100);
=> Total: 100
Escribe con formato printf(“formato”, datos); System.out.printf("Total: %.2f\n", 100f);
=> Total: 100.00

Entrada de datos desde el teclado

1) Se importa al incio del archivo:
import java.util.Scanner;
2) Se crea un objeto:
Scanner sc = new Scanner(System.in);
3) Se usa alguno de los métodos de sc para leer del teclado,
Ejemplo, sea la cadena:
“ Juan 12 3.2 Hola José” // Datos tipeados en el teclado, guardados en un buffer.
Un token es una subcadena separada por: inicio, blancos o fin. El String anterior tiene 5 tokens
 7

Métodos de objeto Scanner: uso sc.metodo();

Descripción Sintaxis del Ejemplos
método
Lee token como String next() String nombre = sc.next(); // lee “Juan”
Lee token como int nextInt() int total = sc.nextInt(); // lee 12
Lee token como double nextDouble() double subtotal = sc.nextDouble(); // lee 3.2
Lee todo el buffer o los nextLine() String linea = sc.nextLine(); // lee el resto de la línea
tokens como String // lee “ Hola José” incluye los blancos iniciales

Ejemplo Escriba un programa que ilustre la entrada de datos y salida de información:

Escriba el Código de producto, precio y cantidad: h123 49.50 2 enter
h123: 49.5 x 2 = 99.0 // Salida
Factura.java // Programa
import java.util.Scanner;
public class Factura{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.print("Escriba el Código de producto, precio y cantidad: ");
// tipee: h123 49.50 2 enter → buffer
// leer del buffer
String codigo = sc.next();
double precio = sc.nextDouble();
int cantidad = sc.nextInt();
double total = precio * cantidad;
System.out.println("\n" + codigo + ": " + precio + " x " + cantidad + " = " + total);
}
}

Ejemplo: Leer y escribir dos líneas:

Ingrese la primera cadena: hola muchacho
hola muchacho
Ingrese la segunda línea: hola otra vez
hola otra vez
// Clase de lectura escritura de dos líneas
import java.util.Scanner; // 1) clase scanner para leer
class A{
public static void main(String[] args){
Scanner sc = new Scanner(System.in); // 2) crea un objeto scaner sc
System.out.print("Ingrese la primera cadena: "); // solicita la primera línea : print
String c1 = sc.nextLine(); // 3) escanea (lee) una línea
System.out.println(c1);
System.out.print("Ingrese la segunda cadena: "); // solicita la segunda línea : print
String c2 =sc.nextLine(); // 3) escanea (lee) una línea
System.out.println(c2);
}
}
 8

Operadores relacionales
Operador Nombre Ejemplo
== Igualdad
!= Desiguladad cantidad == 5
cantidad != 0 // true
> Mayor que cantidad >= 9.99 // false
< Menor que cantidad <= puntoReorden
>= Mayor o igual que
<= Menor o igual que

Métodos de objeto para comparar Strings

Sintaxis de método Descripción Ejemplo
equals(String) Compara el valor del objeto String codigo = sc.next(); // tipee h123
cadena con el argumento
del método. codigo.equals("h124") // false
Es case-sensitive.
equalsIgnoreCase(String) Similar al caso anterior. codigo.equalsIgnoreCase("H123") // true
No es case-sensitive !codigo.equals(otroCodigo) // ! operador

Bloque de sentencias
Un bloque agrupa cero o más sentencias dentro de llaves:
Ejemplos:
Bloque sin sentencias: {}
bloque de 3 sentencias: {sent1; sent2, sent3}
Cuando se agrupa una sola sentencia se puede omitir las llaves:
{sent1;} // es equivalente a : sent1;
Estructura de selección // igual que en C++
Sintaxis Descripción
if (boolExpr1) { bloque1 } if boolExpr1== true, se ejecuta bloque1
[else if (boolExpr2) { bloque2 }] ... else if boolExpr2== true, se ejecuta bloque2
[else { bloque3 }] else se ejecuta bloque3
Ejemplos
int total = 123; int total = 123;
double descuento = 0; if (total < 100) descuento = .05;
if (total >= 100) descuento = .1; else if (total < 1000) descuento = .1;
else descuento = .15;
if (total < 100) descuento = .05;
else descuento = .1; if (total < 100) descuento = .05;
else { descuento = .1;
System.out.println("¡Buen descuento...!");
} // 2 sentencias, requiere { }

Estructura de repetición: while // igual que en C++

Sintaxis Descripción
while (booleanExpression) { Mientras (boolExpresion) sea true, ejecutar el bloque
sentencias //bloque
}
 9

Ejemplos
// Ejecutar el bloque mientras el usuario Sumar los 5 primeros enteros
// permita hacerlo:
Scanner sc = new Scanner(System.in); int i=1, suma=0;
String sigue = "s"; while(i<=5) {
while (sigue.equalsIgnoreCase("s")) { suma += i;}
{ System.out.println("uno"); i++;
System.out.println("dos"); }
} // o también:
system.out.print("Sigue s/n: "); int i=1, suma=0;
sigue = sc.next(); // lee siga while(i<=5) suma += i++;
}

Estructura de repetición: do // igual que en C++

Sintaxis Descripción
do { Ejecutar el bloque, mientras se cumpla la
sentencias //bloque booleanExpression
} while (booleanExpression);

Programe la aplicación PromedioApp, la cual solicita números entre 0 y 100; termina cuando se tipea 999
y se imprime la cantidad de números ingresados y el promedio.
La salida en el monitor puede ser:
Ingrese un número entre 0 y 100 (999 para terminar):

Ingrese un número: 2
Ingrese un número: 4
Ingrese un número: 6
Ingrese un número: 999

Cantidad de números ingresados: 3

Suma total: 12
Promedio: 4
import java.util.Scanner;
class PromedioApp{
static Scanner sc = new Scanner(System.in);
public static void main(String args[]){
int num=0, numLeidos = 0, sumaTotal=0;
do{
System.out.print("Ingrese un número entre 0 y 100 (999 para terminar): ");
num = sc.nextInt();
if(num == 999) break;
if(num <0 || num >100) System.out.println("Número fuera de rango");
else{ ;
sumaTotal += num;
numLeidos++;
}
} while(true);
double promedio = (double)sumaTotal / numLeidos;
System.out.println("\n" + "Números leídos: " + numLeidos + "\n" + "Total: " +
 10

sumaTotal + "\n" + "Promedio: " + promedio + "\n");

}
}

Estructura de repetición: for // igual que en C++

Sintaxis Descripción
for(inicio; boolExpre; cambios){ Ejecutar el bloque mientras se cumpla la
sentencias //bloque booleanExpression.
}

Debug (bug ≡ bicho; debug: sacar los bichos del programa, depurar ) un programa en tiempo de
ejecución
Después de compilar un programa, al procesar se pueden presentar dos tipos de error:
• run time exception: El programa se cancele abruptamente y muestre en la consola, un mensaje
de error que indica el número de instrucción en la que sucedió el error: // Se lee de abajo para
arriba
Ingrese un número: 2
Ingrese otro número: tres // run time exception en la línea 10
Exception in thread "main" java.util.InputMismatchException
at java.util.Scanner.throwFor(Scanner.java:864)
at java.util.Scanner.next(Scanner.java:1485)
at java.util.Scanner.nextInt(Scanner.java:2117) // Leer de abajo para arriba
at java.util.Scanner.nextInt(Scanner.java:2076) // método interno llamado en la línea 10
at A.main(A.java:10) // Error en la línea 10 de la clase A y método main()
El cual indica que se a producido una excepción InputMismatchException (una entrada que no
coincide con el tipo de dato) en la línea 10. Para resolver el problema:
Vamos a la línea 10 del programa y encontramos: num = sc.nextInt();
Vemos que en lugar de tipear 3; se tipeó tres
Más adelante aprenderemos a prevenir este tipo de error (bug).

• Resultados incorrectos: Este es un error de lógica del programador, difícil de percibir, no lo

puede corregir el compilador, porque no corrige lógica sino sintaxis.
No se puede probar que el resultado de la ejecución sea correcto para todos los datos de entrada;
pero si se puede comprobar que los resultados sean correctos para valores de entrada críticos, por
ejemplo; si una variable es divisor; se debe verificar que sea distinta de cero antes de dividir. Para
validar todos las entradas críticas se usa una Matriz de Casos de Prueba que tiene la forma:
Caso Entradas (críticas) Salidas (precalculadas) Salidas (computador) Ok (verdad/falso)
(crítico) ent1 ent2 ... sal1 sal2 ... sal1 sal2 ...
1 1 2 3 10 11 12 10 11 12Verdad
2 5 6 7 20 21 22 20 21 24falso
... ….
La columna Ok toma valores:
verdad: si (sal1 y sal2 y … precalculadas) son iguales a (sal1 y sal2 y … computador)
falso : en otro caso
El programa estará validado si todas las filas de Ok son verdad.

Ejemplo, para el programa anterior:

Matriz de casos de Prueba para la clase PromedioApp
Caso Entradas Salidas precalculadas Salidas computador Ok
num Cantidad Suma Promedio CantidadSuma Promedio
1 2 1 2 2.00 1 2 2.00Verdad
 11

2 2, 5, 4 3 11 3.67 3 11 3.67Verdad
3 0 0 No ingresó datos 0 0 NaNFalso
4 tres

En el caso 3 se muestra en el monitor el promedio NaN (Not a Number) en véz de No ingresó

datos. Ok tiene una fila falsa; por lo tanto el programa anterior tiene un error de lógica.
Solución: Antes de imprimir Promedio se debe verificar si cantidad == 0.

En el caso 4 se presenta un run time exception (excepción en tiempo de ejecución) porque el

dato ingresado fue tres:
Ingrese un número entre 0 y 100 (999 para terminar): tres

Exception in thread "main" java.util.InputMismatchException

at java.base/java.util.Scanner.throwFor(Scanner.java:939)
at java.base/java.util.Scanner.next(Scanner.java:1594)
at java.base/java.util.Scanner.nextInt(Scanner.java:2258)
at java.base/java.util.Scanner.nextInt(Scanner.java:2212)
at PromedioApp.main(PromedioApp.java:8) // línea de error
Esto se resuelve validando que el dato sea numérico.