Manual Java

JAVA

Java es un lenguaje de programación creado por Sun Microsystems para poder funcionar en distintos tipos de procesadores. Su sintaxis es muy parecida a la de C o C++, e incorpora como propias algunas características que en otros lenguajes son extensiones: gestión de hilos, ejecución remota, etc.

El código Java, una vez compilado, puede llevarse sin modificación alguna sobre cualquier máquina, y ejecutarlo. Esto se debe a que el código se ejecuta sobre una máquina hipotética o virtual, la Java Virtual Machine, que se encarga de interpretar el código (ficheros compilados .class) y convertirlo a código particular de la CPU que se esté utilizando (siempre que se soporte dicha máquina virtual).

Cuando se programa con Java, se dispone de antemano de un conjunto de clases ya implementadas. Estas clases (aparte de las que pueda hacer el usuario) forman parte del propio lenguaje (lo que se conoce como API (Application Programming Interface) de Java).

Tipos de datos

Se tienen los siguientes tipos de datos simples. Además, se pueden crear complejos, todos los cuales serán subtipos de Object .

Tipo Tamaño/Formato Descripción Ejemplos

Byte 8 bits, complemento a 2 Entero de 1 byte 210, 0x456

Short 16 bits, complemento a 2 Entero corto "

Int 32 bits, complemento a 2 Entero "

Long 64 bits, complemento a 2 Entero largo "

Float 32 bits, IEEE 754 Real simple precisión 3.12, 3.2E13

Double 64 bits, IEEE 754 Real doble precisión "

Char 16 bits, carácter Carácter simple 'a'

String Cadena de caracteres "cadena"

Bolean true / false verdadero / falso true, false

Identificadores

Nombran variables, funciones, clases y objetos. Comienzan por una letra, carácter de subrayado ‘_’ o símbolo ‘$’. El resto de caracteres pueden ser letras o dígitos (o ’_’). Se distinguen mayúsculas de minúsculas, y no hay longitud máxima. Las variables en Java sólo son válidas desde el punto donde se declaran hasta el final de la sentencia compuesta (las llaves) que la engloba. No se puede declarar una variable con igual nombre que una de ámbito exterior.

En Java se tiene también un término NULL, pero si bien el de C es con mayúsculas (NULL), éste es con minúsculas (null):

String a = null;...if (a == null)...

______________________________________________________________________FISI – UNMSM Luis Guerra G.1

OperadoresSe muestra una tabla con los operadores en orden de precedencia:

Operador Ejemplo Descripción

. a.length Campo o método de objeto

[ ] a[6] Referencia a elemento de array

( ) (a + b) Agrupación de operaciones

++ , -- a++; b-- Autoincremento / Autodecremento de 1 unidad

!, ~ !a ; ~b Negación / Complemento

instanceof a instanceof TipoDato Indica si a es del tipo TipoDato

*, /, % a*b; b/c; c%a Multiplicación, división y resto de división entera

+, - a+b; b-c Suma y resta

<<, >> a>>2; b<<1 Desplazamiento de bits a izquierda y derecha

<, >, <=, >=, ==, != a>b; b==c; c!=a Comparaciones (mayor, menor, igual, distinto...)

&, |, ^ a&b; b|c AND, OR y XOR lógicas

&&, || a&&b; b||c AND y OR condicionales

?: a?b:c Condicional: si a entonces b , si no c

=, +=, -=, *=, /= ... a=b; b*=c Asignación. a += b equivale a (a = a + b)

1. Clase, Objeto, Campos, Métodos


Conceptos de la POO, veremos los conceptos de clase, atributo y operación usando

notación UML; luego su implementación utilizando Java, donde se conoce como clase,

campo y método.

Definición de una clase

Una clase define un tipo de objeto en particular.

Por ejemplo, en una empresa la clase Factura define a todas las facturas que la

empresa emite.

Su sintaxis en Java es:

[ModificadorClase] class NombreClase {

// Campos

// Métodos

}

El ModificadorClase se resume en el siguiente cuadro:

Palabra Clave Descripción

public Define una clase como pública; en caso contrario su visibilidad

será solamente a nivel del paquete donde se encuentra.

abstract Esta palabra clave determina que la clase no puede ser

instanciada; es decir no podemos crear objetos de este tipo de

clase.

Este tipo de clase solo puede ser heredada.

Final Esta palabra clave determina que la clase no puede ser

heredada, quiere decir que no podemos crear subclases de

este tipo de clase.

Este tipo de clase solo puede ser instanciada.

Ejemplo:

class Factura {

// Campos

private int numero;

private double importe;


// Métodos

public void grabar (…) {

. . .

. . .

}

} // Factura

Representación UML de una Clase

Para tener una representación gráfica de una clase se utiliza UML (Unified Modeling

Language), tal como se ilustra en la figura:

Figura 1: Representación UML de una clase

Declaración de Objetos

El operador new se utiliza para crear un objeto de un tipo de clase específica, es decir,

que asigne memoria para el objeto.

Para utilizar el operador new tenemos dos sintaxis.

Sintaxis 1

NombreDeClase nombreDeVariable;

nombreDeVariable = new NombreDeClase ( );

En la primera instrucción se define la variable que apuntará a un objeto que se crea en

la segunda instrucción.

Sintaxis 2

NombreDeClase nombreDeVariable = new NombreDeClase ( );

En este caso tanto la creación de la variable y la creación del objeto se realizan en la

misma instrucción.


Figura 2: Instanciación de una clase (Creación de un objeto)

Asignación de Objetos

Cuando creamos un objeto internamente existe un puntero al que no tenemos acceso,

pero cuando asignamos objetos, lo que realmente estamos asignando son las

direcciones de memoria donde están definidos los objetos, como se explica en la figura

3.

Figura 3: Asignación de objetos

TRABAJANDO CON CAMPOS

Definición

Los campos definen los datos de un objeto; cuando definimos una clase debemos

definirlos y establecer su visibilidad:

La visibilidad determina desde que parte del código se puede acceder al campo.

Sintaxis:

[TipoAcceso] [ModificadorCampo] Tipo nombreCampo [= ValorInicial];

El TipoAcceso puede tomar los valores que se resume en el siguiente cuadro:

Palabra Clave Descripción UML

public Indica que el campo es de acceso público. El acceso

se realiza a través de una instancia del objeto. +


abstract Indica que solo se puede acceder al campo desde

métodos de la misma clase y clases derivadas

(subclases)

Final Indica que solo se puede acceder al campo desde

métodos de la misma clase.

-

Sin especificar Indica acceso de paquete1, se puede acceder al campo

a través de una instancia, pero sólo desde clases que

se encuentren en el mismo paquete.

El ModificadorCampo puede tomar los valores que se resumen en el siguiente cuadro:


static El campo pertenece a la clase, no a los objetos creados a

partir de ella.

Final El campo es una constante, en ese caso debe tener un

valor inicial obligatoriamente. Por convenio en java las

constantes se escriben en mayúsculas.

transient Marca el campo como transitorio, para no ser serializado.

Se usa cuando se trabaja con java beans.

volatile Es un campo accedido de forma asíncrona mediante hilos,

con este modificador se lo notificamos a java.

El ValorInicial permite inicializar la variable con un valor.

De acuerdo a la forma en que se especifica un atributo, objetos de otras clases tienen distintas

posibilidades de accederlos, tal como se resume en el siguiente cuadro:

Acceso Desde private protected public (package)

La propia clase Si Si Si Si

Subclase en el mismo paquete No Si Si Si

Otras clases en el mismo paquete No No Si Si

Subclases en otros paquetes No Si Si No

Otras clases en otros paquetes No No Si No

Ocultando los Datos

1 Los paquetes permiten organizar clases según su naturaleza.______________________________________________________________________FISI – UNMSM Luis Guerra G.6

Uno de los fundamentos de la programación orientada a objetos es que el usuario solo

debe tener acceso a los datos que le son de su interés, y del modo que le corresponde,

por ejemplo solo lectura, solo escritura, ó ambos.

Para conseguir esto se debe declarar los atributos como privados, y se debe

implementar métodos para acceder a ellos. Existe un estándar para definir estos

métodos, por ejemplo, si el campo es nombre los métodos son:

- setNombre Este método permite asignar un valor al campo.

- getNombre Este método permite leer el valor del campo.

Como puede apreciar existen dos prefijos, el prefijo set que se utiliza para asignar un

valor al campo y el prefijo get para leer el valor del campo; de esta manera podemos

seleccionar si se implementa el método set, get, ó ambos, y restringir el nivel de acceso

a los datos.

Otra posibilidad que nos da la implementación de estos métodos es de poder agregar

funcionalidad que puede servir para verificar, por ejemplo, si el dato que se está

signando es correcto ó no.

Ejemplo:

En este ejemplo se ¡lustra el uso de los métodos set y get.

class Factura {

// Campos

private int numero;

// Métodos set y get

public void setNumero (int numero) {

this.numero = numero;

}

public int getNumero ( ) {

return this.numero;

}

. . .

. . .

} // Factura

Como puede apreciar en el código, el método setNumero se utiliza para asignar un

valor al campo numero, mientras que el método getNumero se utiliza para leer su valor.

Es posible agregar lógica en cualquiera de los dos métodos, o en ambos si el caso lo

amerita.


TRABAJANDO CON MÉTODOS

Definición

Los métodos definen el comportamiento de un objeto de una clase concreta y tienen las

siguientes características:

- Agrupan las responsabilidades del objeto (competencias).

- Describen sus acciones.

Las acciones realizadas por un objeto son consecuencia directa de un estímulo externo

(un mensaje enviado desde otro objeto) y dependen del estado del objeto. El estado y

comportamiento de un objeto están relacionados. Por ejemplo, un avión no puede

aterrizar (acción) sino está en vuelo (estado).

Sintaxis:

[TipoAcceso] [ModificadorMétodo]

Tipo NombreMétodo ( [ ListaDeParámetros ] ) {

// Cuerpo de método

}

El TipoAcceso puede tomar los valores que se resumen en el siguiente cuadro:

Palabra Clave Descripción UML

Public Indica que el método es de acceso público. El acceso

se realiza a través de una instancia del objeto. +

Protected Indica que solo se puede acceder al método desde

métodos de la misma clase y clases derivadas

(subclases)

private Indica que solo se puede acceder al método desde

métodos de la misma clase.

-

sin especificar Indica visibilidad de paquete, se puede acceder al

método a través de una instancia, pero sólo desde

clases que se encuentren en el mismo paquete.

El ModificadorMétodo puede tomar los valores que se resumen en el siguiente cuadro:


static El método pertenece a la clase, no a los objetos creados a

partir de ella.


Final El método es definido como método definitivo, esto quiere

decir que no se puede redefinir en una subclase.

transient Determina que el método no se implementa en la clase, su

implementación será en las clases heredadas o subclases.

volatile Permiten sincronizar varios threads para el caso en que

dos o más accedan concurrentemente a los mismos datos.

El Tipo determina el tipo de dato que debe retornar el método, puede ser cualquier tipo

válido, incluso los tipos de clases creados por el programador. Si el método no retorna

ningún valor se debe especificar void.

Los parámetros son opcionales, pero si son necesarios se deben especificar de la siguiente

manera:

Tipol parámetro1, tipo2 parametro2, ... ;

Los parámetros son variables que reciben valores de los argumentos que se le pasan

al método cuando éste es invocado.

Los métodos que son de un tipo diferente de void, deben retornan un valor a la

instrucción que realiza la llamada mediante la instrucción return, utilizando la siguiente

sintaxis:

return expresión;

Donde expresión representa el valor que retorna el método.

Sobrecarga de Métodos

Un método se identifica por su nombre, la cantidad de parámetros y el tipo de sus

parámetros; esto constituye la firma del método (signature).

La sobrecarga permite tener varios métodos con igual nombre pero con diferente

forma, o sea, con diferente cantidad de parámetros y diferentes tipos de datos de sus

parámetros. Los métodos tendrán comportamientos diferentes según el tipo de dato,

cantidad de parámetros o ambos. Al invocar un método, el compilador busca en la

clase el método que corresponda a los argumentos de la invocación.

Un ejemplo ilustrativo lo tenemos con el método valueOf de la clase String.

A continuación tenemos su implementación en Java:

public class Clasel {

// Métodos sobrecargados

public void Operación1 () {


// Implementación

}

public void Operacion1 (int Param1) {

// Implementación

}

public void Operacion1 (String Param1) {

// Implementación

}

public int Operacion1 (int Param1, String Param2) {

// Implementación

return 0;

}

public String Operacion1 (long Param1, String Param2) {

// Implementación

return null;

}

} // Clase1

Ejemplo:

Supongamos que queremos un método que sume dos números, podrías necesitar que

sume dos números de tipo int o double; entonces debemos implementar dos métodos

con el mismo nombre por que se trata de la misma operación, podría ser sumar, pero

con diferentes tipos de datos de sus parámetros, tal como se ¡lustra a continuación:

package egcc;

public class Matematica {

public int sumar (int n1, int n2) {

int suma;

suma = n1 + n2;

return suma;

}

public double sumar (double n1, doble n2

double suma;

suma = n1 + n2;

return suma;

}


} // Matemática

Cuando usamos la clase Matemática el IDE nos permite visualizar los diversos

métodos que están sobrecargados:

Matematica obj=new Matematica();

System.out.println(obj.sumar(….));

EJEMPLO

Una institución financiera necesita de un programa que le permita encontrar el importe

que deben pagar sus clientes por los préstamos que realiza, se sabe que se trata de un

interés compuesto, capitalizare mensualmente. La formula que debe aplicarse es:

M= C(1+i)n

Donde:

