Introducción

a Algoritmos y Java
“Desarrollador Java Inicial”
Java
● Lenguaje de desarrollo de propósito general
● Portable: Funciona en todos los sistemas operativos
● Gran Comunidad y base de un gran número de proyectos
● Maduro
● Orientado a Objetos
● Compilado
Java - Sintaxis Básica - Variables y Tipos de datos primitivos

char unaLetra = 'a';

boolean unValorBooleano = true;
int miPrimerContador = 66;
double unValor = 1.68;
float otroNum = 2.344f;

Importante (Ya veremos qué quiere decir )

● No se le pueden invocar métodos (no tienen)
● Siempre tienen un valor NO nulo
Java - Sintaxis Básica - Operadores y Expresiones

Op Binarias básicas
int miPrimerContador = 66;
double unValor = 1.68;
10 + 20
15 - 12
miPrimerContador + 20
10 * 3
15 - 12
8 / 3
10 * 3
8 % 3 // 2
unValor / 3
2 ** 3 // 8
8 % 3

Precedencia
3 * 2 + 3

(3 * 2) + 3
Java - Sintaxis Básica - Booleanos

Operaciones y predicados
int miPrimerContador = 66;
10 > 20 double unValor = 1.68;
15 >= 12 double otroValor = 1.67;
10 == 3
8 != 3
unValor == (otroValor + 0.01)

boolean unBooleano = true;

boolean otroBooleano = false;

! unBooleano // false
unBooleano && otroBooleano // false Relacionar con condiciones
unBooleano || otroBooleano // true “Monotributo”

unBooleano && (otroBooleano || True) //

true
Java - Sintaxis Básica - Condicionales

if(unValor < otroNum) { char unaLetra = 'a'; unBooleano && (otroBooleano || True)
//una accion switch (unaLetra){ if(unValor < otroNum) {
} case 'b': //una accion
if(unValor < otroNum) { //Hacer A }
//una accion break;
} else { case 'a': int unValor = 1;
//otra accion //Hacer B int otroValor = 2;
} break;
default: boolean unaCond = unValor == (otroValor + 1);
//Hacer Z
}
if(unaCond) {
// hacer algo
}

Relacionar con resolución

de “Monotributo”
Java - Salida Básica - System Out

Todos los lenguajes de programación tienen una forma de enviar información al usuario, ya
sea mediante ventanas o lo que llamamos la “consola”. En este curso, utilizaremos mucho
mostrar contenidos de variables e información usando el comando:

System.out.println(...) Todavía falta para que comprendamos

//Ejemplos por qué hay puntos o que es “System”,
pero rápidamente, hay algo denominado
System.out.println(1) ;
“Clase”, que representa conceptos de
System.out.println(‘a’) ; distinto tipo y ofrece funcionalidades
System.out.println(true) ; varias.
Por ahora simplemente lo usaremos y en
int x = 14;
una pocas clases entenderemos la
System.out.println(x); estructura de lo que estamos usando.
Java - Sintaxis Básica - Bucles

while(condicionX){ int unNum = 10;

//Una Accion while(unNum > 0){
//En algun momento se tiene System.out.println(unNum);
// modificar la condicionX unNum = unNum -1;
} }

for(inicia;condicionX;cambiaElemento){ for(int otroNum=0;otroNum<10;otroNum++){

//Una Accion System.out.println(otroNum);

} }

Relacionar con Programa de

préstamo de herramientas
Arrays y Strings
Sintaxis básica
“Desarrollador Java Inicial”
Agenda

● Arrays
○ Definición
○ Declaración
○ Iteración

● Strings
○ Declaración
○ Uso
○ Métodos principales
Arrays
Definición

Es muy importante en todo algoritmo representar un grupo de elementos. La forma más

simple de hacerlo en todo lenguaje son los Arrays o “Arreglos”. En particular en Java, los
arrays son estructuras de datos que agrupan un conjunto de elementos del mismo tipo:

1 true ‘a’ Elemento número 0 “cero”

37 true ‘c’ Elemento número 1

16 false ‘b’ Elemento número 2

… … …
Etc
Ejemplo de array de números
int numeros[] = new int[3]; // Así se declara un arreglo de enteros

se crea el
se declara array
la variable
1 Elemento número 0 “cero”
numeros[0] = 1; // asignación
numeros[1] = 37; Elemento número 1
37
numeros[2] = 16;
16 Elemento número 2

// También puede inicializarse directo con valores

int numeros[] = new int[]{1,37,16};
Ejemplo de array de números - con
int numeros[] = new int[3]; // Así se declara un arreglo de enteros

1 Elemento número 0 “cero”

numeros[0] = 1;
numeros[1] = 37; Elemento número 1
37
numeros[2] = 16;
16 Elemento número 2

System.out.println(numeros.length)
// imprime por pantalla: 3
// La sintaxis de punto “.” indica que estamos accediendo a una propiedad de
la variable. Lo que vimos como “tipos primitivos” no lo permiten, pero los
arrays tienen una fundamental: “length”, que nos dice el tamaño del array.

for(int indice=0;indice<indice;indice++){
System.out.println(otroNum);// imprime por pantalla cada elemento
}
Java - Sintaxis Básica - Vectores/Arrays básicos
int numeros[] = new int[10];
char letras[] = {'a','b','c'};

numeros[0] = 10;
numeros[5] = 14;

System.out.println(numeros[5] / 7);
//2
for (char letra : letras){
System.out.println(letra);
}
// a
// b
// c
Java - Vectores/Arrays básicos - Importante

● Siempre están numerados desde cero, pero la propiedad “length“ es el tamaño

total del vector. Por ejemplo, si hay un array de 5 elementos, la propiedad
length es 5, pero el índice para acceder al último elemento es el “4”.
● Los arrays son de tamaño fijo. Es decir, si quiero almacenar más elementos,
debo crear un nuevo Array
● Para tener un conjunto de elementos variable, vamos a ver colecciones más
adelante.
Strings
String

