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[ ]) {
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 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, salario y tres 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...",
// 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...",
}else{
"Datos del empleado:n " +
objEmpleado.visualizarDatos(),
"Salida de datos...",
}
} catch (HeadlessException | NumberFormatException e) {
"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


public class DemoCadenas {


String entCad1, entCad2;

boolean res;



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:nn");

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


public class CalcFactorial {


int num, res;


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


public class DeterminaMaximo {


int num1, num2, num3, resNumMax;



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: ");


System.out.print("t - Introduce el tercer número: ");


/ / 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 utilizable
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;
}

// Métodos

public void mostrar() {

System.out.print("t - Nombre: " + nombre + "n");

System.out.print("t - Edad: " + edad);

}
}
// Archivo DemoPersonas.java
public class DemoPersonas {
public static void main(String[ ] args) {
int edad;
String nombre;
//Declaración de objetos
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.tipo = tipo;
}

// Métodos set´s y get´s
public void setTitulo(String titulo){
}
public void setTipo(String tipo){
this.tipo = tipo;
}
public String getTitulo() {
return titulo;
}
public String getTipo() {
return tipo;
}
}

// Archivo DemoPelicula.java
public class DemoPelicula{
public static void main (String[] args) {
String titulo, tipo;
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());
pelicula2.getTitulo() + ", Tipo : " + Pelicula2.getTipo());
pelicula3.getTitulo() + ", Tipo : " + pelicula3.getTipo());
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 {


// 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.nombreEmpresa = nombreEmpresa;

this.edad = edad;

}

Cliente(String nombre, String nombreEmpresa) {


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");
System.out.println("t - " + nombre + ", de la " + empresa +
", tiene " + edad + " años");

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 {
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 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 + "nn";
return strDatosPers;
}
}

// Utilizando un arreglo estatico
import javax.swing.*;
public class ArrayPersonaEst {
String nombre, fechaNac, numTel;
int nObj;
try{
nObj = Integer.parseInt(JOptionPane.showInputDialog(null,
"Numero de objetos a capturar", "Entrada de datos...",
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",
JOptionPane.QUESTION_MESSAGE);

fechaNac = JOptionPane.showInputDialog(null,
"Fecha de nacimiento (DD/MM/AAAA)",
numTel = JOptionPane.showInputDialog(null, "Telefono",
// 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“,
}

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

// Utilizando un arreglo dinamico
public class ArrayPersonaDin {
// 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
numeroTelefono = JOptionPane.showInputDialog(null,
"Número de teléfono", "Entrada de datos...",
// 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){
"Error usted no eligió Si o No.", "Mensaje de error...",
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",
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;
}
return "nt - 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());
}

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

public class Persona{
// Atributos
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;
}

String strDatosPers = "Datos personales:n"+ "t - Nombre: "
+ nombre + "nt – 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();
}

return arrayListaPersonas.toString();

}

}

// Archivo Directorio.java

public class Directorio {
// 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') {
"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...",
// 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 {
"Error número de teléfono no valido....",
"Directorio telefónico",
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) {
"Error usted no eligió Si o No.", "Mensaje de error...",
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 {
"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

Más contenido relacionado

La actualidad más candente (20)

Destacado (20)

Similar a Unidad 2 clases y objetos (20)

Último (20)

Unidad 2 clases y objetos