Curso de Programación Java

Cristian Mamani
@xjkwak

Verano 2018
 Contenido (I)

➔ Bibliografía

➔ Introducción a Git

➔ Estados de Git

➔ Comandos Básicos Git

➔ Ramas en Git

➔ IntelliJ Idea

➔ Introducción a Java

➔ Características de Java

➔ Tipos de datos y operadores

➔ Control de flujo
 Contenido (II)

➔ Programación Orientada a Objetos

➔ Arreglos

➔ Características avanzadas de la Programación Orientada a Objetos

➔ Características avanzadas del lenguaje

➔ Excepciones

➔ Entrada / Salida

➔ Clases útiles
 Bibliografía

➔ https://docs.oracle.com/javase/tutorial/index.html

Documentación oficial actualizada por Oracle.

➔ https://git-scm.com/docs

Documentación oficial de Git.

➔ https://www.jetbrains.com/idea

Sitio oficial de IntelliJ Idea.

➔ https://www.jetbrains.com/help/idea/gui-designer-basics.html

Swing con IntelliJ Idea

➔ https://developer.android.com/training/index.html

Training oficial para Android.

Introducción a Git
 Introducción a Git

➔ Git es un sistema de control de versiones para poder gestionar

las diferentes versiones de archivos.

➔ Originalmente fue diseñado para operar en un entorno Linux.

➔ Multiplataforma: Linux, MacOS, Windows.

➔ Una analogía: Tenemos el famoso CTRL+Z que permite regresar a

una versión anterior.

 Estados de Git

➔ Committed. Es la parte en la que nuestra información está

segura alojada en nuestras bases de datos.

➔ Modified. En esta parte hemos realizado cambios en nuestros

archivos, pero aún no se ven reflejados en nuestra base de

datos.

➔ Staged. En esta parte marcamos nuestros archivos modificados

dejándolos listos para confirmarlos.

 Comandos básicos de Git (I)

➔ Crear un repositorio:

git init

➔ Ver el estado del repositorio:

git status

➔ Agregar un archivo a la zona de Stage.

git add archivo

➔ Hacer commit del o los archivos.

git commit -m “Mensaje significativo sobre el

cambio”
 Comandos básicos de Git (II)

➔ Clonarse un repositorio de Github:

git clone

https://github.com/xjkwak/CursoJavaUMSS2018

➔ Bajarse los últimos cambios de la rama master:

git pull origin master

➔ Enviar los cambios a la rama master.

git push origin master

 Ramas (I)

➔ Son utilizadas para desarrollar funcionalidades aisladas.

➔ La rama master es la rama por defecto cuando se crea un

repositorio.

➔ Las ramas se fusionan nuevamente a la rama principal una vez

finalizado el desarrollo específico.

 Ramas (II)

➔ Crear una rama:

git checkout -b botonesRedondos

➔ Cambiarse a una rama:

git checkout ventanaTransparente

➔ Eliminar una rama:

git branch -d animacionGeneral

➔ Subir una rama al repositorio remoto:

git push origin botonesRedondos

IntelliJ IDEA
 Características Generales

➔ Es un IDE (Integrated Development Environment)

➔ Autocompletado inteligente de código.

➔ Permite depuración de código

➔ Integración con Git y otros Sistemas de Control de Versiones.

➔ Soporte para las últimas versiones de Java (9 y 8)

➔ Soporte para otros lenguajes como: Kotlin, Groovy, Scala.

➔ Pruebas unitarias con JUnit 5.

➔ Detección de código duplicado.

➔ Herramientas para base de datos.

Introducción a Java
 Introducción (I)

➔ Creado en 1991 por Sun Microsystems para lavadoras:

◆ Escasa potencia de cálculo.

◆ Poca memoria.

◆ Distintas CPUs.

➔ Consecuencias:

◆ Lenguaje sencillo que genera código reducido.

◆ Código neutro independiente de la CPU (máquina virtual)

➔ Lenguaje de programación para computadoras desde 1995.

➔ Adquirido por Oracle en 2009.

 Introducción (II)

➔ Oracle describe Java como un lenguaje: “simple, orientado a

objetos, distribuido, interpretado, robusto, seguro, de

arquitectura neutra, portable, de altas prestaciones, multitarea

y dinámico”

➔ Similar en sintaxis a C/C++ y en semántica a SmallTalk.

➔ Ejecución de Java como:

◆ Java Standard Edition: Aplicación de escritorio.

◆ Java Enterprise Edition: Aplicación web.

◆ ...

➔ JDK (Java Development Kit): programas y librerías para

desarrollar, compilar y ejecutar programas Java.

 Características de Java

➔ Lenguaje de fácil uso orientado a objetos.

➔ Lenguaje compilado e interpretado.

➔ Facilita un entorno interpretado:

◆ Velocidad de desarrollo (no de ejecución)

◆ Portabilidad del código

➔ Ejecución multitarea.

➔ Cambios dinámicos en tiempo de ejecución.

➔ Seguridad del código.

 Máquina Virtual Java (JVM)

➔ La Java Virtual Machine es una máquina hipotética que emula por

software a una máquina real. Contiene:

◆ Conjunto de instrucciones máquina (C.O. + Operandos)

◆ Registros

◆ Pila

◆ Memoria

◆ …

➔ El compilador genera bytecodes (instrucciones de código

máquina para JVM)

➔ El intérprete ejecuta y traduce los bytecodes para cada máquina

específica.
 Compilador e Intérprete de Java

➔ El compilador analiza la sintaxis del código fuente (con extensión

*.java). Si no hay errores, genera bytecodes.

> javac Nombre.java ==> Nombre.class

➔ El intérprete es la Máquina Virtual Java que ejecuta los

bytecodes (con extensión *.class) creados por el compilador.

> java Nombre (sin extensión .class)

➔ Aplicación con argumentos:

> java Nombre arg1 arg2 ...

 Garbage Collector

➔ Debe liberarse la memoria reservada dinámicamente que no se

vaya a utilizar más.

➔ En otros lenguajes esta liberación debe realizarla el propio

programador.

➔ La JVM dispone de un thread que rastrea las operaciones de

memoria: el Garbage Collector, el cual:

◆ Verifica y libera la memoria que no se necesita.

◆ Se ejecuta automáticamente.

◆ Puede variar según la implementación de la JVM.

 Formato de los archivos fuente

➔ El archivo fuente contiene 3 elementos principales:

◆ Declaración de paquete (opcional).

◆ Sentencias de importación (opcional).

◆ Declaración de clase o de interfaz.

Ejemplo: Archivo fuente Empleado.java

package abc.financedept;
import java.lang.*;
import java.awt.*;
public class Empleado {
...
}
 Hola Mundo!

Archivo: HolaMundo.java
// Aplicacion ejemplo HolaMundo

public class HolaMundo {

public static void main (String args[]) {
System.out.println(“Hola Mundo!”);
}
}

> javac HolaMundo.java

> java HolaMundo

Hola Mundo!
 Seguridad del Código

➔ La JVM verifica los bytecodes asegurando que:

◆ El código se ajusta a las especificaciones de la JVM.

◆ No hay violaciones de acceso restringido.

◆ El código no provoca desbordamientos de la pila.

◆ Los tipos de los parámetros son correctos para todo el

código.

◆ No existen conversiones ilegales de datos (Ej: convertir de

enteros a punteros)

