Programacion Orientada a Objetos con Java

Ing. Rogelio Cesar Rodriguez Cervantes

1. Conceptos de programacion orientada a objetos 

2. El lenguaje Java 
2.1 Introduccion
2.2 Instalacion

3. Fundamentos del lenguaje     
3.1 Tipos de datos y operadores
3.2 Control de flujo
3.3 Arreglos
3.4 Excepciones
3.5 Entrada de datos (BufferedReader)

4. Clases y Creacion de objetos
4.1 Atributos
4.2 Metodos
4.3 Creacion de objetos
4.4 Miembros static
4.5 Constructor
4.6 Control de acceso
4.7 Herencia

5. Interfaz grafica de usuario
5.1 JCF y Swing
5.2 Administrador de diseño
5.3 Escuchadores

6. Applets

Bibliografia
1. Conceptos de programacion orientada a objetos
Paradigma de programación, el cual trata al programa como una colección de objetos 
independientes cooperando uno con otro
Cada objeto es como un programa en miniatura con sus propios datos, metodos y propósito

Fig. 1.1 orientacion a objetos

Objeto
Esto es, un objeto contiene valores específicos de datos y puede realizar el comportamiento 
descrito por una clase. En términos formales un objeto es una instancia de una clase
En JAVA y C++ un objeto es una variable del tipo clase

Clase
Una clase describe que es algo  y que hace. sta encapsula las propiedades y 
comportamiento de un Objeto. En algunos lenguajes como JAVA y C++ una clase es tratada 
como un tipo definido por el usuario

Partes de una clase
Atributos
Estructuras de datos
La parte de datos que describen el objeto
Métodos 
Descripción del comportamiento del objeto, el algoritmo
Operan en los datos del objeto 
También llamados funciones miembros y/o mensajes

Aspectos principales que forman el paradigma orientado a objetos
Identidad
Los datos están cuantificados en entidades discretas y distinguibles llamadas objetos

Encapsulacion 
Es la habilidad de un objeto para combinar los atributos y el comportamiento
Los objetos con la misma estructura de datos (atributos) y comportamiento (operaciones) se 
agrupa para formar una clase
Ejemplo de clases
// Clase en JAVA
class miClase {
   char c;
   static int p=0;
  
  miClase(char cId){
      c = cId;
      p++;   
  }

  void Muestra(){
      ...
  }
}

Herencia
Es la base para la reusabilidad en los lenguajes orientados a objetos. Es la manera por la 
cual los datos y comportamientos son transferidos desde una clase a otra tomando como 
base una relación jerárquica

Ejemplo de herencia

Fig. 1.2 Diagrama ejemplo de herencia

Ventajas de herencia
Agregar datos y códigos a una clase sin tener que cambiar la clase original 
Reusamiento de código 
Cambia el comportamiento de una clase 

Polimorfismo
La palabra esta compuesta del termino griego: “Poly” que significa  “muchos” y “Morph” un 
sufijo que significa “Forma”. En general se refiere a algo con muchas formas. En Orientación 
a Objetos, se refiere a los métodos que tienen el mismo nombre, pero tienen diferente 
comportamiento
Fig. 1.3 Caricatura de ejemplo polimorfismo
2. El lenguaje JAVA

Origen
Creado por James Gosling, Patrick Naughton, Chris Warth, Ed Frank y Mike Sheridan en Sun 
Microsystems. En 1991 llamado OAK. En 1995 renombrado a Java

Versiones
Java 1.0.2, 1995, 250 clases, lento, inovacion applets

Java 1.1, 1997, 500 clases, menos lento, amigable, se hace popular

Java 2 (1.2 – 1998, 1.3 ­ 2000, 1.4 – 2001), 2300 clases, mas rapido, 3 versiones Micro 
Edition (J2ME), Standard Edition (J2SE) y Enterprise Edition (J2EE), se convierte en el 
lenguaje para aplicaciones web y de moviles

Java 5.0 (1.5 – 2005 y siguientes) 3500 clases, mas amigable e implementa algunas cosas 
de otros lenguajes (templates de c++)

Java caracteristicas
Basado en C++ pero simplificado, más fácil de usar, de más alto nivel
Amplía biblioteca estándar de clases predefinidas
Las aplicaciones Java pueden ser ejecutadas en cualquier plataforma sin necesidad de 
recompilación
Gestión avanzada de memoria mediante un recolector de basura
Gestión avanzada de errores, tanto en tiempo de compilación como de ejecución
Distribuido y multihilo

Java vs C++
Java C++
Interpretado Compilado: más eficiente (± 8:1)
Totalmente portable Aspectos no portables
Memoria dinámica Memoria automática gestionada por el RTS
Garbage collection Memoria dinámica gestionada por el programador
No existen punteros Métodos virtuales y no virtuales
Todos los métodos virtuales Permite herencia múltiple
No tiene herencia múltiple Muy limitada (dynamic_cast)
Información completa sobre las clases en tiempo de  Punteros a void
ejecución Librerias externas, WIN32, MFC, OWL, QT, 
Tratamiento genérico de tipos (wrappers) wxWindows, etc. 
Soporte estándar para interfaces de usuario: AWT, JFC Librerias externas, SDL, etc.
Soporte estándar para concurrencia Librerias externas, CORBA, ActiveX, etc.
Soporte estándar para objetos Variedad de sintaxis y casos excepcionales
distribuidos: RMI Compatible con C
Ejecutable en web browsers(applets)
Homogeneidad del lenguaje
 Ediciones

Standard Edition (J2SE) 
Aplicaciones de propósito general

Enterprise Edition (J2EE)
Aplicaciones de gestión en entornos empresariales

Micro Edition (J2ME)
Aplicaciones para teléfonos móviles, PDAs y otros dispositivos electrónicos que permitan 
aplicaciones embebidas

Kits a bajar en http://java.com
El Java Development Kit (JDK), permite desarrollar y ejecutar aplicaciones Java
El Java Runtime Environment (JRE), permite únicamente la ejecución de aplicaciones

Librerias en J2SE
Sonido
Interfaz de usuario (AWT, SWING)
Gráficos 2D y 3D
Manipulación, carga y descarga de imágenes
Acceso a bases de datos (JDBC)
Componentes (JavaBeans)
XML
Redes y acceso a Internet
Programación distribuida (RMI, CORBA)

