Estructuras

de control
 Visión general

 Estructuras de control: permiten tomar decisiones y repetir

procesos.
 Bifurcaciones y bucles.
 Expresión: conjunto de variables unidas por operadores.
Ordenes para el computador.
 Sentencia: expresión que culmina con un punto y coma.
 Estructuras condicionales (I)

 Permite ejecutar una de entre varias acciones de acuerdo al

valor de una expresión lógica o relacional.

Bifurcación if
if (expresionBooleana) {
sentencias;
}
Bifurcación if else
if (expresionBooleana) {
sentencias1;
} else {
sentencias2;
}
 Estructuras condicionales (II)

Bifurcación if elseif else

if (expresionBooleana) {
sentencias1;
} else if (expresionBooleana) {
sentencias2;
} else if (expresionBooleana) {
sentencias3;
} else {
sentencias4;
}
 Estructuras condicionales (III)

Bifurcación switch
switch (expression) {
case value1: sentencias1; break;
case value2: sentencias2; break;
[default: sentencias3;]
}

switch (i) {
case 0: System.out.println("i es cero"); break;
case 1: System.out.println("i es uno"); break;
case 2: System.out.println("i es dos"); break;
default: System.out.println("i no es 0, 1, 2");
}
 Estructuras condicionales (III)

Bifurcación switch
 Cada sentencia case se corresponde con un único valor de
expresión.
 Los valores no comprendidos en ninguna sentencia case se
pueden gestionar en default.
 En ausencia de break, cuando se ejecuta una sentencia
case se ejecutan también todas las case que van a
continuación, hasta que se llega a un break o hasta que se
termina el switch.
 Bucles (I)

 Se utiliza para realizar un proceso repetidas veces.

 Iteración: bloque de sentencias repetible.

Bucle for
for (initialization; booleanExpression; increment) {
statements;
}

for (int i=10; i>0; i-- ) {

System.out.println( i );
}
 Bucles (II)

Bucle while
while (booleanExpression) {
statements;
}

while (i <= 10) {

System.out.println( i );
i = i + 1;
}
 Bucles (III)

 Bucle do while
do {
sentencias
} while (expresionBooleana);

do {
System.out.println( i );
i = i + 1;
} while (i <= 10)
 Salida de bloques (I)

Sentencia break
 Válida para estructuras condicionales y bucles.
 Sale del bloque en ejecución.

Sentencia continue
 Válida para bucles.
 Sale de la iteración actual y continua con la siguiente
iteración.

Sentencia return
 Válida para estructuras condicionales y bucles.
 Sale del método actual.
 Salida de bloques (II)

 Ejemplo

for (i = 1; i < 5; i++) {

System.out.println(i + ": inicio bloque");
if (i == 2) {
continue;
}
if (i == 3) {
break;
}
System.out.println(i + ": fin bloque");
}
Clases
 Visión general

 Clase: plantilla para crear objetos que agrupa datos

(variables miembro) y funciones (métodos).
 Objeto: ejemplar concreto de una clase, llamado instancia de
clase.
 Declaración

[ACCESO] class NOMBRE_CLASE {

// variables miembro
ACCESO TIPO NOMBRE;
// metodos miembro
ACCESO TIPO_RETORNO NOMBRE ([PARAMETROS]) {}
}
public class Alumno {
private String nombre;
public void imprimirSaludo() {
System.out.println("Hola " + nombre);
}
}
 Variables miembro

 Pueden ser tipos primitivos o referencias a otros objetos.

 Cada objeto tiene sus propios valores de variables miembro.
 Métodos miembro

 Se aplican sobre los objetos mediante el operador punto:

miAlumno.imprimirSaludo();
 Tienen visibilidad directa sobre las variables miembro.
 Pueden definir variables locales.
 Métodos sobrecargados: tienen el mismo nombre pero se
diferencian por el número y/o tipo de parámetros.
 Constructor: método que se invoca cada vez que se crea un
objeto.
 Interfaces

 Conjunto de declaraciones de operaciones.

 Si una clase implementa (implements) una interfaz debe
definir todas las operaciones declaradas en la interface.
 Una clase puede implementar más de una interface.
Principios del
enfoque OO
 Visión general

 Tecnologías de objetos: reutilización.

 Software con estructuras poco acopladas.
 Lenguajes OO presentan encapsulación, polimorfismo y
herencia.
 Programación OO: define los datos y las rutinas para actuar
sobre esos datos.
 Encapsulación

 Mecanismo que une datos y el código que lo manipula,

manteniendo a ambos protegidos de interferencia o abuso.
Java
 Unidad de encapsulación: clase.

 Datos: variables miembro (atributos).

 Código de manipulación de datos: métodos miembro

(métodos).
 Tipos de acceso a datos y código: público (public),

protegido (protected) o privado (private, sólo miembros

de la clase).
 Herencia

 Mecanismo que permite definir una clase en base a la

definición de otra clase.
 Los objetos adquieren propiedades heredadas.

 Permite realizar una clasificación jerárquica.

 Empleando herencia cada clase sólo define las características

que la hacen única.

Java
 extends: la subclase hereda variables y métodos.

 Una clase sólo puede heredar de una única clase.

 Polimorfismo

 Habilidad de una entidad para ser establecida por varios

