Your SlideShare is downloading. ×
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Intro Java
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Intro Java

35,366

Published on

Introduccion a Java

Introduccion a Java

Published in: Technology
5 Comments
5 Likes
Statistics
Notes
No Downloads
Views
Total Views
35,366
On Slideshare
0
From Embeds
0
Number of Embeds
5
Actions
Shares
0
Downloads
1,189
Comments
5
Likes
5
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Introducción a Java Cecilia Hernández 2007
  • 2. 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
  • 3. 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
  • 4.
    • Documentación
      • http://java.sun.com/developer/onlineTraining/
        • 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/
    Java
  • 5. Programando en Java
    • Primer programa
    • 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
    public class Hello { public static void main(String[] args) { System.out.println("Hola, amigo!!"); } }
  • 6. 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
  • 7. Palabras clave en Java
    • Palabras claves tienen significado especial y no pueden usarse como identificadores de variables ni clases ni métodos
    abstract default if private this boolean do implements protected throw break double import public throws byte else instanceof return transient case extends int short try catch final interface static void char finally long strictfp volatile class float native super while const for new switch continue goto package synchronized
  • 8. 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
  • 9. 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;
  • 10. Control de flujo
    • Ciclos
      • for(), while(), do-while()
    • Condicionales
      • If – else
      • switch (expresion){
        • case n: sentencias;
        • case m: sentencias;
        • default: sentencias;
        • }
  • 11. 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
  • 12. 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
  • 13. 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.
  • 14. 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++; }
  • 15.
    • 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
    Métodos estáticos
  • 16. 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);
  • 17. 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
  • 18. 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());
        • }
  • 19. 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
  • 20. Interfaces
    • Como contrato entre clases y ambiente
      • Cuando una clase implementa una interfaz promete que implementa comportamientos definidos en interfaz
    • 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
      • 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
  • 21. 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 ?
  • 22. 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
  • 23. 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
  • 24. 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()
  • 25. 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
        • }
  • 26. 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
  • 27. 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
  • 28. 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
  • 29. 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
  • 30. 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
  • 31. 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 )
  • 32. 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
  • 33. 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
  • 34. 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(); } }
  • 35. 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
  • 36. 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
  • 37. 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
  • 38. 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);
    • }
  • 39. Productor consumidor Semáforos
    • public void put(Object value) throws InterruptedException {
    • vacios.acquireUninterruptibly();// WAIT()
    • mutex.acquireUninterruptibly();
    • queue[inptr] = value;
    • System.out.println(&quot;P : &quot; + count);
    • inptr = (inptr + 1) % size;
    • count++;
    • mutex.release();// SIGNAL()
    • llenos.release();
    • }
  • 40. 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(&quot;C : &quot; + count);
    • mutex.release();
    • vacios.release();
    • return value;
    • }
  • 41. 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(&quot;Produciendo item : &quot; + i);
    • buf.put(new Integer(number++));
    • } catch (InterruptedException e) {
    • System.out.println(&quot;Error al producir : &quot; + e.getMessage());
    • }
    • }
    • }
    • }
  • 42. 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(&quot; Consumiendo : &quot; + j.toString());
    • } catch (InterruptedException e) {
    • System.out.println(&quot;Error al consumir : &quot; + e.getMessage());
    • }
    • }
    • }
    • }
  • 43. 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();
    • }
    • }

×