Compilacion y ejecución de aplicaciones
La compilación genera un ejecutable en bytecode (código intermedio independiente)
Para su ejecución se requiere un JRE específico de la plataforma
El JRE esta formado por una máquina virtual java (JVM) y las librerías de clases.
La JVM interpreta el bytecode o realiza su compilación justo­a­tiempo para que su ejecución 
sea más eficiente

Ventajas y desventajas
Ventajas Desventajas
Se compila la aplicación una vez y los bytecodes son  Velocidad. La interpretación o incluso compilación just­
válidos para cualquier plataforma in­time del bytecode produce aplicaciones. El 
Robusto. La JVM es capaz de detectar gran cantidad  recolector de basura es una sobrecarga adicional al 
de errores procesador
Los ejecutables son pequeños, las librerías de clases  La generalidad hace que no se aprovecha totalmente 
vienen junto a la JVM en el JRE de la plataforma  la potencia de la máquina y del sistema operativo.
concreta
Entorno de desarrollo
JDK. El kit de desarrollo básico proporcionado por Sun. 
Puede bajarse gratuitamente para cualquier plataforma en http://java.sun.com

Entornos de desarrollo adicionales
Sun netBeans. Entorno integrado de desarrollo, realizado en Java. Consume bastantes 
recursos.  Gratis http://www.netbeans.org

Borland JBuilder. Entorno integrado de desarrollo., realizado en Java. Gratis versiones 
limitadas http://borland.com

Open source Eclipse, Entorno integrado de desarrollo, realizado en Java. Gratis 
http://www.eclipse.org/ 

Requieren un JDK instalado

Pasos para instalar el JDK en Windows
1. Desistalar versiones anteriores
2. Cerrar todos los programas
3. Ejecutar jdk­1_5_0­windows­i586.exe
4. Seguir el instalador
5. Configuracion del SDK en Windows
6. Windows XP, NT y 2000
7. Click derecho en “My computer”
8. Seleccionar la pestana “Advanced”
10. Click al boton “Environment variables”
11. En “system variables” seleccionar de la lista el “PATH”
12. Click en el boton “edit”
13. Ingresar el path de donde se instalo el jdk hasta el folder bin, por ejemplo: C:\jdk1.5.0\bin;
14. Click en el boton “Ok”
15. Buscar la variable CLASSPATH, si no existe esta listo, cerrar todas las ventanas con un 
click en botones “Ok”
16. Si existe CLASSPATH editar y agregar: C:\jdk1.5.0\lib\tools.jar; c:\javaclasses;

El primer programa en Java
// Hola.java
class Hola {
    public static void main(String[] args)
    {
        System.out.println("Hola a todos");
    }
}

Compilar con:
     javac Hola.java
3. Fundamentos del lenguaje

Tipos de datos primitivos
Enteros
boolean: Puede contener los valores true o false. 
byte:  8­bits.   ­128 y 127. 
short:  16­bits.  ­32768 y 32767. 
int:  32­bits.  ­2147483648 y 2147483647. 
long:  64­bits.  ­9223372036854775808 y 9223372036854775807. 

Flotantes
float: Tamaño 32­bits. 
double: Tamaño 64­bits. 

Caracter
char: 16­bits. Unicode.  0 a 65535

Clases de tipos de datos
Dato primitivo  Clase
byte  Byte
short Short
int  Integer
long Long
float  Float
double  Double
char  Character
­  String
boolean  Boolean
void  Void
­ BigInteger
                 ­ BigDecimal

Operadores
Operadores Aritméticos
+ Suma
­ Resta
* Multiplicación
/ División
% Resto de la División

Operadores Unarios
+  Indica un valor positivo
­  Negativo, o cambia el signo algebraico
++ suma 1 al operando, como prefijo o sufijo
­­ Resta 1 al operando, como prefijo o sufijo

Operadores Relacionales y Condicionales
>  Mayor que el derecho
>= Mayor o igual que
<  Menor que el derecho
<= Menor o igual que
== Igual que
!= Diferente

Operadores Lógicos
&& AND
|| OR
!  Negacion
&  AND (evaluá ambos)
|  OR (evaluá ambos)

Operador de concatenacion
+ Concatena cadenas de caracteres

Operadores a nivel de bits
>> Desplazamiento a la derecha de los bits del operando
<< Desplazamiento a la izquierda de los bits de operando
&  AND a nivel de bit
| OR a nivel de bit

// AreaC.java
// Calcula el area de un cuadrado, 
// Recibe la entrada de la linea de comandos
// Ejemplo: java AreaC 4
class AreaC {
   
    public static void main(String[] arguments) {
      int lado, area; 
      
      lado = Integer.parseInt(arguments[0]);
      area = lado * lado;

      System.out.println("Area del cuadrado " + area);
   }
}

Ejercicio sugerido: Realize un programa que calcule el area de un triangulo, reciba los 
datos de la linea de comandos 
Manejo de excepciones
Cuando se produce un error en un metodo, “se dispara” un objeto Throwable
Cualquier metodo que haya llamado al metodo puede “capturar la excepcion” y realizar lo que 
se considere oportuno
Despues de capturar la excepcion, el control no vuelve al metodo en el que se produjo la 
excepcion, sino que la ejecucion del programa continua en el punto onde se capturo la 
excepcion

try..catch
Captura las excepciones que se hayan podido producir en el bloque de codigo delimitado por 
try y catch

Al producirce la excepcion, la ejecucion del bloque try termina
catch recibe como argumento un objeto Throwable

// bloque 1 Los bloque se ejecutan:
Try { Sin excepciones     : 
// bloque 2 1 –> 2 –> 4
}  Excepcion bloque 2: 
Catch (Exception error) { 1 –> 2* –> 3 –> 4
// Bloque 3 Excepcion bloque 1: 
} 1*
// bloque 4 * el bloque se interumpe

Nota: solo se captura lo que se indica  en el 
catch

// Captura de excepciones
// Ej. Ok              : java AreaC_TryCatch 4
// Ej. Exception Array : java AreaC_TryCatch
// Ej. Exception format: java AreaC_TryCatch X 
class AreaC_TryCatch {
  public static void main(String[] arguments) {
 int lado = 0, area; 
      
    try {
         lado = Integer.parseInt(arguments[0]);
    System.out.println("Sin Excepciones");
    }
    catch(NumberFormatException e) {
   System.out.println("Excepcion formato numero:"+e);
    }
    catch(ArrayIndexOutOfBoundsException e) {
   System.out.println("Indice fuera del rango: "+e);
    }
    area = lado * lado;
    System.out.println("Area del cuadrado " + area);
  }
}

