Unidad 2 clases y objetos

Declaración de clases.

El elemento básico de la programación orientada a objetos en Java es la clase. Una clase define la forma y comportamiento de un objeto.

Para crear una clase sólo se necesita un archivo fuente que contenga la palabra reservada class seguida de un identificador legal y un bloque delimitado por dos llaves para el cuerpo de la clase. Por ejemplo:

class MiClase{ … }

Un archivo de Java debe tener el mismo nombre que la clase que contiene, y se les suele asignar la extensión ".java". Por ejemplo la clase MiClase se guardaría en un archivo que se llamase MiClase.java. Hay que tener presente que en Java se diferencia entre mayúsculas y minúsculas; el nombre de la clase y el de archivo fuente han de ser exactamente iguales.

Una clase es una plantilla para un objeto. Por lo tanto define la estructura de un objeto y su interfaz funcional, en forma de métodos. La sintaxis general de una definición de clase es: modificador class NombreClase { // Atributos modificador tipo nombreAtributo1; modificador tipo nombreAtributo2; modificador tipo nombreAtributoN;

// Métodos modificador tipo_devuelto nombreMétodo1(lista_de_parámetros){ cuerpo_del_método1; } modificador tipo_devuelto nombreMétodo2(lista_de_parámetros){ cuerpo_del_método2; } }

Dónde:

ü  tipo y tipo_devuelto: han de ser tipos simples Java o nombres de otras clases ya definidas.

ü  NombreClase, nombreAtributo y nombreMétodo: han de ser identificadores Java válidos.

Modificador de la clase:

ü  public Puede ser utilizada por cualquier otra clase, incluyendo las que no pertenecen a su propio paquete.

ü  abstract Indica que la clase contiene métodos abstract, es decir, métodos no implementados. No será posible crear instancias de una clase abstract. Es posible heredar de esta clase y reescribir los métodos no implementados de la clase heredada.

ü  final La clase no admite variaciones. No puede ser heredada.

Modificador de atributo:

ü  public Es visible desde cualquier clase que pueda tener acceso a un objeto al que pertenece el atributo.

ü  private Sólo es visible para los métodos de la clase. No es visible para los métodos de las clases derivadas.

ü  protected Es visible para los métodos de la clase, para los métodos de las clases derivadas y para los métodos de las clases del mismo paquete.

ü  static Indica que es un atributo común para todos los objetos de una clase. Una sola variable compartida por todos los ejemplares de la clase.

ü  final Este atributo es una constante con nombre. Estos atributos reciben un valor en el momento de su declaración y no pueden modificarse posteriormente. Sus identificadores se escriben con mayúsculas.

Modificador de método:

ü  abstract Este método carece de cuerpo (sólo un punto y coma) y debe ser implementado por la clase derivada o subclase. Una clase con un método abstract debe ser declarada abstract.

ü  final No se puede reescribir en una subclase o clase derivada.

ü  static Este método sólo puede acceder a variables static o de clase. Los métodos static son automáticamente final.

Atributos.

Los datos se encapsulan dentro de una clase declarando variables dentro de las llaves de apertura y cierre de la declaración de la clase, variables que se conocen como atributos. Se declaran igual que las variables locales de un método en concreto.

Por ejemplo, este es un programa que declara una clase MiPunto, con dos atributos enteros llamados x e y.

class MiPunto{ int x, y; }

Los atributos se pueden declarar con dos clases de tipos: un tipo simple Java o el nombre de una clase (referencia a objeto).

Cuando se realiza una instancia de una clase (creación de un objeto) se reservará en la memoria un espacio para un conjunto de datos como el que definen los atributos de una clase. A este conjunto de variables se le denomina variables de instancia.

Métodos

Los métodos son subrutinas que definen la interfaz de una clase, sus capacidades y comportamiento.

Un método ha de tener por nombre cualquier identificador legal distinto de los ya utilizados por los nombres de la clase en que está definido. Los métodos se declaran al mismo nivel que las variables de instancia dentro de una definición de clase.

Encapsulamiento

Este concepto consiste en la ocultación del estado, o lo que es lo mismo, de los datos miembro de un objeto, de forma que sólo es posible modificar los mismos mediante las operaciones (métodos, en Java) definidos para dicho objeto.

Cada objeto está aislado del exterior, de forma que la aplicación al final es un conjunto más o menos extenso de objetos que colaboran entre sí mediante el paso de mensajes entre ellos, es decir, mediante la invocación de sus operaciones o métodos. De esta forma, los detalles de implementación permanecen "ocultos" a las personas que usan las clases, evitando así modificaciones o accesos indebidos a los datos que almacenan las clases.

Además, el usuario de la clase no se tiene que preocupar de cómo están implementados los métodos y propiedades, concentrándose sólo en cómo debe usarlos.

La encapsulación es una de las principales ventajas que proporciona la programación orientada a objetos.

Cada vez que se crea una clase se añade otro tipo de dato que se puede utilizar igual que uno de los tipos simples. Por ello al declarar una nueva variable, se puede utilizar un nombre de clase como tipo. A estas variables se les conoce como referencias a objeto. Por ejemplo:

MiPunto p; Esta es una declaración de una variable p que es una referencia a un objeto de la clase MiPunto, de momento con un valor por defecto de null. La referencia null es una referencia a un objeto de la clase Object, y se podrá convertir a una referencia a cualquier otro objeto porque todos los objetos son hijos de la clase Object.

El operador new

El operador new crea una instancia de una clase (objetos) y devuelve una referencia a ese objeto. Por ejemplo:

MiPunto p2 = new MiPunto();

Cuando se realiza una instancia de una clase (mediante new) se reserva en la memoria un espacio para un conjunto de datos como el que definen los atributos de la clase que se indica en la instanciación. A este conjunto de variables se le denomina variables de instancia.

La potencia de las variables de instancia es que se obtiene un conjunto distinto de ellas cada vez que se crea un objeto nuevo. Es importante el comprender que cada objeto tiene su propia copia de las variables de instancia de su clase, por lo que los cambios sobre las variables de instancia de un objeto no tienen efecto sobre las variables de instancia de otro.

Por ejemplo, la clase denominada Caja define tres variables de instancia: ancho, alto y largo. Actualmente, Caja no contiene ningún método.

class Caja{ double altura; double ancho; double largo; }

Es importante recordar que una declaración de clase sólo crea una plantilla; no crea un objeto real. Para crear realmente un objeto de tipo Caja, se utiliza una instrucción como la siguiente:

Caja objCaja = new Caja();

Después de esta instrucción, objCaja será una instancia de la clase Caja.

Cada vez que se crea una instancia de una clase, se crea un objeto que contiene su propia copia de cada variable de instancia definido por la clase. Por lo tanto, cada objeto de Caja contendrá sus propias copias de las variables ancho, altura y largo.

Para poder acceder a estas variables, se utiliza el operador punto (.). El operador punto vincula el nombre del objeto con el nombre de una variable de instancia. Por ejemplo, para asignar a la variable ancho de objCaja el valor de 100, se utiliza la siguiente instrucción:

objCaja.ancho = 100;

Esta declaración indica al compilador que asignara a la variable ancho que está dentro del objeto objCaja el valor de 100. En general, se utiliza el operador punto para acceder a las variables de instancia y los métodos dentro de un objeto.

Ejemplo:

// Archivo Caja.java class Caja{ // Declaración de la clase Caja double altura; double ancho; double largo;

} // Archivo CajaDemo.java public class CajaDemo{ public static void main(String args[ ]) { Caja objCaja = new Caja(); double vol; // Asignación de valores a las variables de instancia objCaja.altura = 10; objCaja.ancho = 20;