◆ Los accesos a los campos de los objetos están autorizados.

Características de Java
 Características del Lenguaje

➔ Sensible a mayúsculas/minúsculas.

➔ Soporta comentarios.

➔ Lenguaje de formato libre.

➔ Permite identificadores.

➔ Incluye palabras reservadas.

➔ Permite variables y constantes.

➔ Convenciones de nomenclatura.

➔ Tiene reglas sobre los tipos de datos.

 Sensible a Mayúsculas/Minúsculas

➔ Se distingue entre mayúsculas y minúsculas.

➔ Los identificadores Cat, cat y CAT son diferentes.

➔ Todas las palabras reservadas del lenguaje van en minúsculas.

 Soporta Comentarios

➔ Existen tres formas de introducir comentarios:

◆ Comentario en una línea.

//Comentario de una línea

◆ Comentario en una o más líneas.

/* Comentario de
Más de una línea */

◆ Comentario de documentación. Se usa con javadoc.

/** Método XYZ: Realiza la labor X

sobre los datos Y devolviendo Z*/

> javadoc Archivo.java => Archivo.html

 Lenguaje de Formato Libre

➔ La disposición de los elementos dentro del código es libre.

➔ Sentencias: línea simple de código terminada en ;

total = a + b + c + d;

➔ Bloque de código: conjunto de sentencias agrupadas entre

llaves:
{
x = x + 1;
y = y +1;
}

➔ Java permite espacios en blanco entre elementos del código.

x1 = y * delta;
x2 = (y+1) * delta;
 Identificadores

➔ Son nombres de clases, variables o métodos.

➔ No tienen longitud máxima.

➔ El primer carácter del identificador debe ser: A-Z, a-z, _, $

➔ El resto: A-Z, a-z, _, $, 0-9

➔ No se permiten vocales acentuadas ni la letra eñe (ñ, Ñ)

➔ No se pueden utilizar palabras reservadas como identificador.

 Palabras reservadas

➔ Palabras con un significado especial para el compilador:

abstract default goto1 null2 synchronized

boolean do if package this

break double implements private throw

byte else import protected throws

case extends instanceof public transient

catch false2 int return true2

char final interface shor try

class finally long static void

const1 float native super volatile

continue for new switch while

assert enum strictfp

1
Palabras no usadas por el lenguaje, pero son reservadas
2
Realmente son constantes del lenguaje
 Variables y Constantes

➔ Variables: zona de memoria cuyos valores van a cambiar durante

la ejecución.

Declaración: <tipo> <identificador>; ó

<tipo> <identificador>, <identificador> . . .;

Ejemplo: int x, y, z;

➔ Constantes: zona de memoria cuyos valores no cambian.

Declaración: final <tipo> <identificador> = <valor>;

Ejemplo: final double PI = 3.14159265;

 Asignación de Variables

➔ Se utiliza el operador asignación =

<variable> = <expresión>;

➔ La parte izquierda siempre debe ser una variable.

➔ La parte derecha puede ser un literal, una variable, una

expresión, una función o una combinación de todos.

➔ Se puede asignar un valor a una variable en el momento de

declararla.

Ejemplo: int i = 0;
 Convenciones de Nomenclatura (I)

➔ Los identificadores que proporciona Java siguen una convención

según el elemento:

◆ Clases: primera letra en mayúscula de cada palabra.

Ejemplo: Empleado, LibroDeCuentas, String

◆ Variables: primera letra en minúscula y la primera letra cada

palabra en mayúsculas.

Ejemplo: contador, numeroTotalAccesos, string

◆ Constantes: todo en mayúsculas, separando cada palabra por

el carácter “_”.

Ejemplo: PI, ANCHO_IMAGEN

 Convenciones de Nomenclatura (II)

➔ Métodos: siguen el mismo formato que las variables seguidas de

paréntesis ()

Ejemplo: sumar(), obtenerResultado()

➔ Estructuras de control: utilizar llaves englobando a toas las

sentencias de una estructura de control, aunque sólo haya una

sentencia. Ejemplo:

if (<expresión booleana>) {
// hacer algo
}
else {
// hacer otra cosa
}
Tipos de Datos y Operadores
 Tipos de Datos

➔ Java define dos tipos de datos:

◆ Tipos primitivos.

◆ Tipos referencia.

➔ Los tipos primitivos son ocho agrupados en cuatro categorías:

◆ Lógico: boolean

◆ Texto: char

◆ Entero: byte, short, int, long

◆ Real: float, double

➔ Los tipos referencia son punteros a objetos.

 Tipo de datos Lógico

➔ El tipo de datos boolean (8 bits) puede tomar dos valores

posibles: true y false.

➔ El tipo boolean no toma valores numéricos.

➔ En Java no se considera cero como falso y distinto de cero como

verdadero (como sucede en C/C++).

➔ No existe conversión entre tipos enteros y tipos lógicos.

int i; int i;
if (i) { if ( i != 0) {
. . . . . .
} }

Error de compilación Correcto

 Tipo de datos de Texto

➔ El tipo char (16 bits) representa sólo un carácter Unicode.

➔ El código universal Unicode incluye el código ASCII y comprende

los caracteres gráficos de prácticamente todos los idiomas

(japonés, chino, braile …)

➔ El literal de texto debe ir entre comillas simples ‘‘

➔ Utiliza la siguiente notación:

◆ Caracteres simples: ‘a’

◆ Caracteres especiales: ‘\t’, ‘\n’

◆ Caracteres Unicode (con 4 dígitos en hexadecimal):

‘\uOOBF’
 Tipo de datos Entero

➔ Existen cuatro tipos de datos enteros: byte (8 bits), short (16

bits), int (32 bits) y long (64 bits)

➔ Todos los tipos tienen signo. El cero se considera positivo.

➔ Los literales enteros se pueden representar con notación:

◆ Decimal: 2, 156, 56453645

◆ Octal: 077, 0700 (empezando con un cero)

◆ Hexadecimal: 0xABFF, 0xCC00 (empezando con Ox)

➔ Por defecto siempre se consideran de tipo int

➔ Seguido de L se considera long: 156L, 077L, 0xABFFL

 Tipo de datos Real

➔ Existen dos tipos de datos reales: float (32 bits) y double (64

bits)

➔ Un literal es de punto flotante si lleva:

◆ Un punto decimal: 3.14159, 2.0

◆ Una E ó e (valor exponencial): 105e25, 1.05E27

◆ Una F ó f (float): 279F, 2.79f

◆ Una D ó d (double): 279D, 2.79d

➔ Un literal real por defecto siempre se considera de tipo double,

si no se indica explícitamente que es un float.

 Resumen de Tipos Primitivos

➔ El tamaño de cada tipo de dato primitivo se mantiene invariable,

independientemente de la arquitectura de la máquina.

➔ El valor por defecto se toma para las variables no inicializadas de los objetos.
Tipo Contiene Valor por defecto Tamaño Valor Min Valor Max

boolean true ó false false 8 bits - -

char Carácter Unicode \u0000 16 bits \u0000 \uFFFF

byte Entero con signo 0 8 bits -128 127

short Entero con signo 0 16 bits -32768 32768

int Entero con signo 0 32 bits -2147483648 2147483647

long Entero con signo 0 64 bits -9223372036854775808 9223372036854775807

float IEEE 754 estándar 0.0 32 bits 1.4E-45 3.4028235E38

punto flotante