Clausula finally
Se utiliza cuando es necesario ejecutar un blque de codigo idependientemente de si se 
produce o no una excepcion
Por ejemplo cerrar un archivo

// bloque 1 Los bloque se ejecutan:
Try { Sin excepciones     : 
// bloque 2 1 –> 2 –> 4 –> 5
}  Excepcion bloque 2: 
Catch (Exception error){ 1 –> 2* –> 3 –> 4 –> 5
   // Bloque 3 Excepcion bloque 1: 
} 1* ­> 4
finally { el bloque se interumpe
   // bloque 4
}
// bloque 5

Clausula throws
Se utiliza cuando un metodo genera una excepcion que no maneja

Ejemplo:
void miMetodo() throws IOException {

// codigo que puede disparar 
// una exception de tipo IOException
}
import java.io.*;

class CambiaPesos {
  public static void main(String[] args)  throws IOException {
    float dolares, pesos; 
    String s;
     
    BufferedReader reader = new BufferedReader(
                     new InputStreamReader(System.in));
   
    System.out.print("Cuantos Dolares a cambiar? "); 
    s = reader.readLine();
    dolares = Float.parseFloat(s);

    pesos = dolares * 10.5f;

    System.out.println("Cantidad en pesos " + pesos);
  }
}
Control de flujo, if..else
Forma 1:
if (expresion­boleana)
   sentencia

Forma 2:
if (expresion­boleana)
   sentencia
else
   sentencia

La condicion debe producir un resultado boleano

// ParArgs.java
// if..else, recibe # de la linea de comandos
class ParArgs {
   public static void main(String[] arguments) {
      int n, iResiduo;

      n = Integer.parseInt(arguments[0]);
      iResiduo = n % 2;
      if (iResiduo == 0)
         System.out.println("Numero es par");
      else
         System.out.println("Numero es impar");
   }
}

Ejercicio sugerido: Modifique este programa para que utilize un objeto BufferedReader y la 
clausula throws

Control de flujo, ciclos

while
while(expresion­boleana)
  sentencia

do­while
do
   sentencia
while(expresion­boleana) 

for
for(inicializacion; expresion­boleana; incremento)
  sentencia
import java.io.*;
import java.util.*;

class whileAdivina {
  public static void main(String[] args) throws IOException {
    
  BufferedReader entrada = new BufferedReader(
                  new InputStreamReader(System.in));
    
    Random random = new Random();
    String tempString;       
    int iMiNumero, iTuNumero = 1;
    
    iMiNumero = random.nextInt(5) + 1; 
    System.out.println("\n\t\tAdivina el numero\n");
    
    while (iTuNumero != 0) {
      System.out.print("Numero entre 1 y 5 (0 fin) "); 
      
      tempString = entrada.readLine();
      iTuNumero = Integer.parseInt(tempString);         
      
      if (iTuNumero == iMiNumero) {
        System.out.println("\n\t\tADIVINASTE!!!");
        iTuNumero = 0;
      }
      else 
         System.out.println("\n\t\tNO ADIVINASTE.");
    } 
  }
}

import java.io.*;
class doPromedio {
   public static void main(String[] arguments) throws 
                                        IOException {
     String tempString;       
     int iContador, iCalificacion, iTotal;
     float fPromedio;  
     BufferedReader entrada = new BufferedReader(
                    new InputStreamReader(System.in));
   
     iContador = iTotal = 0;

     System.out.println("\n\t\tPromedio (0 fin)\n");
     do {
       System.out.print("Calificacion "+iContador+":"); 

       tempString = entrada.readLine();
       iCalificacion = Integer.parseInt(tempString);  
       
iContador++; //cantidad de calificaciones leidas
        iTotal = iTotal + iCalificacion;
      } while (iCalificacion != 0);
      
      // (iContador ­ 1) porque conto el 0 fin  
      fPromedio = (float)iTotal / (iContador ­ 1);
      
      System.out.println("\nPromedio de " 
                         + (iContador ­ 1 ) 
                         + " calificaciones es " 
                         + fPromedio); 
   }
}

class forArguments {
  public static void main(String[] arguments){
    int i;
    for (i = 0; i < arguments.length; i++)
      System.out.println(arguments[i]);
  }
}

break
Se sale del ciclo/bloque sin ejecutar el resto de las sentencias 

Continue
Detiene la ejecucion de la iterqacion actual y regresa al inicio del ciclo para empezar la 
siguiente iteracion 

switch

switch (valor­entero) {
  case valor­entero1 : sentencia; break; 
  case valor­entero2 : sentencia; break;
  case valor­entero3 : sentencia; break;
  case valor­entero4 : sentencia; break;
  case valor­entero5 : sentencia; break;
  // ...
  default: sentencia;
} 

// switchDolar.java
// Convierte dolares a pesos o viceversa
// ejemplo switch con las clausulas case sin el break
import java.io.*;

class switchDolar {
  public static void main(String[] arguments) 
                          throws IOException { 
    BufferedReader entrada = new BufferedReader(
                    new InputStreamReader(System.in));
    char opcion;
    float dolares, pesos, cambio;
    String sTemp;

    System.out.print("Seleccione la opcion");
    System.out.println(" ingresando la primera letra");
    System.out.println("D olares a pesos");
    System.out.println("P esos a dolares");
    System.out.print("Opcion? ");
 
    //opcion=(char)System.in.read();//deja \n en buffer
    sTemp = entrada.readLine();
    opcion = sTemp.charAt(0);

    switch (opcion) {
      case 'd':
      case 'D':
        System.out.println("Cuantos dolares? ");
        dolares = Float.parseFloat(entrada.readLine());

        // 10.5 por omision es double
        pesos = dolares * 10.5f; // la "f" indica float
        System.out.println("Pesos = " + pesos);
        break;
      // Incompleto, para ejercicio
      default:
      System.out.println("opcion no implementada");
   }
  }
}

Ejercicio sugerido: Modifique el programa para que incluya la conversion a dolares, pida el 
tipo de cambio