objCaja.largo = 15; // Cálculo del volumen de la caja vol = objCaja.altura * objCaja.ancho * objCaja.largo; System.out.println("El volumen de la caja es: " + vol); }

}

Por ejemplo, en el siguiente programa se declaran dos objetos de tipo Caja:

// Archivo CajaDemo1.java public class CajaDemo1{ public static void main(String args[ ]) { // Declaración de los objetos Caja objCaja = new Caja(); Caja objCaja1 = new Caja(); double vol; // Asignación de valores a las variables del objeto objCaja objCaja.altura = 10; objCaja.ancho = 20; objCaja.largo = 15; // Asignación de valores a las variables del objeto objCaja1 objCaja1.altura = 3; objCaja1.ancho = 6; objCaja1.largo = 9;

// Cálculo del volumen de la primer caja vol = objCaja.altura * objCaja.ancho * objCaja.largo; System.out.println("El volumen de la primer caja es: " + vol); // Cálculo del volumen de la segunda caja vol = objCaja1.altura * objCaja1.ancho * objCaja1.largo; System.out.println("El volumen de la segunda caja es: " + vol); }

} Como puede verse en la salida del programa, los datos de cada uno de los objetos son diferentes, lo cual indica que el objeto objCaja es completamente independiente al objeto objCaja1.

En el siguiente ejemplo, se utiliza una referencia al objeto objCaja y por medio de esta establece, modifica y visualiza el valor de las variables del objeto.

public class CajaDemo2{ public static void main(String args[]) { Caja objCaja = new Caja(); // Declaración del objeto objCaja Caja refCaja = objCaja; // Declaración de la referncia // Asignación de valores a las variables de instancia por // medio de la referencia refCaja refCaja.altura = 10; refCaja.ancho = 20; refCaja.largo = 15; // Visualización de datos a través de la referencia refCaja System.out.println("El valor del atributo altura es: " + refCaja.altura); System.out.println("El valor del atributo ancho es: " + refCaja.ancho);

System.out.println("El valor del atributo largo es: " + refCaja.largo); // Modificación del valor de la variable a través de la // referencia refCaja refCaja.altura = refCaja.altura + 60; System.out.println("El nuevo valor del atributo altura es: " + refCaja.altura); } }

2.3 Referencia al objeto actual. Java incluye un valor de referencia especial llamado this, que se utiliza dentro de cualquier método para referirse al objeto actual. El valor this se refiere al objeto sobre el que ha sido llamado el método actual. Se puede utilizar this siempre que se requiera una referencia a un objeto del tipo de una clase actual. Si bien en muchos casos se puede omitir su uso, otras veces nos ayuda a resolver ambigüedades o para devolver referencias del objeto que ejecutó el método. El this es un apuntador al objeto mismo donde este. Y sirve para evitar ambigüedades porque se usa para diferenciar el atributo base de la clase; del atributo base que entra como parámetro del método.

Cuando los nombres de los parámetros que recibe un método son iguales a los de los atributos de la clase, los parámetros son ocultados por los atributos, siendo necesario anteponer la palabra reservada this a los atributos para poder referirse a ellos.

Por ejemplo, en el siguiente fragmento de código se muestra el uso de la referencia al objeto actual:

class Caja{ // Atributos

int iTop, iLeft, iBottom, iRight; // Método asignarDatos(int iTop, int iLeft, int iBottom, int iRight){ this.iTop = iTop, this.iLeft = iLeft; this.iBottom = iBottom, this.iRight = iRight;

} }

Ejemplos:

// Archivo Circulo.java class Circulo { // Atributos public static final double PI = 3.1416; public double r; // Métodos public void asignaValor(double r){ this.r = r; } public double calculaPerimetro() {return 2.0 * PI * r;} public double calculaArea() {return PI * r * r;}

}

import java.util.Scanner;

public class DemoCirculo { public static void main(String[ ] args){ double radio; // Declaración de objetos Scanner entDato = new Scanner(System.in); Circulo objCircle = new Circulo(); try{ System.out.println("Dato de entrada: "); System.out.print("\t - Radio: "); radio = entDato.nextDouble(); objCircle.asignaValor(radio); System.out.println("\nDatos de salida: "); // Llamado a los métodos por medio del objeto creado System.out.println("\t - Perímetro: " + objCircle.calculaPerimetro());

System.out.println("\t - Area: " + objCircle.calculaArea()); } catch(Exception e){ System.out.println("Error el dato debe ser numérico..."); } System.exit(0); }

}

Ejemplo:

Elabore una clase Empleado con tres atributos: nombre, edad , salar io y t res métodos : asignarDatos() , incrementarSalario() y visualizarDatos().

Donde el método asignarDatos() debe de recibir como parámetros los datos del empleado para asignarlos a cada uno de los atributos de la clase, el método incrementarSalario() debe de regresar un valor de tipo booleano si al empleado se le incrementa el salario en un 20% siempre y cuando este sea mayor a 40 años de edad; y por último el método visualizarDatos() debe mostrar la información del empleado.

Una vez construida la clase elabore la aplicación que permita crear el objeto de tipo Empleado, leer los datos del mismo, incrementar el salario y visualizar sus datos.

package appempleado;

public class Empleado { // Atributos private String nombre; private int edad; private double salario;

// Métodos public void asignarDatos(String nombre, int edad, double salario) { this.nombre = nombre; this.edad = edad; this.salario = salario; }

public String visualizarDatos() { String salDatos = ""; salDatos += "Nombre: " + nombre + "\nEdad: " + edad +

"\nSalario: " + salario; return salDatos; }

// Incrementa el salario del empleado en un 20%, si este tiene // más de 40 años public boolean incrementarSalario() { boolean aumento = false; if (edad > 40) { salario += salario * 0.20; aumento = true; } return aumento; }

}