C : Capital

I : Tasa de interés por periodo, por ejemplo puede ser mensual

n : Número de periodos

M : Importe acumulado en el número de periodos

Abstracción

A continuación tenemos algunas alternativas de abstraer el problema.

Caso 01

En este caso los atributos son públicos (visibilidad publica) por

lo tanto se puede acceder de manera directa desde

cualquier otra clase u objeto.

El método calcularlmporte hace el cálculo en función al

valor de los campos capital, interés y periodo.

Caso 02

En este caso tenemos un solo método que tiene tres parámetros, a través de los cuales

recibe los datos para hacer el cálculo y retorna el resultado correspondiente.

Banco

+ calcularImporte(capital: double, interes : double, periodos : int) : Double


Banco+ capital : double+ interes : double+ periodo : int

+ calcularImporte()

package tpagoxPrestamo;public class Banco { private double capital; private double interes; private int periodos; public void setCapital(double capital){ this.capital=capital; } public double getCapital(){ return this.capital; } public void setInteres(double interes){ this.interes=interes; } public double getInteres(){ return this.interes; } public void setPeriodos(int periodos){ this.periodos=periodos; } public int getPeriodos(){ return this.periodos; } public double getImporte(){ double importe; importe=this.getCapital()*Math.pow((1+this.getInteres()),this.getPeriodos()); return importe;


}}

public class Principal extends javax.swing.JFrame {

/** Creates new form Principal */ public Principal() { initComponents(); }

private void btnCalcularActionPerformed(java.awt.event.ActionEvent evt) {double capital=Double.parseDouble(this.txtCapital.getText());double interes=Double.parseDouble(this.txtInteres.getText());int periodos=Integer.parseInt(this.txtPeriodos.getText());

//Instanciar la clase BancotpagoxPrestamo.Banco objBanco=new tpagoxPrestamo.Banco();

//ProcesoobjBanco.setCapital(capital);objBanco.setInteres(interes);objBanco.setPeriodos(periodos);double importe=objBanco.getImporte();

//Redondear importe a dos decimalesimporte =importe*100;importe=Math.round(importe);importe=importe/100;

//resultadothis.txtImporte.setText(String.valueOf(importe));}

private void btnLimpiarActionPerformed(java.awt.event.ActionEvent evt) {this.txtCapital.setText("");this.txtInteres.setText("");this.txtPeriodos.setText("");this.txtImporte.setText("");}

private void btnCerrarActionPerformed(java.awt.event.ActionEvent evt) {System.exit(0);}

public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new Principal().setVisible(true); } }); }

// Variables declaration - do not modify private javax.swing.JButton btnCalcular; private javax.swing.JButton btnCerrar; private javax.swing.JButton btnLimpiar; private javax.swing.JLabel jLabel1; private javax.swing.JLabel jLabel2; private javax.swing.JLabel jLabel3;


private javax.swing.JLabel jLabel4; private javax.swing.JLabel jLabel5; private javax.swing.JTextField txtCapital; private javax.swing.JTextField txtImporte; private javax.swing.JTextField txtInteres; private javax.swing.JTextField txtPeriodos; // End of variables declaration

}

Referencia:Desarrollando soluciones con Java y MySql.Eric Gustavo Coronel.Capítulo 3

Ejemplo Dada la clase persona con los atributos: nombre, edad, generar dos instancias de la clase: alumno, profesor; y los métodos: para asignar nombre nombre, edad, y luego visualizar dichos datos.

public class Persona { //privados: String nombre; int edad; //publicos: public void AsignarNombre(String nom){ nombre=nom; } public void AsignarEdad(int e){ edad=e; } public String ObtenerNombre(){ return nombre; } public int ObtenerEdad(){ return edad;


} public static void main(String[] args) { Persona alumno=new Persona(); Persona profesor=new Persona(); alumno.AsignarNombre("Miguel"); alumno.AsignarEdad(20); profesor.AsignarNombre("José"); System.out.println("Nombre del alumno:"+alumno.ObtenerNombre()); System.out.println("edad del alumno:"+alumno.ObtenerEdad()); System.out.println("Nombre del profesor:"+profesor.ObtenerNombre()); }}

******************************

Ejemplo 2public class CComputador {

String marca;String procesador;boolean computadorencendido=true;

public void encendercomputador() {

if(computadorencendido==true)System.out.println("\n computador encendido");

elseSystem.out.println("\n computador apagado");

}

public void estado() {System.out.println("\n Estado del computador:"+"\n Marca:" +marca+ "\n procesador:" +procesador);if(computadorencendido==true)

System.out.println("\n computador encendido");elseSystem.out.println("\n computador apagado");

} public static void main(String[] args) { CComputador computador1=new CComputador();

computador1.marca="DELL";computador1.procesador="Core 2 duo";computador1.encendercomputador();computador1.estado();

}

}


Inicialización y Constructores

public class cRectangulo { private float x1,y1,x2,y2; public static void main(String[] args) { cRectangulo prueba=new cRectangulo(); System.out.println(prueba.CalcularArea()); cRectangulo prueba1=new cRectangulo(1,4,7,6); System.out.println(prueba1.CalcularArea()); }

public cRectangulo() {x1=0;y1=0;x2=0;y2=0;

}

public cRectangulo(float ex1, float ey1,float ex2, float ey2) {x1=ex1;y1=ey1;x2=ex2;y2=ey2;

}

public float CalcularArea() {return (x2-x1)*(y2-y1);

}}

2. Lectura de datos en Java

Lectura de un dato entero en Java

Clase Leer:import java.io.*;

public class Leer {

public static void main(java.lang.String[] args) {// Inserte aquí código para iniciar la aplicación.int dato_int=0;System.out.print("Ingrese un dato entero : ");dato_int=Leer.datoInt();System.out.println("El numero ingresado fue : "+dato_int);

}

//Método datoInt :


public static int datoInt() {return Integer.parseInt(dato());

}

//Método dato:public static String dato() {

String sdato="";try{

InputStreamReader isr = new InputStreamReader(System.in);BufferedReader flujoE = new BufferedReader(isr);sdato=flujoE.readLine();

}catch (IOException e){

System.err.println("ERROR:"+e.getMessage());}return sdato;

}}

Leer un caracter desde el teclado

import java.io.*;

public class leercaracter {

public static void main(String[] args) {

int n;

try{

System.out.print("Dato(Caracter o letra): ");

n=System.in.read(); // Leer caracter desde teclado

System.out.println("Dato ingresado: "+(char)n); // Visualiza el caracter

}

catch(IOException e){

System.err.println("Error: "+e.getMessage());

} } }

Leer y mostrar un caracter desde el teclado