Arreglos
Una dimension
Tipo nombre­arreglo[] = new tipo[tamaño];
o
Tipo[] nombre­arreglo = new tipo[tamaño];

Ejemplo (Arreglo de diez elementos):
   // solo la referencia:
   int arreglo[];  O  int[] arreglo; 
   arreglo = new int[10]; // se aloja la memoria

Inicializacion:
int arreglo[] = {1, 2, 5, 10};
Aquí no hay necesidad del new, Java aloja suficiente memoria para almacenar los valores

import java.util.*;
public class arregloMinMax {
  public static void main(String[] args) {
    int[] arreglo; //, xyz; <<­­ todos son arreglos
    //  int a1[], a2;  // solo a1, a2 es solo un int
    int min, max, i;
    Random aleatorio = new Random();

    arreglo = new int[10];
    for (i = 0; i < 10; i++)
       arreglo[i] = aleatorio.nextInt(100); 

    min = max = arreglo[0];
    for (i = 1; i < 10; i++) {
       System.out.println(arreglo[i]); 
       if (arreglo[i] < min) min = arreglo[i];
       if (arreglo[i] > max) max = arreglo[i];
    }
    System.out.println("menor "+min+" mayor "+max);
  }
}

Arreglos
Dos dimensiones
Tipo nombre­arreglo[][]= new tipo[tamaño][tamaño];
o
Tipo[][] nombre­arreglo= new tipo[tamaño][tamaño];

Ejemplo (Arreglo de 2 x 3 elementos):

   // solo la referencia:
   int arreglo[][];  O  int[][] arreglo; 
   arreglo = new int[2][3]; // se aloja la memoria

Inicializacion:
int arreglo[][] = {{1, 2}, {5, 10}};

Aquí no hay necesidad del new, Java aloja suficiente memoria para almacenar los valores

//Ejemplo de arreglo dos dimensiones
// despliega en forma de matriz
import java.util.*;

public class arregloDosDim {
   public static void main(String[] args) {
      int[][] arreglo = new int[2][3];
      int i, j;
      Random aleatorio = new Random();

      for (i = 0; i < 2; i++) {
      for (j = 0; j < 3; j++) {
        arreglo[i][j] = aleatorio.nextInt(10);   
         System.out.print(" " + arreglo[i][j]);
      }
         System.out.println();
      }
   }
}
4. Clases y creacion de objetos

Clase
Una clase es un método lógico de organizar datos y funciones en una misma estructura
La clase es un patrón a seguir al crear objetos
Al definir una clase se define un tipo de dato definido por el usuario y  sirve para crear 
instancias de este tipo de dato, a estas instancias se le llaman objetos

Forma general
[acceso] class nombre_de_clase [extends...][implements...]
{
   [acceso][static] tipo variable1;
   ...
   [acceso][static] tipo variableN;
   [acceso][static] tipo Metodo1(lista_de_parametros)
   {
       ...
   }
   ...
   [acceso][static] tipo Metodo1(lista_de_parametros) 
   {
       ...
   }
}

// testCFecha.java
class CFecha {
   int dd;
   int mm;
   int aa;
   void actualiza(int d, int m, int a){
   if (d > 0 && d < 31)
     if (m > 0 && m < 13)
       if (a > 0) {
          dd = d;
       mm = m;
       aa = a;
       }
   }
   void despliega(){
   System.out.print(dd + "/" + mm + "/" + aa);
   }
}

class testCFecha {
    public static void main(String[] args) {
    CFecha cf =  new CFecha();;

    cf.actualiza(30, 10, 2010);
     cf.despliega();
    }
}

Ejercicio sugerido: 
­ Tomando como base el ejemplo CFecha realize un clase CHora    con una funcionalidad 
parecida.
− Cree varios objetos de tipo Chora
− Que sucede si manda llamar el metodo despliega antes del de actualiza?

Constructores
Es una función miembro con el mismo nombre que la clase y no debe regresar un valor
Un constructor es utilizado para inicializar el objeto cuando es creado
Tipicamente usado para inicializar las variables del objeto o realizar procedimientos 
necesarios para el funcionamiento del objeto
Por omision Java provee un constructor  que inicializa las variables a cero
Al definir un constructor explicitamente elconstructor por omision deja de usarse

// testCFecha2.java
import java.util.GregorianCalendar;
class CFecha2 {
   int dd;
   int mm;
   int aa;
   CFecha2(){
       GregorianCalendar hoy = new GregorianCalendar();
       dd = hoy.get(GregorianCalendar.DAY_OF_MONTH);
       mm = hoy.get(GregorianCalendar.MONTH);
       aa = hoy.get(GregorianCalendar.YEAR);
   }
   void actualiza(int d, int m, int a){
   if (d > 0 && d < 31)
      if (m > 0 && m < 13)
        if (a > 0) {
           dd = d;
        mm = m;
        aa = a;
        }
   }

void despliega(){
   System.out.print(dd + "/" + mm + "/" + aa);
   }
}

class testCFecha2 {
    public static void main(String[] args) {
    CFecha2 cf =  new CFecha2();;

    //cf.actualiza(30, 10, 2010);
    cf.despliega();
    }
}

Ejercicio sugerido: 
­ Modifique el programa para agregar funciones miembro para actualizar en forma 
independiente el dia, el mes y el aňo respectivamente
− Realize el llamado a tales metodos

Miembros de la clase
Al crear una instancia de la clase se crea una copia  de las variables por cada objeto creado
Por lo tanto cada objeto creado tiene sus propias  variables
Con excepción de las variables miembro estáticas

Miembros estaticos
Llas variables miembro estáticas pertenecen a  todos los objetos derivados de la clase
Son globales para todos los objetos de la misma  clase
También son llamadas variables de la clase ya que  su contenido no depende de cada objeto 
Una clase puede contener datos y funciones  estáticas

// testStatic.java
// Usa una variable static para llevar el conteo de 
// instancias de la clase 

class miClase {
   char c;
   static int poblacion = 0;
   miClase(char cId) {
      c = cId;
      poblacion++;
      System.out.println("\n\tCONSTRUCTOR: " + "Objetos creados " + poblacion); 
   }
   void Muestra() {
      System.out.println("\t\t\t" + c);
   }
}