● String es el tipo de dato (Clase en realidad, ya veremos de qué se trata) de Java

Para representar cadenas de texto, de cualquier tamaño.
● Todos los lenguajes de programación tienen este dato
● Los Strings se declaran con comillas dobles
String txt1 = "Hola!";
String txt2 = "Chau!";

● Se puede pensar como un array del tipo de dato “char”, aunque como veremos,
tiene muchas operaciones particulares. Por ejemplo para acceder a un carácter
en particular se puede hacer:
txt1.charAt(2); // "l"
String - Operaciones

● Existen numerosas operaciones que se pueden hacer con los strings, vamos a tomar las
variables de ejemplo:
String txt1 = "Hola!";
String txt2 = "Chau!";

● Concatenar Strings con “+”

String txt3 = txt1 + txt2 ; // "Hola!Chau!"
String txt4 = txt1 + " " + txt2 ; // "Hola! Chau!"

● Comparar
txt1.equals(txt2); // false
txt1.equals(txt1); // true
-> notar que NO debe usarse el operador == para comparar Strings

● Largo de un String
txt1.length(); // 5
String - Operaciones
String unTexto = "laLA";

● Pasar a mayúscula o minúscula Es importante notar que

unTexto.toLowerCase() + unTexto.toUpperCase(); // lalaLALA toLowerCase y replace,
NO cambian el valor de
● Indicar si contiene otro string la variable “unTexto”,
sino que retornan un
unTexto.contains("la"); //true nuevo String, que puedo
unTexto.contains("aL"); //true guardar en otra variable
unTexto.contains("La"); //false o imprimir por pantalla.
Por ejemplo se pueden
● Ver si inicia o termina con otra cadena encadenar:
unTexto.startsWith("la"); // true
unTexto.endsWith("LE"); // false "hola que tal?".replace(

● Reemplazar "hola","chau").toUpperCase();

unTexto.replace("la", "le"); // leLA // CHAU QUE TAL?

String - Operaciones - Split

Quizás la operación más usada de String, es “split” el cual convierte un String en un String[ ]
(es decir un array de strings), a partir de un separador. Por ejemplo:

String saludo = "hola que tal?" ;

String[] saludoPartido1 = saludo.split(" ");

// "hola", "que", "tal?"

String[] saludoPartido2 = saludo.split("a");

// "hol", " que t", "l?" --> notar la presencia de espacios

String - Escape y caracteres especiales
Todos los lenguajes de programación cuentan con caracteres “especiales”, ya que hay cosas que o bien no
se pueden escribir, coinciden con palabras reservadas o la sintaxis no las soporta. En el caso de Java, el
caracter especial es la contrabarra “\” ( la barra que no es la de dividido ). Vamos con unos ejemplos:
● Enter / Cambio de línea
"hola que tal?\n" → \n es la forma de hacer un cambio de línea, ya que java
no permite strings multi línea

● Tabulación (no es lo mismo que varios espacios)

"Pedro\t18\tprogramador\n" // \t escribe una tabulación

● Escribir una comilla doble: si con “ declaramos un string, como hacemos para que aparezca en el
medio del texto que queremos escribir?
"hola, \"que tal\" " // con \ decimos que “escapamos” el caracter

● Escribir una contrabarra “\”

"Esto es una contra barra \\ " // con \ escapamos a la \ misma, si lo
imprimimos esto dice:
Esto es una contrabarra \
String - Importante para más adelante

● Para tener una referencia completa de la cantidad de cosas que se pueden

hacer con String, y de paso para ir rompiendo el hielo, puede consultar el
JavaDoc de la misma. Los Javadocs son la forma en la cual se documenta la
referencia del código, sobre todo de las clases base de Java.
● No son “mutables” eso quiere decir que no se puede “cambiar” el valor de un
string, sino que declarar uno nuevo. Esto en principio no parece muy
importante, pero más adelante veremos que hay algunos casos en los que
puede importar
● Si bien aún no vimos el concepto de herencia, es importante marcar que no se
puede crear una clase heredar del tipo de dato String
Programas y Archivos
“Desarrollador Java Inicial”
Mirando una función principal o “main”
Cuando desarrollamos, es muy común que necesitemos reutilizar parte de nuestros programas. Por
ejemplo, en el ejercicio de la guía: “dado un vector de números, y un número X, que sume todos los
números > X y retorne el resultado”, probablemente planteamos algo así:

public class Sumatoria {

public static void main(String[] args) {
int numeros[] = new int[] { 1, 37, 16 };
int resultado = 0;
for (int i = 0; i < numeros.length; i++) {
resultado = resultado + i;
}
System.out.println(resultado);
}
}
Por un lado, si quiero cambiar lo que debo calcular, tengo que modificar la variable números, por el otro, el
resultado se imprime por pantalla y se “pierde” al final del programa.
Primer función reutilizable
Ahora, vamos a suponer que quiero calcular un promedio. Pero, suponiendo que no quiero perder el trabajo que ya
Una forma de hacerlo es volver a escribir el “main”: tengo, conceptualmente sería usar el codigo que use para
sumar y dividirlo por su largo
public class Promedio {
public static void main(String[] args) { public class Promedio {
int numeros[] = new int[] { 1, 37, public static void main(String[] args) {
16 }; int numeros[] = new int[] { 1, 37, 16
int resultado = 0; };
for (int i = 0; i < int resultado = sumatoria(numeros);
numeros.length; i++) { resultado = resultado /
resultado = resultado + i; numeros.length;
} System.out.println( resultado );
resultado = resultado / }
numeros.length; }
System.out.println( resultado );
}
}

La pregunta es como representamos esa “sumatoria(numeros)”, para utilizarla en nuestro programa de promedios.
Primer función reutilizable
Entonces queda algo así:

public class Promedio {

public static void main(String[] args) {
int numeros[] = new int[] { 1, 37, 16
};
int resultado = sumatoria(numeros); Vemos entonces la función sumatoria, que recibe la
resultado = resultado / variable números (puede llamarse con cualquier valor) y
numeros.length; retorna un valor en la variable suma que se almacena en la
System.out.println( resultado );
variable “resultado” dentro de main.
}
Las entradas de las funciones se denominan
private static int sumatoria( int[] parámetros, en el caso de sumatoria, el único es
numerosASumar )
numerosASumar. Las funciones pueden tener ninguno o
{
int suma = 0;
más parámetros.
for (int i = 0; i <
numerosASumar .length; i++) {
suma = suma + i;
}
return suma;
}
Archivos - Operaciones - Utilidades
Por su importancia, prácticamente todos los lenguajes de programación poseen la forma de acceder al
sistema de archivos, en el caso de Java, en esta unidad hablaremos de las clases “Files” y “Path”, nos
enfocaremos sobre los archivos de texto y su lectura secuencial.
Nuevamente, si bien no llegamos a ver el concepto de clase, los vamos a tratar como utilidades para
cumplir nuestros objetivos.
Primero que nada, antes de usar estas clases, es necesario importarlas, para que sean más fáciles de
referenciar, para eso, antes de la declaración de nuestra clase principal, vamos a importarlas:

import java.nio.file.Files;

import java.nio.file.Path;
El código mostrado en esta
public class MiPrograma {
PPT funciona con la
versión 17 de la JDK
public static void main(String[] args) {

//...
Archivos - Operaciones - Lectura
Lectura de las líneas de un archivo

Files.readAllLines(Paths.get("C:\\Users\\JuanPablo\\unArchivo.txt" )
- De esto hay varios comentarios para hacer

1) Paths.get("...") prepara la ruta ingresada para que la pueda aceptar el método

readAllLines

2) readAllLines recibe la ruta generada por Paths.get y retorna una lista de Strings. Aún no vimos
ese tipo de dato, pero sabemos que puede ser iterado. Por ejemplo:

String archivo = "C:\\Users\\JuanPablo\\unArchivo.txt" ;

for (String linea : Files.readAllLines(Paths.get(archivo))){
System.out.println(linea);
}

1) Esta forma es útil siempre y cuando el archivo no sea muy grande (unos pocos megas)
Archivos - Operaciones - Escritura

Lectura de las líneas de un archivo

Files.writeString(Paths.get("/home/eze/nuevoArch" ), "hola\n que tal?\n" );

writeString recibe la ruta generada y como segundo parámetro un String con contenido. Nuevamente,
este método es efectivo, cuando el String a escribir no es muy grande.
Manipulación de archivos, creación e información extra
Path unArchivo = Paths.get("../recursos/algo.txt");
System.out.println(unArchivo.toAbsolutePath());

FileTime lastModifiedTime = Files.getLastModifiedTime(unArchivo);

System.out.println(lastModifiedTime);

Path otroArch = Paths.get("../recursos2/algoQueNoExiste.txt");

System.out.println(Files.exists(otroArch));
Files.createFile(otroArch);
System.out.println(Files.exists(otroArch));

Path unTemporal = Files.createTempFile("unPrefijo",".txt");

System.out.println(unTemporal);

System.out.println( Files.isDirectory(unTemporal) ); https://docs.oracle.com/en/java/java

Files.copy(arch1, arch2); se/13/docs/api/java.base/java/nio/fil
Files.move(arch1, arch3); e/Paths.html
Encoding

Path utfFile = Files.createTempFile("some", ".txt");

Files.write(utfFile, "un texto \n con eñes ".getBytes()); // UTF 8

Files.write(utfFile, (System.lineSeparator() +
"y acentos á ").getBytes(),StandardOpenOption.APPEND);

System.out.println(Files.readAllLines(utfFile) .size());

for (String line: Files.readAllLines(utfFile) ) {

System.out.println(line);
}

Path iso88591File = Files.createTempFile("some", ".txt");

StandardOpenOption y
StandardCharsets son Enums o
Files.write(iso88591File, "otro texto con eñes".getBytes(StandardCharsets.ISO_8859_1));
valores enumerados, por ahora
solo diremos que son fijos y
no se pueden cambiar.
Parámetros de comando
Cuando se inicia un programa cualquiera, al mismo se le pueden pasar parámetros. En el caso de Java, si al
programa se la pasan, este los leerá desde la variable args en main. Los parámetros pueden ser cualquier
string y en cualquier cantidad.

public class Sumatoria {

public static void main(String[] args) {
int resultado = 0;
for (int i = 0; i < args.length; i++) {
int numero = Integer. parseInt(args[i]);
resultado = resultado + numero;
}
System.out.println(resultado);
}
}
Leer de consola
import java.util.Scanner;

public class Ejercicio1 {

public static void main(String[] args) {

Scanner scn = new Scanner(System.in);
System.out.println( Otra forma de ingresar datos a un
"Ingrese números separados por UN programa es mediante la consola,
espacio"); en este ejemplo el programa nos
String numeros = scn.nextLine(); pedirá que escribamos algo y
int resultado = 0;
apretemos la tecla “enter” para
for (String numeroStr : numeros.split(" ")) {
int numero = Integer.parseInt(numeroStr); terminar
resultado = resultado + numero;
}
System.out.println(resultado);
}
}
Introducción a la programación
OO en Java
“Desarrollador Java Inicial”
Clases y Objetos - Definición
Para representar conceptos más complejos utilizaremos clases y objetos:

● Una clase es la representación de una entidad o concepto, la cual posee atributos (concepto similar a
variable) y métodos ( concepto similar a función). Sin embargo la clase describe características
generales
● La forma más sencilla de definir un objeto, es describirla como una instancia de una clase. Es decir,
posee las características generales de la misma, pero con valores concretos
 Clases y Objetos - Java
El paquete de una clase se declara en la primer línea y permite que existan
package ar.edu.utn;
varias clases con el mismo nombre
import java.time.LocalDate; Los import permiten utilizar clases de otros paquetes más convenientemente

public class Producto { Nombre de la clase

private String nombre;

private String descripcion;
private LocalDate fechaAlta; Atributos, todos los objetos de una misma clase tienen los mismos atributos, pero con
private Integer pesoKg; distintos valores
private Double precio;

private static final Double minPrecio = 0.1; Atributos de clase o estáticos, su valor es compartido por todos los
objetos de la clase
public Producto(String nombre) {
this.nombre = nombre; Constructor, se utiliza para crear objetos de la clase en cuestión. En
this.fechaAlta = LocalDate.now(); este caso si queremos crear un nuevo producto la sintaxis es:
this.precio = minPrecio; Producto prod = new Producto("Atún");
}

public String getNombre() { Métodos de instancia, funciones que se ejecutan en el contexto del
return this.nombre; objeto. Con la palabra clave “this” se accede al estado (valores de los
} atributos) de un objeto en particular. Por ejemplo, el método
public String getDescripcion() { prod1.getNombre( ) y prod2.getNombre( ) retornan el valor
return this.descripcion; correspondiente a su instancia.
}
public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
}
}
Clase
● Comportamiento y atributos (no valores) compartidos por un conjunto de objetos. Los atributos son
de una clase o tipo primitivo determinado

● Elementos de Instancia:
○ Variables: tienen un valor distinto por Objeto
○ Métodos: código a ejecutar, tiene acceso a variables de instancia

● De Clase o Estáticos
○ Variables: compartida por todos las instancias de una clase
○ Constantes: Variable de clase que no se puede cambiar en tiempo de ejecución, hay que recompilar.
○ Métodos: código a ejecutar, no está asociado con una instancia en particular
○ Por ejemplo:

■ LocalTime.now()
■ Integer.parseInt("1234")
■ Math.abs(-37)
Objetos
● Un objeto es una instancia de una determinada Clase
● Todo objeto se crea a través de un constructor. Con Java, el mismo se llama utilizando la palabra reservada new. Si no
se declara ninguno, por defecto tienen un constructor vacío. Si se declara uno con parámetros, el constructor vacío
debe declararse explícitamente.

public class Producto {

public Producto(String nombre) {

this.nombre = nombre;

public Producto() {

Producto prod = new Producto("Atún");

● Para utilizar un método de un objeto, decimos que al mismo se le envía un “mensaje”. Para representar esto, se pone
un punto “.” luego de una variable referenciando un objeto:
objetoX.metodo(param1,param2,...)
Clase - Visibilidad / Alcance
● Público: atributos o métodos pueden ser utilizados por instancias de cualquier clase.

● Protected: atributos o métodos pueden ser utilizados sólo por instancias de la misma clase o sus
subclases.

● Paquete: atributos o métodos pueden ser utilizados sólo por instancias de clases que están en el
mismo paquete. (propio de Java)

● Privado: atributos o métodos pueden ser utilizados sólo por instancias de la misma clase.

private String nombre;

public String getNombre()

Alcance o scope
Herencia en java
“Desarrollador Java Inicial”
Clase - Herencia
● Concepto: Si X hereda de Y, “una instancia de X es también una instancia de Y”. Por ejemplo:
○ Un Perro es un Mamífero
○ Un Docente es un Empleado y un Empleado es una Persona

● Herencia Simple
○ Una clase puede heredar sólo de una

● En Java:
○ Se heredan los atributos y métodos de instancia
○ Todas las clases heredan de la clase Object
○ Los atributos / métodos de clase no se heredan
○ Los constructores no se heredan
 public abstract class Descuento {

Clase - Herencia - Ejemplo private float valor;

public float getValorDesc() {
return valor;
Por ejemplo, aquí tenemos una jerarquía de }
public void setValorDesc(float valor) {
descuentos. Hay 2 descuentos, el “fijo” y por this.valor = valor;
“porcentaje”. Los objetos pueden ser instancia }

de uno u de otro, no de los 2.

public abstract float valorFinal(
float valorInicial);
}
------------------------
public class DescuentoFijo extends Descuento {
@Override
public float valorFinal(float valorInicial) {
return valorInicial - this.getValorDesc();
}
}
--------------------
public class DescuentoPorcentaje extends Descuento {
@Override
public float valorFinal(float valorInicial) {
return valorInicial - (valorInicial *
this.getValorDesc());
}
}
 public abstract class Descuento {

Clase - Herencia - Ejemplo private float valor;

public float getValorDesc() {
return valor;
Agrandando vamos a suponer que tenemos un }
public void setValorDesc(float valor) {
producto this.valor = valor;
}
public abstract float valorFinal(
float valorInicial);
Descuento desc1 = new DescuentoFijo(); }
------------------------
desc1.setValor(14.0);
public class DescuentoFijo extends Descuento {
System.out.println(desc1.valorFinal(100)); // 86
@Override
//-----------------------------
public float valorFinal(float valorInicial) {
Descuento desc2 = new DescuentoPorcentaje();
return valorInicial - this.getValorDesc();
desc2.setValor(0.3);
}
System.out.println(desc2.valorFinal(100)); // 70
}
--------------------
public class DescuentoPorcentaje extends Descuento {
@Override
public float valorFinal(float valorInicial) {
return valorInicial - (valorInicial *
this.getValorDesc());
}
}
Clase Object de Java
● En Java todas las clases heredan de la clase Object

● La misma tiene varios métodos, que por lo que establecimos antes, los van a compartir TODOS los
objetos que creemos. En principio hablaremos de estos 2:
○ toString:
■ Muestra una representación en String del objeto
■ Orientado al desarrollador
■ X defecto muestra el nombre de la clase y el “identificador” del objeto
○ equals
■ Determina si 2 objetos son “iguales”
■ X defecto es una operación de identidad

● En general, una subclase puede “sobreescribir” la implementación de su padre (especializar el

comportamiento). En particular es conveniente sobreescribir estos 2 métodos.
Interfaces

● Contrato a cumplir
● Sin estado
● Se pueden implementar múltiples
● Se pueden definir constantes
● Semánticamente != heredar

public class ProcesadorProducto

implements UnaInterface {
@Override
public void hacerAlgo(Producto p) {
//hacer algo….
public interface UnaInterface {
}
public void hacerAlgo(Producto p);
public Producto obtenerProducto(String nombre); @Override
} public Producto obtenerProducto(String nombre) {
//retornar algo
return algo;
}
}
Excepciones y Colecciones en Java
“Desarrollador Java Inicial”
Tipos de errores
¿ Qué tipos de errores pueden ocurrir durante la ejecución de un programa / aplicación?
Situación inesperada

En Java ambos se implementan a

través de excepciones o Exceptions
Error de negocio /
Flujos alternativos

Situaciones que tengo en cuenta durante el desarrollo:

● Login incorrecto
● Datos en formato incorrecto
● Modificar los datos de una persona dada de baja
● El archivo necesario no existe
● El mensaje no puede llegar a destino
● etc...
Códigos de error

Primero vamos a ver las siguientes implementaciones

● Login#ingresar(usuario,password): int -> 1 Login ok 2 login error

● RepoUsuario#modificar(usuario):String -> ok, usuario no existe, nombre en formato incorrecto,
apellido vacío , … etc

Este es un mecanismo indicado para cuestiones sencillas (por ejemplo en la mayoría de los SO un proceso
que termina correctamente retorna cero y si hay algún error cualquier otro número), pero cuando las
situaciones de error son más complejas son poco adecuadas
Excepciones

Mecanismo utilizado por diversos lenguajes

de programación para generar y manejar los
errores durante la ejecución de un proceso.

En este ejemplo, lo rojo nunca se ejecuta y el

programa se corta ante la excepción de
SinStockException
Implementación
1. Crear una clase que herede de Exception o RuntimeException
public class NoHayStockException extends Exception {
private final Producto producto ;
public NoHayStockException(Producto producto ) {
this.producto = producto ;
}}

1. Arrojar la Excepción
public class ItemCarrito {
public float precio() throws NoHayStockException {
if (!producto.hayStock()) {
throw new NoHayStockException(producto);
}
return this.cantidad * this.producto.getPrecio();
}}
Implementación
3. “Subir” la Exception
public class CarritoCompra {
public float precio() throws
NoHayStockException {
return item1.precio() + item2.precio()
+ item3.precio();
}
}
4. Tratar la excepción
public static void main(String[] args) {
CarritoCompra carrito = new CarritoCompra();
// Se arma el carrito …
try {
Float precio = carrito.precio();
System.out.println("el precio del carrito es: " + precio.toString());
} catch (NoHayStockException e) {
System.out.println("No hay stock de al menos uno de los productos"
);
}
}
Excepciones Comunes
Java y algunas librerías base, ya establecieron excepciones
comunes y algunas de ellas deberían ser utilizadas o
heredadas antes de crear otras.

No chequeadas

● NullPointerException
● DivisionByCeroException
● IllegalStateException

Chequeadas

● FileNotFoundException
● IOException

….
Para tener en cuenta

● No siempre es fácil determinar cuándo crear una excepción

● Depende un poco de mi marco de referencia, pero en general hay que pensar que errores un “usuario”
puede llegar a cometer (olvidarse de la UI)

● ¿Qué tan específico ser con las excepciones?

○ Mientras más preciso se es, más fácil es saber QUÉ SALIÓ MAL
○ También tener en cuenta que las excepciones pueden tener datos asociados

● ¿Cuántas Crear?
○ Tampoco sirve tener muchos tipos de error…
○ No se puede tener en cuenta todo
Gestión de dependencias
“Desarrollador Java Inicial”
Dependencias de Software

¿Qué es una dependencia?

No siempre queremos desarrollar desde cero toda lógica de nuestro

Sistema, sino que intentamos reutilizar componentes ya creados,
probados y utilizados por gran parte de la comunidad.

Claro está que esto nos ahorra tiempos y costos.

Dependencias de Software

¿Qué es una dependencia?

• Podríamos decir que una dependencia es una biblioteca hecha por

terceros que voy a tener disponible para utilizar en mi proyecto.
Gestores de Dependencias
¿Qué es un Gestor de Dependencias?

• Un Gestor de Dependencias es un Sistema que se encarga, entre

otras cosas, de gestionar todas las dependencias de un proyecto de
Software para que no tengamos que hacerlo nosotros mismos de
forma manual.

• Si lo hiciéramos de forma manual tendríamos que encargarnos de

mantener actualizadas todas las bibliotecas y las bibliotecas de las
cuales éstas dependen.
Gestores de Dependencias
Maven - ¿Qué nos resuelve?

● Creación automática de los proyectos para poder importarlos desde

un IDE.

● Automatización de tareas de compilación/ejecución de

test/cobertura, etc.

● Manejo de las dependencias de nuestro proyecto.

Maven - ¿Cómo funciona?
En el directorio raíz del proyecto se deberá crear un archivo con el nombre
pom.xml

En su versión más básica se parecerá a esto:

<project>
<modelVersion>4.0.0</modelVersion>
<groupId>nombre-proyecto</groupId>
<artifactId>nombre-proyecto</artifactId>
<version>1</version>
</project>
Maven - ¿Cómo usarlo?

¿Cómo uso Maven para importar mi proyecto desde Eclipse o IntelliJ?

Maven - ¿Cómo usarlo?

Para Eclipse: mvn eclipse:clean

Para IntelliJ: mvn idea:clean

Sirve para borrar cualquier configuración del

proyecto anterior.
Maven - ¿Cómo usarlo?

Para Eclipse: mvn eclipse:eclipse

Para IntelliJ: mvn idea:idea

Crea la configuración del proyecto.

Maven - ¿Cómo usarlo?
Para Eclipse: mvn eclipse:eclipse -DdownloadSources=true
-DdownloadJavadocs=true

Para IntelliJ: mvn idea:idea -DdownloadSources=true

-DdownloadJavadocs=true

Crea la configuración del proyecto y baja el código fuente de las

bibliotecas utilizadas.
Maven – pom.xml
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>proyecto</groupId>
<artifactId>proyecto</artifactId>
<version>0.0.1-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
Maven - ¿Cómo usarlo?

● mvn clean: Borra todos los archivos compilados que existan.

● mvn compile: Compila todo el código fuente.

Maven - ¿Cómo usarlo?

● mvn test: Primero compila todo el código fuente si no estuviera

compilado y luego ejecuta los tests.

● mvn install: Ejecuta todos los pasos anteriores (compile, test,

etc) y además junta el código compilado en un archivo .jar y deja la
biblioteca disponible en mi sistema para que la pueda utilizar algún
otro proyecto.
Maven - ¿Cómo agrego dependencias?

Las dependencias en Maven se agregan en el archivo pom.xml

Maven - ¿Cómo agrego dependencias?
<project>
……………………….
<!-- Dependencias -->
<dependencies>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

</dependencies>
……………………….
</project>
Maven - ¿Cómo agrego dependencias?

● Si ya habías importado el proyecto en Eclipse, acordate de hacer

mvn eclipse:eclipse y refrescar el proyecto para que tome los
cambios.

● Si ya habías importado el proyecto en IntelliJ, acordate de hacer

mvn idea:idea y refrescar el proyecto para que tome los cambios.
Persistencia Relacional
“Desarrollador Java Inicial”
Agenda

● DB Relacionales
○ Introducción
○ Tipos
○ Relacionales
○ Relaciones
○ Claves

● Introducción SQL
○ Definición de Datos (DDL)
○ Manipulación de Datos (DML)
○ Consultas (DQL)
DB Relacionales
DB Relacionales - Introducción

Según la RAE:

“Conjunto de datos organizado de tal modo que

permita obtener con rapidez diversos tipos de
información.”
Según Oracle:

“Una base de datos es una colección organizada de

información estructurada, o datos, típicamente
almacenados electrónicamente en un sistema de
computadora”
DB Relacionales - Tipos
DB Relacionales - Relacionales

● Las bases de datos relacionales se popularizaron en los años ochenta.

● Los elementos de una base de datos relacional se organizan como un
conjunto de tablas con columnas y filas.
● La tecnología de base de datos relacional proporciona la manera más eficiente
y flexible de acceder a información estructurada.
 DB Relacionales - Relacionales

https://db-engines.com/en/ranking
DB Relacionales - Relacionales

Entidades
Relaciones
DB Relacionales - Relacionales
DB Relacionales - Relaciones
DB Relacionales - Claves

Clave Primaria (PK) → Las claves primarias (Primary Key) son las que
identifican de manera única cada fila o registro de una tabla, es decir, que no
se puede repetir en una tabla el valor de un campo o columna que se le es
asignado como PK.

Clave Foránea (FK) → Una clave foránea (Foreign Key) es un campo de una
tabla “X” que sirve para relacionar con otra tabla “Y” en la cual el campo de
esta tabla es una clave primaria (PK). Esta clave nos permite mantener la
integridad referencial en la base de datos.
Introducción
SQL
Introducción SQL

● SQL no es un lenguaje propietario sino que es compatible con la mayoría de los

motores de base de datos relacionales.

● Dentro de SQL, existe entre otros un lenguaje de definición de datos (DDL) y un lenguaje
de manipulación de datos (DML).

“SQL es un lenguaje de dominio específico

utilizado en programación, diseñado para
administrar, y recuperar información de sistemas
de gestión de bases de datos relacionales”
Introducción SQL

PRINCIPALES
Introducción SQL - Definición de Datos (DDL)

Se basa en tres instrucciones que se utilizan sobre los

diferentes tipos de objetos de la base de datos: CREATE,
ALTER y DROP. Instrucciones más utilizadas:
● Operaciones sobre tablas: CREATE TABLE, ALTER
TABLE, DROP TABLE.
Introducción SQL - Definición de Datos (DDL)

Nombre de la tabla
CREATE TABLE idioma (
id INT(11),
codigo VARCHAR(45), Tipo de dato
nombre VARCHAR(45)
)

Nombre de la columna
Introducción SQL - Manipulación de Datos (DML)

Abarca las operaciones que se realizan para el

mantenimiento de la base de datos. Podés especificar
qué hacer con los datos: ingresarlos, modificarlos o
eliminarlos.
Las operaciones son:
● Carga de información (INSERT)
● Modificaciones (UPDATE)
● Borrados selectivos (DELETE)
Introducción SQL - Consultas (DQL)

Nombre de la tabla Nombre de columnas

INSERT INTO estudiante (nombre, apellido, edad)

VALUES (“Juan”, “Perez”, 22);

Valores a insertar
Introducción SQL - Consultas (DQL)

Nombre de la tabla

Columnas y Valores a actualizar

UPDATE estudiante
SET nombre = “Pedro”, apellido = “Escobar”
WHERE idEstudiante = 1;

Condición
Introducción SQL - Consultas (DQL)

Nombre de la tabla

DELETE FROM estudiante

WHERE idEstudiante = 2;

Condición
Introducción SQL - Consultas (DQL)

¿Qué es una Query?

Es una pregunta que le haces a la base de datos. Si alguno de los
datos en la base de datos satisface las condiciones de la
pregunta, SQL recupera esos datos.
Introducción SQL - Consultas (DQL)

Nombre de columnas

SELECT nombre, apellido, edad

FROM estudiante
Nombre de la tabla
WHERE edad > 20;

Filtro de filas
 JDBC
“Desarrollador Java Inicial”
JDBC
● JDBC (Java Database Connectivity) conecta una aplicación Java a una fuente de datos como
puede ser una DB.

● Es una API que es usada para:

○ Conectar a una fuente de datos
○ Enviar consultas y actualizaciones
○ Recupera y procesa el resultado

● JDBC utiliza drivers para conectarse a la DB.

Java Data
JDBC
Application Source
JDBC - API

● Application Programming Interfaces

● Es un conjunto de definiciones y protocolos que se utiliza para desarrollar e

integrar el software de las aplicaciones, permitiendo la comunicación a través
de un conjunto de reglas.
JDBC - API

JDBC
SQLite driver SQLite

JDBC Diver Manager

Java JDBC JDBC
Application API JavaDB driver JavaDB

JDBC
… driver …

DBMS
Database Management System
JDBC - API
● JDBC (Java Database Connectivity) conecta una aplicación Java a una fuente de datos como
puede ser una DB.

● Es una API que es usada para:

○ Conectar a una fuente de datos
○ Enviar consultas y actualizaciones
○ Recupera y procesa el resultado

● JDBC utiliza drivers para conectarse a la DB.

Java Data
JDBC
Application Source
JDBC - Implementación

● JDBC Driver es un componente de software que habilita

a la aplicación java a interactuar con la DB.

● Existen 4 tipos de Drivers JDBC

○ JDBC-ODBC bridge driver

○ Native-API driver
○ Network Protocol driver
○ Thin driver
JDBC - Implementación
Para interactuar con una DB debemos considerar 5 pasos:

01 Registrar driver

02 Crear conexión

03 Crear sentencia

04 Ejecutar consulta

05 Cerrar conexión
JDBC - Implementación

1. Registrar la ‘clase’ del driver - Este método se utiliza para registrar la clase que se utilizará como driver.

Sintaxis del método forName() method

public static void forName(String className)throws ClassNotFoundException

2. Crear el objeto de conexión - Este método se utiliza para establecer conexión con la DB.

Sintaxis del método getConnection() method

public static Connection getConnection(String url, String username, String password)throws SQLException

3. Crear la sentencia - Este método es usado para crear la sentencia.

Esta sentencia es la responsable de ejecutar las consultas a la DB.

Sintaxis del método createStatement() method

public Statement createStatement()throws SQLException
JDBC - Implementación

4. Ejecutar consulta - Este método devuelve el resultado de una consulta (filas).

Sintaxis del método executeQuery() method
public ResultSet executeQuery(String sql)throws ClassNotFoundException

5. Cerrar la conexión - Este método finaliza la conexión con la DB.

Sintaxis del método close() method
public void close()throws ClassNotFoundException
JDBC - Conexión

Para conectarnos a una DB (por ej. mysql) debemos conocer la siguiente información:

1. ‘Clase’ del driver: La clase para el driver de mysql es com.mysql.jdbc.Driver

2. URL de conexión: jdbc:mysql://localhost:3306/dbname

● “jdbc” es la API
● “mysql” es la DB
● “localhost” es el nombre del servidor (se puede utilizar la dirección IP)
● “3306” es el número de puerto
● “dbname” es el nombre de la DB

3. Nombre de usuario: el usuario por defecto en mysql es root

4. Password: la contraseña asociada al usuario

JDBC - Conexión

Ejemplo de conexión con mysql

import java.sql.*;
class MysqlCon{
public static void main(String args[]){
try{
Class.forName("com.mysql.jdbc.Driver");
Connection
con=DriverManager.getConnection("jdbc:mysql://localhost:3306/dbname","root","password");
Statement stmt=con.createStatement();
//USO DE LA DB
con.close();
} catch(Exception e){ System.out.println(e);}
}
}
JDBC - Consultas

Para realizar consultas a una DB utilizaremos los métodos de la interfaz Statement.

Los métodos más comunes son:
1. public ResultSet executeQuery(String sql): utilizado para ejecutar sentencias
SELECT. Devuelve un ResultSet.

2. public int executeUpdate(String sql): utilizado para ejecutar sentencias

CREATE, DROP, INSERT, UPDATE, DELETE, etc.
JDBC - Consultas

Ejemplo de Statements con mysql

import java.sql.*;
class FetchRecord{
public static void main(String args[])throws Exception{
Class.forName("com.mysql.jdbc.Driver");
Connection
con=DriverManager.getConnection(“jdbc:mysql://localhost:3306/dbname","root","password”);
Statement stmt=con.createStatement();

ResultSet rs=stmt.executeQuery("select * from emp");

while(rs.next())
System.out.println(rs.getInt(1)+" "+rs.getString(2)+" "+rs.getString(3));

int result=stmt.executeUpdate("delete from emp where id=33");

System.out.println(result + " records affected");
con.close();
}
}
Git y GitHub
“Desarrollador Java Inicial
Agenda

Repositorios
¿Para qué se (públicos –
¿Qué es GIT? ¿Cómo se usa?
usa? privados, local
–remoto)

Instalación en el Configuraciones Comandos

GitHub
SO Globales básicos
¿Qué es GIT?

Git es un herramienta de control de versiones (o sistema de

versionado).

Una herramienta de control de versiones lleva adelante la gestión de

los diversos cambios que se realizan sobre los elementos de algún
código fuente.
¿Qué es GIT?

Un Sistema de Control de Versiones es un sistema que registra los

cambios realizados en un archivo o conjunto de archivos a lo largo del
tiempo, de modo que se puedan recuperar versiones específicas más
adelante.
¿Para qué se usa?

● Compartir código con otras personas.

● Tener un historial de los cambios realizados en el código.

¿Para qué se usa?
Git nos permite:

● Tener un historial de cambios

● Saber quién los hizo y cuándo

● Resolver los conflictos que surjan cuando dos o más personas

modifiquen el mismo archivo (merge)
Repositorios

Un repositorio es un espacio, en la nube, que tenemos asignado para

poder alojar todos los archivos de nuestro proyecto.

Un repositorio es el lugar donde van a estar todos los commits que

forman parte del historial del proyecto.
Repositorios locales y remotos

● GIT trabaja con un repositorio local que está en nuestro equipo,

donde iremos agregando nuestros commits.

● También trabaja con uno remoto en el cual podemos subir nuestros

commits o del cual podemos bajarnos los commits que haya subido
alguien.
¿Cómo se usa?
1. Creamos/borramos/modificamos archivos en una carpeta asociada a un
repositorio (localmente, en nuestro S.O)

1. Seleccionamos los archivos que van a ser parte de un commit.

1. Confirmamos el commit para agregarlo al repositorio.

1. Subimos los commits de nuestro repositorio local al repositorio remoto.

¿Cómo se usa?
GitHub

Existen diferentes plataformas web que implementan y brindan un

Sistema de Versionado de Archivos basados en GIT.
Entre ellos se encuentran:

● GitHub
● GitLab
● Bitbucket
● Gogs
GitHub

También existe la posibilidad de instalar nuestro propio servidor de

GIT, con nuestra propia interfaz gráfica personalizada.

Muchas empresas realizan y usan sus propias instalaciones de

plataformas basadas en GIT, para que el código alojado esté 100% en
su poder y no “en manos de otros”.
GitHub
GitHub y GitLab son dos de las plataformas más utilizadas, junto a
Bitbucket.

Tanto GitHub como GitLab ofrecen repositorios públicos y privados

gratuitos.

Ambas plataformas cuentan con funcionalidades exclusivas por las

cuales hay que pagar. Es por ello que ofrecen tres posibles
suscripciones: free, team (GitHub)/premium (GitLab) y Enterprise
(GitHub)/Ultimate (GitLab)
Instalación en el Sistema Operativo

Para poder utilizar GIT en nuestro equipo necesitamos tener instalado

un cliente de dicho sistema.

El cliente puede tener una interfaz gráfica o puede ser accesible

únicamente mediante la línea de comandos.
Instalación en el Sistema Operativo

● “GIT” es un cliente de GIT que nos permite acceder desde la línea de

comandos de cualquier terminal a las funcionalidades brindadas por
dicho sistema de versionado.

● También instala su propia terminal llamada Git Bash.

● Además, trae un GUI Client muy sencillo y básico.

Instalación en el Sistema Operativo

El link a su sitio de descargas es:

https://git-scm.com/downloads
Instalación en el Sistema Operativo

● Un GUI Client recomendado por sencillez y facilidad de uso es

GitHub Desktop.

● GitHub Desktop tiene soporte para Windows y macOS.

Instalación en el Sistema Operativo

El link a su sitio de descargas es:

https://desktop.github.com/
Configuraciones Globales

Luego de haber instalado algún cliente de GIT en nuestro equipo,

debemos realizar mínimamente las siguientes dos configuraciones:

git config --global user.name "TU NOMBRE"

git config --global user.email "TU DIRECCION DE EMAIL

Git Clone

git clone <url_repositorio_remoto>

Permite clonarnos un repositorio remoto.

En el caso de que el repositorio sea privado, debemos tener el

correspondiente acceso y permiso para descargarlo (debemos tener el
rol de “propietario” o formar parte de los “colaboradores”).
Git Status

git status

Debe ejecutarse en una terminal situados en la raíz de un repositorio

clonado (o descargado).

Permite saber si se realizaron cambios sobre archivos que aún no

fueron commiteados.
Git Add

git add <filename>

Debe ejecutarse en una terminal situados en la raíz de un repositorio

clonado (o descargado).

Permite agregar uno o varios archivos al área de staging (repositorio

local), para que luego éstos sean commiteados (en un mismo commit)
y subidos al repositorio remoto.
Git Commit
git commit –m ‘mensaje’

Debe ejecutarse en una terminal situados en la raíz de un repositorio

clonado (o descargado).

Permite armar y guardar un commit con los archivos que se

encuentran en el área de staging (los que previamente fueron
agregados con git add).

Debe considerarse que un commit es un “punto de cambio del

proyecto”, situado cronológicamente.
Git Push

git push <remote> <branch>

Debe ejecutarse en una terminal situados en la raíz de un repositorio

clonado (o descargado).

Permite subir los commits realizados en nuestro repositorio local al

repositorio remoto para que éstos puedan ser descargados por el resto
del equipo de trabajo.
Git Push
Git Pull

git pull

Debe ejecutarse en una terminal situados en la raíz de un repositorio

clonado (o descargado).

Permite descargar los cambios (commits) desde el repositorio remoto y

actualizar al instante el repositorio local para reflejar ese contenido.
Git Pull
Git Pull

“En este caso, git pull descargará todos los cambios desde el punto de
separación de la rama local y la rama principal. En el ejemplo, ese punto
es E.
El comando git pull recuperará las confirmaciones remotas
divergentes, que son A, B y C. A continuación, el proceso de
incorporación de cambios creará otra confirmación de fusión local que
incluya el contenido de las nuevas confirmaciones remotas
divergentes.”
Git Pull
Git Pull

“En el diagrama anterior, podemos ver la nueva confirmación H, que es

una confirmación de fusión nueva que incluye el contenido de las
confirmaciones remotas A, B y C, y tiene un mensaje de registro
combinado.”