import java.io.*;public class LeerMostrarCaracter { public static void main(String[] args) {


char opcion; InputStreamReader isr=new InputStreamReader(System.in); BufferedReader flujoE=new BufferedReader(isr); PrintStream flujoS=System.out; try{ do{ flujoS.print("Continuar<s/n>: "); opcion=(char)flujoE.read(); flujoE.readLine(); //Limpiar caracteres: \r\n //flujoS.print("Opcion ingresada:"+opcion); System.out.println("Opcion ingresada: "+opcion); }while(opcion!='n'); } catch(IOException e){ System.out.println("Error:"+e.getMessage()); } }}

Leer los datos de un arreglo entero en Java

Clase ALeerimport java.io.*;

public class ALeer {

public static void main(java.lang.String[] args) {int nElementos;System.out.print("Numero de elementos del arreglo: ");nElementos=ALeer.datoInt();int[] m=new int[nElementos];int i=0,j=0;System.out.print("Valores del arreglo: ");for(i=0;i<nElementos;i++){

j=i+1;System.out.print("m["+j+"]=");m[i]=ALeer.datoInt();

}

System.out.println();for(i=0;i<nElementos;i++){

j=i+1;System.out.println("m["+j+"]="+m[i]);

} }

//Método datoIntpublic static int datoInt() {

return Integer.parseInt(dato());

}

//Método datopublic static String dato() {






}

Leer una cadena de caracteres o un textoUtilizando flujo de caracteres de entrada: flujoE, y, para imprimir, referencia al flujo estándar de salida: flujoS.

import java.io.*;public class leerunacadena_u_fe_fs {

public static void main(String[] args) { //Definir un flujo de caracteres de entrada: flujoE InputStreamReader isr=new InputStreamReader(System.in); BufferedReader flujoE=new BufferedReader(isr); //Definir una referencia al flujo estandar de salida: flujoS PrintStream flujoS=System.out; String sdato; try{ flujoS.print("Ingrese un texto: "); sdato=flujoE.readLine(); flujoS.println("Texto ingresado: "+sdato); } catch(IOException e){ System.err.println("Error:"+e.getMessage()); } }}

EJERCICIO

1. Programa en Java para leer datos de alumnos: código, nombre, edad, nacionalidad y notas; hallar el promedio de las notas, y mensaje de aprobado o desaprobado.

import java.io.*; public class CAlumno {

public static void main(java.lang.String[] args) {// Inserte aquí código para iniciar la aplicación.int cod;String nom;int edad,cant,i;String nac;double nota1,nota2,nota3,prom;

System.out.print("Ingrese la cantidad de alumnos:");cant=Leer.datoInt();for(i=0;i<cant;i++){

System.out.println("Alumno["+(i+1)+"] ");System.out.print("codigo["+(i+1)+"]:");cod=Leer.datoInt();System.out.print("Nombre["+(i+1)+"]:");


nom=Leer.dato();System.out.print("Edad["+(i+1)+"]:");edad=Leer.datoInt();System.out.print("Nacionalidad["+(i+1)+"]:");nac=Leer.dato();//INGRESE LAS NOTAS

System.out.print("Nota [1]: ");nota1=Leer.datoDouble();System.out.print("Nota [2]: ");nota2=Leer.datoDouble();System.out.print("Nota [3]: ");nota3=Leer.datoDouble();

//PROMEDIOprom=(nota1+nota2+nota3)/3;if(prom>=10.5){ System.out.print("El promedio de "+nom+"es :"+prom+"… APROBADO");}else { System.out.print("El promedio de "+nom+"es :"+prom+"….DESAPROBADO");}

System.out.println();}

}

}

import java.io.*;public class Leer {

//Método datoInt :public static int datoInt() {

return Integer.parseInt(dato()); }

// datoDoublepublic static double datoDouble() {

return Double.parseDouble(dato()); }

//Método dato:public static String dato() {





}}


Ejercicios Propuestos

1. Realizar un programa que muestre una clase para representar números racionales. Por ejemplo: el número racional 1/3 representado por un número fraccionario sería 0,333333, Valor mas fácil de manipular, pero a costa de perder precisión. Evidentemente, 1/3 * 3 = 1, pero 0,333333 * 3 = 0,999999; para esto se recomiendo utilizar dos métodos: uno para asignar datos y el otro para visualizar los datos.

2. Realizar un programa que utilice objetos de una clase ecuación para evaluar las ecuaciones de la forma: ax3 + bx2 + cx + d

3. Implementar una clase bancaria simule el comportamiento básico de una cuenta abierta en una entidad bancaria cualquiera. Para esto se tiene en cuenta los siguientes datos como: interés, ingresar dinero, retirar dinero, saldo actual, después de abonado el interés.

4. Realizar una aplicación que dé como resultado los intereses producidos y el capital total acumulado de una cantidad c, invertida en un interés r durante t días.

La formula a utilizar es:

I = c * r * t 360*100

5. Realizar una aplicación que dé como resultado las soluciones reales x1 y x2 de una ecuación de segundo grado, de la forma:

ax2 + bx + c = 0Las soluciones de una ecuación de segundo grado viene dadas por la formula:

6. Realizar un programa que a través de un menú permita realizar las operaciones de sumar, restar, multiplicar, dividir y salir. Las operaciones constarán solamente de dos operandos. El menú será visualizado por un método sin argumentos, que devolverá como resultado la opción elegida.

7. Realizar un programa que calcule e imprima la suma de los múltiplos de 5 comprendidos entre dos valores a y b. El programa permitirá introducir valores negativos para a y b, y verificará que a es menor que b. si a es mayor que b, intercambiará estos valores.

8. Realizar un programa que lea una lista de nombres y los almacene en una matriz. Una vez construida la matriz, visualizaremos su contenido.

9. Realizar un programa que lea una lista de valores introducidas por el teclado. A continuación, y sobre las listas, buscar los valores máximo y mínimo, y escribirlos.

10. Realizar un programa que los peso e imprima el histograma correspondiente. Suponer que los pesos están comprendidos entre los valores 10 y 100 Kg. En el histograma sólo aparecerá los pesos que se corresponden con 1 o mas alumnos.

11. Utilizando el método random de la clase Math del paquete java.lang, realizar un programa que muestre 6 números aleatorios entre 1 y 49 ordenados ascendentemente.


12. Realizar un programa que partiendo de dos matrices de cadenas de caracteres clasificadas en orden ascendente, construya y visualice una tercera matriz también clasificada en orden ascendente; está tercera matriz será el resultado de la fusión de las dos primeras matrices.

13. Escribir un programa que calcule la serie:

Para un valor de x dado, se calcularán y se sumarán términos sucesivos de la serie, hasta que el último término sumado sea menor o igual que una constante de error predeterminada (por ejemplo 1 e-7).

14. Elaborar un programa de directorios telefónicos está aplicación mostrará un menú que presentará las operaciones que se pueden realizar sobre la lista de teléfonos. Como Añadir, Buscar, Buscar Siguiente, Eliminar y salir; pero después de realizada una de las opciones deberá regresar al menú principal.

15. Elaborar un programa que permita operar con números racionales en: la suma, resta, multiplicación, división, si son iguales, si es mayor o menor, que acepte entrar tanto negativos como positivos.

16. Construir una clase llamada Luz que simule una luz de semáforo. El atributo color de la clase debe cambiar de Verde a Amarillo y a Rojo y de nuevo regresar a Verde mediante la función Cambio. Cuando se crea un objeto Luz, su color inicial será Rojo.

Acceso en Java usando los métodos getXXX( ), setXXX( ), operador this

Asignar y mostrar el nombre y número de dni de una persona

public class PruebaPersona {

public static void main(String[] args) { Persona persona1=new Persona(); persona1.setNombre("Misael"); persona1.setDni("15645459"); System.out.println("El nombre de persona1 es: "+persona1.getNombre()); System.out.println("y su numero de DNI es : "+persona1.getDni());

}

}

public class Persona {private String nombre,dni;

public void setNombre(String nom) {nombre=nom;

}______________________________________________________________________FISI – UNMSM Luis Guerra G.22

public String getNombre() {return nombre;}

public void setDni(String dni) {this.dni=dni;

}

public String getDni() {return this.dni;}

}

Arreglos Bidimensionales (Matrices)

Declaración: tipo identificador[][];

o bien: tipo[][] identificador;

Creación:Utilizando el operador new.

matriz = new tipo [filas][columnas]; Ejemplo:int[][] temperaturas = new int[12][30];

************************* matriz[índice1][índice2]*************************En Java el índice de la primera componente de un vector es 0 , por lo que matriz[0][0], será el primer elemento de la matriz.El tamaño del arreglo puede obtenerse utilizando la propiedad: length matriz.length : nos da el número de filas matriz[0].length : nos da el número de columnas

Ejemplo Dada una matriz de reales de dos dimensiones, visualizar la suma de cada fila de la matriz.

public class sumafilasdeunamatriz {

public static void main(String[] args) { int nfilas, ncols; // filas y columnas de la matriz do { System.out.print("Número de filas de la matriz: "); nfilas = Leer.datoInt(); }


while (nfilas < 1); // no permitir un valor negativo do { System.out.print("Número de columnas de la matriz: "); ncols = Leer.datoInt(); } while (ncols < 1); // no permitir un valor negativo float[][] m = new float[nfilas][ncols]; // crear la matriz m int fila = 0, col = 0; // subíndices float sumafila = 0; // suma de los elementos de una fila System.out.println("Introducir los valores de la matriz."); for (fila = 0; fila < nfilas; fila++) { for (col = 0; col < ncols; col++) { System.out.print("m[" + fila + "][" + col + "] = "); m[fila][col] = Leer.datoFloat(); } } // Visualizar la suma de cada fila de la matriz System.out.println(); for (fila = 0; fila < nfilas; fila++) { sumafila = 0; for (col = 0; col < ncols; col++) sumafila += m[fila][col]; System.out.println("Suma de la fila " + fila + ": " + sumafila); } System.out.println("\nFin del proceso."); }

}

Arreglo de objetosCuando el tipo de dato de un arreglo es una clase, hablamos de arreglo de objetos, donde cada elemento del arreglo es un objeto.

Ejemplo:

Alumno[ ] ca; //Un arreglo de objetos de la clase Alumno (arreglo de registros de alumno)

public class Alumno { // Registro de datos de un alumno String codigo; String nombre; int promediofinal; public Alumno(){ } …….. …….. }

Ejercicios usando arreglo de objetos

1.Definir un vector de objetos de la clase Alumno, esta clase contiene el código, nombre y nota, además los métodos para ingresar y presentar los datos.


2. Con el vector de objetos del ejercicio 1, presentar los Alumnos de un curso y generar el promedio de la nota del curso.

Ejemplo usando arreglo de objetosGenerar una lista de teléfonos. La lista debe ser un objeto que encapsula la matriz de objetos persona, la clase CPersona define los atributos privados nombre, dirección, teléfono relativos a una persona, métodos respectivos que en un menú de opciones permita: añadir, eliminar y buscar en una lista./////////////////////////////////////////////////////////////////// Ejemplo para trabajar con matriz de objetos//import java.io.*;public class Test { public static void main(String[] args) { // Definir un flujo de caracteres de entrada: flujoE InputStreamReader isr = new InputStreamReader(System.in); BufferedReader flujoE = new BufferedReader(isr); // Definir una referencia al flujo estándar de salida: flujoS PrintStream flujoS = System.out;

// Crear un objeto lista de teléfonos vacío (con cero elementos) CListaTfnos listatfnos = new CListaTfnos(); int opcion = 0, pos = -1; String cadenabuscar = null; String nombre, direccion; long telefono; boolean eliminado = false; do { try { opcion = menu(); switch (opcion) { case 1: // buscar flujoS.print("conjunto de caracteres a buscar "); cadenabuscar = flujoE.readLine(); pos = listatfnos.buscar(cadenabuscar, 0); if (pos == -1) if (listatfnos.longitud() != 0) flujoS.println("búsqueda fallida"); else flujoS.println("lista vacía"); else { flujoS.println(listatfnos.valorEn(pos).obtenerNombre()); flujoS.println(listatfnos.valorEn(pos).obtenerDireccion()); flujoS.println(listatfnos.valorEn(pos).obtenerTelefono()); } break; case 2: // buscar siguiente


pos = listatfnos.buscar(cadenabuscar, pos + 1); if (pos == -1) if (listatfnos.longitud() != 0) flujoS.println("búsqueda fallida"); else flujoS.println("lista vacía"); else { flujoS.println(listatfnos.valorEn(pos).obtenerNombre()); flujoS.println(listatfnos.valorEn(pos).obtenerDireccion()); flujoS.println(listatfnos.valorEn(pos).obtenerTelefono()); } break; case 3: // añadir flujoS.print("nombre: "); nombre = flujoE.readLine(); flujoS.print("dirección: "); direccion = flujoE.readLine(); flujoS.print("teléfono: "); telefono = Leer.datoLong(); listatfnos.añadir(new CPersona(nombre, direccion, telefono)); break; case 4: // eliminar flujoS.print("teléfono: "); telefono = Leer.datoLong(); eliminado = listatfnos.eliminar(telefono); if (eliminado) flujoS.println("registro eliminado"); else if (listatfnos.longitud() != 0) flujoS.println("teléfono no encontrado"); else flujoS.println("lista vacía"); break; case 5: // salir listatfnos = null; } } catch (IOException ignorada) {} } while(opcion != 5);

}

public static int menu() {System.out.print("\n\n");

System.out.println("1. Buscar"); System.out.println("2. Buscar siguiente"); System.out.println("3. Añadir"); System.out.println("4. Eliminar"); System.out.println("5. Salir"); System.out.println(); System.out.print(" Opción: "); int op; do op = Leer.datoInt(); while (op < 1 || op > 5); return op;


}

}

/////////////////////////////////////////////////////////////////// Definición de la clase CListaTfnos.//public class CListaTfnos {

private CPersona[] listaTelefonos; // matriz de objetos private int nElementos; // número de elementos de la matriz

public CListaTfnos() {// Crear una lista vacía

nElementos = 0; listaTelefonos = new CPersona[nElementos];

}/** * Method unElementoMas * @param listaActual */private void unElementoMas(CPersona[] listaActual) {nElementos = listaActual.length;

listaTelefonos = new CPersona[nElementos + 1]; // Copiar la lista actual for ( int i = 0; i < nElementos; i++ ) listaTelefonos[i] = listaActual[i]; nElementos++;

}

/** * Method unElementoMenos * @param listaActual */private void unElementoMenos(CPersona[] listaActual) {if (listaActual.length == 0) return;

int k = 0; nElementos = listaActual.length; listaTelefonos = new CPersona[nElementos - 1]; // Copiar la lista actual for ( int i = 0; i < nElementos; i++ ) if (listaActual[i] != null) listaTelefonos[k++] = listaActual[i]; nElementos--;

}

/** * Method ponerValorEn


* @param i * @param objeto */public void ponerValorEn(int i, CPersona objeto) { if (i >= 0 && i < nElementos)

listaTelefonos[i] = objeto; else System.out.println("Índice fuera de límites");

}

/** * Method valorEn * @param i */public CPersona valorEn(int i) {if (i >= 0 && i < nElementos)

return listaTelefonos[i]; else { System.out.println("Índice fuera de límites"); return null; }

}

/** * Method longitud */public int longitud() {

return nElementos; }

/** * Method añadir */public void añadir(CPersona obj) {unElementoMas(listaTelefonos);

ponerValorEn( nElementos - 1, obj );

}

/** * Method eliminar */public boolean eliminar(long tel) {// Buscar el teléfono y eliminar registro

for ( int i = 0; i < nElementos; i++ ) if (listaTelefonos[i].obtenerTelefono() == tel) { listaTelefonos[i] = null; unElementoMenos(listaTelefonos); return true; }


return false;

}

/** * Method buscar * @param str * @param pos * @return */public int buscar(String str, int pos) {String nom;

if (str == null) return -1; if (pos < 0) pos = 0; for ( int i = pos; i < nElementos; i++ ) { nom = listaTelefonos[i].obtenerNombre(); if (nom == null) continue; // ¿str está contenida en nom? if (nom.indexOf(str) > -1) return i; } return -1;

}}

/////////////////////////////////////////////////////////////////// Definición de la clase CPersona//public class CPersona {

// Atributos private String nombre; private String direccion; private long telefono;

public CPersona() {}

public CPersona(String nom, String dir, long tel) {nombre = nom;

direccion = dir; telefono = tel;

}

/** * Method asignarNombre */public void asignarNombre(String nom) {

nombre = nom;}

/** * Method obtenerNombre


*/public String obtenerNombre() {return nombre;}

/** * Method asignarDireccion*/public void asignarDireccion(String dir) {direccion = dir;}/** * Method obtenerDireccion */public String obtenerDireccion() {return direccion;}

/** * Method asignarTelefono */public void asignarTelefono(long tel) {telefono = tel;}

/** * Method obtenerTelefono */public long obtenerTelefono() { return telefono;}

}

/////////////////////////////////////////////////////////////////// Definición de la clase Leer//import java.io.*;public class Leer {


}public static String dato() {String sdato="";try{



System.err.println("ERROR:"+e.getMessage());}


return sdato;

}

public static long datoLong() {return Long.parseLong(dato());

}

}

Relación entre clases

Ejemplo de Composición y dependenciaConstruir una aplicación que permita pintar un triángulo en la pantalla. La aplicación debe permitir que el usuario introduzca los datos del triángulo: coordenada “x” del vértice superior, coordenada “y” del vértice superior, base, altura, selección del color a través de un combobox en un formulario, usando la siguiente relación de clases:

+Ventana()-asignarLookAndFeel()-setCloseClick()+paint(entrada Graphics g)+main(entrada String[] args)

-Triangulo triangulo

Ventana

+Triangulo()+paint(entrada Graphics g)+mover(entrada int desplazamientox, entrada int desplazamientoy)+ampliar(entrada int zoomout)+reducir(entrada int zoomin)+borrar()

-int verticesuperiorx-int verticesuperiory-int base-int altura-Color color-boolean haydatos

Triangulo

+FormularioTriangulo()+obtenerVerticeSuperiorx()+obtenerVerticeSuperiory()+obtenerBase()+obtenerAltura()+obtenerColor()

-int verticesuperiorx-int verticesuperiory-int base-int altura-Color color-JLabel verticesuperiorLabel-JLabel verticesuperiorLabel-JLabel baseLabel-JLabel alturaLabel-JLabel colorLabel-String verticesuperiorxString-String verticesuperioryString-String baseString-String alturaString-String colorString-JTextField verticesuperiorxTextField-JTextField verticesuperioryTextField-JTextField baseTextField-JTextField alturaTextField-JComboBox colorField

FormularioTriangulo

Fig. 1. Diagrama de clases para pintar un Triángulo

En JCreator:

File-New-Project –

//Clase Ventanapublic class Ventana { public static void main(String[] args) { // Create application frame. VentanaFrame frame = new VentanaFrame();


// Show frame. frame.setVisible(true); }}