double IEEE 754 estándar 0.0 64 bits 4.9E-324 1.7976931348623157E308

punto flotante
 Tipo de datos Referencia

➔ Un tipo referencia guarda un puntero a la dirección donde se

ubica el objeto (32 bits).

➔ Sólo puede almacenar direcciones de objetos de su propio tipo.

➔ Ejemplo:
Computadora pc, sun;
Usuario user;
pc = new Computadora();
user = pc; => Error de compilación
sun = pc; => Correcto

➔ Todas las clases son de tipo referencia.

➔ El valor que toma por defecto una variable de tipo referencia es

null.
 Cadenas de Caracteres

➔ La clase String permite manejar cadenas de caracteres.

➔ El literal String debe ir entre comillas dobles “”

➔ Se puede crear una cadena de caracteres de dos formas:

String nombre = new String (“Pepe”);

String nombre = “Pepe”;

➔ “a” != ‘a’

➔ Para concatenar dos cadenas se utiliza el operador +

“Pepe” + “Pérez” ⇒ “PepePérez”

➔ No se guarda el carácter de fin de cadena.

 Memoria Asignada a una Variable

➔ Tipo primitivo: se asigna la cantidad de memoria que requiere el

tipo de la variable.

Ejemplo: long x; x [ 64 bits ]

➔ Tipo referencia: se asigna el espacio correspondiente a una

dirección de memoria (32 bits).

Ejemplo: Computer pc; pc [ 32 bits ]

String cadena; cadena [ 32 bits ]

Fecha reunion; reunion [ 32 bits ]

 Conversión de Tipos

➔ La conversión de tipos (casting) se debe realizar entre tipos de

la misma naturaleza: numéricos o referencia.

➔ Al convertir un tipo a un tamaño más pequeño se puede perder la

información de los bits de mayor peso.

➔ La sintaxis es: (<tipo>) <expresión>

Ejemplo: byte num8bits = (byte)27;

int num32bits = 27;

num8bits = (byte)num32bits;

Ejemplo: short a, b, c;

C = a + b; ⇒ Error, + devuelve int

C = (shor)(b + c); ⇒ Correcto

 Operadores Java (I)

➔ Operadores unarios: +, -

➔ Operadores aritméticos: +, -, *, /, % (resto de la división)

➔ Operadores de asignación: =, +=, -=, *=, /=, %=

<var> += <expr> ⇒ <var> = <var> + <expr>

➔ Operadores incrementales: ++, --

◆ Precediendo a la variable: ++i, --i

◆ Siguiendo a la variable: i++, i--

i = 6; i = 6; i = 6; i = 6;
j = i++; ==> j = i; j = ++i; ==> i = i + 1;
i = i + 1; j = i;

i = 7, j = 6 i = 7, j = 7
 Operadores Java (II)

➔ Operadores relacionales: == (igual), != (distinto), > (mayor que),

< (menor que), >= (mayor igual que), <= (menor igual que)

➔ Operadores lógicos: && (and), || (or), ! (not), & (and), | (or)

◆ && y || realizan evaluación perezosa:

● op1 && op2 ⇒ si op1 es false, no se evalúa op2

● op1 || op2 ⇒ si op1 es true, no se evalúa op2

◆ & y | siempre evalúan los dos operadores

➔ Operador instanceof: <objeto> instanceof <clase>

determina si un objeto pertenece a una clase.

 Operadores Java (III)

➔ Operador condicional: ?

<exprBooleana> ? <valor1>: <valor2

Permite bifurcaciones condicionales sencillas.

➔ Operadores a nivel de bits: >>, <<, >>>, &, |, ^, ~

◆ op1 >> n desplaza los bits de op1 (con signo) a la derecha
n posiciones.
◆ op1 << n desplaza los bits de op1 (con signo) a la izquierda
n posiciones.
◆ op1 >>> n desplaza los bits de op1 (sin signo) a la derecha
n posiciones.
◆ op1 & op2 Operador AND a nivel de bits.
◆ op1 | op2 Operador OR a nivel de bits
◆ op1 ^ op2 Operador XOR a nivel de bits
◆ ~op1 Operador complemento (NOT a nivel de bits)
 Precedencia de Operadores (I)

➔ Todos los operadores binarios se evalúan de izquierda a derecha,

excepto los operadores de asignación.

Tipo Operador
Operadores sufijos [] . (argumentos) expr++ expr--

Operadores unarios ++expr -expr +expr ~ !

Creación y casting new (tipo)expr

Multiplicativos * / %

Aditivos + -

Desplazamiento << >> >>>

Relacional < > <= >= istanceof

Igualdad == !=
 Precedencia de Operadores (II)

Tipo Operador
Igualdad == !=

AND (bits) &

OR exclusivo (bits) ^

OR inclusivo (bits) |

AND lógico &&

OR lógico ||

Condicional ? :

Asignación = += -= *= /= %= &= ^= |= <<=

>>= >>>=
Estructuras de Control
 Estructuras de Control

➔ Las sentencias de control del flujo de ejecución permiten tomar

decisiones y realizar un proceso repetidas veces.

➔ Hay dos tipos principales de sentencias de control de flujo:

◆ Condicionales: if, switch

◆ Bucles: for, while, do while

➔ Otras sentencias que permiten interrumpir el flujo normal de

ejecución son break y continue

 Sentencia if

➔ Ejecuta un conjunto de sentencias en función del valor de la

expresión de comparación (booleana).

⇒ if (<exprBooleana>) ⇒ if (<exprBooleana>) {
<sentencia>; <grupoSentencias>;
}
⇒ if (<exprBooleana>) ⇒ if (<exprBooleana>) {
<sentencia>; <grupoSentencias1>;
else }
<sentencia>; else {
<grupoSentencias2>;
}
 Sentencia switch

➔ Comparación de igualdad múltiple con la misma variable.

switch (<variable>) {
case literal1: [<grupoSentencias1>;]
[break;]

case literal2: [<grupoSentencias1>;]

[break;]
. . .
case literalN: [<grupoSentencias1>;]
[break;]
[default: <grupoSentencias>;]
}
 Ejemplo switch

Opciones de un menú:
1. Abrir archivo.
2. Cerrar archivo.
3. Cerrar archivo e imprimir datos.
4. Imprimir datos.
5. Salir

switch (opcion) {
case 1: abrirArchivo(); break;

case 2: cerrarArchivo(); break;

case 3: cerrarArchivo();

case 4: imprimirDatos(); break;

case 5:
default: terminarPrograma();
}
 Otro ejemplo switch