class testStatic {
   public static void main(String[] args) {
      System.out.println("Objetos de miClase " + miClase.poblacion + "\n\n");

      miClase miObjeto1 = new miClase('\001');      
      miObjeto1.Muestra();
      
      miClase miObjeto2 = new miClase('\002');      
      miObjeto2.Muestra();
      
      miClase miObjeto3 = new miClase('\003');      
      miObjeto3.Muestra();

      System.out.println("\n\nObjetos de miClase " + miClase.poblacion);
   }
}

// JuegoAdivina.java
// CLASES: JuegoAdivina(main), CampoDeJuego,
//         JugadorVirtual
// OBJETIVO: Jugadores virtuales tratan de adivinar
// numero generado en el CampoDeJuego

class JuegoAdivina {
    public static void main(String[] args) {
     CampoDeJuego juego = new CampoDeJuego();

     juego.iniciaJuego();
    }
}

// CampoDeJuego.java
class CampoDeJuego {
  JugadorVirtual j1;
  JugadorVirtual j2;
  JugadorVirtual j3;

  void iniciaJuego() {
  j1 = new JugadorVirtual();
  j2 = new JugadorVirtual();
  j3 = new JugadorVirtual();

  boolean adivinoJ1 = false;
  boolean adivinoJ2 = false;
  boolean adivinoJ3 = false;

  int numeroGenerado = (int) (Math.random() * 10);
  System.out.println("Pensando numero entre 0 y 9");

             while(true) {
    j1.Adivina();
    j2.Adivina();
                    j3.Adivina();
    if (j1.numero == numeroGenerado)
     adivinoJ1 = true;

    if (j2.numero == numeroGenerado) 
     adivinoJ2 = true;

    if (j3.numero == numeroGenerado) 
     adivinoJ3 = true;

    System.out.println("Jugador uno adivina? " + adivinoJ1);
    System.out.println("Jugador dos adivina? " + adivinoJ2);
    System.out.println("Jugador tres adivina? " + adivinoJ3);

              if (adivinoJ1 || adivinoJ2 || adivinoJ3) {
             System.out.println("Tenemos un GANADOR!, "
                                   + "el numero era " + numeroGenerado);
                  break;
 }
 else
     System.out.println("Los jugadores " 
+ "deben de intentar otra vez.\n");

}
 }
} 

// JugadorVirtual.java
class JugadorVirtual {
    int numero = 0;

    void Adivina() {
    numero = (int) (Math.random() * 10);
    }
}

Ejercicio sugerido: Implementar un identificador entero automaticamente a cada objeto de 
tipo JugadorVirtual dependiendo de la poblacion (ver ejemplo testStatic.java) y usar el 
identificador en la clase CampoDeJuego.

En vez de:
      System.out.println("Jugador uno adivina? " + adivinoJ1);
Usar:
      System.out.println("Jugador “ + j1.id + “ adivina? "  + adivinoJ1);

Ejercicio: cree una clase Cpersona que incluya: nombre, email, Captura(), Despliega()

Especificadores de acceso
Permiten al autor de una librería de componentes establecer qué está disponible para 
programador y qué no 

private
private String NumeroDeIdentidad;

Las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de la 
clase. No son accesibles desde las subclases de esa clase.

Protected
protected void SoloSubClases(){}

Los métodos protegidos pueden ser vistos por las clases derivadas y también por los 
paquetes.

Public
public void CualquieraPuedeAcceder(){}

Cualquier clase desde cualquier lugar puede acceder a las variables y métodos de instancia 
públicos

package (por omision)
void MetodoDeMiPaquete(){}

Por defecto, si no se especifica el control de acceso
Son accesibles por todos los objetos dentro del mismo paquete, pero no por los externos al 
paquete.

Niveles de acceso pemitidos por cada especificador

Especificador   clase   subclase   paquete   todos

private   X 
protected      X  X  X 
public    X  X  X     X
package    X  X X

// SafeArray.java
// Clase para prevenir errores en runtime en arreglo
class SafeArray {
    private int a[];
    private int error;
    public int length;
    
    // crea arreglo dado tamano y valor a regresar
    // si el indice dado esta fuera de rango
    public SafeArray(int n, int errv) {
    a = new int[n];
    error = errv;
    length = n;
    }
    // regresa un valor dado el indice
    public int get(int i) {
    if (enRango(i))
        return a[i];
    return error;
    }   

// pone un valor en el arreglo, 
   // regresa falso en caso de fallo
   public boolean put(int i, int valor) {
   if (enRango(i)) {
       a[i] = valor;
       return true;
    }
    return false;
    }
    
    // regresa falso si el indice no esta en los rangos
    private boolean enRango(int i) {
    if (i >= 0 && i < length)
        return true;
    return false;
    }
}

// testSafeArray.java
// desmuestra el uso del SafeArray
class testSafeArray {
  public static void main(String[] args) {
  SafeArray sa = new SafeArray(5, ­1);
  int x, i;

System.out.println("Falla sin desplegar errores");
for (i=0; i < (sa.length * 2); i++)
    sa.put(i, i * 10);

for (i=0; i < (sa.length * 2); i++) {
    x = sa.get(i);
    if (x != ­1)
System.out.print(x + " ");
}

System.out.println();

System.out.println("\n*Falla reportando errores*");
for (i=0; i < (sa.length * 2); i++)
   if (sa.put(i, i * 10) == false)
   System.out.println("Indice " + i + " fuera de rango");

System.out.println();

for (i=0; i < (sa.length * 2); i++) {
   x = sa.get(i);
   if (x != ­1)
System.out.print(x + " ");
   else
System.out.print("\nIndice " + i  + " fuera de rango");
}
    }
}

Ejercicio: ponga los modificcadores de acceso a la clase Cpersona que realizo en el 
ejercicio anterior

Herencia
Consiste en utilizar una clase ya creada para tomar sus características y convertirla en una 
clase mas especializadas
Para de esta manera reutilizar el código que sea común con la clase base
Y solamente definir nuevos métodos o redefinir algunos de los existentes para ajustarse al 
comportamientos particulares de esta sub­clase.

// JugadorHumano.java
import java.io.*;