import java.awt.*;import java.awt.event.*;import javax.swing.*;public class VentanaFrame extends JFrame { private Triangulo triangulo; /** * The constructor */

public VentanaFrame() { //Pintar la ventana vacía setTitle("Pintar Triangulo "); asignarLookAndFeel(); setCloseClick(); setExtendedState(MAXIMIZED_BOTH); setVisible(true); //Crear un triangulo y añadirlo a la ventana triangulo=new Triangulo(); getContentPane().add(triangulo); //Repintar la ventana con el triangulo pack(); setExtendedState(MAXIMIZED_BOTH); repaint();

} private void asignarLookAndFeel() { //Forzar el Look and Feel de la ventana al del sistema String laf = UIManager.getSystemLookAndFeelClassName(); try { UIManager.setLookAndFeel(laf); } catch (UnsupportedLookAndFeelException exc) {System.err.println("Unsupported: " + laf);} catch (Exception exc) {System.err.println("Error cargando: " + laf);} }

private void setCloseClick() { //Controlar el cierre de la ventana addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0);} }); }

public void paint (Graphics g)


{ super.paint(g); if (triangulo!=null) triangulo.paint(g); }

}

// Clase JPanel: Triangulo import javax.swing.JPanel;import java.awt.*;import javax.swing.*;public class Triangulo extends JPanel {

private int verticesuperiorx;private int verticesuperiory;private int base;private int altura;private Color color;private boolean haydatos=false;

public Triangulo() {//Mostrar el formulario para obtener//los datos del triangulo

FormularioTriangulo formulario=new FormularioTriangulo();JDialog dialog =new JDialog();

dialog.setTitle("Introduzca los datos del triangulo"); dialog.setModal(true); dialog.setContentPane(formulario); dialog.setDefaultCloseOperation(javax.swing.WindowConstants.HIDE_ON_CLOSE); dialog.pack(); dialog.show(); // Obtener los datos introducidos por el usuario verticesuperiorx=formulario.obtenerVerticeSuperiorx(); verticesuperiory=formulario.obtenerVerticeSuperiory(); base=formulario.obtenerBase(); altura=formulario.obtenerAltura(); color=formulario.obtenerColor(); haydatos=true; } public void paint(Graphics g) { int [] coordenadasx=getCoordenadasX(); int [] coordenadasy=getCoordenadasY(); super.paint(g); //Si el usuario ha introducido los datos pinta el triangulo if (haydatos){ g.setColor(color); g.drawPolygon(coordenadasx, coordenadasy, 3); g.fillPolygon(coordenadasx, coordenadasy, 3); g.dispose();


} }

private int [] getCoordenadasX() { int [] coordenadasx = new int [3];

coordenadasx[0]=verticesuperiorx; coordenadasx[1]=verticesuperiorx-(base/2);

coordenadasx[2]=verticesuperiorx+(base/2); return coordenadasx;

}private int [] getCoordenadasY() {

int [] coordenadasy= new int[3]; coordenadasy[0]=verticesuperiory; coordenadasy[1]=verticesuperiory+altura; coordenadasy[2]=verticesuperiory+altura; return coordenadasy;

}

public void mover(int desplazamientox, int desplazamientoy) {verticesuperiorx = verticesuperiorx + desplazamientox;

verticesuperiory = verticesuperiory + desplazamientoy;

}public void ampliar(int zoomin) {

if (zoomin > 0){ base= base * zoomin; altura=altura*zoomin; }

}

public void reducir(int zoomout) { if (zoomout > 0){

base = base / zoomout; altura = altura / zoomout; }

}

public void borrar() { //Pintarme del color del fondo de la ventana

color= this.getBackground(); repaint(); }

}


// Clase JPanel: FormularioTriangulo import javax.swing.JPanel;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class FormularioTriangulo extends JPanel {

//Valores de los cuadros de texto private int verticesuperiorx; private int verticesuperiory; private int base; private int altura; private Color color; //Etiquetas de los campos de texto private JLabel verticesuperiorxLabel; private JLabel verticesuperioryLabel; private JLabel baseLabel; private JLabel alturaLabel; private JLabel colorLabel; //Textos de las etiquetas private static String verticesuperiorxString = "Coordenada x del vértice superior: ";

private static String verticesuperioryString = "Coordenada y del vértice superior: "; private static String baseString = "Base: "; private static String alturaString = "Altura: "; private static String colorString = "Color: "; //Campos de texto y combo para introducir los datos private JTextField verticesuperiorxTextField; private JTextField verticesuperioryTextField; private JTextField baseTextField; private JTextField alturaTextField; private JComboBox colorField;

public FormularioTriangulo() { //crear las etiquetas

verticesuperiorxLabel = new JLabel(verticesuperiorxString); verticesuperioryLabel= new JLabel(verticesuperioryString); baseLabel= new JLabel(baseString); alturaLabel= new JLabel(alturaString); colorLabel= new JLabel(colorString); //crear los campos de texto verticesuperiorxTextField = new JTextField(5); verticesuperioryTextField= new JTextField(5); baseTextField= new JTextField(5); alturaTextField= new JTextField(5); //crear el combo de colores String [] colorValues= {"Azul","Naranja","Verde","Rojo","Amarillo","Gris"}; colorField = new JComboBox(colorValues); colorField.setEditable(false);


//Asignar las etiquetas a los campos de texto verticesuperiorxLabel.setLabelFor(verticesuperiorxTextField); verticesuperioryLabel.setLabelFor(verticesuperioryTextField); baseLabel.setLabelFor(baseTextField); alturaLabel.setLabelFor(alturaTextField); colorLabel.setLabelFor(colorField); //Distribuir las etiqueta en un panel JPanel labelPane = new JPanel(); labelPane.setLayout(new GridLayout(0, 1)); labelPane.add(verticesuperiorxLabel); labelPane.add(verticesuperioryLabel); labelPane.add(baseLabel); labelPane.add(alturaLabel); labelPane.add(colorLabel); //Distribuir los campos de texto en otro panel. JPanel fieldPane = new JPanel(); fieldPane.setLayout(new GridLayout(0, 1)); fieldPane.add(verticesuperiorxTextField); fieldPane.add(verticesuperioryTextField); fieldPane.add(baseTextField); fieldPane.add(alturaTextField); fieldPane.add(colorField); //Poner los dos paneles en un nuevo panel, las etiquetas a la izquierda, //los campos de texto a la derecha. JPanel contentPane = new JPanel(); contentPane.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));

contentPane.setLayout(new BorderLayout()); contentPane.add(labelPane, BorderLayout.CENTER); contentPane.add(fieldPane, BorderLayout.EAST); add(contentPane);

}public Color obtenerColor() {

String string=(String)colorField.getSelectedItem(); Color color; if (string.equals("Azul")) color=Color.BLUE; else if (string.equals("Verde")) color=Color.GREEN; else if (string.equals("Naranja")) color=Color.ORANGE; else if (string.equals("Rojo")) color=Color.RED; else if (string.equals("Amarillo")) color=Color.YELLOW; else if (string.equals("Gris"))


color=Color.GRAY; else color=Color.BLACK; return color;

}

public int obtenerVerticeSuperiorx() {//Obtiene la coordenada x del vertice superior introducida por el usuario if (verticesuperiorxTextField.getText()!= null)

return Integer.parseInt(verticesuperiorxTextField.getText()); else return 0;

}

public int obtenerVerticeSuperiory() {//Obtiene la coordenada y del vertice superior introducida por el usuario

if (verticesuperioryTextField.getText()!= null) return Integer.parseInt(verticesuperioryTextField.getText()); else return 0;

}public int obtenerBase() { if (baseTextField.getText()!= null)

return Integer.parseInt(baseTextField.getText()); else return 0;

}

public int obtenerAltura() { if (alturaTextField.getText()!= null)

return Integer.parseInt(alturaTextField.getText()); else return 0;

}}


En NetBeans IDE 6.1

File – New Project – Java – Java Application – Next - Nombre del Proyecto – desactivar: Create Main Class y Set as Main Project – finish.Luego de creada la Aplicación – sobre el paquete – click derecho – New – JFrame para la clase con el método principal, luego similar para las otras clases JPanel.

import java.awt.*;import javax.swing.*;import java.awt.event.*;public class Ventana extends javax.swing.JFrame {

private Triangulo triangulo; public Ventana() { //Pintar la ventana vacía setTitle("Pintar Triangulo "); asignarLookAndFeel(); setCloseClick(); setExtendedState(MAXIMIZED_BOTH); setVisible(true); //Crear un triangulo y añadirlo a la ventana triangulo=new Triangulo(); getContentPane().add(triangulo);


//Repintar la ventana con el triangulo pack(); setExtendedState(MAXIMIZED_BOTH); repaint(); } private void asignarLookAndFeel() { //Forzar el Look and Feel de la ventana al del sistema String laf = UIManager.getSystemLookAndFeelClassName(); try { UIManager.setLookAndFeel(laf); } catch (UnsupportedLookAndFeelException exc) {System.err.println("Unsupported: " + laf);} catch (Exception exc) {System.err.println("Error cargando: " + laf);} } private void setCloseClick() { //Controlar el cierre de la ventana addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0);} });} public void paint (Graphics g) { super.paint(g); if (triangulo!=null) triangulo.paint(g); } public static void main(String args[]) { new Ventana(); }

}

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

public class Triangulo extends javax.swing.JPanel {

//Coordenada x del vertice superior private int verticesuperiorx; //Coordenada y del vertice superior private int verticesuperiory;


//Base private int base; //Altura private int altura; //Color private Color color; private boolean haydatos=false; // Crea una nueva instancia de Triangulo */ public Triangulo() { // Mostrar el formulario para obtener los datos del triangulo FormularioTriangulo formulario= new FormularioTriangulo(); JDialog dialog =new JDialog(); dialog.setTitle("Introduzca los datos del triangulo"); dialog.setModal(true); dialog.setContentPane(formulario); dialog.setDefaultCloseOperation(javax.swing.WindowConstants.HIDE_ON_CLOSE); dialog.pack(); dialog.show(); // Obtener los datos introducidos por el usuario verticesuperiorx=formulario.obtenerVerticeSuperiorx(); verticesuperiory=formulario.obtenerVerticeSuperiory(); base=formulario.obtenerBase(); altura=formulario.obtenerAltura(); color=formulario.obtenerColor(); haydatos=true; } public void paint(Graphics g) { int [] coordenadasx=getCoordenadasX(); int [] coordenadasy=getCoordenadasY(); super.paint(g); //Si el usuario ha introducido los datos pinta el triangulo if (haydatos){ g.setColor(color); g.drawPolygon(coordenadasx, coordenadasy, 3); g.fillPolygon(coordenadasx, coordenadasy, 3); g.dispose(); } } private int [] getCoordenadasX(){ int [] coordenadasx = new int [3];


coordenadasx[0]=verticesuperiorx; coordenadasx[1]=verticesuperiorx-(base/2); coordenadasx[2]=verticesuperiorx+(base/2); return coordenadasx; } private int [] getCoordenadasY(){ int [] coordenadasy= new int[3]; coordenadasy[0]=verticesuperiory; coordenadasy[1]=verticesuperiory+altura; coordenadasy[2]=verticesuperiory+altura; return coordenadasy; } public void mover (int desplazamientox, int desplazamientoy){ verticesuperiorx = verticesuperiorx + desplazamientox; verticesuperiory = verticesuperiory + desplazamientoy; } public void ampliar (int zoomin){ if (zoomin > 0){ base= base * zoomin; altura=altura*zoomin; } } public void reducir (int zoomout){ if (zoomout > 0){ base = base / zoomout; altura = altura / zoomout; } } public void borrar(){ //Pintarme del color del fondo de la ventana color= this.getBackground(); repaint(); } }

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


import javax.swing.*;public class FormularioTriangulo extends javax.swing.JPanel {

//Valores de los cuadros de texto private int verticesuperiorx; private int verticesuperiory; private int base; private int altura; private Color color; //Etiquetas de los campos de texto private JLabel verticesuperiorxLabel; private JLabel verticesuperioryLabel; private JLabel baseLabel; private JLabel alturaLabel; private JLabel colorLabel; //Textos de las etiquetas private static String verticesuperiorxString = "Coordenada x del vértice superior: "; private static String verticesuperioryString = "Coordenada y del vértice superior: "; private static String baseString = "Base: "; private static String alturaString = "Altura: "; private static String colorString = "Color: "; //Campos de texto y combo para introducir los datos private JTextField verticesuperiorxTextField; private JTextField verticesuperioryTextField; private JTextField baseTextField; private JTextField alturaTextField; private JComboBox colorField; //Crea una nueva instancia de FormularioTriangulo public FormularioTriangulo() { //crear las etiquetas verticesuperiorxLabel = new JLabel(verticesuperiorxString); verticesuperioryLabel= new JLabel(verticesuperioryString); baseLabel= new JLabel(baseString); alturaLabel= new JLabel(alturaString); colorLabel= new JLabel(colorString); //crear los campos de texto verticesuperiorxTextField = new JTextField(5); verticesuperioryTextField= new JTextField(5); baseTextField= new JTextField(5); alturaTextField= new JTextField(5); //crear el combo de colores String [] colorValues= {"Azul","Naranja","Verde","Rojo","Amarillo","Gris"}; colorField = new JComboBox(colorValues); colorField.setEditable(false);


//Asignar las etiquetas a los campos de texto verticesuperiorxLabel.setLabelFor(verticesuperiorxTextField); verticesuperioryLabel.setLabelFor(verticesuperioryTextField); baseLabel.setLabelFor(baseTextField); alturaLabel.setLabelFor(alturaTextField); colorLabel.setLabelFor(colorField); //Distribuir las etiqueta en un panel JPanel labelPane = new JPanel(); labelPane.setLayout(new GridLayout(0, 1)); labelPane.add(verticesuperiorxLabel); labelPane.add(verticesuperioryLabel); labelPane.add(baseLabel); labelPane.add(alturaLabel); labelPane.add(colorLabel); //Distribuir los campos de texto en otro panel. JPanel fieldPane = new JPanel(); fieldPane.setLayout(new GridLayout(0, 1)); fieldPane.add(verticesuperiorxTextField); fieldPane.add(verticesuperioryTextField); fieldPane.add(baseTextField); fieldPane.add(alturaTextField); fieldPane.add(colorField); //Poner los dos paneles en un nuevo panel, las etiquetas a la izquierda, //los campos de texto a la derecha. JPanel contentPane = new JPanel(); contentPane.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20)); contentPane.setLayout(new BorderLayout()); contentPane.add(labelPane, BorderLayout.CENTER); contentPane.add(fieldPane, BorderLayout.EAST); add(contentPane); } //Obtiene el Color seleccionado por el usuario public Color obtenerColor() { String string=(String)colorField.getSelectedItem(); Color color; if (string.equals("Azul")) color=Color.BLUE; else if (string.equals("Verde")) color=Color.GREEN; else if (string.equals("Naranja")) color=Color.ORANGE; else if (string.equals("Rojo")) color=Color.RED;


else if (string.equals("Amarillo")) color=Color.YELLOW; else if (string.equals("Gris")) color=Color.GRAY; else color=Color.BLACK; return color; } //Obtiene la coordenada x del vertice superior introducida por el usuario public int obtenerVerticeSuperiorx(){ if (verticesuperiorxTextField.getText()!= null) return Integer.parseInt(verticesuperiorxTextField.getText()); else return 0; } //Obtiene la coordenada y del vertice superior introducida por el usuario public int obtenerVerticeSuperiory(){ if (verticesuperioryTextField.getText()!= null) return Integer.parseInt(verticesuperioryTextField.getText()); else return 0; } //Obtiene la base introducida por el usuario public int obtenerBase(){ if (baseTextField.getText()!= null) return Integer.parseInt(baseTextField.getText()); else return 0; } //Obtiene la altura introducida por el usuario public int obtenerAltura(){ if (alturaTextField.getText()!= null) return Integer.parseInt(alturaTextField.getText()); else return 0; } }

EJERCICIOS1. Construir una aplicación que pinte un rectángulo en la pantalla. La

aplicación debe permitir que el usuario ingrese los datos del rectángulo: coordenada “x” del vértice superior izquierdo, coordenada “y” del vértice superior izquierdo, base, altura, selección del color a través de un combobox en un formulario, usar diagrama de clases similar al ejercicio anterior.


2. Implementar un juego que consista en ir formando una tortuga con los valores que los jugadores obtengan de los números al tirar un dado: seis para el cuerpo, uno para cada pata y dos para la cabeza. Las reglas son las siguientes:

Pueden jugar N jugadores El dado ira pasando de mano en mano por todos los jugadores y cada jugador

tirará el dado una vez que le toque. Cuando saque 6 significa que formó el cuerpo, y puede recién formar las

patas. Cuando halla formado el cuerpo y todas las patas, recién puede buscar la

cabeza. Gana el que primero forme la tortuga

Elaborar diagrama de clases, programa en Java.

HERENCIA SIMPLE

Ejercicio 1Elaborar una aplicación dada una clase Test que permita crear objetos de la clase CCuentaAhorro con el atributo cuota de mantenimiento o comisión, ésta clase es derivada de la clase base CCuenta que tiene los atributos: nombre, cuenta, saldo, interés. Mostrar: nombre, cuenta, saldo, interés para dos clientes.

// Aplicación para trabajar con la clase base: CCuenta...//public class Test{ public static void main(String[] args) { CCuentaAhorro cliente01 = new CCuentaAhorro(); CCuentaAhorro cliente02 = new CCuentaAhorro("Un nombre", "Una cuenta", 1000000, 3.5, 300); cliente01.asignarNombre("Un nombre"); cliente01.asignarCuenta("Una cuenta"); cliente01.asignarTipoDeInterés(2.5); cliente01.asignarCuotaManten(300); cliente01.ingreso(1000000); cliente01.reintegro(500000); cliente01.comisiones(); System.out.println("Cliente 1"); System.out.println("Nombre: "+cliente01.obtenerNombre()); System.out.println("Cuenta: "+cliente01.obtenerCuenta()); System.out.println("Saldo: "+cliente01.estado()); System.out.println("Interés: "+cliente01.obtenerTipoDeInterés()); System.out.println(); System.out.println("Cliente 2"); System.out.println("Nombre: "+cliente02.obtenerNombre()); System.out.println("Cuenta: "+cliente02.obtenerCuenta()); System.out.println("Saldo: "+cliente02.estado()); System.out.println("Interés: "+cliente02.obtenerTipoDeInterés());


}}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Clase CCuentaAhorro: clase derivada de CCuenta//import java.util.*;public class CCuentaAhorro extends CCuenta{ // Atributos private double cuotaMantenimiento; // Métodos public CCuentaAhorro() {} // constructor sin parámetros public CCuentaAhorro(String nom, String cue, double sal, double tipo, double mant) { super(nom, cue, sal, tipo); // invoca al constructor CCuenta asignarCuotaManten(mant); // inicia cuotaMantenimiento }