public String literal(int digito) {

String respuesta = "";

switch (digito) {

case 1: respuesta = "uno";

break;

case 2: respuesta = "dos";

break;

case 3: respuesta = "tres";

break;

default: respuesta = "No es un dígito del 1 al 3";

return respuesta;
}
 Sentencia for

➔ Permite la ejecución repetida de un grupo de sentencias con

mayor control:

for (<A>; <B>; <C>) {

<D>
}

◆ A: Asignaciòn del valor inicial de las variables que

intervienen en la expresión.

◆ B: Expresión booleana que verifica si se sigue ejecutando el

ciclo.

◆ C: Nuevo valor de las variables.

◆ D: Grupo de sentencias que se ejecutan una y otra vez.

 Sentencia while

➔ El grupo de sentencias se ejecuta mientras se cumpla la

expresión booleana:

while (<exprBooleana>) {
<grupoSentencias>;
}

➔ El grupo de sentencias se ejecuta por lo menos 0 veces.

 Sentencia do while

➔ El grupo de sentencias se ejecuta mientras se cumpla la

expresión booleana:

do {
<grupoSentencias>;
} while (<exprBooleana>);

➔ El grupo de sentencias se ejecuta por lo menos 1 vez.

 Sentencias break y continue

➔ La sentencia break provoca la terminación inmediata de un bucle

o sentencia switch (sin ejecutar el resto de sentencias).

Válido para for, while, do while y switch

➔ La sentencia continue provoca la terminación inmediata de una

iteración de un bucle.

Válido para for, while y do while.

Programación Orientada a
Objetos (POO)
 Conceptos de la Orientación a Objetos

➔ Clases: patrones que indican cómo construir los objetos.

➔ Objetos: instancias de las clases en tiempo de ejecución.

Ejemplo: plano de arquitecto vs edificios.

➔ Miembros de la clase:

◆ Atributos: características o propiedades de los objetos.

Pueden ser variables numéricas, lógicas, caracteres o

referencias a otros objetos.

◆ Métodos: comportamiento de los objetos. Son funciones que

operan sobre los atributos de los objetos.

 Diagrama de Clase

➔ Representación gráfica de una clase:

CLASE

Atributos

Métodos
 Características de la Orientación a Objetos

➔ Cada objeto tiene características reconocibles y es único.

Ejemplo: Un Estudiante tiene Nombre, Código SIS, Carrera.

➔ Cada objeto es único.

Ejemplo: El estudiante Juan Pari con Código SIS 201001123

estudia Ingeniería electrónica.

➔ El código fuente orientado a objetos define clases.

➔ En tiempo de ejecución el programa crea objetos a partir de

cada clase.

➔ Los objetos almacenan información.

➔ Los objetos realizan operaciones sobre sus atributos.

 Paradigmas de Programación (I)

➔ Paradigma estructurado o procedural: los programas se dividen

en procedimientos independientes con acceso total a los datos

comunes.

Algoritmos + Estructuras de Datos = Programas

➔ Paradigma funcional: el resultado de un cálculo es la entrada del

siguiente, así hasta que se produce el valor deseado.

 Paradigmas de Programación (II)

➔ Paradigma orientado a objetos: los datos se consideran la

parte más importante del programa, de modo que se agrupan en

objetos.

Los objetos modelan las características de los problemas del

mundo real, su comportamiento ante estas características y su

forma de interactuar con otro elementos.

Objetos + Mensajes = Programas

 Ejemplo

➔ Tomarse un café en una cafetería:

Procedural: Orientado a Objetos:

➔ El cliente entra en la ➔ El cliente entra en la

cafetería. cafetería.
➔ El cliente pasa detrás de la ➔ El cliente pide un café al
barra. camarero.
➔ El cliente prepara la ➔ El camarero prepara la
cafetera. cafetera.
➔ El cliente se sirve el café. ➔ La cafetera hace el café.
➔ El cliente se bebe el café ➔ El camarero sirve el café al
cliente.
➔ El cliente se bebe el café.
 Mínimo Programa Orientado a Objetos

➔ Archivo: MinProgOO.java

public class MinProgOO {

public static void main(String[] args) {
Objeto obj = new Objeto();
obj.saludar();
}
}

class Objeto {
public void saludar() {
System.out.println("Hola Mundo!");
}
}
 Definición de Clase

➔ Sintaxis:

class <NombreClase> {
//Declaración de atributos
<tipo> <variable>;

//Declaración de métodos
<tipo> <nombreMétodo> (<argumentos>) {
. . .
}
}

➔ El nombre del archivo Java debe coincidir con el de la clase

definida en él ⇒ <NombreClase>.java

➔ Se recomienda definir una clase por cada archivo java.

 Ejemplo de Clase

➔ Clase que modela a una fecha ⇒ Fecha.java

class Fecha {
//Atributos
int dia;
int mes;
int año;

//Métodos
void mostrarFecha() { . . . }
boolean esAñoBisiesto() { . . . }
}
 Creación de un Objeto

➔ Se utiliza la palabra reservada new

<refObjeto> = new <NombreClase>();

➔ Ejemplo:
Fecha reunion;
reunion = new Fecha();
 Acceso a los miembros de un objeto

➔ A través del operador punto (.) se puede acceder tanto a los

atributos como a los métodos.

<refObjeto>.<atributo> ó <refObjeto>.<método>()

Ejemplo:

Fecha reunion = new Fecha();

reunion.dia = 31;

reunion.mes = 1;

reunion.año = 2018;

reunion.mostrarFechaCorta();
 Métodos

➔ Los métodos son bloques de código definidos dentro de una

clase.

➔ Un método tiene acceso a todos los atributos de su clase.

➔ Pueden ser llamados o invocados desde cualquier sitio.

➔ Un método puede invocar a otros métodos.

➔ Los métodos que se invocan a sí mismos son recursivos.

➔ En Java no se puede definir un método dentro de otro.

➔ Todos los programas se inician con el método main.

 Definición de Métodos (I)

<tipoRetorno> <nombreMétodo> (<parámetros>) {

<bloqueCódigo>
}

➔ <tipoRetorno>: tipo de dato que retorna el método (primitivo

o referencia). Si no devuelve ningún valor, debe ser void.

➔ <nombreMétodo>: identificador del método

➔ <parámetros>: el método admite que le pasen parámetros

separados por comas.

➔ <bloqueCódigo>: Conjunto de sentencias que implementan la

tarea que debe realizar el método.

 Definición de Métodos (II)

➔ Si el método devuelve un valor, debe utilizar la sentencia

return

Ejemplo: return <valor>;

Donde <valor> debe ser del mismo <tipoRetorno> con que se

ha declarado el método.

➔ El código se ejecuta hasta alcanzar la sentencia return (sólo si

devuelve un valor) o hasta el final del método (si no devuelve

nada).

➔ Se pueden declarar variables locales si son necesarias.

 Ámbito de las variables (I)

➔ En Java se dispone de tres tipos de variables:

◆ Atributos pertenecientes a una clase.

◆ Parámetros de un método de la clase.

◆ Variables locales de un método de la clase.

➔ Los parámetros trabajan como variables locales.

class Ejemplo {
int x; // atributos
void metodo(int y) { // parámetro
int z; // variable local
x = y + z;
}
}
 Ámbito de las variables (II)

➔ Los atributos son visibles desde cualquier parte de la clase.

➔ Los parámetros y variables locales sólo son visibles dentro del

método al que pertenecen. Dejan de existir al finalizar el

método.

➔ Dentro de un método si una variable local o parámetro coincide

con un atributo, sólo se accede a la variable del método.

 El puntero this

➔ Se emplea para apuntar al objeto actual dentro de un método.

➔ Con this se hace accesible un atributo cuyo identificador

coincide con una variable local.

class Ejemplo {
int x;
void metodo(int y) {
int z = 1;
int x = 2;
x = y + z;
}
}
 Sobrecarga de Métodos

➔ A veces se necesitan varios métodos que hagan la misma tarea

pero con distintos argumentos.

➔ Java permite utilizar un mismo nombre para diferentes métodos,

siempre que se pueda identificar cada método.

➔ Un método se identifica por su nombre, el tipo de retorno, el

número de argumentos que tiene y el tipo de cada uno de ellos.

void mostrarInt(int i) void mostrar(int i)

void mostrarLong(long l) void mostrar(long l)

void mostrarFloat(float f) void mostrar(float f)

➔ A esto se llama sobrecarga de métodos.

 Constructores (I)

➔ Un constructor es un tipo especial de método que permite

construir un objeto de una clase. Ejemplo:

class Fecha {
. . .
public Fecha() { . . . }
public Fecha(int d, int m, int a) { . . . }
. . .
}

➔ Tienen el mismo nombre que la clase.

➔ No definen tipo de retorno.

➔ Se utilizan con la palabra reservada new

Fecha compadres = new Fecha(1, 2, 2018);

 Constructores (II)

➔ Los constructores se pueden sobrecargar y son opcionales.

➔ Si no se define ningún constructor, Java proporciona uno por

defecto. Incorpora el siguiente código a la clase:

class <NombreClase> {
. . .
public <NombreClase>() { }

. . .
}

➔ Si se tiene un constructor con argumentos, se pierde el

constructor por defecto.

➔ Normalmente, en el constructor se inicializan los atributos.

Características Avanzadas de la
OO
 Conceptos Avanzados de la OO

➔ Hay tres conceptos avanzados relacionados con la orientación a

objetos:

◆ Encapsulación: permite la protección de ciertas partes de un

objeto del acceso desde otros objetos externos.

◆ Herencia: jerarquía de clases basada en la agrupación de

atributos y/o de métodos comunes.

◆ Polimorfismo: tratamiento generalizado de todas las clases

pertenecientes a una jerarquía de herencia.

 Encapsulación

➔ La encapsulación consiste en el agrupamiento de datos y su

tratamiento en una misma estructura.

➔ Permite la protección de la manipulación externa de algunas

partes de los objetos.

➔ Un objeto suele tener datos y código privados de acceso

restringido.

➔ Fuerza al usuario a utilizar una interfaz para acceder a los

datos.

➔ Hace que el código sea más fácil de mantener.

 Modificadores para Restringir el Acceso

➔ La definición de los miembros de una clase se puede ampliar

añadiendo modificadores al principio:

[<modificador>] <tipo> <identificador>;

[<modificador>] <tipo> <nombre> (<params>) { . . . }

➔ Los modificadores permiten acceder a los datos o al código de

manera restringida:

◆ public: el miembro de la clase es accesible desde cualquier

parte del código.

◆ private: el miembro de la clase sólo es accesible desde

código perteneciente a la propia clase.

 Ejemplo de Encapsulación (I)

class Fecha { class Fecha {

public int dia; private int dia;
public int mes; private int mes;
public int año; private int año;
} }

. . . . . .
Fecha f = new Fecha(); Fecha f = new Fecha();
f.dia = 5; f.dia = 5; ⇒ ERROR
f.mes = 2; f.mes = 2; ⇒ ERROR
f.año = 2018; f.año = 2018; ⇒ ERROR
. . . . . .
int d;
d = f.dia; ⇒ ERROR
. . .
 Ejemplo de Encapsulación (II)

class Fecha {
private int dia;
private int mes;
private int año;
public void setDia(int d) {
if ( d > 0 && d < 32) {
dia = d;
}
}
public int getDia() {
return dia;
}
}
. . .
Fecha f = new Fecha();
f.setDia(34); ⇒ El método setDia valida el valor asignado
int d = f.getDia();
. . .
 Plain Old Java Object (POJO)

➔ POJO es un término que existe en el marco de la programación

orientada a objetos.

➔ Se utiliza para describir estructuras de objetos.

➔ Un POJO es simplemente una clase que debe ser lo más simple

posible.
 Ejemplo de POJO

public class Estudiante {

private String nombre;

private String codSis;

public String getNombre() {

return nombre;
}

public void setNombre(String nombre) {

this.nombre = nombre;
}

public String getCodSis() {

return codSis;
}

public void setCodSis(String codSis) {

this.codSis = codSis;
}
}
 Herencia (I)

➔ Jerarquía de clases basada en agrupar atributos y/o métodos

comunes. Vertebrados

Mamíferos Anfibios Aves

Caninos Felinos

➔ Las clases descendientes se llaman subclases.

➔ Las clases ascendientes se llaman superclases.

➔ Las subclases heredan características y métodos de las

superclases (excepto los constructores)

 Herencia (II)

➔ Supongamos, por ejemplo, que tenemos la clase Aula y la clase

Laboratorio definidas como sigue:

class Aula { class Laboratorio {
int numAsientos; int numAsientos;
String nombre; String nombre;
boolean tienePizarra; int numMaquinas;
} }

➔ Las partes comunes se pueden agrupar en una misma clase,

manteniendo las otras dos clases con las partes no comunes y

heredando de esta nueva clase con la palabra reservada

extends.
 Herencia (III)

class Aula { //Clase padre

int numAsientos; class Ambiente {
String nombre; int numAsientos;
boolean tienePizarra; String nombre;
} }

class Laboratorio { //Clases hijas

int numAsientos; class Aula extends Ambiente {
String nombre; boolean tienePizarra;
int numMaquinas; }
}
class Laboratorio extends Ambiente {
int numMaquinas;
}
 Relación “es-un”

➔ Para saber si la relación de una herencia es correcta, se plantea

la pregunta: “¿La subclase es una superclase?. La respuesta debe

ser “sí”. ¿un aula es un ambiente? ⇒ Sí.

¿un laboratorio es un ambiente? ⇒ Sí.

class Bici { class Bici {
int numRuedas; int numRuedas;
int numAsientos; int numAsientos;
int velocidadMax; int velocidadMax;
} }
class Avion {
int numRuedas; class Avion extends Bici {
int numAsientos; int numAlas;
int velocidadMax; }
int numAlas;
} ¿Avión es una Bici? ⇒ NO
 Herencia Simple

➔ Si una clase hereda de una única clase se considera herencia

simple.

➔ Si una clase hereda de varias clases se considera herencia

múltiple.

➔ En Java sólo se permite la herencia simple.

➔ La herencia simple hace que el código sea reutilizable.

 Relación de Contenido (“tiene un”)

➔ Una clase puede contener referencias de objetos de otras

clases.

➔ Se diferencia de la herencia en que es necesario instanciarlos

por separado.

➔ Responde afirmativamente a la pregunta: ¿<Contenedor>

tiene-un <Contenido>?
class Motor { class Chasis { class Coche {
. . . . . . Motor motor;
} } Chasis chasis;
}

¿Un Coche tiene-un Motor? ⇒ SI

¿Un Coche tiene-un Chasis? ⇒ SI
 Sobreescritura de Métodos

➔ También llamados métodos virtuales.

➔ Una subclase puede modificar los métodos que ha heredado de la

superclase, manteniendo los mismos nombre, tipo de retorno y

lista de parámetros.

class Animal {
public void saludar() {
System.out.println("El animal saluda!");
}
}
class Gato extends Animal {
public void saludar() {
System.out.println("Miauuu");
}
}
 Otras características de la Herencia

➔ Todas las clases proporcionadas por Java y las que defina el

programador heredan de una clase común: la clase Object.

El compilador añade extends Object a todas las clases que no

heredan explícitamente de ninguna otra.

class Fecha { class Fecha extends Object {

. . . . . .
} }
 Modificador de acceso protected

➔ Los atributos y métodos de una clase se pueden proteger con

otro modificador: protected, cuyo acceso queda restringido a

la clase donde se define y a todas sus subclases.

 Resumen de Modificadores de Acceso

Modificador Misma clase Clase hija Otra clases Otras clases

del mismo de otro
paquete paquete

private SI NO NO NO

protected SI SI NO NO

public SI SI SI SI

default SI SI SI NO
 Polimorfismo

➔ Polimorfismo indica “muchas formas”.

➔ Una clase sólo tiene una forma, pero una variable que hace

referencia a la superclase de una jerarquía puede tener muchas

formas (una por cada subclase).

Animal a = new Gato(“Michu Michu”);

Animal b = new Perro(“Ayudante de Santa”);

b.ladrar(); ⇒ ERROR

((Perro)b).ladrar();

➔ Pueden utilizarse de dos maneras:

◆ Parámetros polimórficos.

◆ Colecciones heterogéneas.
 Parámetros Polimórficos

class Mascota { . . . }

class Raton extends Mascota { . . . }

class Gato extends Mascota { . . . }

class Veterinario {
public void vacunar(Mascota m) {
. . .
}
}
. . .
Veterinario doctor = new Veterinario();
Gato tom = new Gato();
Raton jerry = new Raton();
doctor.vacunar(tom);
doctor.vacunar(jerry);
. . .
Arreglos
 Arreglos

➔ Los arreglos o arrays son estructuras de memoria que almacenan

en una variable múltiples valores del mismo tipo.

➔ Los arrays son objetos ⇒ se crean con new.

➔ Se utilizan los corchetes, [], para declarar el array y para

acceder a sus elementos.

➔ Pueden ser de cualquier tipo (primitivo o referencia)

➔ Declaración de arrays:

<tipo> <variable>[]; ó <tipo>[] <variable>;

int a[]; equivale a int[] a;

int a[], b, c; (a es un array, b y c son enteros)

int[] a, b, c; (a, b y c son arrays) ⇒ RECOMENDADO

 Instanciación de Arrays

➔ Creación de objetos array:

<variable> = new <tipo>[<tamaño>];

➔ Al crear el objeto, el número de elementos (<tamaño>) se

guarda en un atributo llamado length

➔ El primer elemento del array está en la posición 0 y el último en

la posición length-1

int a[] = new int[20];

a[0] = 15;
int i = a[0];
System.out.println(a.length); ==> 20
System.out.println(i); ==> 15
 Inicialización de Arrays

➔ Cuando se instancia un objeto array, sus elementos se inicializan

al valor por defecto del tipo correspondiente.

➔ Si se conocen los valores iniciales de cada elemento, se pueden

inicializar con los valores entre llaves y separados por comas (a

la vez que se declara.

int[] primos = {2, 3, 5};

Equivale a:

int[] primos = new int[3];

primos[0] = 2;

primos[1] = 3;

primos[2] = 5;
 Ejemplos de Arrays

int[] digitos = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

String[] dias = {"lunes", "martes", "miércoles",
"jueves","viernes", "sábado", "domingo"};
Fecha[] carnavales = {new Fecha(12,2,2018),
new Fecha(13,2,2018)};

➔ Recorrido de una lista:

for (int i = 0; i < digitos.length; i++) {

System.out.println(digitos[i]);
}
 Colecciones Heterogéneas

➔ Hasta ahora un array sólo podía contener elementos del mismo

tipo (colección homogénea).

➔ Utilizando polimorfismo se pueden tener elementos de distinto

tipo en un array (colección heterogénea)

➔ Se crean utilizando arrays definidos con el tipo superclase.

Mascota listaMascotas[] = new Mascota[5];

listaMascotas[0] = new Mascota();
listaMascotas[1] = new Gato();
listaMascotas[2] = new Raton();
listaMascotas[3] = new Raton();
listaMascotas[4] = new Gato();
 Ejemplo de Colecciones Heterogéneas

class Animal {
public void saludar() { }
}

class Gato extends Animal {

public void saludar() {
System.out.println("Miauu");
}
}

class Perro extends Animal {

public void saludar() {
System.out.println("Guau");
}
}
. . .
Animal lista[] = {new Gato(), new Perro(), new Gato(), new Perro()};
for (int i = 0; i < lista.length; i++) {
lista[i].saludar();
}
Características Avanzadas de
Java
 Paquetes

➔ Un paquete es una agrupación de clases (librería).

➔ Uno puede crearse sus propios paquetes con la sentencia

package al inicio del archivo fuente:

package <nombre.paquete>;

Ejemplo: package bo.edu.umss;

➔ La composición de nombres (separados por puntos) está

relacionada con la jerarquía de directorios.

bo/edu/umss/

➔ Los nombres de los paquetes se escriben con minúsculas.

 Ejemplo de Paquetes

package bo.edu.umss;

class Estudiante {
. . .
}

➔ La clase Estudiante realmente se llama

bo.edu.umss.Estudiante

➔ Si no se indica la sentencia package, la clase Estudiante

pertenecerá a un paquete por defecto sin nombre.

 Sentencia import

➔ La sentencia import indica al compilador dónde están ubicadas

las clases que estamos utilizando.

➔ Para importa sólo una clase de un paquete:

import <nombre.paquete>.<NombreClase>;

➔ Para importar todas las clases de un paquete:

import <nombre.paquete>.*;

➔ El compilador añade a todos los ficheros la línea:

import java.lang.*;

Que es el paquete que contiene las clases fundamentales para

programar en Java (System, String, Object, Math…)

 Ejemplo de import

import bo.edu.umss.*;

class EstudianteAuxiliar extends Estudiante {

Double sueldo;
}

➔ Si no se pone el import, deberíamos referirnos a Estudiante

como bo.edu.umss.Estudiante.

➔ La clase EstudianteAuxiliar pertenece al paquete anónimo

por defecto.

➔ Double pertenece al paquete java.lang

 Modificador static

➔ Los miembros de una clase pertenecen a los objetos.

➔ Para acceder a los atributos y métodos de una clase es necesario

crear primero un objeto.

➔ El modificador static puede aplicarse a atributos y métodos

para acceder a ellos sin instanciar ningún objeto.

➔ Los miembros estáticos pertenecen a la clase, no a los objetos.

[<modifiAcceso>] static <tipo> <identificador>;

[<modifiAcceso>] static <tipo> <nombre> (<params>) {

}
 Variables y Métodos Estáticos (I)

➔ Los miembros estáticos pertenecen a la clase y son accesibles

por todos los objetos de esa clase.

➔ Una variable estática es una variable global dentro de la clase.

➔ Para acceder a un miembro estático, hay que utilizar el nombre

de la clase a la que pertenece.

double tangente(double x) {
return Math.sin(x) / Math.cos(x);
}
 Variables y Métodos Estáticos (II)

➔ Los métodos estáticos sólo pueden acceder a sus propios

parámetros y a las variables estáticas y no se pueden

sobreescribir.

class Error {
int x;
public static int y;

public static void calcular() {

y = 15;
x = 20; ⇒ ERROR
}
}
 Ejemplo static

class Mate {
public static final double PI = 3.1416;

public static double sumar(double a, double b) {

return a + b;
}
}
. . .
double res = Mate.sumar(10, 15);
System.out.println(Mate.PI);
 Clases Abstractas

➔ Una clase abstracta es una clase de la que no se pueden crear

objetos.

➔ Representa un concepto que no se puede instanciar.

➔ Se define anteponiendo el modificador abstract a la definición

de una clase.

abstract class Mamifero { . . . }

class Canino extends Mamifero { . . . }
class Felino extends Mamifero { . . . }
class Roedor extends Mamifero { . . . }
. . .
Mamifero m = new Mamifero(); ⇒ ERROR
 Métodos Abstractos

➔ Un método es abstracto si se declara (dentro de una clase

abstracta), pero no se implementa.

➔ Todas las subclases de una clase abstracta deben implementar

los métodos abstractos que tenga definidos.

abstract class Ficha {

public abstract void mover();
}

class Alfil extends Ficha {

public void mover() { . . . }
}

class Torre extends Ficha {

public void mover() { . . . }
}
 Interfaces (I)

➔ Una interface es un conjunto de declaraciones de métodos.

➔ Declaración:

interface <NombreInterfaz> {
<tipo> <nombreMétodo1> (<params>);
<tipo> <nombreMétodo2> (<params>);
. . .
}

➔ Una clase que implementa el código de la interfaz debe

implementar todos sus métodos, aunque no lleven código.
class <NombreClase> implements <NombreInterfaz> {
<tipo> <nombreMétodo1> (<params>) { <código> }
<tipo> <nombreMétodo2> (<params>) { <código> }
. . .
}
 Interfaces (II)

➔ Las interfaces sirven para:

◆ Declarar métodos que serán implementados por una o más

clases.

◆ Definir la interfaz de programación de un objeto, sin

mostrar el cuerpo actual de la clase.

➔ Cada interfaz se escribe en un archivo .java con el mismo nombre

de la interfaz.
 Equivalencia Interfaz - Clase Abstracta

interface Interfaz { abstract class Interfaz {

<tipo> <método1>(); abstract <tipo> <método1>();
<tipo> <método2>(); abstract <tipo> <método2>();
. . . . . .
<tipo> <métodoN>(); abstract <tipo> <métodoN>();
} }
 Operadores de Comparación de Objetos (I)

➔ El método equals(), definido en la clase Object, determina si

las referencias apuntan a un mismo objeto.

public boolean equals (Object obj) {

➔ El método equals() y el operador == comparan las referencias

de los objetos, no sus contenidos.

➔ El método equals() está sobreescrito en ciertas clases

(String, Date, File, etc.) en las que devuelve true cuando el

contenido y el tipo de los objetos son iguales.

➔ Cualquier clase definida por el usuario puede sobreescribir el

método equals().
 Operadores de Comparación de Objetos (II)

class Fecha {
private int dia;
private int mes;
private int año;
. . .
public boolean equals (Object obj) {
Fecha otra = (Fecha)obj;
return this.dia == otra.dia && this.mes == otra.mes
&& this.año == otra.año;
}
}
. . .
Fecha f1 = new Fecha(14,2,2018);
Fecha f2 = new Fecha(21,12,2018);
Fecha f3 = new Fecha(14,2,2018);

if (f1.equals(f2)) { ⇒ FALSE
. . .
}

if (f1.equals(f3)) { ⇒ TRUE
. . .
}
Excepciones
 Introducción

➔ Java incorpora en el lenguaje el manejo de errores en tiempo de

ejecución (división por cero, índice fuera de límites, archivo que

no existe..) ⇒ Tolerancia a fallos.

➔ Estos errores reciben el nombre de excepciones.

➔ Si no se gestiona una excepción, se termina la ejecución del

programa con un mensaje de error.

➔ Programar manejando excepciones hace que se separen el código

de la tarea a realizar y el código de control de errores. Ejemplo:

abrir y leer de un archivo.

 Sentencia try - catch

➔ Sintaxis (dos formas):

try { try {
// Hacer algo // Hacer algo
} catch (SAXException e) { } catch (SAXException | IOException
e.printStackTrace(); | ParserConfigurationException e) {
} catch (IOException e) { e.printStackTrace();
e.printStackTrace(); }
} catch (ParserConfigurationException e)
{
e.printStackTrace();
}

➔ Para gestionar excepciones, se coloca el código que puede

causarlas dentro de la cláusula try y tantas cláusulas catch

como posibles excepciones haya.

 Propagación de Excepciones

➔ Consideremos el siguiente caso:

◆ main() llama al método primero()

◆ primero() llama al método segundo()

◆ En segundo() se produce una excepción.

➔ Si segundo() no captura la excepción con un catch, se propaga

a primero(); si éste tampoco la trata, se propaga a main().

Por último, si en main() tampoco se gestiona, se termina el

programa con un error de ejecución.

 Cláusula finally

try {
// Código protegido que puede provocar excepciones

}
finally {
// Código que se ejecuta siempre al final
}

➔ La cláusula finally define un bloque que se ejecuta siempre

independientemente de que se haya capturado o no la excepción.

➔ Si dentro de try hay una sentencia return, se ejecuta finally

antes de devolver el valor.

 Cláusula try-catch-finally

➔ Sistema de carga de combustible:

try {
abrirManguera();
cargarCosbustible();
}catch (MangueraRotaException e){
darAlarma();
avisarEncargados();
}
finally {
cerrarManguera();
}
Java Swing
 Java Swing

➔ Swing es un extenso conjunto de componentes que van desde los

más simples, como etiquetas, hasta los más complejos como

tablas, árboles y documentos de texto con estilo.

➔ Casi todos los componentes Swing descienden de un mismo padre

llamado JComponent.

➔ Swing es una capa más encima de AWT más que una sustitución

del mismo.

➔ La gran mayoría de clases de Swing comienza con J: JLabel,

JButton, JTable, JProgressBar, etc.

Clases Swing
 JFC y Swing

➔ JFC es el acrónimo para Java Foundation Classes.

➔ Engloba un conjunto de características para construir interfaces

gráficas de usuario y añadir funcionalidad de gráficos e

interactividad a aplicaciones Java.

Característica Descripción

Componentes Swing Componentes desde botones hasta tablas.

Soporte para L&F cambiable Es posible cambiar la apariencia y comportamiento de

aplicaciones Java Swing.

API de accesibilidad Habilita accesibilidad en los componentes.

API Java 2D Facilita la incorporación de gráficos 2D en alta calidad.

Internacionalización Posibilita a la aplicación interactuar con usuarios de todo

el mundo en su propio idioma y convenciones culturales.
 Paquetes Java Swing

➔ El API Swing es poderoso y flexible (e inmenso). Consta de 18

paquetes:

javax.accessibility javax.swing.plaf

javax.swing.text javax.swing

javax.swing.plaf.basic javax.swing.text.html

javax.swing.border javax.swing.plaf.metal

javax.swing.text.html.parser javax.swing.colorchooser

javax.swing.plaf.multi javax.swing.text.rtf

javax.swing.event javax.swing.plaf.synth

javax.swing.tree javax.swing.filechooser

javax.swing.table javax.swing.undo
 String es una clase Thread-safe

➔ Es posible llamar a cualquier método de la clase String desde

múltiples hilos de ejecución.

➔ String es inmutable.
 Swing no es Thread-safe

➔ Los componentes de Swing como JLabel, JTable,

JTextfield, etc. no son Thread-safe lo que significa que no se

puede llamar a los métodos de esos componentes más que del hilo

EDT (Event Dispatcher Thread).

SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
final JFrame ventana = new JFrame("My frame:)");
ventana.setSize(300,300);
ventana.setVisible(true);
}
});
Java FX
 Introducción a JavaFX