class JugadorHumano extends JugadorVirtual {
  int readInt(){
    BufferedReader reader = new BufferedReader(
new InputStreamReader(System.in));
    String s = "0";
    int n = 0;

    try {
     s = reader.readLine();
     numero = Integer.parseInt(s);
    }
    catch(IOException e) {
     System.out.println("IOException: " + e);
    }
    catch(NumberFormatException e) {
    System.out.println("NumberFormatException:" + e);
    }   
      

finally {
       return n;
      }
    } 
    
    public void Adivina() {
      System.out.print("Jugador pide numero "); 
      numero = readInt();
    }
} 

// CampoDeJuego.java
class CampoDeJuego {
  JugadorVirtual j1;
  JugadorVirtual j2;
  JugadorHumano humano;

  public void iniciaJuego() {
  j1 = new JugadorVirtual();
  j2 = new JugadorVirtual();
  humano = new JugadorHumano();

  boolean adivinoJ1 = false;
  boolean adivinoJ2 = false;
  boolean adivinoHumano = false;

  int numeroGenerado = (int) (Math.random() * 10);
 System.out.println("Pensando numero entre 0 y 9");  

while(true) {
  j1.Adivina();
  j2.Adivina();
  humano.Adivina();

  if (j1.numero == numeroGenerado) adivinoJ1 = true;
  if (j2.numero == numeroGenerado) adivinoJ2 = true;
  if (humano.numero == numeroGenerado) 
  adivinoHumano = true;

 System.out.println("Jugador 1 adivina? "+adivinoJ1);
 System.out.println("Jugador 2 adivina? "+adivinoJ2);
System.out.println("Jugador 3 adivina?"+adivinoHumano);

  if (adivinoJ1 || adivinoJ2 || adivinoHumano) {
       System.out.println("GANADOR!, el numero era " + numeroGenerado);
      break;
  }
  else 
       System.out.println("intentar otra vez.\n");
}
}
}
5. Interfaz grafica de usuario

JFC (Java Foundation Classes)
Grupo de características para ayudar a construir interfaces gráficas de usuario

Librerias:
 AWT
 Java 2D
 Accessibility
 Drag and Drop
 Swing

Swing
Escrito totalmente en java
Se apoya sobre AWT y añade JComponents
Utiliza el modelo de eventos
Selección de diferentes apariencias
Proporciona utilidades para facilitar creación de aplicaciones gráficas

Apariencia
GUI independiente de la plataforma existente
Identica apariencia en distintas plataformas
Permite usar diferentes apariencia
Pueden programarse nuevas apariencia

Paquetes principales
javax.swing
javax.swing.event

Componentes
Contenedores de alto nivel:
 JFrame, JApplet, JWindow, JDialog 

Componentes ligeros:
JButton, JPanel, JTree, etc. 

Los contenedores de alto nivel prestan funcionalidad a los componentes ligeros:
Espacio donde pintarse, Manejo de eventos, etc.
Un componente puede contener otros componentes

Ejemplo: un boton con una imagen

// TestHolaSwing.java
import javax.swing.*;

class HolaSwing extends JFrame{  
   HolaSwing(){
    JLabel lblHola = new JLabel( "Hola a todos!" );

    setDefaultCloseOperation(EXIT_ON_CLOSE);
    
    getContentPane().add( lblHola );
    setSize(200, 100);
    setVisible( true );
  }
}

public class TestHolaSwing {
  public static void main( String argv[] ) {
      HolaSwing hola = new HolaSwing();
  }
}

Lista de componentes
 
Componente                   
                     
     Descripción
   
JButton  Botón
JCheckBox  Botón de comprobación.
JCheckBoxMenuItem  Botón de comprobación para usar en menús
JColorChooser  Selector de colores
JComboBox  Entrada de texto con lista de valores
JComponent  Raíz de la jerarquia de componentes Swing
JEditorPane  Editor de texto. Normalmente HTML o RTF
JFileChooser  Selector de ficheros
JLabel  Etiqueta
JList  Lista
JMenu  Menú dentro de un JMenuBar o dentro de otro menú
JMenuBar  Barra de Menús
JMenuItem  Elemento seleccionable en un menú
JOptionPane  Ventanas de dialogo
JPasswordField  Entrada de passwords
JRadioButton  Botón excluyente
JRadioButtonMenuItem  Botón excluyente para usar en menús
JScrollBar  Barra de desplazamiento
JSeparator  Líneas de separación
JSlider  Deslizador
JTable  Tabla
JTextArea  Edición de múltiples líneas de texto plano
JTextComponent  Raíz de los editores de texto
JTextField  Edición de una línea de texto plano
JTextPane  Subclase de JEditorPane para hacer procesadores de texto
JToggleButton  Padre de JCheckBox y JRadioButton
JToolBar  Barra de herramientas o acciones
JToolTip  Ventana informativa
JTree  Árboles

Contenedores
 
Contenedor                   
                     
    Descripción
   
Box    Posiciona hijos usando BoxLayout
JApplet  Applets
JDesktopPane  Desktop que contiene JInternalFrame(s)
JDialog  Presentación de dialogos
JFrame  Ventana
JInternalFrame  Ventana interna. Suele usarse dentro de un JDesktopPane
JLayeredPane  Contenedores apilados
JPanel  Agrupar hijos
JRootPane  Usado por JApplet, JDialog, JFrame, JInternalFrame y JWindow Proporciona muchas 
características
JScrollPane Añade barras de desplazamiento a su hijo
JSplitPane  Muestra dos hijos pudiendo ajustar sus tamaños relativos
JTabbedPane  Solapas para mostrar diferentes hijos
JViewPort  Muestra una parte de sus hijo. Típicamente usado por  JScrollPane
JWindow  Ventana sin decoración

// TestCForma.java
import javax.swing.*;
class CForma extends JFrame { 
  JLabel usernameLabel    = new JLabel("Username  : ");
  JLabel passwordLabel  = new JLabel("Password  : ");
  JTextField     username = new JTextField(15);
  JPasswordField password = new JPasswordField(15);
  JButton        btnAcepta= new JButton("Acepta");
  public CForma() {
    super("Forma");  // Titulo de la forma
    setDefaultCloseOperation(EXIT_ON_CLOSE);
  
    setSize(260, 140);
    JPanel panel = new JPanel();
    panel.add(usernameLabel);
    panel.add(username);
    panel.add(passwordLabel);
    panel.add(password);
    panel.add(btnAcepta);
 
   setContentPane(panel);

   setVisible(true);
  }
}