public void asignarCuotaManten(double cantidad) { if (cantidad < 0) { System.out.println("Error: cantidad negativa"); return; } cuotaMantenimiento = cantidad; } public double obtenerCuotaManten() { return cuotaMantenimiento; } public void comisiones() { // Se aplican mensualmente por el mantenimiento de la cuenta GregorianCalendar fechaActual = new GregorianCalendar(); int día = fechaActual.get(Calendar.DAY_OF_MONTH); if (día == 1) reintegro(cuotaMantenimiento); }}//////////////////////////////////////////////////////////////////// Clase CCuenta: clase abstracta que agrupa los datos comunes a// cualquier tipo de cuenta bancaria.//public abstract class CCuenta{ // Atributos


private String nombre; private String cuenta; private double saldo; private double tipoDeInterés; // Métodos public CCuenta() {}; public CCuenta(String nom, String cue, double sal, double tipo) { asignarNombre(nom); asignarCuenta(cue); ingreso(sal); asignarTipoDeInterés(tipo); } public void asignarNombre(String nom) { if (nom.length() == 0) { System.out.println("Error: cadena vacía"); return; } nombre = nom; } public String obtenerNombre() { return nombre; }

public void asignarCuenta(String cue) { if (cue.length() == 0) { System.out.println("Error: cuenta no válida"); return; } cuenta = cue; }

public String obtenerCuenta() { return cuenta; } public double estado() { return saldo; } public abstract void comisiones(); public void ingreso(double cantidad) {


if (cantidad < 0) { System.out.println("Error: cantidad negativa"); return; } saldo += cantidad; } public void reintegro(double cantidad) { if (saldo - cantidad < 0) { System.out.println("Error: no dispone de saldo"); return; } saldo -= cantidad; }

public void asignarTipoDeInterés(double tipo) { if (tipo < 0) { System.out.println("Error: tipo no válido"); return; } tipoDeInterés = tipo; } public double obtenerTipoDeInterés() { return tipoDeInterés; }}

Bibliografía: Cap. 10 - Java 2 - Fco. Javier Ceballos.

Ejercicio 2Dada la clase base Figura y las clases derivadas círculo y rectángulo hallar el área de dos objetos Círculo y rectángulo dada la clase base respectiva y datos dados, desde el programa principal como radio, largo y ancho, respecto a un punto en la clase base.

import java.io.*;public class JerarquiadeClases {

/** * @param args the command line arguments */ public static void main(String[] args) { Figura f=new Circulo(0,0,5.5);


System.out.println("Area del circulo: "+f.area()); //f=new Rectangulo(0,0,5.5,2.0); Figura r=new Rectangulo(0,0,5.5,2.0); //Rectangulo r=new Rectangulo(0,0,5.5,2.0); System.out.println("Area del rectangulo: "+r.area()); }

}

public abstract class Figura { protected int x; protected int y; public Figura(int x,int y){ this.x=x; this.y=y; } public abstract double area();}

class Circulo extends Figura{ protected double radio; public Circulo(int x,int y,double radio){ super(x,y); this.radio=radio; } public double area(){ return Math.PI*radio*radio; } }

class Rectangulo extends Figura{ protected double ancho,alto; public Rectangulo(int x,int y, double ancho, double alto){ super(x,y); this.ancho=ancho; this.alto=alto; } public double area(){ return ancho*alto; }}


CLASE ABSTRACTA – POLIMORFISMODada un clase CBanco que define una matriz de referencias a objetos de tipo cuenta bancaria (clase CCuenta), siendo CCuenta una clase abstracta con los atributos: nombre, cuenta, saldo, interés, que incluye a dos clases derivadas: CCuentaAhorro con el atributo cuota de mantenimiento; y la clase CCuentaCorriente con los atributos: transacciones, importe por transacciones, transacciones exentas; y, a la vez CCuentaCorriente es clase base de CCuentaCorrienteConIn (Cuenta corriente con intereses). En una clase Test definir un menú de opciones que permita:

1. Saldo2. Buscar siguiente3. Ingreso4. Reintegro // Ingreso5. Añadir6. Eliminar7. Mantenimiento8. Salir

Seleccione opción: Asimismo en la clase Test en el método principal crear un objeto banco del tipo CBanco ( con cero elementos).

import java.io.*;/////////////////////////////////////////////////////////////////// Aplicación para trabajar con la clase CBanco y la jerarquía// de clases derivadas de CCuenta//public class Test{ // Para la entrada de datos se utiliza Leer.class public static CCuenta leerDatos(int op) { CCuenta obj = null; String nombre, cuenta; double saldo, tipoi, mant; System.out.print("Nombre.................: "); nombre = Leer.dato(); System.out.print("Cuenta.................: "); cuenta = Leer.dato(); System.out.print("Saldo..................: "); saldo = Leer.datoDouble(); System.out.print("Tipo de interés........: "); tipoi = Leer.datoDouble(); if (op == 1) { System.out.print("Mantenimiento..........: "); mant = Leer.datoDouble(); obj = new CCuentaAhorro(nombre, cuenta, saldo, tipoi, mant); } else { int transex; double imptrans; System.out.print("Importe por transacción: "); imptrans = Leer.datoDouble(); System.out.print("Transacciones exentas..: "); transex = Leer.datoInt(); if (op == 2) obj = new CCuentaCorriente(nombre, cuenta, saldo, tipoi, imptrans, transex);


else obj = new CCuentaCorrienteConIn(nombre, cuenta, saldo, tipoi, imptrans, transex); } return obj; } public static int menú() { System.out.print("\n\n"); System.out.println("1. Saldo"); System.out.println("2. Buscar siguiente"); System.out.println("3. Ingreso"); System.out.println("4. Reintegro"); System.out.println("5. Añadir"); System.out.println("6. Eliminar"); System.out.println("7. Mantenimiento"); System.out.println("8. Salir"); System.out.println(); System.out.print(" Opción: "); int op; do op = Leer.datoInt(); while (op < 1 || op > 8); return op; } public static void main(String[] args) { // Definir una referencia al flujo estándar de salida: flujoS PrintStream flujoS = System.out; // Crear un objeto banco vacío (con cero elementos) CBanco banco = new CBanco();

int opción = 0, pos = -1; String cadenabuscar = null; String nombre, cuenta; double cantidad; boolean eliminado = false;

do { opción = menú(); switch (opción) { case 1: // saldo flujoS.print("Nombre o cuenta, total o parcial "); cadenabuscar = Leer.dato(); pos = banco.buscar(cadenabuscar, 0); if (pos == -1) if (banco.longitud() != 0) flujoS.println("búsqueda fallida"); else flujoS.println("no hay clientes"); else { flujoS.println(banco.clienteEn(pos).obtenerNombre()); flujoS.println(banco.clienteEn(pos).obtenerCuenta());


flujoS.println(banco.clienteEn(pos).estado()); } break; case 2: // buscar siguiente pos = banco.buscar(cadenabuscar, pos + 1); if (pos == -1) if (banco.longitud() != 0) flujoS.println("búsqueda fallida"); else flujoS.println("no hay clientes"); else { flujoS.println(banco.clienteEn(pos).obtenerNombre()); flujoS.println(banco.clienteEn(pos).obtenerCuenta()); flujoS.println(banco.clienteEn(pos).estado()); } break; case 3: // ingreso case 4: // reintegro flujoS.print("Cuenta: "); cuenta = Leer.dato(); pos = banco.buscar(cuenta, 0); if (pos == -1) if (banco.longitud() != 0) flujoS.println("búsqueda fallida"); else flujoS.println("no hay clientes"); else { flujoS.print("Cantidad: "); cantidad = Leer.datoDouble(); if (opción == 3) banco.clienteEn(pos).ingreso(cantidad); else banco.clienteEn(pos).reintegro(cantidad); } break; case 5: // añadir flujoS.print("Tipo de cuenta: 1-(CA), 2-(CC), 3-CCI "); do opción = Leer.datoInt(); while (opción < 1 || opción > 3); banco.añadir(leerDatos(opción)); break; case 6: // eliminar flujoS.print("Cuenta: "); cuenta = Leer.dato(); eliminado = banco.eliminar(cuenta); if (eliminado) flujoS.println("registro eliminado"); else if (banco.longitud() != 0) flujoS.println("cuenta no encontrada"); else flujoS.println("no hay clientes"); break; case 7: // mantenimiento for (pos = 0; pos < banco.longitud(); pos++) { banco.clienteEn(pos).comisiones(); banco.clienteEn(pos).intereses(); }


break; case 8: // salir banco = null; } } while(opción != 8); }}///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Clase CBanco: clase que mantiene una matriz de referencias a// objetos de cualquier tipo de cuenta bancaria.//public class CBanco{ private CCuenta[] clientes; // matriz de objetos private int nElementos; // número de elementos de la matriz public CBanco() { // Crear una matriz vacía nElementos = 0; clientes = new CCuenta[nElementos]; } private void unElementoMás(CCuenta[] clientesActuales) { nElementos = clientesActuales.length; // Crear una matriz con un elemento más clientes = new CCuenta[nElementos + 1]; // Copiar los clientes que hay actualmente for ( int i = 0; i < nElementos; i++ ) clientes[i] = clientesActuales[i]; nElementos++; } private void unElementoMenos(CCuenta[] clientesActuales) { if (clientesActuales.length == 0) return; int k = 0; nElementos = clientesActuales.length; // Crear una matriz con un elemento menos clientes = new CCuenta[nElementos - 1]; // Copiar los clientes no nulos que hay actualmente for ( int i = 0; i < nElementos; i++ ) if (clientesActuales[i] != null) clientes[k++] = clientesActuales[i]; nElementos--; } public void insertarCliente( int i, CCuenta objeto ) { // Asignar al elemento i de la matriz, un nuevo objeto if (i >= 0 && i < nElementos) clientes[i] = objeto; else System.out.println("Índice fuera de límites"); } public CCuenta clienteEn( int i ) { // Devolver la referencia al objeto i de la matriz


if (i >= 0 && i < nElementos) return clientes[i]; else { System.out.println("Índice fuera de límites"); return null; } } public int longitud() { return nElementos; } public void añadir(CCuenta obj) { // Añadir un objeto a la matriz unElementoMás(clientes); insertarCliente( nElementos - 1, obj ); } public boolean eliminar(String cuenta) { // Buscar la cuenta y eliminar el objeto for ( int i = 0; i < nElementos; i++ ) if (cuenta.compareTo(clientes[i].obtenerCuenta()) == 0) { clientes[i] = null; // enviar el objeto a la basura unElementoMenos(clientes); return true; } return false; } public int buscar(String str, int pos) { // Buscar un objeto y devolver su posición String nom, cuen; if (str == null) return -1; if (pos < 0) pos = 0; for ( int i = pos; i < nElementos; i++ ) { // Buscar por el nombre nom = clientes[i].obtenerNombre(); if (nom == null) continue; // ¿str está contenida en nom? if (nom.indexOf(str) > -1) return i; // Buscar por la cuenta cuen = clientes[i].obtenerCuenta(); if (cuen == null) continue; // ¿str está contenida en cuen? if (cuen.indexOf(str) > -1) return i; } return -1; }}//////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////// Clase CCuenta: clase abstracta que agrupa los datos comunes a// cualquier tipo de cuenta bancaria.//public abstract class CCuenta{ // Atributos private String nombre; private String cuenta; private double saldo; private double tipoDeInterés; // Métodos public CCuenta() {}; public CCuenta(String nom, String cue, double sal, double tipo) { asignarNombre(nom); asignarCuenta(cue); ingreso(sal); asignarTipoDeInterés(tipo); } public void asignarNombre(String nom) { if (nom.length() == 0) { System.out.println("Error: cadena vacía"); return; } nombre = nom; } public String obtenerNombre() { return nombre; } public void asignarCuenta(String cue) { if (cue.length() == 0) { System.out.println("Error: cuenta no válida"); return; } cuenta = cue; } public String obtenerCuenta() { return cuenta; } public double estado() { return saldo; } public abstract void comisiones();


public abstract double intereses(); public void ingreso(double cantidad) { if (cantidad < 0) { System.out.println("Error: cantidad negativa"); return; } saldo += cantidad; } public void reintegro(double cantidad) { if (saldo - cantidad < 0) { System.out.println("Error: no dispone de saldo"); return; } saldo -= cantidad; }

public void asignarTipoDeInterés(double tipo) { if (tipo < 0) { System.out.println("Error: tipo no válido"); return; } tipoDeInterés = tipo; } public double obtenerTipoDeInterés() { return tipoDeInterés; }}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////import java.io.*;public class Leer {


}public static String dato() {String sdato="";try{





}

public static long datoLong() {return Long.parseLong(dato());

}public static double datoDouble() {

return Double.parseDouble(dato()); }

}import java.util.*;//////////////////////////////////////////////////////////////////// Clase CCuentaAhorro: clase derivada de CCuenta//public class CCuentaAhorro extends CCuenta{ // Atributos private double cuotaMantenimiento; // Métodos public CCuentaAhorro() {} // constructor sin parámetros public CCuentaAhorro(String nom, String cue, double sal, double tipo, double mant) { super(nom, cue, sal, tipo); // invoca al constructor CCuenta asignarCuotaManten(mant); // inicia cuotaMantenimiento }