➔ JavaFX es una familia de productos y tecnologías de Oracle para

la creación de RIAs (Rich Internet Applications), esto es,

aplicaciones web que tienen las características y capacidades de

aplicaciones de escritorio.

➔ Las aplicaciones JavaFX pueden ser ejecutadas en una amplia

variedad de dispositivos lo que permite crear aplicaciones de

escritorio, para celulares, para la Web, TV, consolas de

videojuegos, reproductores Blueray.

 Aplicaciones JavaFX

➔ Dado que JavaFX está disponible como un API Java, el código de

la aplicación JavaFX puede hacer referencia al API de otros

paquetes Java.

➔ El L&F (Look and Feel) de las aplicaciones JavaFX puede ser

personalizado a través de CSS (Cascading Style Sheets).

➔ Se puede crear las interfaces por código o usando JavaFX Scene

Builder.
 Crear una aplicación JavaFX

➔ Debido a que las aplicaciones JavaFX están escritos en el

lenguaje Java puede utilizarse cualquier IDE que admita Java

como Netbeans, Eclipse o IntelliJ IDEA.

 Scene Graph

➔ El gráfico de escena (Scene Graph) JavaFX es el punto de

partida para la construcción de una aplicación JavaFX.

➔ Es un árbol jerárquico de nodos que representa todos los