Manejador de eventos
Cada vez que el usuario interactúa con la aplicación se dispara un evento
Para que una componente reaccione frente a un evento, debe tener un "escuchador"
El “escuchador” debe tener al menos un método que se ejecutará al escuchar un evento en particular

Ejemplos de eventos y sus escuchadores
 
Acción que dispara un evento        
                     
                     
   Tipo de escuchador
   
El usario hace un click, presiona Return
en un área de texto o selecciona un menú ActionListener
El usuario escoje un frame (ventana principal) WindowListener
El usuario hace un click sobre una componente MouseListener
El usuario pasa el mouse sobre una componente MouseMotionListener
Una componente se hace visible     ComponentListener
 Una componente adquiere el foco del teclado  FocusListener
Cambia la selección en una lista o tabla ListSelectionListener

import javax.swing.*;
import java.awt.event.*;
class CAreaC extends JFrame implements ActionListener {
   JLabel     lblLado  = new JLabel("Lado");
   JTextField txtLado  = new JTextField("0", 5);
   JButton btnCalcula  = new JButton("Calcula Area");
   JLabel lblArea      = new JLabel("Area ");
   JLabel lblResultado = new JLabel(""); 
   public CAreaC() {
     super("Calcula el area de un cuadrado");
     setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     setSize(300, 100);
   
     JPanel panel = new JPanel();
     panel.add(lblLado);       
     panel.add(txtLado);
     panel.add(btnCalcula);    
     panel.add(lblArea);
     panel.add(lblResultado);  
     setContentPane(panel);
     btnCalcula.addActionListener(this);
     setVisible(true);
  }
  public void actionPerformed(ActionEvent evento) {
    int lado;
    Object fuente = evento.getSource();
       
     if (fuente == btnCalcula) {
      try {
         lado = Integer.parseInt(txtLado.getText());
         lblResultado.setText("" + (lado * lado));
       } 
       catch (NumberFormatException e) {
          txtLado.setText("0");
          lblResultado.setText("0");
       }
     } 
  }
}

class TestAreaC {
    public static void main(String[] arguments) {
        CAreaC area = new CAreaC();
    }
}

Ejercicio sugerido: 
− Realize un programa que calcule el area de un triangulo utilizando el swing

Administrador de diseño
Utilizado para organizar los componentes que se agregan a un contenedor y mostrarlos a la vez en un 
orden preestablecido

Cada contenedor tiene asignado un administrador de diseño de forma predeterminada

FlowLayout
Coloca los componentes de izquierda a derecha (igual que se coloca el texto en un párrafo)

BorderLayout
Divide un contenedor en cinco secciones denominadas: norte, sur, este, oeste y centro. Los 
componentes se colocarán en una sección u otra según decidamos

GridLayout
Coloca los componentes en filas y columnas

CardLayout
Permite colocar grupos diferentes de componentes en instantes diferentes de la ejecución (similar a los 
paneles con pestañas)

GridBagLayout
Coloca los componentes en filas y columnas. A diferencia de GridLayout, permite que un componente 
pueda ocupar más de una columna

BoxLayout
Coloca los componentes en una única fila o columna, ajustándose al espacio que haya

Ejemplo
// TestCBordes.java
import javax.swing.*;
import java.awt.*;

class CBordes extends JFrame {
   ImageIcon icon = new ImageIcon("mundo.gif");      
   
   JButton boton1 = new JButton("Norte");
   JButton boton2 = new JButton("Sur", icon);
   JButton boton3 = new JButton("Este");
   JButton boton4;
   JButton boton5;
      
   CBordes() {
      super("Border Layout");
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      setSize(640, 480);
      boton3.setIcon(icon);
      boton4 = new JButton("Oeste");
      boton5 = new JButton(icon);

 BorderLayout lm = new BorderLayout();   
      JPanel panel = new JPanel();
      
      panel.setLayout(lm);
      panel.add("North", boton1);
      panel.add("South", boton2);
      panel.add("East",  boton3);
      panel.add("West",  boton4);
      panel.add("Center",boton5);
      setContentPane(panel);

     // reduce el tamano de la ventana a lo necesario:
      pack(); 
      setVisible(true);
   }
}

class TestCBordes {
   public static void main(String[] arguments) {
      CBordes borde = new CBordes();
   }
}
import javax.swing.*;
import java.awt.*;
class CGrid extends JFrame {
   JButton[] boton = new JButton[6];
   int i;
   CGrid() {
      super("Border Layout");
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      setSize(640, 480);      
      GridLayout lm = new GridLayout(3, 2, 10, 10);   
      JPanel panel = new JPanel();

      panel.setLayout(lm);
      for (i = 0; i < 6; i++) {
         boton[i] = new JButton("TEST "+ i);
         panel.add(boton[i]);
      }
      setContentPane(panel);
      pack(); 
      setVisible(true);
   }
}

Ejemplo
// Varios Layout managers: 2 GridLayouts
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;

class CAdivina extends JFrame implements  ActionListener, FocusListener {
   int        iMiNumero;
   int        iTuNumero;
   Random     random;
   
   JLabel     lblNumero = new JLabel("Numero (1 ­ 5)");
   JTextField txtNumero = new JTextField(15);
   JLabel     lblAdivina= new JLabel();   
   JButton    btnAcepta = new JButton("Acepta");
   JButton    btnSalir  = new JButton("Salir");