public void asignarCuotaManten(double cantidad) { if (cantidad < 0) { System.out.println("Error: cantidad negativa"); return; } cuotaMantenimiento = cantidad; } public double obtenerCuotaManten() { return cuotaMantenimiento; } public void comisiones() { // Se aplican mensualmente por el mantenimiento de la cuenta GregorianCalendar fechaActual = new GregorianCalendar(); int día = fechaActual.get(Calendar.DAY_OF_MONTH); if (día == 1) reintegro(cuotaMantenimiento); } public double intereses() { GregorianCalendar fechaActual = new GregorianCalendar(); int día = fechaActual.get(Calendar.DAY_OF_MONTH); if (día != 1) return 0.0; // Acumular los intereses por mes sólo los días 1 de cada mes


double interesesProducidos = 0.0; interesesProducidos = estado() * obtenerTipoDeInterés() / 1200.0; ingreso(interesesProducidos); // Devolver el interés mensual por si fuera necesario return interesesProducidos; }}//////////////////////////////////////////////////////////////////

import java.util.*;//////////////////////////////////////////////////////////////////// Clase CCuentaCorriente: clase derivada de CCuenta//public class CCuentaCorriente extends CCuenta{ // Atributos private int transacciones; private double importePorTrans; private int transExentas; // Métodos public CCuentaCorriente() {} // constructor sin parámetros public CCuentaCorriente(String nom, String cue, double sal, double tipo, double imptrans, int transex) { super(nom, cue, sal, tipo); // invoca al constructor CCuenta transacciones = 0; // inicia transacciones asignarImportePorTrans(imptrans); // inicia importePorTrans asignarTransExentas(transex); // inicia transExentas }

public void decrementarTransacciones() { transacciones--; } public void asignarImportePorTrans(double imptrans) { if (imptrans < 0) { System.out.println("Error: cantidad negativa"); return; } importePorTrans = imptrans; } public double obtenerImportePorTrans() { return importePorTrans; } public void asignarTransExentas(int transex) { if (transex < 0) { System.out.println("Error: cantidad negativa"); return;


} transExentas = transex; } public int obtenerTransExentas() { return transExentas; } public void ingreso(double cantidad) { super.ingreso(cantidad); transacciones++; } public void reintegro(double cantidad) { super.reintegro(cantidad); transacciones++; }

public void comisiones() { // Se aplican mensualmente por el mantenimiento de la cuenta GregorianCalendar fechaActual = new GregorianCalendar(); int día = fechaActual.get(Calendar.DAY_OF_MONTH); if (día == 1) { int n = transacciones - transExentas; if (n > 0) reintegro(n * importePorTrans); transacciones = 0; } } public double intereses() { GregorianCalendar fechaActual = new GregorianCalendar(); int día = fechaActual.get(Calendar.DAY_OF_MONTH); if (día != 1) return 0.0; // Acumular los intereses por mes sólo los días 1 de cada mes double interesesProducidos = 0.0; // Hasta 3000 euros al 0.5%. El resto al interés establecido. if (estado() <= 3000) interesesProducidos = estado() * 0.5 / 1200.0; else { interesesProducidos = 3000 * 0.5 / 1200.0 + (estado() - 3000) * obtenerTipoDeInterés() / 1200.0; } ingreso(interesesProducidos); // Este ingreso no debe incrementar las transacciones decrementarTransacciones(); // Devolver el interés mensual por si fuera necesario return interesesProducidos; }}


//////////////////////////////////////////////////////////////////

import java.util.*;//////////////////////////////////////////////////////////////////// Clase CCuentaCorrienteConIn: clase derivada de CCuentaCorriente//public class CCuentaCorrienteConIn extends CCuentaCorriente{ // Métodos public CCuentaCorrienteConIn() {} // constructor sin parámetros public CCuentaCorrienteConIn(String nom, String cue, double sal, double tipo, double imptrans, int transex) { // Invocar al constructor de la superclase super(nom, cue, sal, tipo, imptrans, transex); } public double intereses() { GregorianCalendar fechaActual = new GregorianCalendar(); int día = fechaActual.get(Calendar.DAY_OF_MONTH); if (día != 1 || estado() < 3000) return 0.0; // Acumular interés mensual sólo los días 1 de cada mes double interesesProducidos = 0.0; interesesProducidos = estado() * obtenerTipoDeInterés() / 1200.0; ingreso(interesesProducidos); // Este ingreso no debe incrementar las transacciones decrementarTransacciones(); // Devolver el interés mensual por si fuera necesario return interesesProducidos; }}//////////////////////////////////////////////////////////////////

Interfaz IFecha

import java.util.*;//////////////////////////////////////////////////////////////////// Interfaz IFecha: métodos y constantes para obtener// el día, mes y año//public interface IFecha{ public final static int DIA_DEL_MES = Calendar.DAY_OF_MONTH; public final static int MES_DEL_AÑO = Calendar.MONTH; public final static int AÑO = Calendar.YEAR; public abstract int día(); public abstract int mes(); public abstract int año();}


EJERCICIOS

1. Vaca, cerdo son animales que tienen peso y no hablan pero si dicen algo, es el caso de la vaca (muu), o, caso del cerdo (oinc). Crear una instancia de vaca por ejemplo daisy, una instancia de cerdo por ejemplo porky. Usando polimorfismo redefinir un método para que al seleccionar un animal de los indicados se diga algo de uno de ellos, y el proceso continué mientras no se desee salir, en un menú de opciones.

2. Controlar o manejar una excepción de división por cero, dados dos números enteros cualesquiera. Cuando los datos son correctos el proceso continua, y pregunta si desea terminar.

3. Dado las instancias cuadrado, círculo, rectángulo, además una clase base Figura; redefinir el método calcular el área, para cada una de las figuras, cuando se solicite en el programa principal desde un menú de opciones el área de ellas. Recuerde leer: lado, radio, largo y ancho,

MENU1. Área de un cuadrado2. Area de un círculo3. Area de un rectángulo4. Salir

Seleccione opción:

CLASES GENERICASClases con variables o parámetros que representan tipos.Por ejemplo, dada una clase genérica Par que permita establecer un tipo T, para manejar enteros y caracteres, y luego a través de un método intercambiar los valores, para luego presentar intercambiado los valores en el programa principal.

public class Par <T>{private T a, b;public Par(T a, T b){

this.a = a;this.b = b;

} public void setA(T a){this.a=a;} public T getA(){return a;} public void setB(T b){this.b=b;} public T getB(){return b;}

public Par<T> swap(){return new Par<T>(b, a);

}}

import java.io.*;import javax.swing.JOptionPane;public class Prueba {______________________________________________________________________FISI – UNMSM Luis Guerra G.62

public static void main(String[] args) { int n1,n2; char ca=' ',cb=' '; System.out.println("Numeros para intercambiar usando clase generica"); n1=Integer.parseInt(JOptionPane.showInputDialog("Primer numero:")); n2=Integer.parseInt(JOptionPane.showInputDialog("Segundo numero:")); // Instanciación de la clase genérica para Integer(Enteros)

// No se puede usar int porque no es una clasePar<Integer> p = new Par<Integer>(n1,n2);

System.out.println("Par de enteros, antes del cambio: n1="+p.getA()+" n2="+p.getB()); p = p.swap(); System.out.println("Par de enteros, despues del cambio: n1="+p.getA()+" n2="+p.getB()); System.out.println("Caracteres para intercambiar usando clase generica"); InputStreamReader isr=new InputStreamReader(System.in); BufferedReader flujoE=new BufferedReader(isr); PrintStream flujoS=System.out; try{ flujoS.print("Primer caracter<letra>: "); ca=(char)flujoE.read(); flujoE.readLine(); //Limpiar caracteres: \r\n flujoS.print("Segundo caracter<letra>: "); cb=(char)flujoE.read(); flujoE.readLine(); //Limpiar caracteres: \r\n } catch(IOException e){ System.out.println("Error:"+e.getMessage()); }

// Instanciación de la clase genérica para Character(Caracteres) //Par<Character> p1 = new Par<Character>('a','b');

Par<Character> p1 = new Par<Character>(ca,cb); System.out.println("Par de aracteres, antes del cambio: ca="+p1.getA()+" cb="+p1.getB()); p1=p1.swap(); System.out.println("Par de caracteres, despues del cambio: ca="+p1.getA()+" cb="+p1.getB()); } }

Ejercicios:1. Programa utilizando clase genérica, para hallar el menor, intemedio y mayor de tres números

enteros, a su vez de tres letras.2. Programa utilizando clase genérica para ordenar cinco números y ordenar cinco letras,

ascendente y/o descendente.

Clase genérica de Conexión a Bases de datos

Una clase Genérica de conexión a bases de datos.

Una clase generica que realiza una conexión a bases de datos mysql, la cual esta declarada dentro del

paquete conexión, recibe cuatro parametros:


String ip, String bd, String usr, String pass, los cuales se pueden enviar desde otra clase en donde se

instancie y se invoque... ejemplo:

GenericaDb np = new GenericaDb("192.168.54.2","listadb","admin","4dm1n1str");

despues se puede acceder a los elementos de la clase de la siguiente forma:

//Para obtener la conexion

Connexion conexion = qpn.getConexion();

package conexion;

/****************************************

* * http://www.comunidadjava.org/?q=node/430* @author Marco A. Trejo Lemus *

* 17/06/2008 09:47:01 AM *

****************************************/

import java.sql.*;

public class GenericaDb

{

public String driver,url,ip,bd,usr,pass;

public Connection conexion;

public GenericaDb(String ip, String bd, String usr, String pass)

{ driver="com.mysql.jdbc.Driver";

this.bd = bd;

this.usr = usr;

this.pass = pass;

url = new String("jdbc:mysql://"+ip+"/"+bd);

try

{ Class.forName(driver).newInstance();

conexion=DriverManager.getConnection(url,usr,pass);

System.out.println("Conexion a Base de Datos "+bd+" Ok");

}

catch (Exception exc)

{ System.out.println("Error al tratar de abrir la base de Datos"+bd+" : "+exc);

}

}

public Connection getConexion()

{ return conexion;

}

public Connection CerrarConexion() throws SQLException

{ conexion.close(); conexion = null;

return conexion;

}

} //fin de la clase

"Por mas dificil que parezca un reto si se puede alcanzar si realmente lo intentamos"

Marco Antonio Trejo Lemus ******** Comunidad Java México

*****************************************************************

EXCEPCIONES


http://www.comunidadjava.org/?q=node/430

Excepciones en Java pemiten manejar situaciones anómalas.Las palabras try y catch trabajan conjuntamente y pueden traducirse: probar un fragmento de código, si es satisfactorio continuar con la ejecución del programa, de no ser así atrapar la excepción y manejarla.Ejemplo:Dado un arreglo de objeto, para guardar diez números reales, si se ingresara otro carácter(s) que no sea número real, manejar la excepción, indicando, “Ese dato no es válido. Teclee otro”.Utilizar la clase Leer, dada anteriormente.

public class LeerDatos{ public static void main(String[] args) { boolean eof = true; float[] a = new float[10]; int i = 0; System.out.println("Ingresar datos "); System.out.print("Dato float: "); while (i < 10 && Float.isNaN(a[i] = Leer.datoFloat()) != eof) { i++; System.out.print("Dato float: "); } System.out.println(); for (int k = 0; k < i; k++) System.out.print(a[k] + " "); System.out.println(); }}import java.io.*;public class Leer{ public static String dato() { String sdato = ""; try { // Definir un flujo de caracteres de entrada: flujoE InputStreamReader isr = new InputStreamReader(System.in); BufferedReader flujoE = new BufferedReader(isr); // Leer. La entrada finaliza al pulsar la tecla Entrar sdato = flujoE.readLine(); } catch(IOException e) { System.err.println("Error: " + e.getMessage()); } return sdato; // devolver el dato tecleado } public static short datoShort() { try { String sdato = dato(); if (sdato == null) { System.out.println(); return Short.MIN_VALUE;


} else return Short.parseShort(sdato); } catch(NumberFormatException e) { System.out.print("Ese dato no es válido. Teclee otro: "); return datoShort(); } } public static int datoInt() { try { String sdato = dato(); if (sdato == null) { System.out.println(); return Integer.MIN_VALUE; } else return Integer.parseInt(sdato); } catch(NumberFormatException e) { System.out.print("Ese dato no es válido. Teclee otro: "); return datoInt(); } } public static long datoLong() { try { String sdato = dato(); if (sdato == null) { System.out.println(); return Long.MIN_VALUE; } else return Long.parseLong(sdato); } catch(NumberFormatException e) { System.out.print("Ese dato no es válido. Teclee otro: "); return datoLong(); } } public static float datoFloat() { try { String sdato = dato(); if (sdato == null) { System.out.println();


return Float.NaN; // No es un Número; valor float. } else { Float f = new Float(sdato); return f.floatValue(); } } catch(NumberFormatException e) { System.out.print("Ese dato no es válido. Teclee otro: "); return datoFloat(); } }/* public static float datoFloat() { try { Float f = new Float(dato()); return f.floatValue(); } catch(NumberFormatException e) { System.out.print("Ese dato no es válido. Teclee otro: "); return datoFloat(); } catch(NullPointerException e) { return Float.NaN; // No es un Número; valor float. } }*/ public static double datoDouble() { try { Double d = new Double(dato()); return d.doubleValue(); } catch(NumberFormatException e) { System.out.print("Ese dato no es válido. Teclee otro: "); return datoDouble(); } catch(NullPointerException e) { return Double.NaN; // No es un Número; valor double. } }} //******** Bibliografía Cap. 11 – Ceballos Java 2

Excepciones PropiasEjemplo:


Se conoce la longitud de los tres lados enteros de un triángulo, el área puede calcularse de la siguiente manera:

area = Math.sqrt(s*(s-a)*(s-b)*(s-c)); donde: s=(a+b+c)/2

En un programa elabore un método para calcular y devolver el área; permita que lance una excepción cuando las tres longitudes no puedan formar un triángulo. Desarrolle un método invocador que atrape la excepción

import java.util.InputMismatchException;import java.util.Scanner;class Cuando3LnofT extends Exception{}public class ExcepcionCuando3LnofT { public static double area(double l1,double l2, double l3) throws Exception, InputMismatchException{ double s,carea; if(l1<l2+l3 && l2<l1+l3 && l3<l1+l2){ s=(l1+l2+l3)/2; carea=Math.sqrt(s*(s-l1)*(s-l2)*(s-l3)); return carea; } else throw new Cuando3LnofT(); } public static void main(String[] args) throws Exception{ Scanner lado=new Scanner(System.in); double resultado=0; try{ System.out.println("Tres lados enteros de un triangulo para hallar area:"); System.out.println("\n 1er lado: "); double lado1=lado.nextDouble(); System.out.println("\n 2do lado: "); double lado2=lado.nextDouble(); System.out.println("\n 3er lado: "); double lado3=lado.nextDouble(); resultado = area(lado1, lado2, lado3); System.out.println("El area es:"+resultado); } catch(Cuando3LnofT e){ System.err.println("ERROR: los tres lados no forman un triangulo"); } catch(InputMismatchException inputMismatchException){ System.err.printf("\n Excepcion: %s\n",inputMismatchException); System.out.println("Debe ingresar numeros enteros. Intente de nuevo\n"); } }}

PERSISTENCIA


Característica de la programación orientada a objetos que permite la persistencia de los objetos. Llevar la información a disco, y reconstruir después en el momento de la lectura.

import java.io.*;

/////////////////////////////////////////////////////////////////

// Aplicación: Lista de teléfonos. Cuando la aplicación finaliza

// la lista es salvada en un archivo "listatfnos.dat" y cuando

// se inicia se recupera de ese archivo.

//

public class Test

{

public static int menú()

{

System.out.print("\n\n");

System.out.println("1. Buscar");

System.out.println("2. Buscar siguiente");

System.out.println("3. Añadir");

System.out.println("4. Eliminar");

System.out.println("5. Salir");

System.out.println();

System.out.print(" Opción: ");

int op;

do

op = Leer.datoInt();

while (op < 1 || op > 5);

return op;

}

public static void main(String[] args)

{

// Definir un flujo de caracteres de entrada: flujoE

InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader flujoE = new BufferedReader(isr);

// Definir una referencia al flujo estándar de salida: flujoS

PrintStream flujoS = System.out;

CListaTfnos listatfnos;

int opción = 0, pos = -1;

String cadenabuscar = null;

String nombre, dirección;

long teléfono;

boolean eliminado = false;______________________________________________________________________FISI – UNMSM Luis Guerra G.69

boolean listaModificada = false;

try

{

// Crear un objeto lista de teléfonos vacío (con 0 elementos)

// o con el contenido del fichero listatfnos.dat si existe.

File fichero = new File("listatfnos.dat");

if (!fichero.exists())

{

listatfnos = new CListaTfnos();

flujoS.println("Se ha creado una lista de teléfonos nueva");

}

else

{

ObjectInputStream ois = new ObjectInputStream(

new FileInputStream("listatfnos.dat"));

listatfnos = (CListaTfnos)ois.readObject();

ois.close();

flujoS.println("Se cargó la lista de teléfonos con éxito");

}

do

{

opción = menú();

switch (opción)

{

case 1: // buscar

flujoS.print("conjunto de caracteres a buscar ");

cadenabuscar = flujoE.readLine();

pos = listatfnos.buscar(cadenabuscar, 0);

if (pos == -1)

if (listatfnos.longitud() != 0)

flujoS.println("búsqueda fallida");

else

flujoS.println("lista vacía");

else

{

flujoS.println(listatfnos.valorEn(pos).obtenerNombre());

flujoS.println(listatfnos.valorEn(pos).obtenerDirección());

flujoS.println(listatfnos.valorEn(pos).obtenerTeléfono());

}


break;

case 2: // buscar siguiente

pos = listatfnos.buscar(cadenabuscar, pos + 1);

if (pos == -1)


flujoS.println("búsqueda fallida");

else


else

{

flujoS.println(listatfnos.valorEn(pos).obtenerNombre());

flujoS.println(listatfnos.valorEn(pos).obtenerDirección());

flujoS.println(listatfnos.valorEn(pos).obtenerTeléfono());

}

break;

case 3: // añadir

flujoS.print("nombre: "); nombre = flujoE.readLine();

flujoS.print("dirección: "); dirección = flujoE.readLine();

flujoS.print("teléfono: "); teléfono = Leer.datoLong();

listatfnos.añadir(new CPersona(nombre, dirección, teléfono));

listaModificada = true;

break;

case 4: // eliminar

flujoS.print("teléfono: "); teléfono = Leer.datoLong();

eliminado = listatfnos.eliminar(teléfono);

if (eliminado)

{

flujoS.println("registro eliminado");

listaModificada = true;

}

else


flujoS.println("teléfono no encontrado");

else


break;

case 5: // salir

// guardar lista

if (listaModificada)

{

ObjectOutputStream ous = new ObjectOutputStream(


new FileOutputStream("listatfnos.dat"));

ous.writeObject(listatfnos);

ous.close();

}

listatfnos = null;

}

}

while(opción != 5);

}

catch (IOException e)

{

System.out.println("Error: " + e.getMessage());

}

catch (ClassNotFoundException e)

{

System.out.println("Error: " + e.getMessage());

}

}

}

/////////////////////////////////////////////////////////////////

// Definición de la clase CListaTfnos.

//

import java.io.*;

public class CListaTfnos implements Serializable

{

private CPersona[] listaTeléfonos; // matriz de objetos

private int nElementos; // número de elementos de la matriz

private CPersona[] asignarMemoria(int nElementos)

{

try

{

return new CPersona[nElementos];

}

catch (OutOfMemoryError e)

{

System.out.println(e.getMessage());

return listaTeléfonos;

}

}


public CListaTfnos()

{

// Crear una lista vacía

nElementos = 0;

listaTeléfonos = asignarMemoria(nElementos);

}

private void unElementoMás(CPersona[] listaActual)

{

nElementos = listaActual.length;

listaTeléfonos = asignarMemoria(nElementos + 1);

// Copiar la lista actual

for ( int i = 0; i < nElementos; i++ )

listaTeléfonos[i] = listaActual[i];

nElementos++;

}

private void unElementoMenos(CPersona[] listaActual)

{

if (listaActual.length == 0) return;

int k = 0;

nElementos = listaActual.length;

listaTeléfonos = asignarMemoria(nElementos - 1);

// Copiar la lista actual


if (listaActual[i] != null)

listaTeléfonos[k++] = listaActual[i];

nElementos--;

}

public void ponerValorEn( int i, CPersona objeto )

{

if (i >= 0 && i < nElementos)

listaTeléfonos[i] = objeto;

else

System.out.println("Índice fuera de límites");

}

public CPersona valorEn( int i )

{

if (i >= 0 && i < nElementos)


return listaTeléfonos[i];

else

{

System.out.println("Índice fuera de límites");

return null;

}

}

public int longitud() { return nElementos; }

public void añadir(CPersona obj)

{

unElementoMás(listaTeléfonos);

ponerValorEn( nElementos - 1, obj );

}

public boolean eliminar(long tel)

{

// Buscar el teléfono y eliminar registro


if (listaTeléfonos[i].obtenerTeléfono() == tel)

{

listaTeléfonos[i] = null;

unElementoMenos(listaTeléfonos);

return true;

}

return false;

}

public int buscar(String str, int pos)

{

String nom;

if (str == null) return -1;

if (pos < 0) pos = 0;

for ( int i = pos; i < nElementos; i++ )

{

nom = listaTeléfonos[i].obtenerNombre();

if (nom == null) continue;

// ¿str está contenida en nom?

if (nom.indexOf(str) > -1)

return i;


}

return -1;

}

}

/////////////////////////////////////////////////////////////////

// Definición de la clase CPersona

//

import java.io.*;

public class CPersona implements Serializable

{

// Atributos

private String nombre;

private String dirección;

private long teléfono;

// Métodos

public CPersona() {}

public CPersona(String nom, String dir, long tel)

{

nombre = nom;

dirección = dir;

teléfono = tel;

}

public void asignarNombre(String nom)

{

nombre = nom;

}

public String obtenerNombre()

{

return nombre;

}

public void asignarDirección(String dir)

{

dirección = dir;

}

public String obtenerDirección()

{


return dirección;

}

public void asignarTeléfono(long tel)

{

teléfono = tel;

}

public long obtenerTeléfono()

{

return teléfono;

}

}

CONEXIÓN A BASE DE DATOS: JAVA – SQL SERVER


Probar DSN en SQL SERVER

package paquetePconexion;

import java.sql.*;

public class PanelPrincipal extends javax.swing.JPanel {

/** Creates new form PanelPrincipal */ public PanelPrincipal() { initComponents(); }

private void btnProbarDsnDatosActionPerformed(java.awt.event.ActionEvent evt) { try{ Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection cn=DriverManager.getConnection("jdbc:odbc:dsnDatos","sa",""); DatabaseMetaData meta=cn.getMetaData(); txtSalida.append("\nDatabase:\t"+meta.getDatabaseProductName()); txtSalida.append("\nversion:\t"+meta.getDatabaseProductVersion()); cn.close(); } catch(Exception ex){ txtSalida.setText("La conexion fracasó por:\n\n"); txtSalida.append(ex.toString()); }}

private javax.swing.JButton btnProbarDsnDatos; private javax.swing.JScrollPane jScrollPane1; private javax.swing.JTextArea txtSalida;

}

public class Principal extends javax.swing.JFrame {

/** Creates new form Principal */ public Principal() { initComponents(); add(new PanelPrincipal()); setSize(300,200); }

public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new Principal().setVisible(true); } }); } }


Mantenimiento a una Base de Datos

Se podrá insertar, eliminar y actualizar registros de una tabla mediante las sentencias del SQI: Insert, Delete y Update.

La sentencia INSERTINSERT INTO NombreTabla (ColumnasDeTabla) VALUES (DatosParaColumnas)

Ejemplo:Insert Into Personas (Nombre, edad) Values (‘Sergio Vásquez Fano’,17)

La sentencia DELETEDELETE FROM NombreTabla WHERE CondiciónDeBúsqueda

Ejemplo:Delete From Personas Where Nombre like ‘Sergio Vásquez Fano’

La sentencia UPDATEUPDATE Nombre Tabla SET Columna 1 = Expresión, Columna 2 = Expresión... WHERE CondiciónDeBúsqueda

Ejemplos:Update Personas Set Edad = 22 Where Nombre = ‘Diva Martinez’

EJEMPLO (NetBeans – SqlServer)


Desarrollar una aplicación que permite dar mantenimiento (nuevo, eliminar y actualizar datos) a una tabla de una base de datos creada con SQL Server en un menú de opciones.

Paso 1:

Ejecutar en el Analizador de Consultas(Quero Analyzer) del SQL Server el siguiente script:

-- Crea base de datos con nombre: Datos

CREATE DATABASE Datos

ON PRIMARY(NAME=DatosData, FILENAME='c:\Datos.mdf')

LOG ON(NAME=DatosLog, FILENAME='c:\Log.ldf')

GO

USE Datos -- activa Datos

GO

-- crea tabla Personas

Create Table Personas(idPersona int identity(1,1),Nombre varchar(60) NOT NULL,Email

varchar(60),Telefono varchar(10))

-- Inserta filas a tabla personas

Insert Personas values('Joel Penia','[email protected]','1234567')

Insert Personas(Nombre,Email,Telefono) values('Beatriz Llontop','[email protected]','7654321')

Paso 2:El paso consiste en crear el dsn: dsnDatos mediante ODBC y debe apuntar a la base de datos: Datos del paso 1.

Paso 3:______________________________________________________________________FISI – UNMSM Luis Guerra G.79

Una vez creada la base de datos (Datos) y el dsn (dsnDatos), entonces podemos iniciar el desarrollo de nuestra aplicación.

Nuevo proyecto de nombre ProyectoBds1, nuevo paquete de nombre proyectobds1.

Las clases para ésta aplicación son: JDBComboBox, JDBTable, Mantenimiento, MiMenu, PanelNuevo, PanelEliminar y PanelActualizar.

package proyectobds1;

import java.sql.*;

import javax.swing.*;

public class JDBComboBox extends JComboBox{

// constructor

public JDBComboBox(String select, String dsn, String login, String password){

try{

Class.forName("sun.jdbc.odbc.Jdbc0dbcDriver");

Connection cn = DriverManager.getConnection("jdbc:odbc:"+dsn, login, password);

Statement st = cn.createStatement();

ResultSet rs = st.executeQuery(select);

while(rs.next()) addItem(rs.getString(1)); // columna 1

cn.close ( );

}

catch(Exception ex){

String s = "La consulta fracasó por: \n\n" + ex.toString();

JOptionPane.showMessageDialog(null,s,"Error",JOptionPane.ERROR_MESSAGE);

} // fin del catch

} // fin del constructor

} // fin de la clase


import java.sql.*;

import java.util.Vector;


import javax.swing.table.*;

public class JDBTable extends JTable{

Vector cache;

int colCount;

String[] headers;


public JDBTable(String dsn, String login, String password, String query){

setModel(formaMiTabla(dsn,login,password,query));

}

public TableModel formaMiTabla(String dsn, String login, String password, String query){

cache=new Vector();

try{

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

Connection cn=DriverManager.getConnection("jdbc:odbc:"+dsn,login,password);

Statement st=cn.createStatement();

ResultSet rs=st.executeQuery(query);

ResultSetMetaData meta=rs.getMetaData();

colCount =meta.getColumnCount();

// nombres de columnas

headers=new String[colCount];

for(int h=1;h<=colCount;h++){

headers[h-1]=meta.getColumnName(h);

}

while(rs.next()){

String[] record=new String[colCount];

for(int i=0;i<colCount;i++)

record[i]=rs.getString(i+1);

cache.addElement(record);

}

// notifica que tenemos una nueva tabla

((AbstractTableModel)getModel()).fireTableChanged(null);

cn.close();

}

catch(Exception e){

JOptionPane.showMessageDialog(null, "Fracasó por:\n\n"+e.toString());

}

return new AbstractTableModel(){

//titulo de columna

@Override

public String getColumnName(int i){

return headers[i];

}

// cuántas columnas

public int getColumnCount(){ return colCount;}

// cuántas filas

public int getRowCount(){ return cache.size();}


//cadena en fila, columna. Inicia en (0,0)

public Object getValueAt(int row, int col){

return ((String[])cache.elementAt(row))[col];

}

};

}

}


import java.awt.event.*;


public class Mantenimiento extends JFrame{

public Mantenimiento(String s,JPanel p, int width, int height){

super(s);

getContentPane().add(p);

addWindowListener(new WindowAdapter(){

@Override

public void windowClosing(WindowEvent e){

setVisible(false);

dispose();

}

});

setSize(width,height);

setVisible(true);

}

}

A continuación, construimos un Frame para el menú en una clase de nombre MiMenú. Clic derecho en el paquete proyectobds1, nuevo JFrame, nuevo JFrame Form de nombre MiMenu donde hacemos el siguiente diseño:

Mi Menu con BorderLayout. En el norte colocamos una barra de menú (jMenuBar1) donde modificamos las opciones por defecto y agregamos un nuevo menú para Ver la tabla de personas. En cada opción de menú colocamos sus respectivos Menu Items hasta lograr el diseño requerido. Utilice la propiedad title para escribir un título del frame.

Observe la distribución de los objetos y los nombres de variable utilizados.


Vamos al código fuente (source) de MiMenu para establecer el tamaño de la ventana y escribir

un método que retorne el menú Item que permite ver la tabla de personas.


import java.sql.*;


public class MiMenu extends javax.swing.JFrame {

public MiMenu() {

initComponents();

setSize(500,400);

}

public JMenuItem getMniVerTablaPersonas(){

return mniVerTablaPersonas;

}

Regresamos al diseño de MiMenu y hacemos clic derecho en el menultem Salir, elegimos Events, Action, ActionPerformed para programar su acción

private void mniArchivoSalirActionPerformed(java.awt.event.ActionEvent evt) {

dispose();

System.exit(0);

}______________________________________________________________________FISI – UNMSM Luis Guerra G.83

Regresamos al diseño de MiMenu y hacemos clic derecho en el menultem Mantenimiento-Nuevo, elegimos Events, Action, ActionPerformed para programar su acción.

private void mniMantenimientoNuevoActionPerformed(java.awt.event.ActionEvent evt) {

new Mantenimiento("Nuevo Registro", new PanelNuevo(this),300,200);

}

Regresamos al diseño de MiMenu y hacemos clic derecho en el menultem Ver Tabla de Personas, elegimos Events, Action, ActionPerformed para programar su acción.

private void mniVerTablaPersonasActionPerformed(java.awt.event.ActionEvent evt) {

JDBTable jdbt=new JDBTable("dsnDatos","sa","","Select Nombre, Email, Telefono from Personas");

getContentPane().removeAll();

getContentPane().add(jdbt);

paintComponents(getContentPane().getGraphics());

}

public boolean hayRegistros(String select){

boolean hay=false;

try{


Connection cn=DriverManager.getConnection("jdbc:odbc:dsnDatos","sa","");


ResultSet rs=st.executeQuery(select);

hay=rs.next();

cn.close();

}


String s="El Select fracasó por:\n\n"+ex.toString();


}

return hay;

}

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new MiMenu().setVisible(true);

}

});

}