elementos visuales de la interfaz de usuario de la aplicación.

➔ Puede controlar la entrada y puede ser renderizado.

➔ Un simple elemento en el gráfico de la escena es llamado nodo.

➔ Cada nodo tiene un ID, clase de estilo y un volumen de

delimitación.

➔ Todos los nodos tienen tienen un padre y 0 más hijos, excepto el

nodo raìz: el gráfico de escena.

Android
 Android

➔ Android es el sistema operativo utilizado en más de mil millones

de teléfonos inteligentes y tablets.

➔ A cada versión de Android se le ha puesto el nombre de un dulce.

➔ Si hay una nueva versión de Android eso significa que ahora es

posible realizar algo nuevo con nuestro dispositivo.

 Historia de Android (I)

➔ Comenzó el año 2003 siendo una compañia creada por Andy

Rubin, Rich Miner y otros.

➔ Su meta era desarrollar un sistema operativo inteligente que

tuviese en cuenta la localización y los gustos de su propietario y

actuase en consecuencia.

➔ El año 2005 la compra la compañia y el proyecto y deciden poner

todo su esfuerzo para lanzar un buen producto al mercado.

 Historia de Android (II)

➔ El año 2008 sale la primera versión: Android 1.0 (Apple Pie)

➔ El año 2009 sale Android 1.1 (Banana Bread)