package appempleado;

import java.awt.HeadlessException; import javax.swing.JOptionPane;

public class AppEmpleado { public static void main(String[] args) { // Declaración de variables y objeto String nomEmp; int edadEmp; double sueldoEmp; Empleado objEmpleado = new Empleado(); try { // Entrada de datos nomEmp = JOptionPane.showInputDialog(null, "Nombre: ", "Entrada de datos...", JOptionPane.INFORMATION_MESSAGE); edadEmp = Integer.parseInt( JOptionPane.showInputDialog(null, "Edad: ",

"Entrada de datos...", JOptionPane.INFORMATION_MESSAGE)); sueldoEmp = Double.parseDouble( JOptionPane.showInputDialog(null, "Sueldo: ", "Entrada de datos...", JOptionPane.INFORMATION_MESSAGE)); // Asignación de datos a los atributos del objeto objEmpleado.asignarDatos(nomEmp, edadEmp, sueldoEmp); // Incrementa el salario del empleado en un 20% if (objEmpleado.incrementarSalario()) { String msg; msg = "El salario se le incremento un 20%"; // Datos de salida JOptionPane.showMessageDialog(null, "Datos del empleado:\n " + objEmpleado.visualizarDatos() + "\n " + msg,

"Salida de datos...", JOptionPane.INFORMATION_MESSAGE); }else{ JOptionPane.showMessageDialog(null, "Datos del empleado:\n " + objEmpleado.visualizarDatos(), "Salida de datos...", JOptionPane.INFORMATION_MESSAGE); } } catch (HeadlessException | NumberFormatException e) { JOptionPane.showMessageDialog(null, "Error el dato debe ser numérico", "Mensaje de error...", JOptionPane.ERROR_MESSAGE); } System.exit(0); }

}

Declaración:

En Java un método es un módulo de un programa separado del cuerpo principal, que realiza una tarea específica y que puede regresar un valor a la parte principal del programa u otro método que lo invoque.

Existen tres clases de métodos: los primeros son de tipo computacional que son diseñados para realizar operaciones con los argumentos y regresan un valor basado en el resultado de esa operación, los segundos son aquellos que manipulan información y regresan un valor que indican la terminación o la falla de esa manipulación y los terceros son aquellos que no regresan ningún valor, es decir son estrictamente métodos vacíos.

La implementación de un método consiste en dos partes, la declaración y el cuerpo.

La sintaxis de la declaración de un método es la siguiente:

<modificador > <tipovalordevuelto> <nombreMétodo>([<listaParámetros>]){ cuerpo de instrucciones; return valordevuelto; }

El tipo de dato del valor devuelto por la instrucción return debe corresponder con el tipo de dato que el método tiene que devolver. Por ejemplo, no se puede devolver un doble desde un método que fue declarado para devolver un entero.

Dónde:

tipovalordevuelto, especifica el tipo de valor que el método regresara utilizando la instrucción return. Si no se especifica un tipo se asume por default que el tipo regresado es int.

listaParámetros, es una lista de variables identificada con un tipo de dato, separadas estas por comas (,) que almacenaran los valores que recibe el método; estas variables actúan como locales dentro del cuerpo del método. La declaración de parámetros es la especificación de cada tipo de parámetro recibido.

return, esta instrucción permite regresar el valor (resultado) que genera el método al término de la tarea especificada.

Por ejemplo el siguiente método devuelve la suma de dos enteros:

int suma(int x, int y){ return (x + y); }

En el caso de que no se desee devolver ningún valor se deberá indicar como tipo la palabra reservada void.

Así mismo, si no se desean parámetros, la declaración del método debería incluir un par de paréntesis vacíos (sin void). Por ejemplo:

void vacio(){ … };

Los métodos son llamados, indicando una instancia individual de la clase, que tendrá su propio conjunto único de variables de instancia, por lo que los métodos se pueden referir directamente a ellas.

Por ejemplo, el método inicializa() sirve para establecer valores a las dos variables de instancia de una clase.

void inicializa( int valorX, int valorY){ x = valorX; y = valorY; }

Tras la sección de declaración del método, se pueden declarar las variables que el método vaya a necesitar. Estas son locales al método y tanto su visibilidad como su longevidad están inscritas dentro del cuerpo del método. Estas variables también se denominan objetos locales.

Las variables locales son creadas cada vez que el método es invocado y destruidas al terminar éste y son sólo conocidas por el método, sin embargo los atributos existen mientras exista el objeto y son conocidas (al menos) por todos los métodos de la clase.

Mensajes.

Una clase consta de variables (definición de los atributos o características) junto con métodos (comportamientos comunes) que operan sobre esas variables.

Los métodos de un objeto son el vehículo para interactuar sobre otros objetos. Cuando el objeto A desea que el objeto B ejecute una operación (método), el objeto A (emisor) envía un mensaje al objeto B (receptor).

Para que el objeto procese el mensaje que recibe, debe estar programado de acuerdo a esa finalidad por lo tanto debe poseer un método que coincida con ese mensaje.

A veces el objeto necesita más información, de modo que sepa exactamente lo que ha de hacer. La información se pasa junto con el mensaje como un parámetro del método a ejecutar.

Una vez que el objeto procesa el mensaje ejecutando el método correspondiente y dependiendo de la definición del método puede no informar al emisor que ya ha realizado las operaciones solicitadas o bien responder al emisor devolviendo un valor.

Paso de parámetros.

A continuación del nombre del método aparece la lista de parámetros que puede recibir el método. Si el método no recibe ningún parámetro sólo se indican los paréntesis. En el código fuente siguiente se muestra la declaración de un método con parámetros.

void miVentana(int iTop, int iLeft, int iBottom, int iRight, String sTítulo, boolean BarraEstado){

<Implementación> }

Como se puede observar, los parámetros que un método recibe son parejas de:

<tipo> <nombreVariable>

Si existe más de un parámetro, estos deben ir separados por comas.

Por ejemplo el método miVentana recibe cuatro parámetros de tipo numérico entero, que son las coordenadas de la ventana, un parámetro de tipo cadena que es el título de la ventana y un parámetro lógico (booleano) que indica si la ventana tiene o no barra de estado. Veamos ahora algunas otras consideraciones acerca de los parámetros en Java: ü  En Java, cualquier tipo de dato válido puede ser pasado

como parámetro a un método: tipos primitivos, objetos, arreglos, etc.

ü  En Java, no se puede pasar un método como parámetro a

