Download Introduccion a Java

Introducción a Java
Cecilia Hernández
2007
Introducción a Java


Lenguaje de Programación Orientado a Objetos
Características
 Independiente de la plataforma
• Compilador no genera código ejecutable nativo a la
máquina donde se ejecuta
• Compilador produce un formato especial llamado byte
codes
• Para que bytescodes puedan ejecutarse en una máquina
específica se necesita un intérprete en tiempo de
ejecución. El intérprete es el que genera código de
lenguaje de máquina entendido por la máquina
• Ambiente de ejecución normalmente se conoce como Java
Virtual Machine (JVM)

Recolector de basura
• Memoria es liberada automáticamente cuando JMV lo
determina
Plataforma Java


Incluye
 J2SE Java 2 Standard Edition
 J2EE Java 2 Enterprise Edition
 Java ME Java APIs para desarrollo de aplicaciones en
PDAs y celulares
 Compilador Just in time. En lugar de interpretar una
instrucción a la vez, interpreta el bytecode completo a
código nativo en máquina cuando se carga en MV
Versión
 Version actual de Java es normalmente referida a 1.6 o
6.0
Java

Documentación

http://java.sun.com/developer/onlineTrainin
g/
• Tutorial J2SE JDK
http://java.sun.com/docs/books/tutorial/index.html

Especificación de API de Java Standard Edition
6.0

http://java.sun.com/javase/6/docs/api/
Programando en Java

Primer programa
public class Hello {
public static void main(String[] args) {
System.out.println("Hola, amigo!!");
}
}



Compilador: javac : Traduce archivos .java en .class
(bytecodes)
Intérprete: java : dinámicamente ejecuta programa previa
interpretación de bytecode a código de lenguaje de máquina
Existen ambientes para la creación, edición, compilación y
ejecución: Eclipse, NetBeans, DrJava, etc
Estructura de programas en Java


Cada programa ejecutable en java consiste
en una clase
Aplicación


Al menos una de las clases debe contener el
método main
Declaración de método main debe ser método
estático
• Metodo asociado a clase no objeto

Declaración public, cualquiera puede invocarlo
Palabras clave en Java
abstract
boolean
break
byte
case
catch
char
class
const
continue

default
do
double
else
extends
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
package
private
this
protected throw
public
throws
return
transient
short
try
static
void
strictfp
volatile
super
while
switch
synchronized
Palabras claves tienen significado especial
y no pueden usarse como identificadores
de variables ni clases ni métodos
Tipos de datos

Tipos primitivos

Tipos de datos simples definidos por el
lenguaje de programación
• En Java son 8
• boolean (true o false), char (16 bits set
caracteres unicode), byte (8 bits con signo),
short (16 bits), int (32 bits), long (64 bits), float
(32 bits punto flotante), double (64 bits punto
flotante)
• Tipos no primitivos se conocen como Tipos
Objetos
Constantes

Declaración


public static final <type>
<name> = <value> ;
Ejemplos
public static final int DAYS_IN_WEEK = 7;
public static final double INTEREST_RATE =
3.5;
public static final int SSN = 658234569;
Control de flujo

Ciclos


for(), while(), do-while()
Condicionales


If – else
switch (expresion){
case n: sentencias;
case m: sentencias;
…
default: sentencias;
}
Objetos





Instancias de tipos de datos complejos
llamados clases
Entidad que contiene datos y
comportamientos
Existen variables, que almacenan datos
dentro de un objeto
Existen métodos dentro de objeto que
representan su comportamiento
Creación de objetos en Java mediante uso
de keyboard new
Variables de referencia