   Font fBold; 

Adivina(){
      super("Adivina el numero que estoy pensando");
      setSize(400, 300);
      setDefaultCloseOperation(EXIT_ON_CLOSE);      

      fBold = new Font("Monospaced", Font.BOLD, 16);
      lblAdivina.setFont(fBold);
      
      GridLayout mainGrid = new GridLayout(3,1,20,20);
      GridLayout grid = new GridLayout(1, 2, 10, 10);
      
      JPanel panel = new JPanel();
      JPanel secPanel = new JPanel();
      JPanel btnPanel = new JPanel();
      
      btnAcepta.addActionListener(this);
      btnSalir.addActionListener(this);
      txtNumero.addFocusListener(this); 

      random = new Random();
      iMiNumero = random.nextInt(5) + 1;

      secPanel.setLayout(grid);
      secPanel.add(lblNumero);
      secPanel.add(txtNumero);

      btnPanel.setLayout(grid);
      btnPanel.add(btnAcepta);      
      btnPanel.add(btnSalir);      

      panel.setLayout(mainGrid);
      panel.add(secPanel);
      panel.add(lblAdivina);      
      panel.add(btnPanel);

      panel.setBackground(Color.yellow);
      setContentPane(panel);
      pack();      
      setVisible(true);
   }

public void actionPerformed(ActionEvent evento) {
      Object fuente = evento.getSource();
      
      if (fuente == btnAcepta) {
         try {
            iTuNumero = Integer.parseInt(
                                  txtNumero.getText());
         } 
         catch(NumberFormatException e) {
            iTuNumero = 0;
         }
         if (iTuNumero == iMiNumero) {
            lblAdivina.setForeground(Color.red);
            lblAdivina.setText("ADIVINASTE!!!");
            iMiNumero = random.nextInt(5) + 1;
         }
         else {
            lblAdivina.setForeground(Color.black);      
            lblAdivina.setText("NO ADIVINASTE.");
         }
      }

 if (fuente == btnSalir) 
         System.exit(0);
   }

   public void focusGained(FocusEvent evento) {
      txtNumero.setText("");
   }

   public void focusLost(FocusEvent evento) { }
}

Ejercicio sugerido: 
− Realize un programa cambie de dolares a pesos, pida el tipo de cambio, utilize varios layout 
managers
6. Applets

Eventos
Evento Llamado
init()  Inicializacion, llamado solo una vez
start()  Despues de Init() y cada vez que recibe  la “atencion” (focus)
paint() Cuando se dibuja el area del applet
stop()  Cuando sale de la “atencion” (focus) 
destroy()  Cuando termina

Ejemplo

import javax.swing.*;
public class swingApplet1 extends JApplet {
   public void init() {
      JLabel jlNota = new 
      JLabel("Primer Applet!"); 
      getContentPane().add(jlNota);
   }
} 

codigo HTML llama la clase anterior

<html>
<head>
<title>swingApplet1</title>
</head>
<body>
   <applet code="swingApplet1" width=200 height=100>
      programa requiere un browser con java.
   </applet>
</body>
</html> 

Ejemplo

import javax.swing.*;
import java.awt.*;

// <applet code=botonApplet width=200 height=50>
// </applet>

public class botonApplet extends JApplet {
   private JButton btnAcepta = new JButton("Acepta");
   private JButton btnCancela = new JButton("Cancela");
 private JLabel lblMensaje=new JLabel("Java daba do!");
  
   public void init() {
      JPanel panel = new JPanel();
      setSize(80, 100);
      panel.add(lblMensaje);
      panel.add(btnAcepta);
      panel.add(btnCancela);
      setContentPane(panel);
  }
}

// Varios Layout managers: FlowLayout, GridLayout

// <APPLET CODE="elAreaC.class" WIDTH=350 HEIGHT=120>
// </applet>

import java.awt.event.*;
import javax.swing.*;
import java.awt.*;

public class elAreaC extends JApplet implements ActionListener {
   int lado, area; 
   JLabel     lblTitulo=new JLabel("Area de cuadrado");
   JLabel     lblLado  = new JLabel("Dame el Lado "); 
   JLabel     lblResp  = new JLabel("Area es "); 
   JLabel     lblArea  = new JLabel("");
   JTextField txtLado  = new JTextField(15);
   JButton    btnAcepta= new JButton("Acepta");

btnAcepta.addActionListener(this);
      
      JPanel mainPanel = new JPanel();
      JPanel secPanel = new JPanel();

      secPanel.setLayout(gridLayout);
      secPanel.add(lblLado);
      secPanel.add(txtLado);
      secPanel.add(lblResp);
      secPanel.add(lblArea);
      
      mainPanel.add(lblTitulo);
      mainPanel.add(secPanel);
      mainPanel.add(btnAcepta);      
   
      setContentPane(mainPanel);
   }

 public void actionPerformed(ActionEvent evento) {
      Object fuente = evento.getSource();
      
      if (fuente == btnAcepta) {
         lado = Integer.parseInt(txtLado.getText());
         area = lado * lado;
         
         lblArea.setText("" + area);
      }
   }
}

Ejercicio sugerido: 
− Realize un applet que cambie de dolares a pesos, pida el tipo de cambio

import javax.swing.*;
import java.awt.*;
//<applet code=GraphicsApplet.class width=1 height=1>
//</applet>
public class GraphicsApplet extends JApplet {
    public void init() {
       resize(400, 300);
       setBackground(Color.black);
       setForeground(Color.green);
    }
    public void paint(Graphics g) {
       Font type=new Font("Monospaced", Font.BOLD, 18);
       g.setFont(type);    
       g.drawString("G r a f i c a s", 70, 40);
       g.drawRect(100, 50, 200, 150); // x1,y1, w, h
       g.drawLine(0, 0, 200, 150);
       g.drawOval(150, 150, 30, 30); 
       g.fillOval(200, 150, 30, 30); 
       g.setColor(Color.yellow); 
       g.fillRect(250, 150, 50, 50);
       g.drawOval(0, 0, 50, 50);
}}

// gifApplet.java, Cambia background, foreground, 
// fonts y despliega una imagen gif
import javax.swing.*;
import java.awt.*;
//<applet code=gifApplet.class width=1 height=1>
//</applet>
public class gifApplet extends JApplet {
   Image imagen;
    public void init() {
         imagen = getImage(getCodeBase(), "mundo.gif");
        resize(400, 300);
        setBackground(Color.black);
        setForeground(Color.yellow);
    }
    public void paint(Graphics g) {
        Font type = new Font("Monospaced", Font.BOLD, 18);
      
        // Font.PLAIN
        g.setFont(type);    
        g.drawString("Nuestro Hogar", 70, 40);
        g.drawImage(imagen, 100, 50, this);
}}
BIBLIOGRAFIA
Teach yourself Java 2 in 21 days
Laura Lemay 
Rogers Cadenhead
SAMS

Head First Java, 2a ed.
Sierra & Bates
O'REILLY

Java 2 a Beginner's guide, 2a ed
Herbert Schildt
Osborne

Excepciones, Fernando Berzal
http://elvex.ugr.es/decsai/java/pdf/B2­excepciones.pdf

Programacion avanzada, Antonio Jesús Rueda Ruiz 
http://wwwdi.ujaen.es/asignaturas/progav/