otro método, pero se puede pasar el objeto e invocar el método deseado.

ü Cuando los nombres de los parámetros que recibe un método son iguales a los de los atributos de la clase, los parámetros son ocultados por los atributos, siendo necesario anteponer la palabra reservada this a los atributos para poder referirse a ellos

ü  En Java, los parámetros se pasan por valor, no por referencia, esto quiere decir, que para los datos de tipos primitivos, lo que se pasa es el valor de la variable, y para los datos de tipo referencia (como son los objetos) se pasa la dirección de memoria.

Retorno de valores.

Una vez indicados los modificadores del método se debe indicar el tipo de valor de retorno del método. En Java, un método puede devolver un valor o no devolver nada.

En el primer caso, al declarar el método se tiene que especificar el tipo de dato que se va a devolver, en el segundo caso, hay que declararlo como de tipo void.

Para devolver el valor deseado, se utiliza la sentencia return seguida del valor, el cual puede ser el resultado de una expresión de cualquier tipo, lo que obviamente incluye el contenido de un dato de la clase o una variable, o bien un tipo primitivo (true, null, int, etc.).

Un ejemplo podría ser el que muestra en el código siguiente:

public boolean estaVacio(){ if(items.size() == 0) return true; else return false;

} Una vez indicados los modificadores y el tipo del valor de retorno del método, lo siguiente que debemos facilitar es el nombre del método, el nombre puede ser cualquier identificador válido en Java..

Ejemplos:

// Archivo Cadenas.java class Cadenas{ // Declaración e implementación de la clase // Atributos String cad1, cad2;

// Métodos public void asignaValor(String cad1,String cad2){ this.cad1 = cad1; this.cad2 = cad2; }

public boolean comparaCad(String cad1, String cad2) { if(cad1.equals(cad2)) return true; else return false; }

public void imprimeCad(){ System.out.println("El valor del primer atributo es: " + cad1); System.out.println("El valor del segundo atributo es: " + cad2); }

}

// Archivo DemoCadenas.java import java.util.Scanner;