// Variables declaration - do not modify

private javax.swing.JMenuBar jMenuBar1;

private javax.swing.JMenuItem mniArchivoSalir;

private javax.swing.JMenuItem mniMantenimientoActualizar;

private javax.swing.JMenuItem mniMantenimientoEliminar;

private javax.swing.JMenuItem mniMantenimientoNuevo;

private javax.swing.JMenuItem mniVerTablaPersonas;

private javax.swing.JMenu mnuArchivo;

private javax.swing.JMenu mnuMantenimiento;

private javax.swing.JMenu mnuVer;

// End of variables declaration

}A continuación diseñamos el PanelNuevo. Clic derecho en el paquete proyectobds1, nuevo

JPanelForm de nombre PanelNuevo donde hacemos el siguiente diseño.

PanelNuevo con BorderLayout. En el sur colocamos un botón para grabar.

En el centro colocamos otro panel (jPanel1) con BorderLayout. En el oste colocamos otro

panel (jPanel2) con GridLayout de 1 columna, 3 filas donde colocamos las etiquetas.

En el centro del panel jPanel1 colocamos otro panel (jPanel3) con GridLayout de 1 columna,

3. filas donde colocamos las cajas de texto.

Observe la distribución de los objetos y los nombres de variable utilizados.


Vamos al código fuente (source) de PanelNuevo para declarar un objeto Menú y recibirlo a