Variables de tipos de objetos son llamadas
referencias
Referencias no almacenan objeto, sino que
almacenan la dirección de una ubicación en
memoria del objeto
Si uno asigna una referencia a otra para
referirse al mismo objeto, el objeto no es
copiado. Las dos referencias comparten el
mismo objeto. Llamando un método en
cualquiera de las dos variables modificará
el mismo objeto
Variables estáticas static
Variables estáticas
• También se les conoce como class variables
• Variables que se asocian a clase no a objeto
• Variable común a todos los objetos (variables
compartidas entre todos los objetos de la clase)
• Se define como variable de clase con la
palabra clave static
• Ejemplo : Identificador de cuenta de
CuentaBanco. Un número que identifique
únicamente a dueño de cuenta.
Ejemplo variables estáticas
public class CuantaBanco {
private String nombre;
private int balance;
private int Id;
private static int proxIdDisponible = 1;
/** Constructor, establece nombre dueño y
balance inicial de la cuenta */
public CuentaBanco(String nombre, int
balance){
this.nombre = nombre;
this.balance = balance;
this.Id = proxIdDisponible;
proxIdDisponible++;
}
Métodos estáticos

Algunos métodos no están asociados, en forma
natural, con objetos particulares


Ejemplo, métodos en clase Math, sqrt, sin, cos, tan
También podría darse el caso que nos gustaría
llamar un métodos antes de crear un objeto

Tales métodos pueden ser declarados estáticos: el
método no es parte de una instancia sino que de la
clase
• Se invocan enviando mensaje a la clase
• No puede accesar referencia “this” o cualquier
variable o método dentro de un método estático
dado que no está asociado a un objeto
Entrada de datos

Gráfico. Usar un método estático showInputDialog de
la clase JOptionPane

Método despliega un dialog y retorna un string ingresado por
usuario o nulo si entrada se cancela
• Si se desea un entero o real como entrada debe convertirse con
Integer.parseInt o Double.parseDouble
• String input = JOptionPane.showInputDialog(“Ingrese su edad”);
• If(input != null) edad = Integer.parseInt(input);

Texto: Usando System.in (solo lee bytes)

Para leer por caracteres usar InputStreamReader
• InputStreamReader reader = new
InputStreamReader(System.in); // no lee por string, solo
caracteres
• Para leer por líneas usar BufferedReader texto = new
BufferedReader(new InputStreamReader(System.in));
• Ejemplo
• System.out.println(“Ingrese su edad”):
• String input = texto.readLine();
• Int edad = Interger.parseInt(input);
Salida de datos

Modo texto-más simple:


Usando System.out.print (ln)
E/S en java es poderosa, pero no tan
simple.

Mirar
http://java.sun.com/docs/books/tutorial
/essential/io/index.html
Strings

Secuencias de caracteres Unicode


String bienvenida = “Hola”
Strings no inmutables. Una vez creados no se pueden
modificar. Si se necesitan strings que se pueden
modificar usar clase StringBuffer


Clase no contiene métodos de set
Algunos métodos definidos en String
• charAt, length, substring, equal

Para analizar strings se puede usar clase StringTokenizer
String frutas = “uvas, manzanas, peras”
StringTokenizer tokenizer = new StringTokenizer(frutas, “,”);
while (tokenizer.hasMoreElements()){
String fruta = new String(tokenizer.nextToken());
}
Clases

Concretas
Todos sus métodos definidos
 Instanciables
 Pueden ser superclases


Abstractas
Al menos uno de sus métodos no definidos
 No instanciables
 Pueden ser superclases
 Proporcionan implementación parcial

Interfaces

Como contrato entre clases y ambiente


Como clases abstractas, pero sólo permiten
declaración de métodos sin su implementación




Definen conjunto de métodos que son útiles en varias clases
No instanciables
Una clase puede implementar cualquier número de
interfaces


Cuando una clase implementa una interfaz promete que
implementa comportamientos definidos en interfaz
Debe implementar todos los métodos de las interfaces
Un dato puede definirse con tipo de interface
Interaces de java importantes

Runnable, collection, iterator, Comparable
Diseñando con clases

Uno de los mayores beneficios de OO


Reconocer características comunes cuando se
diseña
Como se capturan las características comunes
en un diseño?
• Se quiere definir/describir (estas características) solo
una vez, sin repetirlas en cada clase
• Como se relacionan distintas clases con partes
comunes del diseño ?
Relaciones entre clases

Relación “tiene-un/una”. A esto se denomina
Composición



Ejemplo: Un auto “tiene-un” motor, 4 ruedas, un
volante, etc
La relación en este caso es que un objeto tiene un
componente que es otro objeto
Relación “es un/una” En este caso, una clase
define comportamiento general y clases
específicas definen comportamiento específico

Ejemplo: Persona, estudiante, profesor. Estudiante es
una persona
Herencia

Superclases



Cada clase es un tipo especial de su superclase
Referencias this (a la de objeto actual) super (referencia a superclase)
Herencia Simple en clases


Una clase sólo puede ser derivada de una superclase
Una clase A extends B.
• B es superclase de A o A es clase derivada de B

Herencia Múltiple mediante interfaces

Interfaces como clases abstractas
• public class abstract A
•
abstract void metodo();
• Definen métodos cuya implementación es proporcionada por clases que implementan
interface
• public interface X { …}
• Public interface Y{ … }

Una clase puede implementar múltiples interfaces
• class A implements X, Y

Una clase puede derivar de una clase e implementar
múltiples interfaces

class A extends B implements X,Y
Overloading y Overriding

Overloading


Varios métodos definidos en una clase, todos
con el mismo nombre, pero diferentes
argumentos
Overriding

Usando herencia
• Clase A superclase
• Define método dibujar()
• Clase B subclase
• Redefine método dibujar()
Excepciones

Cualquier cosa que no funcione bien que
podría resultar en una excepción


Exception es una clase con muchas subclases
que permiter capturar diferentes tipos de
problemas
Usar try y catch para capturar excepciones
try
{
// sentencias de código que pueden arrojar
excepciones, ejemplo división por cero
}
catch (ArithmeticException e)
{
// codigo que atiende division por cero
}
Throws vs throw
throw :
Un objeto puede detectar una excepción y enviarla como
respuesta al mensaje.
throws :
public Object clone() throws
CloneNotSupportedException {
•
Indica que método puede (es posible) enviar
excepcion CloneNotSupported. Debe incluirse
la lista de excepciones que método podría
enviar.
• Chequeado por compilador
Algunas excepciones java estándar






IllegalArgumentException
 Valor de parámetro es inapropiado
NullPointerException
 El valor del parámetro es null, cuando no debería
IndexOutOfBoundsException
 Arreglo o lista esta fuera de rango
FileNotFoundException
 No encuentra archivo
InterruptedException
 Se produce una excepción por interrupción
IOException
 Excepciones producidas en E/S
Paquetes

Clases de java se pueden agrupar en paquetes.
 Nombres de paquetes separados por . Como



java.io.* // clases de E/S y archivos
java.util.* // contenedores, date/time,
java.lang.* //clases básicas de java, importadas automáticamente
• Math, Integer, Double, System, Thread, String, etc



javax.swing.* // clases soporte gráfico
java.net.* // clases soporte comm en red, sockets, URLs
Para garantizar nombres de paquetes únicos Sun recomienda dar
nombres en sentido inverso a dominios en urls


Los archivos de paquetes creados deben seguir jerarquía de
directorios dados en secuencia dada en nombre paquete
cl.udec.inf.sc.pedro : Clases definidas en pedro debe estar en
directorio cl/udec/inf/sc/pedro
Importando paquetes



Para importar paquetes de clases ya definidos usar import
Ejemplos
 import java.util.* // incluye un conjunto de contenedores
definidos en java como ArrayLists, Vectors, HashMaps,
Lists, etc
 import java.io.* // incluye clases de clases para
entrada/salida
 import java.lang.* // import no necesario
Si nombre de clase en un paquete es igual a otra en otro
paquete y ambos son importados, de debe usar el nombre
de paquete con clase. Ejemplo
 java.util.Date y java.sql.Date
Creando paquetes

Para poner una clase en un paquete se agrega
la sentencia de package nombre paquete
package cl.udec.inf.pedro;
public class Cuenta{
…
}
 Cuando la sentencia package no se agrega la
clase pertenece al paquete por defecto
Implementaciones de Colecciones
en Java

ArrayList implementa List (usando arreglos)
LinkedList implementa List (usando listas
enlazadas)
HashSet implementa Set (usando tablas hash)
TreeSet implementa Set (usando árboles)
HashMap implementa Map (usando tablas hash)

TreeMap implementa Map (usando árboles)




Arrays, ArrayLists, Vectors


Arrays pueden contener datos primitivos u objetos mientras que ArrayLists
sólo objetos
Arrays son de tamaño fijo, mientras que ArrayLists crecen dinámicamente

ArrayLists en Java 6.0
• Como templates en C++
• Tipo de objeto especificado en momento de creación de ArrayList
• ArrayList<String> vec1 = new ArrayList<String>();
• ArrayList<String> vec2 = new ArrayList<String>(10);
• Algunos métodos comunes
• Add, remove, size, get, contains, indexOf, isEmpty, etc

Ventaja de ArrayList
• No se necesita saber tamaño a priori

Desventaja
• No se puede ocupar la notación [] para obtener elementos

Vectors

Similar a ArrayLists
• Métodos de acceso sincronizados, luego más lento
• Se puede usar notación [] directamente, además de una serie de otros métodos

LinkedLists

Lento acceso itemes individuales, rápido al agregar
Hebras y Sincronización

Hebra


Una secuencia de sentencias de código que
puede estar en ejecución concurrente con
otras hebras
Para crear hebras en Java
• Crear una clase que implementa la
• Clase que implementa interface Runnable
• Class A implements Runnable
• Clase derivada de clase Thread
• Class A extends Thread
• Implementar el método run con un loop que hace
algo en un periodo de tiempo
• Crear una instancia de clase A
• Invocar operación start, la que llama a método run
Creando hebras
/** Opción 1 */
import java.lang.*;
public class A extends Thread
{
private: …
public A(){…}
public void run()
{
....
}
public static void main(String[] args){
A thread1 = new A();
thread1.start();
}
}
/** Opción 2 */
import java.lang.*;
public class B implements Runnable
{
private: …
public B(){…}
public void run()
{
....
}
public static void main(String[] args){
B b = new B();
Thread thread1 = new Thread(b);
thread1.start();
}
}
Otras operaciones sobre hebras

join


Permite a una hebra esperar por la
terminación de otra
sleep

Una hebra puede dormir por un
tiempo dado
• Método estático
Manejando hebras en Java 6

Soporte para aplicaciones
concurrentes

Aplicación crea y maneja hebras
• Mediante uso de clase Thread o interface
Runnable

Pasar tareas concurrentes a clase
Executor
• API para crear y manejar hebras
• Proporciona pool de hebras para
aplicaciones de gran escala
Sincronización


Sincronización
 Keyword synchronized para indicar, bloque o método sincronizado, sólo
una hebra puede ejecutarse dentro de bloque o método sincronizado
Paquete java.util.concurrent
 Operaciones atómicas: (concurrent.atomic)
• Acciones atómicas sobre variables volátiles
• Variable volatile utilizada para decir a compilador que variable puede ser
modificada por múltiples hebras y se necesita último valor almacenado

Estructuras de datos accesadas atomicamente
• Colas, listas, tablas hash, etc.

Locks
• Hasta java 1.4 cada objeto tiene un lock asociado
• Desde java 1.5 construcciones de locks para locks, LectoresEscritores y locks
reentrantes

Semáforos
• Desde java 1.5
• http://java.sun.com/javase/6/docs/api/

Monitores
• Usar keyword synchronized para exclusión mutua en métodos
• Hasta java 1.4 sólo soportaba una variable de condición por objeto
•
•
wait() y notifyAll() como acciones en variable de condición (En Java, única por objeto)
Monitor tipo Mesa luego, wait() debe ser encerrado en ciclo while()
• Desde java 1.5 clase Condition (son variables de condición)
•
await(), signal() y signalAll() son los principales métodos disponibles
Ejemplo Productor-Consumidor con
semáforos
import java.util.concurrent.Semaphore;
public class QueuePC {
private int size;
private Object[] queue;
private int inptr = 0;
private int outptr = 0;
private int count = 0;
private Semaphore vacios;
private Semaphore llenos;
private Semaphore mutex;
public QueuePC(Integer size) {
this.size = size.intValue();
queue = new Object[size];
vacios = new Semaphore(size, true);
llenos = new Semaphore(0, true);
mutex = new Semaphore(1, true);
}
Productor consumidor Semáforos
public void put(Object value) throws
InterruptedException {
vacios.acquireUninterruptibly();// WAIT()
mutex.acquireUninterruptibly();
queue[inptr] = value;
System.out.println("P : " + count);
inptr = (inptr + 1) % size;
count++;
mutex.release();// SIGNAL()
llenos.release();
}
Productor consumidor Semáforos
public Object get() throws InterruptedException {
Object value;
llenos.acquireUninterruptibly();
mutex.acquireUninterruptibly();
value = queue[outptr];
outptr = (outptr + 1) % size;
count--;
System.out.println("C : " + count);
mutex.release();
vacios.release();
return value;
}
Productor consumidor Semáforos
public class Producer extends Thread {
private QueuePC buf;
private int id;
private static int number=0;
public Producer(QueuePC buf, Integer id) {
this.buf = buf;
this.id = id.intValue();
this.setName(new String(id.toString()));
}
public void run() {
for (int i = 1; i <= 50; i++) {
try {
System.out.println("Produciendo item : " + i);
buf.put(new Integer(number++));
} catch (InterruptedException e) {
System.out.println("Error al producir : " +
e.getMessage());
}
}
}
}
Productor consumidor Semáforos
public class Consumer extends Thread {
private QueuePC buf;
private int id;
public Consumer(QueuePC buf, Integer id) {
this.buf = buf;
this.id = id.intValue();
this.setName(new String(id.toString()));
}
public void run() {
for (int i = 1; i <= 50; i++) {
try {
Object j = buf.get();
System.out.println("\tConsumiendo : " +
j.toString());
} catch (InterruptedException e) {
System.out.println("Error al consumir : " +
e.getMessage());
}
}
}
}
Productor consumidor Semáforos
import java.util.*;
/** Clase que define test de prueba para Problema
ProductorConsumidor usando semaforos */
public class TestSemPC {
public static void main(String[] args){
QueuePC queue = new QueuePC(new Integer(1));
Producer prod1 = new Producer(queue, new Integer(1));
Consumer cons1 = new Consumer(queue, new Integer(1));
Producer prod2 = new Producer(queue, new Integer(2));
Consumer cons2 = new Consumer(queue, new Integer(2));
Producer prod3 = new Producer(queue, new Integer(3));
prod1.start();
prod2.start();
prod3.start();
cons1.start();
cons2.start();
}
}