public class DemoCadenas { public static void main(String[] args) { String entCad1, entCad2; boolean res; // Declaración de objetos Scanner entDato = new Scanner(System.in); Cadenas objCad = new Cadenas();

System.out.print("Datos de entrada:\n"); System.out.print("\t- Primer cadena de caracteres: "); entCad1 = entDato.nextLine(); System.out.print("\t- Segunda cadena de caracteres: "); entCad2 = entDato.nextLine(); // Llamada a los métodos del objeto objCad objCad.asignaValor(entCad1,entCad2); System.out.print("\nValores de los atributos del objeto:\n\n"); objCad.imprimeCad(); res = objCad.comparaCad(entCad1,entCad2); if(res) System.out.println("Cadenas exactamente iguales...\n"); else System.out.println("Las cadenas comparadas no son" + " exactamente iguales...\n"); }

}

// Archivo Factorial.java

class Factorial{ // Declaración e implementación de la clase // Método public int calculaFactorial(int numero){ int resultado = 1; while(numero > 0){ resultado = resultado*numero; numero--; } return resultado; }

}

// Archivo CalcFactorial.java import java.util.Scanner;

public class CalcFactorial { public static void main(String[] args) { int num, res; Scanner entDato = new Scanner(System.in); Factorial objFactor = new Factorial(); try{ // Lectura de datos System.out.print("Introduce el numero: "); num = entDato.nextInt(); // Llamada al método calculaFactorial() res = objFactor.calculaFactorial(num); // Despliega el resultado System.out.println("\nEl factorial de " + num + " es: " + res); }

catch(Exception e){ System.out.println("\nError el dato no es numérico..."); } System.exit(0); }

}

// Archivo Maximo.java

class Maximo{ // Declaración e implementación de la clase

// Implementación del método public int maximoValor(int x, int y, int z){ int valorMax = x; if(y > valorMax) valorMax = y; if(z > valorMax) valorMax = z; // Valor máximo devuelto return valorMax; }

}

// Archivo DeterminaMaximo.java import java.util.Scanner;

public class DeterminaMaximo { public static void main(String[] args) { int num1, num2, num3, resNumMax; // Declaración de objetos Scanner entDato = new Scanner(System.in); Maximo objMax = new Maximo(); try{ // Lectura de datos System.out.print("Datos de entrada:\n "); System.out.print("\t - Introduce el primer número: "); num1 = entDato.nextInt(); System.out.print("\t - Introduce el segundo número: "); num2 = entDato.nextInt(); System.out.print("\t - Introduce el tercer número: "); num3 = entDato.nextInt();

/ / L l a m a d a a l m é t o d o m á x i m o Va l o r ( ) resNumMax = objMax.maximoValor(num1,num2,num3); // Despliega el resultado System.out.print("Resultado:\n "); System.out.print("\t - El valor máximo de los tres números es: " + resNumMax + "\n"); } catch(Exception e){ System.out.println("Error el dato no es numérico..."); } System.exit(0); }

}

El constructor no devuelve ningún tipo, ni siquiera void. Su misión es iniciar todo estado interno de un objeto (atributos), haciendo que el objeto sea uti l izable inmediatamente; reservando memoria para sus atributos e iniciando sus valores.

Constructor. Las clases pueden implementar un método especial llamado constructor. Un constructor es un método que inicia un objeto inmediatamente después de su creación. De esta forma nos evitamos el tener que iniciar las variables explícitamente para su iniciación.

El constructor tiene exactamente el mismo nombre de la clase que lo implementa; no puede haber ningún otro método que comparta su nombre con el de su clase. Una vez definido, se llamará automáticamente al constructor al crear un objeto de esa clase (al utilizar el operador new).

ü Debe declararse como public.

Por ser métodos, los constructores también aceptan parámetros. Cuando en una clase no especificamos ningún tipo de constructor, el compilador añade uno público por omisión sin parámetros, el cual no hace nada.

Características de los constructores:

ü Un constructor, tiene el mismo nombre de la clase a la cual pertenece.

ü No puede ser heredado.

ü No retorna ningún valor, por lo cual no debe especificarse ningún tipo de dato.

En el siguiente segmento de código de la clase Persona podemos ver dos constructores: El primero, que no toma parámetros, se llama constructor por defecto. Nuestro constructor por defecto nos permite crear una persona que se llame "Juan López" y que tenga 17 años. El segundo constructor permite especificar la edad y el nombre de la persona que se va a construir.

Por ejemplo, supongamos una clase llamada Datos class Datos{ // Declaración de atributos int edadM; // Declaración de los métodos constructores public Datos(); //constructor sin parámetros public Datos(int edad){//Constructor con parámetros edadM = edad; }

}

// Archivo Persona.java

class Persona{ // Atributos int edad; String nombre;

// Métodos constructores public Persona(){ // Constructor por defecto edad = 17; nombre = "Juan López"; }

public Persona(String nombre, int edad){ this.edad = edad; this.nombre = nombre; }

// Métodos public void mostrar() { System.out.print("\t - Nombre: " + nombre + "\n"); System.out.print("\t - Edad: " + edad); }

}

// Archivo DemoPersonas.java import java.util.Scanner;

public class DemoPersonas { public static void main(String[ ] args) { int edad; String nombre; //Declaración de objetos Scanner entDato = new Scanner(System.in); Persona objPer = new Persona();

System.out.print("Datos del objeto objPer:\n"); objPer.mostrar(); Persona objPer1 = new Persona("María", 16); System.out.print("\nDatos del objeto objPer1:\n"); objPer1.mostrar(); try{ System.out.print("\nDatos de entrada para el objeto objPer2:\n"); System.out.print("\t - Nombre: "); nombre = entDato.nextLine(); System.out.print("\t - Edad: "); edad = entDato.nextInt(); Persona objPer2 = new Persona(nombre, edad); System.out.print("Datos del objeto objPer2:\n"); objPer2.mostrar(); }

catch(Exception e){ System.out.println("Error el dato debe ser numérico..."); } System.exit(0); }

}

// Archivo Pelicula.java

class Pelicula{ // Declaración e implementación de la clase // Atributos private String titulo; private String tipo;

// Métodos constructores public Pelicula() { }

public Pelicula (String titulo){ this.titulo = titulo; }

public Pelicula (String titulo, String tipo) { this.titulo = titulo; this.tipo = tipo; }

// Métodos set´s y get´s

public void setTitulo(String titulo){ this.titulo = titulo; }

public void setTipo(String tipo){ this.tipo = tipo; }

public String getTitulo() { return titulo; }

public String getTipo() { return tipo; }

}

// Archivo DemoPelicula.java

import java.util.Scanner;

public class DemoPelicula{ public static void main (String[] args) { String titulo, tipo; // Declaración de objetos Scanner entDatos = new Scanner(System.in); Pelicula pelicula1 = new Pelicula(); Pelicula pelicula2 = new Pelicula("Amor prohibido"); Pelicula pelicula3 = new Pelicula("El patriota", "Acción"); System.out.println("Datos de entrada:\n"); System.out.print("\t - Titulo de la película:"); titulo = entDatos.nextLine(); System.out.print("\t - Tipo de película:"); tipo = entDatos.nextLine();

// Creación del objeto a través de método constructor con // parámetros Pelicula pelicula4 = new Pelicula(titulo, tipo); System.out.println("Datos de salida:\n"); System.out.println("\t - Titulo pelicula1: " + pelicula1.getTitulo() + ", Tipo : " + pelicula1.getTipo()); System.out.println("\t - Titulo pelicula2: " +

pelicula2.getTitulo() + ", Tipo : " + Pelicula2.getTipo()); System.out.println("\t - Titulo pelicula3: " +

pelicula3.getTitulo() + ", Tipo : " + pelicula3.getTipo()); System.out.println("\t - Titulo pelicula4: " +

pelicula4.getTitulo() + ", Tipo : " + Pelicula4.getTipo()); }

}

En resumen es un método de clase que sirve para realizar ciertas operaciones necesarias al dejar de existir un objeto, por ejemplo, cerrar conexiones de una comunicación, cerrar archivos, etc.

Destructor.

Un destructor es un método que se invoca automáticamente cuando el objeto se destruye. Java no posee destructores, porque tiene recolección de basura. Un destructor es un método que es ejecutado cada vez que se destruye (se elimina de la RAM) un objeto, el objetivo de este método es el de eliminar toda la memoria que ocupó un objeto. En Java no es necesaria la definición de destructores (es más no existen), pues el mismo lenguaje se encarga de la eliminación y liberación de la memoria ocupada por un objeto, esto se realiza cada vez que un objeto pierde todas sus referencias.

ü Un método puede ser sobrecargado en la misma clase o en una subclase.

Cuando en una clase, se define un mismo método, con diferente número de parámetros, o bien con el mismo número de parámetros pero diferenciándose en la definición, en la cual, al menos un parámetro sea de diferente tipo, cuando esto sucede, se dice que el método está sobrecargado. Un método sobrecargado se utiliza para reutilizar el nombre de un método pero con diferentes parámetros (opcionalmente un tipo diferente de retorno). Las reglas para sobrecargar un método son las siguientes:

ü  Los métodos sobrecargados deben de cambiar la lista de parámetros.

ü  Pueden cambiar el tipo de retorno. ü  Pueden cambiar el modificador de acceso. ü  Pueden declarar nuevas o más amplias excepciones.

Lo que define qué método es el que se va a llamar son los parámetros que se envían al mismo durante la llamada. Si se invoca a un método con un String como parámetro, se ejecutará el método que tenga un String como parámetro. Si se invoca a un método con un parámetro que no es definido en ninguna de las versiones sobrecargadas entonces el compilador arrojará un mensaje de error.

Por ejemplo, se desea sobrecargar el siguiente método:

public void cambiarTamaño(int tamaño, String nombre, float patron){ }

Los siguientes métodos son sobrecargas legales del método cambiarTamaño():

public void cambiarTamaño(int tamaño, String nombre){}

public int cambiarTamaño(int tamaño, float patron){}

Ejemplos:

// Archivo Sobrecarga.java

class Sobrecarga{ // Declaración y definición de la clase // Definición de métodos sobrecargados public void numeros(int x, int y){ System.out.println("Método que recibe enteros."); }

public void numeros(double x, double y){ System.out.println("Método que recibe flotantes."); }

public void numeros(String cadena){ System.out.println("Método que recibe una cadena"); }

}

// Archivo DemoSobrecarga.java

public class DemoSobrecarga { public static void main(String[] args) { // Declaración de los objetos Sobrecarga s = new Sobrecarga(); int a = 1; int b = 2; // Llamada a los métodos sobrecargados a través del objeto s.numeros(a,b); s.numeros(3.2, 5.7); s.numeros("Método sobrecargado"); }

}

// Archivo Cliente.java

class Cliente { // Declaración y definición de la clase // Atributos String nombre, nombreEmpresa; int edad;

// Constructores sobrecargados Cliente(){ nombre = nombreEmpresa = null; edad = 0; }

Cliente(String nombre, String nombreEmpresa, int edad) { this.nombre = nombre; this.nombreEmpresa = nombreEmpresa; this.edad = edad; }

Cliente(String nombre, String nombreEmpresa) { this.nombre = nombre; this.nombreEmpresa = nombreEmpresa; }

}

// Archivo DemoCliente.java public class DemoCliente{ public static void main(String [ ] args) { String nombre, empresa; int edad; // Declaración y creación de los objetos de tipo Cliente() Cliente objCliente1 = new Cliente(); Cliente objCliente2 = new Cliente("Isaac", "Empresa ITCH",19); Cliente objCliente3 = new Cliente("José Luis", "Empresa el Chiupacabras");

// Obtención de los datos de cada uno de los atributos de los // objetos creados System.out.println("Datos de salida:"); nombre = objCliente2.nombre; empresa = objCliente2.nombreEmpresa; edad = objCliente2.edad; System.out.println("\t - "+ nombre + ", de la " + empresa + ", tiene " + edad + " años"); nombre = objCliente1.nombre; empresa = objCliente1.nombreEmpresa; edad = objCliente1.edad; System.out.println("\t - " + nombre + ", de la " + empresa + ", tiene " + edad + " años"); nombre = objCliente3.nombre; empresa = objCliente3.nombreEmpresa; edad = objCliente3.edad;

System.out.println("\t - " + nombre + ", de la " + empresa + ", tiene "+ edad + " años"); }

}

// Archivo Operación.java

import java.lang.ArithmeticException;

class Operacion{ // Definición y declaración de la clase // Métodos sobrecargados public int suma(int x, int y){ return (x + y); }

public float suma(float x, float y) { return (x + y); }

public double suma(double x, double y) { return (x + y); }

public int resta(int x, int y){ return (x - y); }

public float resta(float x, float y) { return (x - y); }

public double resta(double x, double y) { return (x - y); }

public int producto(int x, int y){ return (x * y); }

public float producto(float x, float y) { return (x * y); }

public double producto(double x, double y) { return (x * y); } public int division(int x, int y) throws ArithmeticException{ return x/y; } public float division(float x, float y) throws ArithmeticException{ return x/y; }

public double division(double x, double y) throws ArithmeticException{ return x/y; }

}

// Archivo Calculadora.java public class Calculadora { public static void main(String[] args) { Operacion objOperador = new Operacion(); try{ System.out.println(“Resultado de las operaciones:\n "); System.out.println("\t - El producto de 10.75 * 33.87 = " + objOperador.producto(10.75,33.87)); System.out.println("\t - La división de 43/5 = " + objOperador.division(43,5));

System.out.println("\t - La suma de 10.75 + 33.87 = " + objOperador.suma(10.75f,33.87f)); System.out.println("\t - La resta de 10.75 - 33.87 = " + objOperador.resta(10.75,33.87)); System.out.println("\t - La división de 33.75/0.0 = " + objOperador.division(33.75,0.0)); System.out.println("\t - La división de 33/0 = " + objOperador.division(33,0)); } catch(Exception e){

System.out.println("\t - Error división por cero"); } }

}