través de su constructor:


import java.sql.*;


public class PanelNuevo extends javax.swing.JPanel {

MiMenu menu=null;

/** Creates new form PanelNuevo */

public PanelNuevo(MiMenu menu) {

initComponents();

this.menu=menu;

}

Regresamos al diseño del PanelNuevo y hacemos doble clic en el botón Grabar para

programar su acción:


private void btnGrabarActionPerformed(java.awt.event.ActionEvent evt) {

try{




String no=txtNombre.getText();

String em=txtEmail.getText();

String te=txtTelefono.getText();

if(no.length()!=0)

st.execute("Insert Into Personas Values('"+no+"','"+em+"','"+te+"')");

cn.close();

menu.getMniVerTablaPersonas().doClick(); // Actualiza JTable

} catch(Exception ex){

String s = "La sentencia fracasó por: \n\n" + ex.toString();


}

// cierra el formulario

((Mantenimiento) getTopLevelAncestor()).dispose();

}

Referencia:

Java for Windows with NetBeans IDE

Julio Vásquez Paragulla

Capítulo 13


Seguidamente diseñamos el PanelEliminar. Clic derecho en el paquete proyectobds1, nuevo

JPanelForm de nombre PanelEliminar donde hacemos el siguiente diseño:

PanelEliminar con BorderLayout. En el sur colocamos un botón para eliminar un registro.

En el norte colocaremos un comboBox con los nombres de personas que se encuentren en la

tabla de la base de datos, pero lo haremos escribiendo el código.

Vamos al código fuente (source) del PanelEliminar para escribir lo siguiente:


import java.awt.BorderLayout;

import proyectobds1.JDBComboBox;

public class PanelEliminar extends javax.swing.JPanel {

JDBComboBox lst = new JDBComboBox("Select Nombre From Personas","dsnDatos","sa","");

MiMenu menu = null;

public PanelEliminar(MiMenu menu) {

initComponents();

this.menu=menu;

add(lst,BorderLayout.NORTH);


}

private javax.swing.JButton btnEliminar;

}

Observe que el objeto lst de la clase JDBComboBox es creado y agregado al norte del panel.

Regresamos al diseño del PanelEliminar y hacemos doble clic en el botón Eliminar para programar su acción:

private void btnEliminarActionPerformed(java.awt.event.ActionEvent evt) {

try{




String n=lst.getSelectedItem().toString();

st.execute("Delete From Personas Where Nombre like '"+n+"'");

cn.close();

menu.getMniVerTablaPersonas().doClick(); // Actualiza JTable

}


String s="La sentencia fracasó por:\n\n"+ex.toString();


}

// cierra el formulario

((Mantenimiento) getTopLevelAncestor()).dispose();

}

private void mniMantenimientoEliminarActionPerformed(java.awt.event.ActionEvent evt) {

if(hayRegistros("select * from Personas"))

new Mantenimiento("Eliminar Registro", new PanelEliminar(this),300,200);

else

JOptionPane.showMessageDialog(null,"No hay Registros..!","Sin Registros!",JOptionPane.ERROR_MESSAGE);

}

public boolean hayRegistros(String select){

boolean hay=false;

try{




ResultSet rs=st.executeQuery(select);

hay=rs.next();


}


String s="El select fracasó por:\n\n"+ex.toString();


}

return hay;

}


REFERENCIAS

1. Joyanes, Luis; Zahonero, Luis. Programación en C, C++, Java y UML. 2010. Edit. Mc Graw Hill. México.

2. Deitel & Deitel. Java como programar. 2008. Edit. Pearson Prentice Hall. México.

3. Francisco, Javier Ceballos. Java 2. Curso de Programación. 2000 . Edit. Alfa Omega Ra-ma. España.

4. Douglas Bell, Mike Parr. Java para estudiantes. 2003. Edit. Pearson.

5. Jhon Zukowski. Java 2. 2003. Edit. Anaya Multimedia.

6. Marco Trejo Lemus. Comunidad Java México. http://www.comunidadjava.org/?q=node/43. 17-6-2008 .

7. García-Bermejo, José Rafael. Java SE6 & Swing. 2007. Edit. Pearson. España.

8. Coronel Castillo, Eric. Java y MySql. 2009. Editora Macro. Perú.

9. Vásquez Paragulla, Julio. Java SE for Windows with NetBeans IDE. 2008. Lima.


http://www.comunidadjava.org/?q=node/43.%2017-6-2008

http://www.comunidadjava.org/?q=node/43.%2017-6-2008

Manual Java

Documents

Transcript of Manual Java