tipos posibles.
Java
 Herencia (extends).

 Implementación de interfaces (implements).

 Ejemplo I

public abstract class Producto {

protected String codigo;
protected double precio;
public abstract void imprimirDatos();
…
}
public class Computador extends Producto {
private String memoria;
private String procesador;
public void imprimirDatos() {
…}
}
 Ejemplo II
public class Golosina extends Producto {
private int gramos;
public void imprimirDatos() {
…
}
}
public static void main(String[] main) {
Computador prod1 = new Computador();
prod1.setCodigo("1001");
prod1.setMemoria("2 GB");
prod1.setPrecio(1200);
prod1.setProcesador("AMD 3 Ghz");
prod1.setNombre("Computador intel");
 Ejemplo III
prod1.imprimirDatos();
Golosina prod2 = new Golosina();
prod2.setCodigo("1023");
prod2.setGramos(700);
prod2.setPrecio(0.8);
prod2.setNombre("Chizitos");
prod2.imprimirDatos();
Producto prod = null;
prod = prod1;
prod.imprimirDatos();
prod = prod2;
prod.imprimirDatos();
}
}
public interface figura{
public double area();
}
public class circulo implements figura{
private double radio;
public circulo (double radio){
this.radio=radio;
}
public double area(){
return Math.PI*radio*radio;
}
}
Paquetes
 Visión general

 Paquete: agrupación de clases.

 Para que una clase pase a formar parte de un paquete
llamado mipaquete, hay que introducir en la primera línea
de ella la sentencia:
package mipaquete;
 Nombramiento

 Generalmente son escritos con letras minúsculas.

 El nombre de un paquete puede constar de varios nombres
separados por puntos.
com.dcs.uap.util
 Buena práctica: iniciar con el nombre de dominio.
 Importación

 Nombre de clase completo =

NOMBRE_PAQUETE.NOMBRE_CLASE

 Ejemplo
import edu.una.util.Ejemplo;
Arreglos y
colecciones
 Visión general

 Arreglo: objeto que almacena elementos de un mismo tipo.

 Colección: objeto que almacena objetos en forma dinámica.
 Colecciones en Java: listas (List) y conjuntos (Set).
 Arreglos

 Creación: TIPO[ ] NOMBRE = new TIPO[TAMANHO];

double[] promedios = new double[n];
Alumno[] alumnos = new Alumno[n];
 Número de elementos: length
promedios.length
 Acceso a elementos: [indice], indice puede ser un valor entre
0 y length – 1
promedios[0] = 12.5;
 Array bidimensional:
int [][] edades = new int[3][4];
Colecciones (I)
 Colecciones (II)
List miLista = new ArrayList();
miLista.add("Hola");
for (int i = 0; i < miLista.size(); i++) {
System.out.println(miLista.get(i));
}
List<Integer> miLista=new ArrayList<Integer>();

List<String> listaCadenas = new

LinkedList<String>();
for (String s : listaCadenas)
System.out.println(s);

Set<String> miConjunto = new HashSet<String>();

Manejo de
cadenas
 Secuencias de escape

 Comilla simple: \’
 Doble comilla: \"
 Backslash: \\
 Nueva línea: \n
 Tabulador (tab): \t
 Subcadenas

 indexOf: devuelve la posición en la que aparece por primera

vez un String en otro.
 subString: devuelve un String extraído de otro.

String cadena = "012345abcdef012345";

int posicion = cadena.indexOf("abc"); // 6
posicion = cadena.indexOf("abc", 7); // -1
posicion = cadena.lastIndexOf("0"); // 12
String cadena2 = "";
cadena2 = cadena.subString(6, 13);
// abcdef0
 Modificación

 trim: elimina los espacios en blanco al comienzo y final de la

cadena y retorna esa cadena.
 toUpperCase: devuelve la cadena convertida en mayúsculas.
 toLowerCase: devuelve la cadena convertida en minúsculas.

cadena = " abcdef ";

cadena.trim(); // abcdef
cadena.toUpperCase(); // ABCDEF
cadena.toLowerCase(); // abcdef
 Otras funciones

 length: devuelve el número de caracteres de la cadena.

 equals: indica si una cadena es igual a otra.
 valueOf: devuelve la representación String de su argumento.

String cadena = "abcdef";

int tamanho = cadena.length(); // 5
cadena = String.valueOf(3500); // "3500"
if (cadena.equals("uap")) {
System.out.println("Cadena es igual a uap");
}
public class Entrada {
static String inicializar(){ String buzon=""; InputStreamReader
flujo=new InputStreamReader(System.in); BufferedReader
teclado=new BufferedReader(flujo);
try{ buzon=teclado.readLine();
} catch(Exception e)
{ System.out.append("Entrada incorrecta)"); }
return buzon;
}
static int entero()
{
int valor=Integer.parseInt(inicializar()); return valor;
}
 Ejercicios

1. Muestra los números primos entre 1 y 100

2. Del siguiente String “La lluvia en Sevilla es una maravilla”
cuenta cuantas vocales hay en total (recorre el String con
charAt)
3. Sumar los 30 primeros números
4. Mostrar la longitud de una cadena
5. Dada una cadena, extraer la cuarta y quinta letra usando el
método substring