public class Persona{ // Atributos private String nombre; private String fechaNac; private String telefono;

// Constructores public Persona(String nom, String fechaN, String tel){ nombre = nom; fechaNac = fechaN; telefono = tel; }

public Persona(Persona objPersona){ this (objPersona.getNombre(), objPersona.getFechaNac(), objPersona.getTelefono()); }

// Métodos public String getNombre(){ return nombre; }

public String getFechaNac(){ return fechaNac; }

public String getTelefono(){ return telefono; }

public String toString(){ String strDatosPers = " - Nombre: "+ nombre +"\n – Fecha Nac.: "

+ fechaNac + "\n - Teléfono:: " + telefono + "\n\n"; return strDatosPers; }

}

// Utilizando un arreglo estatico import javax.swing.*;

public class ArrayPersonaEst { public static void main(String[] args) { String nombre, fechaNac, numTel; int nObj; try{ nObj = Integer.parseInt(JOptionPane.showInputDialog(null, "Numero de objetos a capturar", "Entrada de datos...", JOptionPane.INFORMATION_MESSAGE)); if(nObj > 0){ // Se crea el espacio para nObj referencias a Persona Persona[ ] arrayPersonas = new Persona[nObj]; for(int i = 0; i < nObj; i++){ // Entrada de datos nombre = JOptionPane.showInputDialog(null, "Nombre", "Entrada de datos...", JOptionPane.QUESTION_MESSAGE);

fechaNac = JOptionPane.showInputDialog(null, "Fecha de nacimiento (DD/MM/AAAA)", "Entrada de datos...", JOptionPane.QUESTION_MESSAGE); numTel = JOptionPane.showInputDialog(null, "Telefono", "Entrada de datos...", JOptionPane.QUESTION_MESSAGE); // Se almacenan los datos de tipo Persona en el arreglo arrayPersonas[i] = new Persona(nombre,fechaNac,numTel); } // Salida de datos String datosSal = ""; for(int i = 0; i < nObj; i++) datosSal += arrayPersonas[i].toString(); JOptionPane.showMessageDialog(null, datosSal, "Datos personales“, JOptionPane.INFORMATION_MESSAGE); }

else JOptionPane.showMessageDialog(null, "Error: el dato debe ser mayor a cero....", "Mensaje de error...", JOptionPane.ERROR_MESSAGE); } catch(Exception e){ JOptionPane.showMessageDialog(null, "Error: el dato debe ser numérico....", "Mensaje de error...", JOptionPane.ERROR_MESSAGE); } System.exit(0); }

}

// Utilizando un arreglo dinamico

import javax.swing.*;

public class ArrayPersonaDin { public static void main(String[] args) { // Declaración de variables y arreglos de objetos int i = 0, j, seleccion; char resp = 'S'; String strListaPer = ""; String nombre, fechaNac, numeroTelefono; // Declaración del arreglo arrayListaPer y reservación del // espacio para almacenar un objeto de tipo Persona Persona arrayListaPer[ ] = new Persona[1]; // Declaración del arreglo opción y reservación del espacio // para almacenar dos String Object opcion[ ] = {"Si", "No"};

// Entrada de datos while(resp == 'S'){ // Lectura de datos nombre = JOptionPane.showInputDialog(null, "Nombre", "Entrada de datos...", JOptionPane.QUESTION_MESSAGE); fechaNac = JOptionPane.showInputDialog(null, "Fecha de nacimiento (DD/MM/AAAA)", "Entrada de datos...", JOptionPane.QUESTION_MESSAGE); numeroTelefono = JOptionPane.showInputDialog(null, "Número de teléfono", "Entrada de datos...", JOptionPane.QUESTION_MESSAGE); // Declaración y creación del objeto objPersona con los // datos capturados. Persona objPersona = new Persona(nombre, fechaNac, numeroTelefono);

// Almacenamiento del objeto de tipo Persona en el // arreglo arrayListaPer. if(i > 0){ // Se crea un arreglo de objetos temporal del tamaño // del arreglo de objetos arrayListaPer mas uno. Persona objPersonaTemp[ ] = new Persona[i + 1]; // Se almacenan todos los objetos contenidos en // arrayListaPer al arreglo objPersonaTemp. for ( j = 0; j < i; j++) objPersonaTemp[j] = arrayListaPer[j]; // Se agrega el objeto creado al arreglo de objetos // objPersonaTemp en la última posición de este. objPersonaTemp[i] = objPersona; // Se asignan los objetos del arreglo objPersonaTemp // al arreglo de objetos arrayListaPer y el arreglo // objPersonaTemp se destruye. arrayListaPer = objPersonaTemp; }

else{ // Se almacena el primer objeto al arreglo de objetos // arrayListaPer arrayListaPer[i] = objPersona; } i++; // Se incrementa en uno el valor de i, que sirve como // índice en el arreglo de objetos arrayListaPer

seleccion = JOptionPane.showOptionDialog(null, "Deseas ingresar otro objeto?", "Mensaje...", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null,opcion, "Si"); if(seleccion == 0) resp = 'S'; if(seleccion == 1) resp = 'N';

if(seleccion == -1){ JOptionPane.showMessageDialog(null, "Error usted no eligió Si o No.", "Mensaje de error...", JOptionPane.ERROR_MESSAGE); System.exit(1); } } // Obtención de los objetos almacenados en el arreglo y // visualización de estos. for(j = 0; j < i; j++) strListaPer += "Registro No. " + (j+1) + "\n" + arrayListaPer[j].toString(); JOptionPane.showMessageDialog(null, strListaPer, "Datos personales", JOptionPane.INFORMATION_MESSAGE); System.exit(0); }

}

Ejercicio:

Se desea implementar una aplicación para una institución bancaria que permita a esta registrar a sus Cuentahabientes, así como también cada una de sus Cuentas y cada uno de los Movimientos que estas tengan.

Para realizar la apertura de una Cuenta para un Cuentahabiente por primera vez, se deben de solicitar los datos de este y de la cuenta a aperturar; registrando el primer movimiento de la cuenta.

Cuando un Cuentahabiente desea aperturar una nueva Cuenta y este ya tiene al menos registrada una, no es necesario solicitar los datos de este, pero si los de la nueva cuenta; registrando también el primer movimiento de la cuenta.

Una vez que un Cuentahabiente al menos tiene una Cuenta, se pueden realizar movimientos en estas; los cuales pueden ser de: apertura, cancelación, deposito, retiro, transferencia y saldo.

Donde:

ü  Apertura: este movimiento se realiza cuando se crea una Cuenta nueva.

ü  Cancelación: para realizar la eliminación de una Cuenta, esta debe tener su saldo en cero y los movimientos registrados de la Cuenta deberán ser eliminados. Así como también los datos del Cuentahabiente dueño, siempre y cuando sea su única Cuenta.

ü  Deposito: este movimiento se utiliza para incrementar el saldo de la Cuenta.

ü  Retiro: para realizar este movimiento, se debe tener un saldo mayor a cero y menor o igual a lo que se desea retirar.

ü  Transferencia: este movimiento se realiza cuando de una Cuenta se desea transferir una cantidad a otra Cuenta, siendo estas del mismo Cuentahabiente o de diferentes Cuentahabientes.

ü  Saldo: este movimiento permite conocer el saldo que se tiene actualmente en la Cuenta.

Diagrama de clase (Manejo de cuentas)

CuentaHabiente

- nombre : String - edad : int - calle : String - colonia : String - ciudad : String - telefono: String

// Métodos

Cuenta

- numCuenta int - tipoCuenta: String - fechaApert: String - saldo : float

// Métodos

Cancelacion

- numCuenta int - nombre: String - fechaCanc: String

// Métodos

Movimiento

- fechaMov: String - tipoMov: String -- cantidad : float

// Métodos

1 1..* 1 1..*

1

0..1

Ejemplos:

Se desea implementar una aplicación que permita almacenar los datos de un grupo de personas (nombre, fecha de nacimiento, números de teléfonos y tipo de estos (casa, trabajo o móvil)) en una agenda electrónica.

Diagrama de clases. +Agenda

-arrayListaPersonas[[] : ListaPersonas

+Agenda() +agregarPersona(objPersona: Persona): void +toString(): String

+ListaPersonas

-arrayListaPer[[] : Persona -i : int

+ListaPersonas() +agregarListaPersona(objPersona: Persona): void +toString(): String

+Telefono -numTel : String -tipoTel : String

+Telefono(numero: String, tipo: String) +Telefono(objTelefono : Telefono) +obtenerNumero() : String +obtenerTipo() : String +toString(): String

+Persona

-nombre : String -fechaNac : String -arrayListaTel : ListaTelefonos

+Persona(nom: String, fechaN: String) +Persona(objPersona : Persona) +agregarTelefono(numTel : String, tipoTel : String) : void +agregarTelefono(objTelefono: Telefono) : void +obtenerNombre() : String +obtenerFechaNac() : String +toString(): String

+ListaTelefonos -arrayListaTel[[] : Telefono -i : int

+ListaTelefonos() +agregarDatosTel(numTelefono: String, tipoTelefono: String): void +agregarDatosTel(teléfono: Telefono): void +toString(): String

-arrayListaPersonas

-arrayListaTel 1

1

// Archivo Telefono.java public class Telefono{ // Atributos private String numTel; private String tipoTel;

// Constructores public Telefono(String numero, String tipo){ numTel = numero; tipoTel = tipo; }

public Telefono(Telefono objTelefono){ numTel = objTelefono.getNumero(); tipoTel = objTelefono.getTipo(); }

// Métodos public String getNumero(){ return numTel; }

public String getTipo(){ return tipoTel; }

public String toString(){ return "\n\t - Numero = " + getNumero() + "\t" + "Tipo = " + getTipo(); }

}

// Archivo ListaTelefonos.java

public class ListaTelefonos{ // Atributos private Telefono arrayListaTel[ ]; private int i;

// Constructor public ListaTelefonos(){ i = 0; arrayListaTel = new Telefono[1]; }

// Métodos public void agregarDatosTel(String numTelefono, String tipoTelefono){ Telefono objTelefono = new Telefono(numTelefono, tipoTelefono);

if (i > 0){ Telefono objTelefonoTemp[ ] = new Telefono[i + 1]; for (int j = 0; j < i; j++) objTelefonoTemp[j] = arrayListaTel[j]; arrayListaTel = objTelefonoTemp; } arrayListaTel[i] = objTelefono; i++; }

public void agregarDatosTel(Telefono telefono){ agregarDatosTel(telefono.getNumero(), telefono.getTipo()); }

public String toString(){ String strListaTel = ""; if (i > 0){ for(int j = 0; j < i; j++) strListaTel += arrayListaTel[j].toString(); } return strListaTel; }

}


public class Persona{ // Atributos private String nombre; private String fechaNac; private ListaTelefonos arrayListaTel;

// Constructores public Persona(String nom, String fechaN){ nombre = nom; fechaNac = fechaN; arrayListaTel = new ListaTelefonos(); }

public Persona(Persona objPersona){ this (objPersona. getNombre(), objPersona. getFechaNac()); }

// Métodos public void agregarTelefono(String numTel, String tipoTel){ arrayListaTel.agregarDatosTel(numTel, tipoTel); }

public void agregarTelefono(Telefono objTelefono){ arrayListaTel.agregarDatosTel(objTelefono); }

public String getNombre(){ return nombre; }

public String getFechaNac(){ return fechaNac; }

public String toString(){ String strDatosPers = "Datos personales:\n"+ "\t - Nombre: " + nombre + "\n\t – Fecha Nac.: " + fechaNac + "\nLista de Teléfono(s): " + arrayListaTel.toString(); return strDatosPers; }

}

// Archivo ListaPersonas.java

public class ListaPersonas{ // Atributos private Persona arrayListaPer[ ]; private int i;

// Constructor public ListaPersonas(){ i = 0; arrayListaPer = new Persona[1]; }

// Métodos public void agregarListaPersona(Persona objPersona){ if(i > 0){ Persona objPersonaTemp[] = new Persona[i + 1]; for (int j = 0; j < i; j++)

objPersonaTemp[j] = arrayListaPer[j]; arrayListaPer = objPersonaTemp; } arrayListaPer[i] = objPersona; i++; }

public int numPersonas(){ return i; }

public String toString () { String strListaPer = ""; for(int j = 0; j < i; j++) strListaPer += "Registro No. " + (j+1) +"\n" + arrayListaPer[j].toString() + "\n"; return strListaPer; }

}

// Archivo Agenda.java

public class Agenda{ private ListaPersonas arrayListaPersonas; // Constructor public Agenda(){ arrayListaPersonas = new ListaPersonas(); }

// Métodos public void agregarPersona(Persona objPersona){ arrayListaPersonas.agregarListaPersona(objPersona); }

public int tamAgenda(){ return arrayListaPersonas.numPersonas(); }

public String toString(){ return arrayListaPersonas.toString(); }

}

// Archivo Directorio.java

import javax.swing.*;

public class Directorio { public static void main(String[] args) { // Declaración del arreglo de objetos objAgenda de tipo Agenda, // objetos y variables Agenda objAgenda = new Agenda(); Object opcion[] = {"Si", "No"}; char resp = 'S'; int seleccion; boolean telValido; String cadTitulo = "Agenda personal"; String nombre, fechaNac, numeroTelefono, tipoTelefono;

// Entrada de datos while (resp == 'S') { nombre = JOptionPane.showInputDialog(null, "Nombre", "Entrada de datos..", JOptionPane.QUESTION_MESSAGE);

fechaNac = JOptionPane.showInputDialog(null, "Fecha de nacimiento (DD/MM/AAAA)", "Entrada de datos...", JOptionPane.QUESTION_MESSAGE); // Declaración y creación del objeto objPersona a partir de los // datos de entrada Persona objPersona = new Persona(nombre, fechaNac); // Lectura y validación de los teléfonos de la persona int resp1 = 0; while (resp1 == 0) { numeroTelefono = JOptionPane.showInputDialog(null, "Número de teléfono", "Entrada de datos...", JOptionPane.QUESTION_MESSAGE); // Llamado del método validaNum() para validar el número // de teléfono y solicitar su tipo if (validaNum(numeroTelefono)) { Object tipoTel = JOptionPane.showInputDialog(null, "Tipo de teléfono:", "Entrada de datos...", JOptionPane.QUESTION_MESSAGE, null,

new Object[]{"Casa", "Móvil", "Trabajo"}, "Casa"); tipoTelefono = tipoTel.toString(); // Llamado del método agregarTelefono() para agregar // el teléfono al objeto objPersona objPersona.agregarTelefono(numeroTelefono, tipoTelefono); telValido = true; } else { JOptionPane.showMessageDialog(null, "Error número de teléfono no valido....", "Directorio telefónico", JOptionPane.ERROR_MESSAGE); telValido = false; } resp1 = JOptionPane.showOptionDialog(null, "Deseas ingresar otro número:", "Directorio telefónico", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[]{"Si", "No"}, "Si");

// Llamado del método agregarPersona() para agregar el // objeto al arreglo de tipo Persona if (telValido && resp1 != 0) objAgenda.agregarPersona(objPersona); } //while(res1) seleccion = JOptionPane.showOptionDialog(null, "Deseas registrar a otra persona?", "Mensaje...", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null, opcion, "Si"); if (seleccion == 0) resp = 'S'; if (seleccion == 1) resp = 'N'; if (seleccion == -1) { JOptionPane.showMessageDialog(null, "Error usted no eligió Si o No.", "Mensaje de error...", JOptionPane.ERROR_MESSAGE); System.exit(1); }

}// while(res) // Obtención de los objetos almacenados en el arreglo y // visualización de estos. if (objAgenda.tamAgenda() > 0) { // Se crea el área de salida JTextArea areaSalida = new JTextArea(); // Se coloca el texto al área de salida areaSalida.setText(objAgenda.toString()); JOptionPane.showMessageDialog(null, areaSalida, "Directorio telefónico", OptionPane.INFORMATION_MESSAGE); // Se limpia el área de salida areaSalida.setText(""); } else { JOptionPane.showMessageDialog(null, "Error no existen personas a visualizar...", cadTitulo, JOptionPane.ERROR_MESSAGE); } System.exit(1); }// main

// Método para validar el número de teléfono static boolean validaNum(String numTel) { boolean flag = true; for (int i = 0; i < numTel.length(); i++) { if (!Character.isDigit(numTel.charAt(i))) { i = numTel.length() + 1; flag = false; } } return flag; }// validaNum()

}// class

Unidad 2 clases y objetos

Education

Transcript of Unidad 2 clases y objetos