➔ En abril de 2009 sale Android 1.5 (Cupcake) que ya incluye un

SDK, el cual permitió el desarrollo de aplicaciones por parte de

terceros.

➔ En septiembre de 2009 sale Android 1.6 (Donut) que incluye un

cuadro de búsqueda rápida, soporte a diversidad de tamaños de

pantalla mediante density-independent pixel (dp).

➔ En noviembre de 2009 sale Android 2.0 (Eclair) que incluye

Google Maps, pantalla de inicio personalizada, inicio de comandos

por voz.
 Historia de Android (III)

➔ En mayo de 2010 sale Android 2.2 (Froyo) que incluye mejoras en

las funciones por voz, zona Wifi portatil, mejoras en

rendimiento.

➔ En diciembre de 2010 sale Android 2.3 (Giberbread) que incluye

mejoras en NFC, gestión de batería, api para el desarrollo de

video juegos.

➔ En febrero de 2011 sale Android 3.0 (Honeycomb) diseñado para

Tabletas, pantallas más grances, botones touch, botón multitask.

➔ En octubre 2011 sale Android 4.0 (Ic cream sandwich) que

incluye pantalla de inicio personalizada, carpetas para

aplicaciones, control de uso de datos.

 Historia de Android (IV)

➔ Android 4.1 (Jelly Bean) sale en Julio de 2012 con Google Now.

➔ Android 4.4 (Kit Kat) sale en Octubre de 2013 con Ok Google,

teléfono inteligente que aprende de las preferencias del usuario.

➔ Android 5.0 (Lollipop) sale en Junio de 2014 que incluye Material

Design, Multipantalla, Notificaciones en la pantalla de bloqueo.

➔ Android 6.0 (Marshmallow) sale en Agosto de 2015 que incluye

gestor de permisos.

➔ Android 7.0 (Nougat) sale en Mayo de 2016 que incluye

incremento del lenguaje, notificaciones y seguridad.

➔ Android 8.0 (Oreo) sale en Agosto de 2017 que incluye una

forma más rápida de acelerar las nuevas versiones de Android.

 Requerimientos

➔ Sistema Operativo:

◆ Windows: 7/8/10 (32 o 64 bits)

◆ Mac: 10.8.5 o versiones posteriores

◆ Linux: Gnome o KDE 64 bits que pueda correr 32 bits.

➔ Memoria: mínimo 4 Gb de RAM, se recomienda 8 Gb.

➔ Disco: 4 Gb de espacio mínimo disponible en el disco.

➔ Resolución de pantalla: 1280x800.

➔ Para el emulador acelerado: Sistema operativo de 64 bits y

procesador Intel.

➔ Software: Java, Android Studio, SDK Android.

https://developer.android.com/studio/index.html#Requirements
 SDK Android

➔ Versiones de API de Android.

➔ Emuladores para dispositivos virtuales.

➔ SDK Tools.
 Arquitectura de Android

➔ Proyecto Android:

◆ Código fuente (Java).

◆ Archivos de recursos y vistas.

◆ Android Manifest.

◆ Librerías de código.

➔ Ejecutable APK

◆ Apk es tipo de empaquetado.

◆ Contiene archivos .dex.

◆ Resources (imágenes, fuentes).

◆ Android Manifest.
 Android Studio

➔ Basado en IntelliJ IDEA.

➔ Instant run.

➔ Editor de código inteligente.

➔ Diseño para equipos.

➔ Desarrollo para todos los dispositivos Android.

 SDK Manager

➔ El SDK Manager permite seleccionar las APIs que necesitamos y

la ruta donde se van a guardar estas.

➔ Como mínimo se recomienda instalar la versión menor y la más

reciente a la que se quiera soportar.

➔ Es recomendable considerar desde la versión Android 4.0.

 AVD Manager

➔ AVD (Android Virtual Device)

➔ El AVD Manager permite crear un emulador.

➔ Un AVD contiene un perfil de hardware, imagen del sistema,

área de almacenamiento, apariencia y otras propiedades.

 Modelo Vista Controlador en Android

➔ Las aplicaciones en Android tienen por defecto arquitectura

MVC.

➔ Vistas: La interfaz definida en XML.

➔ Controlador: Controla todo lo que la vista necesita hacer.

➔ Modelo: La lógica de negocio relacionada directamente con los

datos de la aplicación.
 View

➔ Un view es un objeto que sirve para dibujar algo en la pantalla

con el cual el usuario puede interactuar.

https://developer.android.com/reference/android/view/View.html
 LinearLayout

➔ Es un ViewGroup que alinea a todos los hijos en una sola

dirección: vertical u horizontal.

https://developer.android.com/guide/topics/ui/layout/linear.html